1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * |
4 | * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk) |
5 | */ |
6 | #include <linux/errno.h> |
7 | #include <linux/types.h> |
8 | #include <linux/socket.h> |
9 | #include <linux/in.h> |
10 | #include <linux/kernel.h> |
11 | #include <linux/module.h> |
12 | #include <linux/timer.h> |
13 | #include <linux/string.h> |
14 | #include <linux/sockios.h> |
15 | #include <linux/net.h> |
16 | #include <net/ax25.h> |
17 | #include <linux/inet.h> |
18 | #include <linux/netdevice.h> |
19 | #include <linux/skbuff.h> |
20 | #include <net/sock.h> |
21 | #include <linux/uaccess.h> |
22 | #include <linux/fcntl.h> |
23 | #include <linux/mm.h> |
24 | #include <linux/interrupt.h> |
25 | |
26 | /* |
27 | * The default broadcast address of an interface is QST-0; the default address |
28 | * is LINUX-1. The null address is defined as a callsign of all spaces with |
29 | * an SSID of zero. |
30 | */ |
31 | |
32 | const ax25_address ax25_bcast = |
33 | {{'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, 0 << 1}}; |
34 | const ax25_address ax25_defaddr = |
35 | {{'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, 1 << 1}}; |
36 | const ax25_address null_ax25_address = |
37 | {{' ' << 1, ' ' << 1, ' ' << 1, ' ' << 1, ' ' << 1, ' ' << 1, 0 << 1}}; |
38 | |
39 | EXPORT_SYMBOL_GPL(ax25_bcast); |
40 | EXPORT_SYMBOL_GPL(ax25_defaddr); |
41 | EXPORT_SYMBOL(null_ax25_address); |
42 | |
43 | /* |
44 | * ax25 -> ascii conversion |
45 | */ |
46 | char *ax2asc(char *buf, const ax25_address *a) |
47 | { |
48 | char c, *s; |
49 | int n; |
50 | |
51 | for (n = 0, s = buf; n < 6; n++) { |
52 | c = (a->ax25_call[n] >> 1) & 0x7F; |
53 | |
54 | if (c != ' ') *s++ = c; |
55 | } |
56 | |
57 | *s++ = '-'; |
58 | |
59 | if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) { |
60 | *s++ = '1'; |
61 | n -= 10; |
62 | } |
63 | |
64 | *s++ = n + '0'; |
65 | *s++ = '\0'; |
66 | |
67 | if (*buf == '\0' || *buf == '-') |
68 | return "*" ; |
69 | |
70 | return buf; |
71 | |
72 | } |
73 | |
74 | EXPORT_SYMBOL(ax2asc); |
75 | |
76 | /* |
77 | * ascii -> ax25 conversion |
78 | */ |
79 | void asc2ax(ax25_address *addr, const char *callsign) |
80 | { |
81 | const char *s; |
82 | int n; |
83 | |
84 | for (s = callsign, n = 0; n < 6; n++) { |
85 | if (*s != '\0' && *s != '-') |
86 | addr->ax25_call[n] = *s++; |
87 | else |
88 | addr->ax25_call[n] = ' '; |
89 | addr->ax25_call[n] <<= 1; |
90 | addr->ax25_call[n] &= 0xFE; |
91 | } |
92 | |
93 | if (*s++ == '\0') { |
94 | addr->ax25_call[6] = 0x00; |
95 | return; |
96 | } |
97 | |
98 | addr->ax25_call[6] = *s++ - '0'; |
99 | |
100 | if (*s != '\0') { |
101 | addr->ax25_call[6] *= 10; |
102 | addr->ax25_call[6] += *s++ - '0'; |
103 | } |
104 | |
105 | addr->ax25_call[6] <<= 1; |
106 | addr->ax25_call[6] &= 0x1E; |
107 | } |
108 | |
109 | EXPORT_SYMBOL(asc2ax); |
110 | |
111 | /* |
112 | * Compare two ax.25 addresses |
113 | */ |
114 | int ax25cmp(const ax25_address *a, const ax25_address *b) |
115 | { |
116 | int ct = 0; |
117 | |
118 | while (ct < 6) { |
119 | if ((a->ax25_call[ct] & 0xFE) != (b->ax25_call[ct] & 0xFE)) /* Clean off repeater bits */ |
120 | return 1; |
121 | ct++; |
122 | } |
123 | |
124 | if ((a->ax25_call[ct] & 0x1E) == (b->ax25_call[ct] & 0x1E)) /* SSID without control bit */ |
125 | return 0; |
126 | |
127 | return 2; /* Partial match */ |
128 | } |
129 | |
130 | EXPORT_SYMBOL(ax25cmp); |
131 | |
132 | /* |
133 | * Compare two AX.25 digipeater paths. |
134 | */ |
135 | int ax25digicmp(const ax25_digi *digi1, const ax25_digi *digi2) |
136 | { |
137 | int i; |
138 | |
139 | if (digi1->ndigi != digi2->ndigi) |
140 | return 1; |
141 | |
142 | if (digi1->lastrepeat != digi2->lastrepeat) |
143 | return 1; |
144 | |
145 | for (i = 0; i < digi1->ndigi; i++) |
146 | if (ax25cmp(&digi1->calls[i], &digi2->calls[i]) != 0) |
147 | return 1; |
148 | |
149 | return 0; |
150 | } |
151 | |
152 | /* |
153 | * Given an AX.25 address pull of to, from, digi list, command/response and the start of data |
154 | * |
155 | */ |
156 | const unsigned char *ax25_addr_parse(const unsigned char *buf, int len, |
157 | ax25_address *src, ax25_address *dest, ax25_digi *digi, int *flags, |
158 | int *dama) |
159 | { |
160 | int d = 0; |
161 | |
162 | if (len < 14) return NULL; |
163 | |
164 | if (flags != NULL) { |
165 | *flags = 0; |
166 | |
167 | if (buf[6] & AX25_CBIT) |
168 | *flags = AX25_COMMAND; |
169 | if (buf[13] & AX25_CBIT) |
170 | *flags = AX25_RESPONSE; |
171 | } |
172 | |
173 | if (dama != NULL) |
174 | *dama = ~buf[13] & AX25_DAMA_FLAG; |
175 | |
176 | /* Copy to, from */ |
177 | if (dest != NULL) |
178 | memcpy(dest, buf + 0, AX25_ADDR_LEN); |
179 | if (src != NULL) |
180 | memcpy(src, buf + 7, AX25_ADDR_LEN); |
181 | |
182 | buf += 2 * AX25_ADDR_LEN; |
183 | len -= 2 * AX25_ADDR_LEN; |
184 | |
185 | digi->lastrepeat = -1; |
186 | digi->ndigi = 0; |
187 | |
188 | while (!(buf[-1] & AX25_EBIT)) { |
189 | if (d >= AX25_MAX_DIGIS) |
190 | return NULL; |
191 | if (len < AX25_ADDR_LEN) |
192 | return NULL; |
193 | |
194 | memcpy(&digi->calls[d], buf, AX25_ADDR_LEN); |
195 | digi->ndigi = d + 1; |
196 | |
197 | if (buf[6] & AX25_HBIT) { |
198 | digi->repeated[d] = 1; |
199 | digi->lastrepeat = d; |
200 | } else { |
201 | digi->repeated[d] = 0; |
202 | } |
203 | |
204 | buf += AX25_ADDR_LEN; |
205 | len -= AX25_ADDR_LEN; |
206 | d++; |
207 | } |
208 | |
209 | return buf; |
210 | } |
211 | |
212 | /* |
213 | * Assemble an AX.25 header from the bits |
214 | */ |
215 | int ax25_addr_build(unsigned char *buf, const ax25_address *src, |
216 | const ax25_address *dest, const ax25_digi *d, int flag, int modulus) |
217 | { |
218 | int len = 0; |
219 | int ct = 0; |
220 | |
221 | memcpy(buf, dest, AX25_ADDR_LEN); |
222 | buf[6] &= ~(AX25_EBIT | AX25_CBIT); |
223 | buf[6] |= AX25_SSSID_SPARE; |
224 | |
225 | if (flag == AX25_COMMAND) buf[6] |= AX25_CBIT; |
226 | |
227 | buf += AX25_ADDR_LEN; |
228 | len += AX25_ADDR_LEN; |
229 | |
230 | memcpy(buf, src, AX25_ADDR_LEN); |
231 | buf[6] &= ~(AX25_EBIT | AX25_CBIT); |
232 | buf[6] &= ~AX25_SSSID_SPARE; |
233 | |
234 | if (modulus == AX25_MODULUS) |
235 | buf[6] |= AX25_SSSID_SPARE; |
236 | else |
237 | buf[6] |= AX25_ESSID_SPARE; |
238 | |
239 | if (flag == AX25_RESPONSE) buf[6] |= AX25_CBIT; |
240 | |
241 | /* |
242 | * Fast path the normal digiless path |
243 | */ |
244 | if (d == NULL || d->ndigi == 0) { |
245 | buf[6] |= AX25_EBIT; |
246 | return 2 * AX25_ADDR_LEN; |
247 | } |
248 | |
249 | buf += AX25_ADDR_LEN; |
250 | len += AX25_ADDR_LEN; |
251 | |
252 | while (ct < d->ndigi) { |
253 | memcpy(buf, &d->calls[ct], AX25_ADDR_LEN); |
254 | |
255 | if (d->repeated[ct]) |
256 | buf[6] |= AX25_HBIT; |
257 | else |
258 | buf[6] &= ~AX25_HBIT; |
259 | |
260 | buf[6] &= ~AX25_EBIT; |
261 | buf[6] |= AX25_SSSID_SPARE; |
262 | |
263 | buf += AX25_ADDR_LEN; |
264 | len += AX25_ADDR_LEN; |
265 | ct++; |
266 | } |
267 | |
268 | buf[-1] |= AX25_EBIT; |
269 | |
270 | return len; |
271 | } |
272 | |
273 | int ax25_addr_size(const ax25_digi *dp) |
274 | { |
275 | if (dp == NULL) |
276 | return 2 * AX25_ADDR_LEN; |
277 | |
278 | return AX25_ADDR_LEN * (2 + dp->ndigi); |
279 | } |
280 | |
281 | /* |
282 | * Reverse Digipeat List. May not pass both parameters as same struct |
283 | */ |
284 | void ax25_digi_invert(const ax25_digi *in, ax25_digi *out) |
285 | { |
286 | int ct; |
287 | |
288 | out->ndigi = in->ndigi; |
289 | out->lastrepeat = in->ndigi - in->lastrepeat - 2; |
290 | |
291 | /* Invert the digipeaters */ |
292 | for (ct = 0; ct < in->ndigi; ct++) { |
293 | out->calls[ct] = in->calls[in->ndigi - ct - 1]; |
294 | |
295 | if (ct <= out->lastrepeat) { |
296 | out->calls[ct].ax25_call[6] |= AX25_HBIT; |
297 | out->repeated[ct] = 1; |
298 | } else { |
299 | out->calls[ct].ax25_call[6] &= ~AX25_HBIT; |
300 | out->repeated[ct] = 0; |
301 | } |
302 | } |
303 | } |
304 | |