1 // SPDX-License-Identifier: GPL-2.0-or-later 1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* 2 /*
3 * 3 *
4 * Copyright Jonathan Naylor G4KLX (g4klx@g4kl 4 * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
5 */ 5 */
6 #include <linux/module.h> 6 #include <linux/module.h>
7 #include <linux/proc_fs.h> 7 #include <linux/proc_fs.h>
8 #include <linux/kernel.h> 8 #include <linux/kernel.h>
9 #include <linux/interrupt.h> 9 #include <linux/interrupt.h>
10 #include <linux/fs.h> 10 #include <linux/fs.h>
11 #include <linux/types.h> 11 #include <linux/types.h>
12 #include <linux/sysctl.h> 12 #include <linux/sysctl.h>
13 #include <linux/string.h> 13 #include <linux/string.h>
14 #include <linux/socket.h> 14 #include <linux/socket.h>
15 #include <linux/errno.h> 15 #include <linux/errno.h>
16 #include <linux/fcntl.h> 16 #include <linux/fcntl.h>
17 #include <linux/in.h> 17 #include <linux/in.h>
18 #include <linux/if_ether.h> /* For the sta 18 #include <linux/if_ether.h> /* For the statistics structure. */
19 #include <linux/slab.h> 19 #include <linux/slab.h>
20 #include <linux/uaccess.h> 20 #include <linux/uaccess.h>
21 21
22 #include <asm/io.h> 22 #include <asm/io.h>
23 23
24 #include <linux/inet.h> 24 #include <linux/inet.h>
25 #include <linux/netdevice.h> 25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h> 26 #include <linux/etherdevice.h>
27 #include <linux/if_arp.h> 27 #include <linux/if_arp.h>
28 #include <linux/skbuff.h> 28 #include <linux/skbuff.h>
29 29
30 #include <net/ip.h> 30 #include <net/ip.h>
31 #include <net/arp.h> 31 #include <net/arp.h>
32 32
33 #include <net/ax25.h> 33 #include <net/ax25.h>
34 #include <net/netrom.h> 34 #include <net/netrom.h>
35 35
36 /* 36 /*
37 * Only allow IP over NET/ROM frames thro 37 * Only allow IP over NET/ROM frames through if the netrom device is up.
38 */ 38 */
39 39
40 int nr_rx_ip(struct sk_buff *skb, struct net_d 40 int nr_rx_ip(struct sk_buff *skb, struct net_device *dev)
41 { 41 {
42 struct net_device_stats *stats = &dev- 42 struct net_device_stats *stats = &dev->stats;
43 43
44 if (!netif_running(dev)) { 44 if (!netif_running(dev)) {
45 stats->rx_dropped++; 45 stats->rx_dropped++;
46 return 0; 46 return 0;
47 } 47 }
48 48
49 stats->rx_packets++; 49 stats->rx_packets++;
50 stats->rx_bytes += skb->len; 50 stats->rx_bytes += skb->len;
51 51
52 skb->protocol = htons(ETH_P_IP); 52 skb->protocol = htons(ETH_P_IP);
53 53
54 /* Spoof incoming device */ 54 /* Spoof incoming device */
55 skb->dev = dev; 55 skb->dev = dev;
56 skb->mac_header = skb->network_header; 56 skb->mac_header = skb->network_header;
57 skb_reset_network_header(skb); 57 skb_reset_network_header(skb);
58 skb->pkt_type = PACKET_HOST; 58 skb->pkt_type = PACKET_HOST;
59 59
60 netif_rx(skb); 60 netif_rx(skb);
61 61
62 return 1; 62 return 1;
63 } 63 }
64 64
65 static int nr_header(struct sk_buff *skb, stru 65 static int nr_header(struct sk_buff *skb, struct net_device *dev,
66 unsigned short type, 66 unsigned short type,
67 const void *daddr, const 67 const void *daddr, const void *saddr, unsigned int len)
68 { 68 {
69 unsigned char *buff = skb_push(skb, NR 69 unsigned char *buff = skb_push(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
70 70
71 memcpy(buff, (saddr != NULL) ? saddr : 71 memcpy(buff, (saddr != NULL) ? saddr : dev->dev_addr, dev->addr_len);
72 buff[6] &= ~AX25_CBIT; 72 buff[6] &= ~AX25_CBIT;
73 buff[6] &= ~AX25_EBIT; 73 buff[6] &= ~AX25_EBIT;
74 buff[6] |= AX25_SSSID_SPARE; 74 buff[6] |= AX25_SSSID_SPARE;
75 buff += AX25_ADDR_LEN; 75 buff += AX25_ADDR_LEN;
76 76
77 if (daddr != NULL) 77 if (daddr != NULL)
78 memcpy(buff, daddr, dev->addr_ 78 memcpy(buff, daddr, dev->addr_len);
79 buff[6] &= ~AX25_CBIT; 79 buff[6] &= ~AX25_CBIT;
80 buff[6] |= AX25_EBIT; 80 buff[6] |= AX25_EBIT;
81 buff[6] |= AX25_SSSID_SPARE; 81 buff[6] |= AX25_SSSID_SPARE;
82 buff += AX25_ADDR_LEN; 82 buff += AX25_ADDR_LEN;
83 83
84 *buff++ = READ_ONCE(sysctl_netrom_netw !! 84 *buff++ = sysctl_netrom_network_ttl_initialiser;
85 85
86 *buff++ = NR_PROTO_IP; 86 *buff++ = NR_PROTO_IP;
87 *buff++ = NR_PROTO_IP; 87 *buff++ = NR_PROTO_IP;
88 *buff++ = 0; 88 *buff++ = 0;
89 *buff++ = 0; 89 *buff++ = 0;
90 *buff++ = NR_PROTOEXT; 90 *buff++ = NR_PROTOEXT;
91 91
92 if (daddr != NULL) 92 if (daddr != NULL)
93 return 37; 93 return 37;
94 94
95 return -37; 95 return -37;
96 } 96 }
97 97
98 static int __must_check nr_set_mac_address(str 98 static int __must_check nr_set_mac_address(struct net_device *dev, void *addr)
99 { 99 {
100 struct sockaddr *sa = addr; 100 struct sockaddr *sa = addr;
101 int err; 101 int err;
102 102
103 if (!memcmp(dev->dev_addr, sa->sa_data 103 if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
104 return 0; 104 return 0;
105 105
106 if (dev->flags & IFF_UP) { 106 if (dev->flags & IFF_UP) {
107 err = ax25_listen_register((ax 107 err = ax25_listen_register((ax25_address *)sa->sa_data, NULL);
108 if (err) 108 if (err)
109 return err; 109 return err;
110 110
111 ax25_listen_release((const ax2 !! 111 ax25_listen_release((ax25_address *)dev->dev_addr, NULL);
112 } 112 }
113 113
114 dev_addr_set(dev, sa->sa_data); !! 114 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
115 115
116 return 0; 116 return 0;
117 } 117 }
118 118
119 static int nr_open(struct net_device *dev) 119 static int nr_open(struct net_device *dev)
120 { 120 {
121 int err; 121 int err;
122 122
123 err = ax25_listen_register((const ax25 !! 123 err = ax25_listen_register((ax25_address *)dev->dev_addr, NULL);
124 if (err) 124 if (err)
125 return err; 125 return err;
126 126
127 netif_start_queue(dev); 127 netif_start_queue(dev);
128 128
129 return 0; 129 return 0;
130 } 130 }
131 131
132 static int nr_close(struct net_device *dev) 132 static int nr_close(struct net_device *dev)
133 { 133 {
134 ax25_listen_release((const ax25_addres !! 134 ax25_listen_release((ax25_address *)dev->dev_addr, NULL);
135 netif_stop_queue(dev); 135 netif_stop_queue(dev);
136 return 0; 136 return 0;
137 } 137 }
138 138
139 static netdev_tx_t nr_xmit(struct sk_buff *skb 139 static netdev_tx_t nr_xmit(struct sk_buff *skb, struct net_device *dev)
140 { 140 {
141 struct net_device_stats *stats = &dev- 141 struct net_device_stats *stats = &dev->stats;
142 unsigned int len = skb->len; 142 unsigned int len = skb->len;
143 143
144 if (!nr_route_frame(skb, NULL)) { 144 if (!nr_route_frame(skb, NULL)) {
145 kfree_skb(skb); 145 kfree_skb(skb);
146 stats->tx_errors++; 146 stats->tx_errors++;
147 return NETDEV_TX_OK; 147 return NETDEV_TX_OK;
148 } 148 }
149 149
150 stats->tx_packets++; 150 stats->tx_packets++;
151 stats->tx_bytes += len; 151 stats->tx_bytes += len;
152 152
153 return NETDEV_TX_OK; 153 return NETDEV_TX_OK;
154 } 154 }
155 155
156 static const struct header_ops nr_header_ops = 156 static const struct header_ops nr_header_ops = {
157 .create = nr_header, 157 .create = nr_header,
158 }; 158 };
159 159
160 static const struct net_device_ops nr_netdev_o 160 static const struct net_device_ops nr_netdev_ops = {
161 .ndo_open = nr_open, 161 .ndo_open = nr_open,
162 .ndo_stop = nr_close, 162 .ndo_stop = nr_close,
163 .ndo_start_xmit = nr_xmit, 163 .ndo_start_xmit = nr_xmit,
164 .ndo_set_mac_address = nr_set_mac_a 164 .ndo_set_mac_address = nr_set_mac_address,
165 }; 165 };
166 166
167 void nr_setup(struct net_device *dev) 167 void nr_setup(struct net_device *dev)
168 { 168 {
169 dev->mtu = NR_MAX_PACKE 169 dev->mtu = NR_MAX_PACKET_SIZE;
170 dev->netdev_ops = &nr_netdev_o 170 dev->netdev_ops = &nr_netdev_ops;
171 dev->header_ops = &nr_header_o 171 dev->header_ops = &nr_header_ops;
172 dev->hard_header_len = NR_NETWORK_L 172 dev->hard_header_len = NR_NETWORK_LEN + NR_TRANSPORT_LEN;
173 dev->addr_len = AX25_ADDR_LE 173 dev->addr_len = AX25_ADDR_LEN;
174 dev->type = ARPHRD_NETRO 174 dev->type = ARPHRD_NETROM;
175 175
176 /* New-style flags. */ 176 /* New-style flags. */
177 dev->flags = IFF_NOARP; 177 dev->flags = IFF_NOARP;
178 } 178 }
179 179
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.