Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 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. |
| 5 | * |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 6 | * DECnet Neighbour Functions (Adjacency Database and |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * On-Ethernet Cache) |
| 8 | * |
| 9 | * Author: Steve Whitehouse <SteveW@ACM.org> |
| 10 | * |
| 11 | * |
| 12 | * Changes: |
| 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 |
| 19 | * working. |
| 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 |
| 24 | * |
| 25 | */ |
| 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <linux/net.h> |
| 28 | #include <linux/module.h> |
| 29 | #include <linux/socket.h> |
| 30 | #include <linux/if_arp.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 31 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 41 | #include <linux/atomic.h> |
Eric W. Biederman | 457c4cb | 2007-09-12 12:01:34 +0200 | [diff] [blame] | 42 | #include <net/net_namespace.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | #include <net/neighbour.h> |
| 44 | #include <net/dst.h> |
| 45 | #include <net/flow.h> |
| 46 | #include <net/dn.h> |
| 47 | #include <net/dn_dev.h> |
| 48 | #include <net/dn_neigh.h> |
| 49 | #include <net/dn_route.h> |
| 50 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | static int dn_neigh_construct(struct neighbour *); |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 52 | static void dn_neigh_error_report(struct neighbour *, struct sk_buff *); |
| 53 | static int dn_neigh_output(struct neighbour *neigh, struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | /* |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 56 | * Operations for adding the link layer header. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | */ |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 58 | static const struct neigh_ops dn_neigh_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | .family = AF_DECnet, |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 60 | .error_report = dn_neigh_error_report, |
| 61 | .output = dn_neigh_output, |
| 62 | .connected_output = dn_neigh_output, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | }; |
| 64 | |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 65 | static u32 dn_neigh_hash(const void *pkey, |
| 66 | const struct net_device *dev, |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 67 | __u32 *hash_rnd) |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 68 | { |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 69 | return jhash_2words(*(__u16 *)pkey, 0, hash_rnd[0]); |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 70 | } |
| 71 | |
Eric W. Biederman | 60395a2 | 2015-03-03 17:10:44 -0600 | [diff] [blame] | 72 | static bool dn_key_eq(const struct neighbour *neigh, const void *pkey) |
| 73 | { |
| 74 | return neigh_key_eq16(neigh, pkey); |
| 75 | } |
| 76 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | struct neigh_table dn_neigh_table = { |
| 78 | .family = PF_DECnet, |
YOSHIFUJI Hideaki / 吉藤英明 | daaba4f | 2013-02-09 07:00:59 +0000 | [diff] [blame] | 79 | .entry_size = NEIGH_ENTRY_SIZE(sizeof(struct dn_neigh)), |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 80 | .key_len = sizeof(__le16), |
Eric W. Biederman | bdf53c5 | 2015-03-02 00:13:22 -0600 | [diff] [blame] | 81 | .protocol = cpu_to_be16(ETH_P_DNA_RT), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | .hash = dn_neigh_hash, |
Eric W. Biederman | 60395a2 | 2015-03-03 17:10:44 -0600 | [diff] [blame] | 83 | .key_eq = dn_key_eq, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | .constructor = dn_neigh_construct, |
| 85 | .id = "dn_neigh_cache", |
| 86 | .parms ={ |
| 87 | .tbl = &dn_neigh_table, |
Jiri Pirko | 1f9248e | 2013-12-07 19:26:53 +0100 | [diff] [blame] | 88 | .reachable_time = 30 * HZ, |
| 89 | .data = { |
| 90 | [NEIGH_VAR_MCAST_PROBES] = 0, |
| 91 | [NEIGH_VAR_UCAST_PROBES] = 0, |
| 92 | [NEIGH_VAR_APP_PROBES] = 0, |
| 93 | [NEIGH_VAR_RETRANS_TIME] = 1 * HZ, |
| 94 | [NEIGH_VAR_BASE_REACHABLE_TIME] = 30 * HZ, |
| 95 | [NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ, |
| 96 | [NEIGH_VAR_GC_STALETIME] = 60 * HZ, |
| 97 | [NEIGH_VAR_QUEUE_LEN_BYTES] = 64*1024, |
| 98 | [NEIGH_VAR_PROXY_QLEN] = 0, |
| 99 | [NEIGH_VAR_ANYCAST_DELAY] = 0, |
| 100 | [NEIGH_VAR_PROXY_DELAY] = 0, |
| 101 | [NEIGH_VAR_LOCKTIME] = 1 * HZ, |
| 102 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | }, |
| 104 | .gc_interval = 30 * HZ, |
| 105 | .gc_thresh1 = 128, |
| 106 | .gc_thresh2 = 512, |
| 107 | .gc_thresh3 = 1024, |
| 108 | }; |
| 109 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | static int dn_neigh_construct(struct neighbour *neigh) |
| 111 | { |
| 112 | struct net_device *dev = neigh->dev; |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 113 | struct dn_neigh *dn = container_of(neigh, struct dn_neigh, n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | struct dn_dev *dn_db; |
| 115 | struct neigh_parms *parms; |
| 116 | |
| 117 | rcu_read_lock(); |
| 118 | dn_db = rcu_dereference(dev->dn_ptr); |
| 119 | if (dn_db == NULL) { |
| 120 | rcu_read_unlock(); |
| 121 | return -EINVAL; |
| 122 | } |
| 123 | |
| 124 | parms = dn_db->neigh_parms; |
| 125 | if (!parms) { |
| 126 | rcu_read_unlock(); |
| 127 | return -EINVAL; |
| 128 | } |
| 129 | |
| 130 | __neigh_parms_put(neigh->parms); |
| 131 | neigh->parms = neigh_parms_clone(parms); |
Paul E. McKenney | 1f07247 | 2005-08-17 12:05:27 -0700 | [diff] [blame] | 132 | rcu_read_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 134 | neigh->ops = &dn_neigh_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | neigh->nud_state = NUD_NOARP; |
| 136 | neigh->output = neigh->ops->connected_output; |
| 137 | |
| 138 | if ((dev->type == ARPHRD_IPGRE) || (dev->flags & IFF_POINTOPOINT)) |
| 139 | memcpy(neigh->ha, dev->broadcast, dev->addr_len); |
| 140 | else if ((dev->type == ARPHRD_ETHER) || (dev->type == ARPHRD_LOOPBACK)) |
| 141 | dn_dn2eth(neigh->ha, dn->addr); |
| 142 | else { |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 143 | net_dbg_ratelimited("Trying to create neigh for hw %d\n", |
| 144 | dev->type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | return -EINVAL; |
| 146 | } |
| 147 | |
| 148 | /* |
| 149 | * Make an estimate of the remote block size by assuming that its |
| 150 | * two less then the device mtu, which it true for ethernet (and |
| 151 | * other things which support long format headers) since there is |
| 152 | * an extra length field (of 16 bits) which isn't part of the |
| 153 | * ethernet headers and which the DECnet specs won't admit is part |
| 154 | * of the DECnet routing headers either. |
| 155 | * |
| 156 | * If we over estimate here its no big deal, the NSP negotiations |
| 157 | * will prevent us from sending packets which are too large for the |
| 158 | * remote node to handle. In any case this figure is normally updated |
| 159 | * by a hello message in most cases. |
| 160 | */ |
| 161 | dn->blksize = dev->mtu - 2; |
| 162 | |
| 163 | return 0; |
| 164 | } |
| 165 | |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 166 | static void dn_neigh_error_report(struct neighbour *neigh, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | { |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 168 | printk(KERN_DEBUG "dn_neigh_error_report: called\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | kfree_skb(skb); |
| 170 | } |
| 171 | |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 172 | static int dn_neigh_output(struct neighbour *neigh, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | { |
Eric Dumazet | adf3090 | 2009-06-02 05:19:30 +0000 | [diff] [blame] | 174 | struct dst_entry *dst = skb_dst(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | struct dn_route *rt = (struct dn_route *)dst; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | struct net_device *dev = neigh->dev; |
| 177 | char mac_addr[ETH_ALEN]; |
David S. Miller | 3329bdf | 2012-02-01 16:34:25 -0500 | [diff] [blame] | 178 | unsigned int seq; |
| 179 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | |
| 181 | dn_dn2eth(mac_addr, rt->rt_local_src); |
David S. Miller | 3329bdf | 2012-02-01 16:34:25 -0500 | [diff] [blame] | 182 | do { |
| 183 | seq = read_seqbegin(&neigh->ha_lock); |
| 184 | err = dev_hard_header(skb, dev, ntohs(skb->protocol), |
| 185 | neigh->ha, mac_addr, skb->len); |
| 186 | } while (read_seqretry(&neigh->ha_lock, seq)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | |
David S. Miller | 3329bdf | 2012-02-01 16:34:25 -0500 | [diff] [blame] | 188 | if (err >= 0) |
| 189 | err = dev_queue_xmit(skb); |
| 190 | else { |
| 191 | kfree_skb(skb); |
| 192 | err = -EINVAL; |
| 193 | } |
| 194 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 197 | static int dn_neigh_output_packet(struct net *net, struct sock *sk, struct sk_buff *skb) |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 198 | { |
| 199 | struct dst_entry *dst = skb_dst(skb); |
| 200 | struct dn_route *rt = (struct dn_route *)dst; |
| 201 | struct neighbour *neigh = rt->n; |
| 202 | |
| 203 | return neigh->output(neigh, skb); |
| 204 | } |
| 205 | |
| 206 | /* |
| 207 | * For talking to broadcast devices: Ethernet & PPP |
| 208 | */ |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 209 | static int dn_long_output(struct neighbour *neigh, struct sock *sk, |
| 210 | struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | struct net_device *dev = neigh->dev; |
| 213 | int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3; |
| 214 | unsigned char *data; |
| 215 | struct dn_long_packet *lp; |
| 216 | struct dn_skb_cb *cb = DN_SKB_CB(skb); |
| 217 | |
| 218 | |
| 219 | if (skb_headroom(skb) < headroom) { |
| 220 | struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); |
| 221 | if (skb2 == NULL) { |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 222 | net_crit_ratelimited("dn_long_output: no memory\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | kfree_skb(skb); |
| 224 | return -ENOBUFS; |
| 225 | } |
Eric Dumazet | 5d0ba55 | 2012-06-04 01:17:19 +0000 | [diff] [blame] | 226 | consume_skb(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | skb = skb2; |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 228 | net_info_ratelimited("dn_long_output: Increasing headroom\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | data = skb_push(skb, sizeof(struct dn_long_packet) + 3); |
| 232 | lp = (struct dn_long_packet *)(data+3); |
| 233 | |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 234 | *((__le16 *)data) = cpu_to_le16(skb->len - 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | *(data + 2) = 1 | DN_RT_F_PF; /* Padding */ |
| 236 | |
| 237 | lp->msgflg = DN_RT_PKT_LONG|(cb->rt_flags&(DN_RT_F_IE|DN_RT_F_RQR|DN_RT_F_RTS)); |
| 238 | lp->d_area = lp->d_subarea = 0; |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 239 | dn_dn2eth(lp->d_id, cb->dst); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | lp->s_area = lp->s_subarea = 0; |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 241 | dn_dn2eth(lp->s_id, cb->src); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | lp->nl2 = 0; |
| 243 | lp->visit_ct = cb->hops & 0x3f; |
| 244 | lp->s_class = 0; |
| 245 | lp->pt = 0; |
| 246 | |
Arnaldo Carvalho de Melo | c1d2bbe | 2007-04-10 20:45:18 -0700 | [diff] [blame] | 247 | skb_reset_network_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 249 | return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, |
| 250 | &init_net, sk, skb, NULL, neigh->dev, |
| 251 | dn_neigh_output_packet); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | } |
| 253 | |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 254 | /* |
| 255 | * For talking to pointopoint and multidrop devices: DDCMP and X.25 |
| 256 | */ |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 257 | static int dn_short_output(struct neighbour *neigh, struct sock *sk, |
| 258 | struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | struct net_device *dev = neigh->dev; |
| 261 | int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2; |
| 262 | struct dn_short_packet *sp; |
| 263 | unsigned char *data; |
| 264 | struct dn_skb_cb *cb = DN_SKB_CB(skb); |
| 265 | |
| 266 | |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 267 | if (skb_headroom(skb) < headroom) { |
| 268 | struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); |
| 269 | if (skb2 == NULL) { |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 270 | net_crit_ratelimited("dn_short_output: no memory\n"); |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 271 | kfree_skb(skb); |
| 272 | return -ENOBUFS; |
| 273 | } |
Eric Dumazet | 5d0ba55 | 2012-06-04 01:17:19 +0000 | [diff] [blame] | 274 | consume_skb(skb); |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 275 | skb = skb2; |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 276 | net_info_ratelimited("dn_short_output: Increasing headroom\n"); |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 277 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | |
| 279 | data = skb_push(skb, sizeof(struct dn_short_packet) + 2); |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 280 | *((__le16 *)data) = cpu_to_le16(skb->len - 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | sp = (struct dn_short_packet *)(data+2); |
| 282 | |
| 283 | sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS)); |
| 284 | sp->dstnode = cb->dst; |
| 285 | sp->srcnode = cb->src; |
| 286 | sp->forward = cb->hops & 0x3f; |
| 287 | |
Arnaldo Carvalho de Melo | c1d2bbe | 2007-04-10 20:45:18 -0700 | [diff] [blame] | 288 | skb_reset_network_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 290 | return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, |
| 291 | &init_net, sk, skb, NULL, neigh->dev, |
| 292 | dn_neigh_output_packet); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | /* |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 296 | * For talking to DECnet phase III nodes |
| 297 | * Phase 3 output is the same as short output, execpt that |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | * it clears the area bits before transmission. |
| 299 | */ |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 300 | static int dn_phase3_output(struct neighbour *neigh, struct sock *sk, |
| 301 | struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | struct net_device *dev = neigh->dev; |
| 304 | int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2; |
| 305 | struct dn_short_packet *sp; |
| 306 | unsigned char *data; |
| 307 | struct dn_skb_cb *cb = DN_SKB_CB(skb); |
| 308 | |
| 309 | if (skb_headroom(skb) < headroom) { |
| 310 | struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); |
| 311 | if (skb2 == NULL) { |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 312 | net_crit_ratelimited("dn_phase3_output: no memory\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | kfree_skb(skb); |
| 314 | return -ENOBUFS; |
| 315 | } |
Eric Dumazet | 5d0ba55 | 2012-06-04 01:17:19 +0000 | [diff] [blame] | 316 | consume_skb(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | skb = skb2; |
Joe Perches | e87cc47 | 2012-05-13 21:56:26 +0000 | [diff] [blame] | 318 | net_info_ratelimited("dn_phase3_output: Increasing headroom\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | data = skb_push(skb, sizeof(struct dn_short_packet) + 2); |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 322 | *((__le16 *)data) = cpu_to_le16(skb->len - 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | sp = (struct dn_short_packet *)(data + 2); |
| 324 | |
| 325 | sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS)); |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 326 | sp->dstnode = cb->dst & cpu_to_le16(0x03ff); |
| 327 | sp->srcnode = cb->src & cpu_to_le16(0x03ff); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | sp->forward = cb->hops & 0x3f; |
| 329 | |
Arnaldo Carvalho de Melo | c1d2bbe | 2007-04-10 20:45:18 -0700 | [diff] [blame] | 330 | skb_reset_network_header(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 332 | return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, |
| 333 | &init_net, sk, skb, NULL, neigh->dev, |
| 334 | dn_neigh_output_packet); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | } |
| 336 | |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 337 | int dn_to_neigh_output(struct net *net, struct sock *sk, struct sk_buff *skb) |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 338 | { |
| 339 | struct dst_entry *dst = skb_dst(skb); |
| 340 | struct dn_route *rt = (struct dn_route *) dst; |
| 341 | struct neighbour *neigh = rt->n; |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 342 | struct dn_neigh *dn = container_of(neigh, struct dn_neigh, n); |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 343 | struct dn_dev *dn_db; |
| 344 | bool use_long; |
| 345 | |
| 346 | rcu_read_lock(); |
| 347 | dn_db = rcu_dereference(neigh->dev->dn_ptr); |
| 348 | if (dn_db == NULL) { |
| 349 | rcu_read_unlock(); |
| 350 | return -EINVAL; |
| 351 | } |
| 352 | use_long = dn_db->use_long; |
| 353 | rcu_read_unlock(); |
| 354 | |
| 355 | if (dn->flags & DN_NDFLAG_P3) |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 356 | return dn_phase3_output(neigh, sk, skb); |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 357 | if (use_long) |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 358 | return dn_long_output(neigh, sk, skb); |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 359 | else |
David Miller | 7026b1d | 2015-04-05 22:19:04 -0400 | [diff] [blame] | 360 | return dn_short_output(neigh, sk, skb); |
Eric W. Biederman | aaa4e70 | 2015-03-04 10:16:43 -0600 | [diff] [blame] | 361 | } |
| 362 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | /* |
| 364 | * Unfortunately, the neighbour code uses the device in its hash |
| 365 | * function, so we don't get any advantage from it. This function |
| 366 | * basically does a neigh_lookup(), but without comparing the device |
| 367 | * field. This is required for the On-Ethernet cache |
| 368 | */ |
| 369 | |
| 370 | /* |
| 371 | * Pointopoint link receives a hello message |
| 372 | */ |
| 373 | void dn_neigh_pointopoint_hello(struct sk_buff *skb) |
| 374 | { |
| 375 | kfree_skb(skb); |
| 376 | } |
| 377 | |
| 378 | /* |
| 379 | * Ethernet router hello message received |
| 380 | */ |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 381 | int dn_neigh_router_hello(struct net *net, struct sock *sk, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 382 | { |
| 383 | struct rtnode_hello_message *msg = (struct rtnode_hello_message *)skb->data; |
| 384 | |
| 385 | struct neighbour *neigh; |
| 386 | struct dn_neigh *dn; |
| 387 | struct dn_dev *dn_db; |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 388 | __le16 src; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 390 | src = dn_eth2dn(msg->id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | |
| 392 | neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1); |
| 393 | |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 394 | dn = container_of(neigh, struct dn_neigh, n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | |
| 396 | if (neigh) { |
| 397 | write_lock(&neigh->lock); |
| 398 | |
| 399 | neigh->used = jiffies; |
Eric Dumazet | fc766e4c | 2010-10-29 03:09:24 +0000 | [diff] [blame] | 400 | dn_db = rcu_dereference(neigh->dev->dn_ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | |
| 402 | if (!(neigh->nud_state & NUD_PERMANENT)) { |
| 403 | neigh->updated = jiffies; |
| 404 | |
| 405 | if (neigh->dev->type == ARPHRD_ETHER) |
| 406 | memcpy(neigh->ha, ð_hdr(skb)->h_source, ETH_ALEN); |
| 407 | |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 408 | dn->blksize = le16_to_cpu(msg->blksize); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | dn->priority = msg->priority; |
| 410 | |
| 411 | dn->flags &= ~DN_NDFLAG_P3; |
| 412 | |
Joe Perches | 06f8fe1 | 2011-07-01 09:43:03 +0000 | [diff] [blame] | 413 | switch (msg->iinfo & DN_RT_INFO_TYPE) { |
| 414 | case DN_RT_INFO_L1RT: |
| 415 | dn->flags &=~DN_NDFLAG_R2; |
| 416 | dn->flags |= DN_NDFLAG_R1; |
| 417 | break; |
| 418 | case DN_RT_INFO_L2RT: |
| 419 | dn->flags |= DN_NDFLAG_R2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | } |
| 421 | } |
| 422 | |
Patrick Caulfield | 5062430 | 2006-01-03 14:24:02 -0800 | [diff] [blame] | 423 | /* Only use routers in our area */ |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 424 | if ((le16_to_cpu(src)>>10) == (le16_to_cpu((decnet_address))>>10)) { |
Patrick Caulfield | 5062430 | 2006-01-03 14:24:02 -0800 | [diff] [blame] | 425 | if (!dn_db->router) { |
| 426 | dn_db->router = neigh_clone(neigh); |
| 427 | } else { |
| 428 | if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority) |
| 429 | neigh_release(xchg(&dn_db->router, neigh_clone(neigh))); |
| 430 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | } |
| 432 | write_unlock(&neigh->lock); |
| 433 | neigh_release(neigh); |
| 434 | } |
| 435 | |
| 436 | kfree_skb(skb); |
| 437 | return 0; |
| 438 | } |
| 439 | |
| 440 | /* |
| 441 | * Endnode hello message received |
| 442 | */ |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 443 | int dn_neigh_endnode_hello(struct net *net, struct sock *sk, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | { |
| 445 | struct endnode_hello_message *msg = (struct endnode_hello_message *)skb->data; |
| 446 | struct neighbour *neigh; |
| 447 | struct dn_neigh *dn; |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 448 | __le16 src; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 450 | src = dn_eth2dn(msg->id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | |
| 452 | neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1); |
| 453 | |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 454 | dn = container_of(neigh, struct dn_neigh, n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | |
| 456 | if (neigh) { |
| 457 | write_lock(&neigh->lock); |
| 458 | |
| 459 | neigh->used = jiffies; |
| 460 | |
| 461 | if (!(neigh->nud_state & NUD_PERMANENT)) { |
| 462 | neigh->updated = jiffies; |
| 463 | |
| 464 | if (neigh->dev->type == ARPHRD_ETHER) |
| 465 | memcpy(neigh->ha, ð_hdr(skb)->h_source, ETH_ALEN); |
| 466 | dn->flags &= ~(DN_NDFLAG_R1 | DN_NDFLAG_R2); |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 467 | dn->blksize = le16_to_cpu(msg->blksize); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | dn->priority = 0; |
| 469 | } |
| 470 | |
| 471 | write_unlock(&neigh->lock); |
| 472 | neigh_release(neigh); |
| 473 | } |
| 474 | |
| 475 | kfree_skb(skb); |
| 476 | return 0; |
| 477 | } |
| 478 | |
| 479 | static char *dn_find_slot(char *base, int max, int priority) |
| 480 | { |
| 481 | int i; |
| 482 | unsigned char *min = NULL; |
| 483 | |
| 484 | base += 6; /* skip first id */ |
| 485 | |
| 486 | for(i = 0; i < max; i++) { |
| 487 | if (!min || (*base < *min)) |
| 488 | min = base; |
| 489 | base += 7; /* find next priority */ |
| 490 | } |
| 491 | |
| 492 | if (!min) |
| 493 | return NULL; |
| 494 | |
| 495 | return (*min < priority) ? (min - 6) : NULL; |
| 496 | } |
| 497 | |
| 498 | struct elist_cb_state { |
| 499 | struct net_device *dev; |
| 500 | unsigned char *ptr; |
| 501 | unsigned char *rs; |
| 502 | int t, n; |
| 503 | }; |
| 504 | |
| 505 | static void neigh_elist_cb(struct neighbour *neigh, void *_info) |
| 506 | { |
| 507 | struct elist_cb_state *s = _info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 508 | struct dn_neigh *dn; |
| 509 | |
| 510 | if (neigh->dev != s->dev) |
| 511 | return; |
| 512 | |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 513 | dn = container_of(neigh, struct dn_neigh, n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | if (!(dn->flags & (DN_NDFLAG_R1|DN_NDFLAG_R2))) |
| 515 | return; |
| 516 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 517 | if (s->t == s->n) |
| 518 | s->rs = dn_find_slot(s->ptr, s->n, dn->priority); |
| 519 | else |
| 520 | s->t++; |
| 521 | if (s->rs == NULL) |
| 522 | return; |
| 523 | |
| 524 | dn_dn2eth(s->rs, dn->addr); |
| 525 | s->rs += 6; |
| 526 | *(s->rs) = neigh->nud_state & NUD_CONNECTED ? 0x80 : 0x0; |
| 527 | *(s->rs) |= dn->priority; |
| 528 | s->rs++; |
| 529 | } |
| 530 | |
| 531 | int dn_neigh_elist(struct net_device *dev, unsigned char *ptr, int n) |
| 532 | { |
| 533 | struct elist_cb_state state; |
| 534 | |
| 535 | state.dev = dev; |
| 536 | state.t = 0; |
| 537 | state.n = n; |
| 538 | state.ptr = ptr; |
| 539 | state.rs = ptr; |
| 540 | |
| 541 | neigh_for_each(&dn_neigh_table, neigh_elist_cb, &state); |
| 542 | |
| 543 | return state.t; |
| 544 | } |
| 545 | |
| 546 | |
| 547 | #ifdef CONFIG_PROC_FS |
| 548 | |
| 549 | static inline void dn_neigh_format_entry(struct seq_file *seq, |
| 550 | struct neighbour *n) |
| 551 | { |
Kees Cook | f92ceb0 | 2017-05-08 15:31:44 -0700 | [diff] [blame] | 552 | struct dn_neigh *dn = container_of(n, struct dn_neigh, n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | char buf[DN_ASCBUF_LEN]; |
| 554 | |
| 555 | read_lock(&n->lock); |
| 556 | seq_printf(seq, "%-7s %s%s%s %02x %02d %07ld %-8s\n", |
Harvey Harrison | c4106aa | 2008-11-27 00:12:47 -0800 | [diff] [blame] | 557 | dn_addr2asc(le16_to_cpu(dn->addr), buf), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | (dn->flags&DN_NDFLAG_R1) ? "1" : "-", |
| 559 | (dn->flags&DN_NDFLAG_R2) ? "2" : "-", |
| 560 | (dn->flags&DN_NDFLAG_P3) ? "3" : "-", |
| 561 | dn->n.nud_state, |
| 562 | atomic_read(&dn->n.refcnt), |
| 563 | dn->blksize, |
| 564 | (dn->n.dev) ? dn->n.dev->name : "?"); |
| 565 | read_unlock(&n->lock); |
| 566 | } |
| 567 | |
| 568 | static int dn_neigh_seq_show(struct seq_file *seq, void *v) |
| 569 | { |
| 570 | if (v == SEQ_START_TOKEN) { |
| 571 | seq_puts(seq, "Addr Flags State Use Blksize Dev\n"); |
| 572 | } else { |
| 573 | dn_neigh_format_entry(seq, v); |
| 574 | } |
| 575 | |
| 576 | return 0; |
| 577 | } |
| 578 | |
| 579 | static void *dn_neigh_seq_start(struct seq_file *seq, loff_t *pos) |
| 580 | { |
| 581 | return neigh_seq_start(seq, pos, &dn_neigh_table, |
| 582 | NEIGH_SEQ_NEIGH_ONLY); |
| 583 | } |
| 584 | |
Philippe De Muyter | 56b3d97 | 2007-07-10 23:07:31 -0700 | [diff] [blame] | 585 | static const struct seq_operations dn_neigh_seq_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 586 | .start = dn_neigh_seq_start, |
| 587 | .next = neigh_seq_next, |
| 588 | .stop = neigh_seq_stop, |
| 589 | .show = dn_neigh_seq_show, |
| 590 | }; |
| 591 | |
| 592 | static int dn_neigh_seq_open(struct inode *inode, struct file *file) |
| 593 | { |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 594 | return seq_open_net(inode, file, &dn_neigh_seq_ops, |
| 595 | sizeof(struct neigh_seq_state)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 596 | } |
| 597 | |
Arjan van de Ven | 9a32144 | 2007-02-12 00:55:35 -0800 | [diff] [blame] | 598 | static const struct file_operations dn_neigh_seq_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | .owner = THIS_MODULE, |
| 600 | .open = dn_neigh_seq_open, |
| 601 | .read = seq_read, |
| 602 | .llseek = seq_lseek, |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 603 | .release = seq_release_net, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | }; |
| 605 | |
| 606 | #endif |
| 607 | |
| 608 | void __init dn_neigh_init(void) |
| 609 | { |
WANG Cong | d7480fd | 2014-11-10 15:59:36 -0800 | [diff] [blame] | 610 | neigh_table_init(NEIGH_DN_TABLE, &dn_neigh_table); |
Gao feng | d4beaa6 | 2013-02-18 01:34:54 +0000 | [diff] [blame] | 611 | proc_create("decnet_neigh", S_IRUGO, init_net.proc_net, |
| 612 | &dn_neigh_seq_fops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 613 | } |
| 614 | |
| 615 | void __exit dn_neigh_cleanup(void) |
| 616 | { |
Gao feng | ece31ff | 2013-02-18 01:34:56 +0000 | [diff] [blame] | 617 | remove_proc_entry("decnet_neigh", init_net.proc_net); |
WANG Cong | d7480fd | 2014-11-10 15:59:36 -0800 | [diff] [blame] | 618 | neigh_table_clear(NEIGH_DN_TABLE, &dn_neigh_table); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 619 | } |