1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * |
4 | * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk) |
5 | * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk) |
6 | * Copyright Darryl Miles G7LED (dlm@g7led.demon.co.uk) |
7 | */ |
8 | #include <linux/module.h> |
9 | #include <linux/moduleparam.h> |
10 | #include <linux/capability.h> |
11 | #include <linux/errno.h> |
12 | #include <linux/types.h> |
13 | #include <linux/socket.h> |
14 | #include <linux/in.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/kernel.h> |
17 | #include <linux/sched/signal.h> |
18 | #include <linux/timer.h> |
19 | #include <linux/string.h> |
20 | #include <linux/sockios.h> |
21 | #include <linux/net.h> |
22 | #include <linux/stat.h> |
23 | #include <net/ax25.h> |
24 | #include <linux/inet.h> |
25 | #include <linux/netdevice.h> |
26 | #include <linux/if_arp.h> |
27 | #include <linux/skbuff.h> |
28 | #include <net/net_namespace.h> |
29 | #include <net/sock.h> |
30 | #include <linux/uaccess.h> |
31 | #include <linux/fcntl.h> |
32 | #include <linux/termios.h> /* For TIOCINQ/OUTQ */ |
33 | #include <linux/mm.h> |
34 | #include <linux/interrupt.h> |
35 | #include <linux/notifier.h> |
36 | #include <net/netrom.h> |
37 | #include <linux/proc_fs.h> |
38 | #include <linux/seq_file.h> |
39 | #include <net/ip.h> |
40 | #include <net/tcp_states.h> |
41 | #include <net/arp.h> |
42 | #include <linux/init.h> |
43 | |
44 | static int nr_ndevs = 4; |
45 | |
46 | int sysctl_netrom_default_path_quality = NR_DEFAULT_QUAL; |
47 | int sysctl_netrom_obsolescence_count_initialiser = NR_DEFAULT_OBS; |
48 | int sysctl_netrom_network_ttl_initialiser = NR_DEFAULT_TTL; |
49 | int sysctl_netrom_transport_timeout = NR_DEFAULT_T1; |
50 | int sysctl_netrom_transport_maximum_tries = NR_DEFAULT_N2; |
51 | int sysctl_netrom_transport_acknowledge_delay = NR_DEFAULT_T2; |
52 | int sysctl_netrom_transport_busy_delay = NR_DEFAULT_T4; |
53 | int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW; |
54 | int sysctl_netrom_transport_no_activity_timeout = NR_DEFAULT_IDLE; |
55 | int sysctl_netrom_routing_control = NR_DEFAULT_ROUTING; |
56 | int sysctl_netrom_link_fails_count = NR_DEFAULT_FAILS; |
57 | int sysctl_netrom_reset_circuit = NR_DEFAULT_RESET; |
58 | |
59 | static unsigned short circuit = 0x101; |
60 | |
61 | static HLIST_HEAD(nr_list); |
62 | static DEFINE_SPINLOCK(nr_list_lock); |
63 | |
64 | static const struct proto_ops nr_proto_ops; |
65 | |
66 | /* |
67 | * NETROM network devices are virtual network devices encapsulating NETROM |
68 | * frames into AX.25 which will be sent through an AX.25 device, so form a |
69 | * special "super class" of normal net devices; split their locks off into a |
70 | * separate class since they always nest. |
71 | */ |
72 | static struct lock_class_key nr_netdev_xmit_lock_key; |
73 | static struct lock_class_key nr_netdev_addr_lock_key; |
74 | |
75 | static void nr_set_lockdep_one(struct net_device *dev, |
76 | struct netdev_queue *txq, |
77 | void *_unused) |
78 | { |
79 | lockdep_set_class(&txq->_xmit_lock, &nr_netdev_xmit_lock_key); |
80 | } |
81 | |
82 | static void nr_set_lockdep_key(struct net_device *dev) |
83 | { |
84 | lockdep_set_class(&dev->addr_list_lock, &nr_netdev_addr_lock_key); |
85 | netdev_for_each_tx_queue(dev, f: nr_set_lockdep_one, NULL); |
86 | } |
87 | |
88 | /* |
89 | * Socket removal during an interrupt is now safe. |
90 | */ |
91 | static void nr_remove_socket(struct sock *sk) |
92 | { |
93 | spin_lock_bh(lock: &nr_list_lock); |
94 | sk_del_node_init(sk); |
95 | spin_unlock_bh(lock: &nr_list_lock); |
96 | } |
97 | |
98 | /* |
99 | * Kill all bound sockets on a dropped device. |
100 | */ |
101 | static void nr_kill_by_device(struct net_device *dev) |
102 | { |
103 | struct sock *s; |
104 | |
105 | spin_lock_bh(lock: &nr_list_lock); |
106 | sk_for_each(s, &nr_list) |
107 | if (nr_sk(s)->device == dev) |
108 | nr_disconnect(s, ENETUNREACH); |
109 | spin_unlock_bh(lock: &nr_list_lock); |
110 | } |
111 | |
112 | /* |
113 | * Handle device status changes. |
114 | */ |
115 | static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr) |
116 | { |
117 | struct net_device *dev = netdev_notifier_info_to_dev(info: ptr); |
118 | |
119 | if (!net_eq(net1: dev_net(dev), net2: &init_net)) |
120 | return NOTIFY_DONE; |
121 | |
122 | if (event != NETDEV_DOWN) |
123 | return NOTIFY_DONE; |
124 | |
125 | nr_kill_by_device(dev); |
126 | nr_rt_device_down(dev); |
127 | |
128 | return NOTIFY_DONE; |
129 | } |
130 | |
131 | /* |
132 | * Add a socket to the bound sockets list. |
133 | */ |
134 | static void nr_insert_socket(struct sock *sk) |
135 | { |
136 | spin_lock_bh(lock: &nr_list_lock); |
137 | sk_add_node(sk, list: &nr_list); |
138 | spin_unlock_bh(lock: &nr_list_lock); |
139 | } |
140 | |
141 | /* |
142 | * Find a socket that wants to accept the Connect Request we just |
143 | * received. |
144 | */ |
145 | static struct sock *nr_find_listener(ax25_address *addr) |
146 | { |
147 | struct sock *s; |
148 | |
149 | spin_lock_bh(lock: &nr_list_lock); |
150 | sk_for_each(s, &nr_list) |
151 | if (!ax25cmp(&nr_sk(s)->source_addr, addr) && |
152 | s->sk_state == TCP_LISTEN) { |
153 | sock_hold(sk: s); |
154 | goto found; |
155 | } |
156 | s = NULL; |
157 | found: |
158 | spin_unlock_bh(lock: &nr_list_lock); |
159 | return s; |
160 | } |
161 | |
162 | /* |
163 | * Find a connected NET/ROM socket given my circuit IDs. |
164 | */ |
165 | static struct sock *nr_find_socket(unsigned char index, unsigned char id) |
166 | { |
167 | struct sock *s; |
168 | |
169 | spin_lock_bh(lock: &nr_list_lock); |
170 | sk_for_each(s, &nr_list) { |
171 | struct nr_sock *nr = nr_sk(s); |
172 | |
173 | if (nr->my_index == index && nr->my_id == id) { |
174 | sock_hold(sk: s); |
175 | goto found; |
176 | } |
177 | } |
178 | s = NULL; |
179 | found: |
180 | spin_unlock_bh(lock: &nr_list_lock); |
181 | return s; |
182 | } |
183 | |
184 | /* |
185 | * Find a connected NET/ROM socket given their circuit IDs. |
186 | */ |
187 | static struct sock *nr_find_peer(unsigned char index, unsigned char id, |
188 | ax25_address *dest) |
189 | { |
190 | struct sock *s; |
191 | |
192 | spin_lock_bh(lock: &nr_list_lock); |
193 | sk_for_each(s, &nr_list) { |
194 | struct nr_sock *nr = nr_sk(s); |
195 | |
196 | if (nr->your_index == index && nr->your_id == id && |
197 | !ax25cmp(&nr->dest_addr, dest)) { |
198 | sock_hold(sk: s); |
199 | goto found; |
200 | } |
201 | } |
202 | s = NULL; |
203 | found: |
204 | spin_unlock_bh(lock: &nr_list_lock); |
205 | return s; |
206 | } |
207 | |
208 | /* |
209 | * Find next free circuit ID. |
210 | */ |
211 | static unsigned short nr_find_next_circuit(void) |
212 | { |
213 | unsigned short id = circuit; |
214 | unsigned char i, j; |
215 | struct sock *sk; |
216 | |
217 | for (;;) { |
218 | i = id / 256; |
219 | j = id % 256; |
220 | |
221 | if (i != 0 && j != 0) { |
222 | if ((sk=nr_find_socket(index: i, id: j)) == NULL) |
223 | break; |
224 | sock_put(sk); |
225 | } |
226 | |
227 | id++; |
228 | } |
229 | |
230 | return id; |
231 | } |
232 | |
233 | /* |
234 | * Deferred destroy. |
235 | */ |
236 | void nr_destroy_socket(struct sock *); |
237 | |
238 | /* |
239 | * Handler for deferred kills. |
240 | */ |
241 | static void nr_destroy_timer(struct timer_list *t) |
242 | { |
243 | struct sock *sk = from_timer(sk, t, sk_timer); |
244 | bh_lock_sock(sk); |
245 | sock_hold(sk); |
246 | nr_destroy_socket(sk); |
247 | bh_unlock_sock(sk); |
248 | sock_put(sk); |
249 | } |
250 | |
251 | /* |
252 | * This is called from user mode and the timers. Thus it protects itself |
253 | * against interrupt users but doesn't worry about being called during |
254 | * work. Once it is removed from the queue no interrupt or bottom half |
255 | * will touch it and we are (fairly 8-) ) safe. |
256 | */ |
257 | void nr_destroy_socket(struct sock *sk) |
258 | { |
259 | struct sk_buff *skb; |
260 | |
261 | nr_remove_socket(sk); |
262 | |
263 | nr_stop_heartbeat(sk); |
264 | nr_stop_t1timer(sk); |
265 | nr_stop_t2timer(sk); |
266 | nr_stop_t4timer(sk); |
267 | nr_stop_idletimer(sk); |
268 | |
269 | nr_clear_queues(sk); /* Flush the queues */ |
270 | |
271 | while ((skb = skb_dequeue(list: &sk->sk_receive_queue)) != NULL) { |
272 | if (skb->sk != sk) { /* A pending connection */ |
273 | /* Queue the unaccepted socket for death */ |
274 | sock_set_flag(sk: skb->sk, flag: SOCK_DEAD); |
275 | nr_start_heartbeat(skb->sk); |
276 | nr_sk(skb->sk)->state = NR_STATE_0; |
277 | } |
278 | |
279 | kfree_skb(skb); |
280 | } |
281 | |
282 | if (sk_has_allocations(sk)) { |
283 | /* Defer: outstanding buffers */ |
284 | sk->sk_timer.function = nr_destroy_timer; |
285 | sk->sk_timer.expires = jiffies + 2 * HZ; |
286 | add_timer(timer: &sk->sk_timer); |
287 | } else |
288 | sock_put(sk); |
289 | } |
290 | |
291 | /* |
292 | * Handling for system calls applied via the various interfaces to a |
293 | * NET/ROM socket object. |
294 | */ |
295 | |
296 | static int nr_setsockopt(struct socket *sock, int level, int optname, |
297 | sockptr_t optval, unsigned int optlen) |
298 | { |
299 | struct sock *sk = sock->sk; |
300 | struct nr_sock *nr = nr_sk(sk); |
301 | unsigned int opt; |
302 | |
303 | if (level != SOL_NETROM) |
304 | return -ENOPROTOOPT; |
305 | |
306 | if (optlen < sizeof(unsigned int)) |
307 | return -EINVAL; |
308 | |
309 | if (copy_from_sockptr(dst: &opt, src: optval, size: sizeof(opt))) |
310 | return -EFAULT; |
311 | |
312 | switch (optname) { |
313 | case NETROM_T1: |
314 | if (opt < 1 || opt > UINT_MAX / HZ) |
315 | return -EINVAL; |
316 | nr->t1 = opt * HZ; |
317 | return 0; |
318 | |
319 | case NETROM_T2: |
320 | if (opt < 1 || opt > UINT_MAX / HZ) |
321 | return -EINVAL; |
322 | nr->t2 = opt * HZ; |
323 | return 0; |
324 | |
325 | case NETROM_N2: |
326 | if (opt < 1 || opt > 31) |
327 | return -EINVAL; |
328 | nr->n2 = opt; |
329 | return 0; |
330 | |
331 | case NETROM_T4: |
332 | if (opt < 1 || opt > UINT_MAX / HZ) |
333 | return -EINVAL; |
334 | nr->t4 = opt * HZ; |
335 | return 0; |
336 | |
337 | case NETROM_IDLE: |
338 | if (opt > UINT_MAX / (60 * HZ)) |
339 | return -EINVAL; |
340 | nr->idle = opt * 60 * HZ; |
341 | return 0; |
342 | |
343 | default: |
344 | return -ENOPROTOOPT; |
345 | } |
346 | } |
347 | |
348 | static int nr_getsockopt(struct socket *sock, int level, int optname, |
349 | char __user *optval, int __user *optlen) |
350 | { |
351 | struct sock *sk = sock->sk; |
352 | struct nr_sock *nr = nr_sk(sk); |
353 | int val = 0; |
354 | int len; |
355 | |
356 | if (level != SOL_NETROM) |
357 | return -ENOPROTOOPT; |
358 | |
359 | if (get_user(len, optlen)) |
360 | return -EFAULT; |
361 | |
362 | if (len < 0) |
363 | return -EINVAL; |
364 | |
365 | switch (optname) { |
366 | case NETROM_T1: |
367 | val = nr->t1 / HZ; |
368 | break; |
369 | |
370 | case NETROM_T2: |
371 | val = nr->t2 / HZ; |
372 | break; |
373 | |
374 | case NETROM_N2: |
375 | val = nr->n2; |
376 | break; |
377 | |
378 | case NETROM_T4: |
379 | val = nr->t4 / HZ; |
380 | break; |
381 | |
382 | case NETROM_IDLE: |
383 | val = nr->idle / (60 * HZ); |
384 | break; |
385 | |
386 | default: |
387 | return -ENOPROTOOPT; |
388 | } |
389 | |
390 | len = min_t(unsigned int, len, sizeof(int)); |
391 | |
392 | if (put_user(len, optlen)) |
393 | return -EFAULT; |
394 | |
395 | return copy_to_user(to: optval, from: &val, n: len) ? -EFAULT : 0; |
396 | } |
397 | |
398 | static int nr_listen(struct socket *sock, int backlog) |
399 | { |
400 | struct sock *sk = sock->sk; |
401 | |
402 | lock_sock(sk); |
403 | if (sock->state != SS_UNCONNECTED) { |
404 | release_sock(sk); |
405 | return -EINVAL; |
406 | } |
407 | |
408 | if (sk->sk_state != TCP_LISTEN) { |
409 | memset(&nr_sk(sk)->user_addr, 0, AX25_ADDR_LEN); |
410 | sk->sk_max_ack_backlog = backlog; |
411 | sk->sk_state = TCP_LISTEN; |
412 | release_sock(sk); |
413 | return 0; |
414 | } |
415 | release_sock(sk); |
416 | |
417 | return -EOPNOTSUPP; |
418 | } |
419 | |
420 | static struct proto nr_proto = { |
421 | .name = "NETROM" , |
422 | .owner = THIS_MODULE, |
423 | .obj_size = sizeof(struct nr_sock), |
424 | }; |
425 | |
426 | static int nr_create(struct net *net, struct socket *sock, int protocol, |
427 | int kern) |
428 | { |
429 | struct sock *sk; |
430 | struct nr_sock *nr; |
431 | |
432 | if (!net_eq(net1: net, net2: &init_net)) |
433 | return -EAFNOSUPPORT; |
434 | |
435 | if (sock->type != SOCK_SEQPACKET || protocol != 0) |
436 | return -ESOCKTNOSUPPORT; |
437 | |
438 | sk = sk_alloc(net, PF_NETROM, GFP_ATOMIC, prot: &nr_proto, kern); |
439 | if (sk == NULL) |
440 | return -ENOMEM; |
441 | |
442 | nr = nr_sk(sk); |
443 | |
444 | sock_init_data(sock, sk); |
445 | |
446 | sock->ops = &nr_proto_ops; |
447 | sk->sk_protocol = protocol; |
448 | |
449 | skb_queue_head_init(list: &nr->ack_queue); |
450 | skb_queue_head_init(list: &nr->reseq_queue); |
451 | skb_queue_head_init(list: &nr->frag_queue); |
452 | |
453 | nr_init_timers(sk); |
454 | |
455 | nr->t1 = |
456 | msecs_to_jiffies(READ_ONCE(sysctl_netrom_transport_timeout)); |
457 | nr->t2 = |
458 | msecs_to_jiffies(READ_ONCE(sysctl_netrom_transport_acknowledge_delay)); |
459 | nr->n2 = |
460 | msecs_to_jiffies(READ_ONCE(sysctl_netrom_transport_maximum_tries)); |
461 | nr->t4 = |
462 | msecs_to_jiffies(READ_ONCE(sysctl_netrom_transport_busy_delay)); |
463 | nr->idle = |
464 | msecs_to_jiffies(READ_ONCE(sysctl_netrom_transport_no_activity_timeout)); |
465 | nr->window = READ_ONCE(sysctl_netrom_transport_requested_window_size); |
466 | |
467 | nr->bpqext = 1; |
468 | nr->state = NR_STATE_0; |
469 | |
470 | return 0; |
471 | } |
472 | |
473 | static struct sock *nr_make_new(struct sock *osk) |
474 | { |
475 | struct sock *sk; |
476 | struct nr_sock *nr, *onr; |
477 | |
478 | if (osk->sk_type != SOCK_SEQPACKET) |
479 | return NULL; |
480 | |
481 | sk = sk_alloc(net: sock_net(sk: osk), PF_NETROM, GFP_ATOMIC, prot: osk->sk_prot, kern: 0); |
482 | if (sk == NULL) |
483 | return NULL; |
484 | |
485 | nr = nr_sk(sk); |
486 | |
487 | sock_init_data(NULL, sk); |
488 | |
489 | sk->sk_type = osk->sk_type; |
490 | sk->sk_priority = READ_ONCE(osk->sk_priority); |
491 | sk->sk_protocol = osk->sk_protocol; |
492 | sk->sk_rcvbuf = osk->sk_rcvbuf; |
493 | sk->sk_sndbuf = osk->sk_sndbuf; |
494 | sk->sk_state = TCP_ESTABLISHED; |
495 | sock_copy_flags(nsk: sk, osk); |
496 | |
497 | skb_queue_head_init(list: &nr->ack_queue); |
498 | skb_queue_head_init(list: &nr->reseq_queue); |
499 | skb_queue_head_init(list: &nr->frag_queue); |
500 | |
501 | nr_init_timers(sk); |
502 | |
503 | onr = nr_sk(osk); |
504 | |
505 | nr->t1 = onr->t1; |
506 | nr->t2 = onr->t2; |
507 | nr->n2 = onr->n2; |
508 | nr->t4 = onr->t4; |
509 | nr->idle = onr->idle; |
510 | nr->window = onr->window; |
511 | |
512 | nr->device = onr->device; |
513 | nr->bpqext = onr->bpqext; |
514 | |
515 | return sk; |
516 | } |
517 | |
518 | static int nr_release(struct socket *sock) |
519 | { |
520 | struct sock *sk = sock->sk; |
521 | struct nr_sock *nr; |
522 | |
523 | if (sk == NULL) return 0; |
524 | |
525 | sock_hold(sk); |
526 | sock_orphan(sk); |
527 | lock_sock(sk); |
528 | nr = nr_sk(sk); |
529 | |
530 | switch (nr->state) { |
531 | case NR_STATE_0: |
532 | case NR_STATE_1: |
533 | case NR_STATE_2: |
534 | nr_disconnect(sk, 0); |
535 | nr_destroy_socket(sk); |
536 | break; |
537 | |
538 | case NR_STATE_3: |
539 | nr_clear_queues(sk); |
540 | nr->n2count = 0; |
541 | nr_write_internal(sk, NR_DISCREQ); |
542 | nr_start_t1timer(sk); |
543 | nr_stop_t2timer(sk); |
544 | nr_stop_t4timer(sk); |
545 | nr_stop_idletimer(sk); |
546 | nr->state = NR_STATE_2; |
547 | sk->sk_state = TCP_CLOSE; |
548 | sk->sk_shutdown |= SEND_SHUTDOWN; |
549 | sk->sk_state_change(sk); |
550 | sock_set_flag(sk, flag: SOCK_DESTROY); |
551 | break; |
552 | |
553 | default: |
554 | break; |
555 | } |
556 | |
557 | sock->sk = NULL; |
558 | release_sock(sk); |
559 | sock_put(sk); |
560 | |
561 | return 0; |
562 | } |
563 | |
564 | static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) |
565 | { |
566 | struct sock *sk = sock->sk; |
567 | struct nr_sock *nr = nr_sk(sk); |
568 | struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr; |
569 | struct net_device *dev; |
570 | ax25_uid_assoc *user; |
571 | ax25_address *source; |
572 | |
573 | lock_sock(sk); |
574 | if (!sock_flag(sk, flag: SOCK_ZAPPED)) { |
575 | release_sock(sk); |
576 | return -EINVAL; |
577 | } |
578 | if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct full_sockaddr_ax25)) { |
579 | release_sock(sk); |
580 | return -EINVAL; |
581 | } |
582 | if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25))) { |
583 | release_sock(sk); |
584 | return -EINVAL; |
585 | } |
586 | if (addr->fsa_ax25.sax25_family != AF_NETROM) { |
587 | release_sock(sk); |
588 | return -EINVAL; |
589 | } |
590 | if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) { |
591 | release_sock(sk); |
592 | return -EADDRNOTAVAIL; |
593 | } |
594 | |
595 | /* |
596 | * Only the super user can set an arbitrary user callsign. |
597 | */ |
598 | if (addr->fsa_ax25.sax25_ndigis == 1) { |
599 | if (!capable(CAP_NET_BIND_SERVICE)) { |
600 | dev_put(dev); |
601 | release_sock(sk); |
602 | return -EPERM; |
603 | } |
604 | nr->user_addr = addr->fsa_digipeater[0]; |
605 | nr->source_addr = addr->fsa_ax25.sax25_call; |
606 | } else { |
607 | source = &addr->fsa_ax25.sax25_call; |
608 | |
609 | user = ax25_findbyuid(current_euid()); |
610 | if (user) { |
611 | nr->user_addr = user->call; |
612 | ax25_uid_put(assoc: user); |
613 | } else { |
614 | if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE)) { |
615 | release_sock(sk); |
616 | dev_put(dev); |
617 | return -EPERM; |
618 | } |
619 | nr->user_addr = *source; |
620 | } |
621 | |
622 | nr->source_addr = *source; |
623 | } |
624 | |
625 | nr->device = dev; |
626 | nr_insert_socket(sk); |
627 | |
628 | sock_reset_flag(sk, flag: SOCK_ZAPPED); |
629 | dev_put(dev); |
630 | release_sock(sk); |
631 | |
632 | return 0; |
633 | } |
634 | |
635 | static int nr_connect(struct socket *sock, struct sockaddr *uaddr, |
636 | int addr_len, int flags) |
637 | { |
638 | struct sock *sk = sock->sk; |
639 | struct nr_sock *nr = nr_sk(sk); |
640 | struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr; |
641 | const ax25_address *source = NULL; |
642 | ax25_uid_assoc *user; |
643 | struct net_device *dev; |
644 | int err = 0; |
645 | |
646 | lock_sock(sk); |
647 | if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) { |
648 | sock->state = SS_CONNECTED; |
649 | goto out_release; /* Connect completed during a ERESTARTSYS event */ |
650 | } |
651 | |
652 | if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) { |
653 | sock->state = SS_UNCONNECTED; |
654 | err = -ECONNREFUSED; |
655 | goto out_release; |
656 | } |
657 | |
658 | if (sk->sk_state == TCP_ESTABLISHED) { |
659 | err = -EISCONN; /* No reconnect on a seqpacket socket */ |
660 | goto out_release; |
661 | } |
662 | |
663 | if (sock->state == SS_CONNECTING) { |
664 | err = -EALREADY; |
665 | goto out_release; |
666 | } |
667 | |
668 | sk->sk_state = TCP_CLOSE; |
669 | sock->state = SS_UNCONNECTED; |
670 | |
671 | if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) { |
672 | err = -EINVAL; |
673 | goto out_release; |
674 | } |
675 | if (addr->sax25_family != AF_NETROM) { |
676 | err = -EINVAL; |
677 | goto out_release; |
678 | } |
679 | if (sock_flag(sk, flag: SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */ |
680 | sock_reset_flag(sk, flag: SOCK_ZAPPED); |
681 | |
682 | if ((dev = nr_dev_first()) == NULL) { |
683 | err = -ENETUNREACH; |
684 | goto out_release; |
685 | } |
686 | source = (const ax25_address *)dev->dev_addr; |
687 | |
688 | user = ax25_findbyuid(current_euid()); |
689 | if (user) { |
690 | nr->user_addr = user->call; |
691 | ax25_uid_put(assoc: user); |
692 | } else { |
693 | if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) { |
694 | dev_put(dev); |
695 | err = -EPERM; |
696 | goto out_release; |
697 | } |
698 | nr->user_addr = *source; |
699 | } |
700 | |
701 | nr->source_addr = *source; |
702 | nr->device = dev; |
703 | |
704 | dev_put(dev); |
705 | nr_insert_socket(sk); /* Finish the bind */ |
706 | } |
707 | |
708 | nr->dest_addr = addr->sax25_call; |
709 | |
710 | release_sock(sk); |
711 | circuit = nr_find_next_circuit(); |
712 | lock_sock(sk); |
713 | |
714 | nr->my_index = circuit / 256; |
715 | nr->my_id = circuit % 256; |
716 | |
717 | circuit++; |
718 | |
719 | /* Move to connecting socket, start sending Connect Requests */ |
720 | sock->state = SS_CONNECTING; |
721 | sk->sk_state = TCP_SYN_SENT; |
722 | |
723 | nr_establish_data_link(sk); |
724 | |
725 | nr->state = NR_STATE_1; |
726 | |
727 | nr_start_heartbeat(sk); |
728 | |
729 | /* Now the loop */ |
730 | if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) { |
731 | err = -EINPROGRESS; |
732 | goto out_release; |
733 | } |
734 | |
735 | /* |
736 | * A Connect Ack with Choke or timeout or failed routing will go to |
737 | * closed. |
738 | */ |
739 | if (sk->sk_state == TCP_SYN_SENT) { |
740 | DEFINE_WAIT(wait); |
741 | |
742 | for (;;) { |
743 | prepare_to_wait(wq_head: sk_sleep(sk), wq_entry: &wait, |
744 | TASK_INTERRUPTIBLE); |
745 | if (sk->sk_state != TCP_SYN_SENT) |
746 | break; |
747 | if (!signal_pending(current)) { |
748 | release_sock(sk); |
749 | schedule(); |
750 | lock_sock(sk); |
751 | continue; |
752 | } |
753 | err = -ERESTARTSYS; |
754 | break; |
755 | } |
756 | finish_wait(wq_head: sk_sleep(sk), wq_entry: &wait); |
757 | if (err) |
758 | goto out_release; |
759 | } |
760 | |
761 | if (sk->sk_state != TCP_ESTABLISHED) { |
762 | sock->state = SS_UNCONNECTED; |
763 | err = sock_error(sk); /* Always set at this point */ |
764 | goto out_release; |
765 | } |
766 | |
767 | sock->state = SS_CONNECTED; |
768 | |
769 | out_release: |
770 | release_sock(sk); |
771 | |
772 | return err; |
773 | } |
774 | |
775 | static int nr_accept(struct socket *sock, struct socket *newsock, int flags, |
776 | bool kern) |
777 | { |
778 | struct sk_buff *skb; |
779 | struct sock *newsk; |
780 | DEFINE_WAIT(wait); |
781 | struct sock *sk; |
782 | int err = 0; |
783 | |
784 | if ((sk = sock->sk) == NULL) |
785 | return -EINVAL; |
786 | |
787 | lock_sock(sk); |
788 | if (sk->sk_type != SOCK_SEQPACKET) { |
789 | err = -EOPNOTSUPP; |
790 | goto out_release; |
791 | } |
792 | |
793 | if (sk->sk_state != TCP_LISTEN) { |
794 | err = -EINVAL; |
795 | goto out_release; |
796 | } |
797 | |
798 | /* |
799 | * The write queue this time is holding sockets ready to use |
800 | * hooked into the SABM we saved |
801 | */ |
802 | for (;;) { |
803 | prepare_to_wait(wq_head: sk_sleep(sk), wq_entry: &wait, TASK_INTERRUPTIBLE); |
804 | skb = skb_dequeue(list: &sk->sk_receive_queue); |
805 | if (skb) |
806 | break; |
807 | |
808 | if (flags & O_NONBLOCK) { |
809 | err = -EWOULDBLOCK; |
810 | break; |
811 | } |
812 | if (!signal_pending(current)) { |
813 | release_sock(sk); |
814 | schedule(); |
815 | lock_sock(sk); |
816 | continue; |
817 | } |
818 | err = -ERESTARTSYS; |
819 | break; |
820 | } |
821 | finish_wait(wq_head: sk_sleep(sk), wq_entry: &wait); |
822 | if (err) |
823 | goto out_release; |
824 | |
825 | newsk = skb->sk; |
826 | sock_graft(sk: newsk, parent: newsock); |
827 | |
828 | /* Now attach up the new socket */ |
829 | kfree_skb(skb); |
830 | sk_acceptq_removed(sk); |
831 | |
832 | out_release: |
833 | release_sock(sk); |
834 | |
835 | return err; |
836 | } |
837 | |
838 | static int nr_getname(struct socket *sock, struct sockaddr *uaddr, |
839 | int peer) |
840 | { |
841 | struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr; |
842 | struct sock *sk = sock->sk; |
843 | struct nr_sock *nr = nr_sk(sk); |
844 | int uaddr_len; |
845 | |
846 | memset(&sax->fsa_ax25, 0, sizeof(struct sockaddr_ax25)); |
847 | |
848 | lock_sock(sk); |
849 | if (peer != 0) { |
850 | if (sk->sk_state != TCP_ESTABLISHED) { |
851 | release_sock(sk); |
852 | return -ENOTCONN; |
853 | } |
854 | sax->fsa_ax25.sax25_family = AF_NETROM; |
855 | sax->fsa_ax25.sax25_ndigis = 1; |
856 | sax->fsa_ax25.sax25_call = nr->user_addr; |
857 | memset(sax->fsa_digipeater, 0, sizeof(sax->fsa_digipeater)); |
858 | sax->fsa_digipeater[0] = nr->dest_addr; |
859 | uaddr_len = sizeof(struct full_sockaddr_ax25); |
860 | } else { |
861 | sax->fsa_ax25.sax25_family = AF_NETROM; |
862 | sax->fsa_ax25.sax25_ndigis = 0; |
863 | sax->fsa_ax25.sax25_call = nr->source_addr; |
864 | uaddr_len = sizeof(struct sockaddr_ax25); |
865 | } |
866 | release_sock(sk); |
867 | |
868 | return uaddr_len; |
869 | } |
870 | |
871 | int nr_rx_frame(struct sk_buff *skb, struct net_device *dev) |
872 | { |
873 | struct sock *sk; |
874 | struct sock *make; |
875 | struct nr_sock *nr_make; |
876 | ax25_address *src, *dest, *user; |
877 | unsigned short circuit_index, circuit_id; |
878 | unsigned short peer_circuit_index, peer_circuit_id; |
879 | unsigned short frametype, flags, window, timeout; |
880 | int ret; |
881 | |
882 | skb_orphan(skb); |
883 | |
884 | /* |
885 | * skb->data points to the netrom frame start |
886 | */ |
887 | |
888 | src = (ax25_address *)(skb->data + 0); |
889 | dest = (ax25_address *)(skb->data + 7); |
890 | |
891 | circuit_index = skb->data[15]; |
892 | circuit_id = skb->data[16]; |
893 | peer_circuit_index = skb->data[17]; |
894 | peer_circuit_id = skb->data[18]; |
895 | frametype = skb->data[19] & 0x0F; |
896 | flags = skb->data[19] & 0xF0; |
897 | |
898 | /* |
899 | * Check for an incoming IP over NET/ROM frame. |
900 | */ |
901 | if (frametype == NR_PROTOEXT && |
902 | circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) { |
903 | skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN); |
904 | skb_reset_transport_header(skb); |
905 | |
906 | return nr_rx_ip(skb, dev); |
907 | } |
908 | |
909 | /* |
910 | * Find an existing socket connection, based on circuit ID, if it's |
911 | * a Connect Request base it on their circuit ID. |
912 | * |
913 | * Circuit ID 0/0 is not valid but it could still be a "reset" for a |
914 | * circuit that no longer exists at the other end ... |
915 | */ |
916 | |
917 | sk = NULL; |
918 | |
919 | if (circuit_index == 0 && circuit_id == 0) { |
920 | if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG) |
921 | sk = nr_find_peer(index: peer_circuit_index, id: peer_circuit_id, dest: src); |
922 | } else { |
923 | if (frametype == NR_CONNREQ) |
924 | sk = nr_find_peer(index: circuit_index, id: circuit_id, dest: src); |
925 | else |
926 | sk = nr_find_socket(index: circuit_index, id: circuit_id); |
927 | } |
928 | |
929 | if (sk != NULL) { |
930 | bh_lock_sock(sk); |
931 | skb_reset_transport_header(skb); |
932 | |
933 | if (frametype == NR_CONNACK && skb->len == 22) |
934 | nr_sk(sk)->bpqext = 1; |
935 | else |
936 | nr_sk(sk)->bpqext = 0; |
937 | |
938 | ret = nr_process_rx_frame(sk, skb); |
939 | bh_unlock_sock(sk); |
940 | sock_put(sk); |
941 | return ret; |
942 | } |
943 | |
944 | /* |
945 | * Now it should be a CONNREQ. |
946 | */ |
947 | if (frametype != NR_CONNREQ) { |
948 | /* |
949 | * Here it would be nice to be able to send a reset but |
950 | * NET/ROM doesn't have one. We've tried to extend the protocol |
951 | * by sending NR_CONNACK | NR_CHOKE_FLAGS replies but that |
952 | * apparently kills BPQ boxes... :-( |
953 | * So now we try to follow the established behaviour of |
954 | * G8PZT's Xrouter which is sending packets with command type 7 |
955 | * as an extension of the protocol. |
956 | */ |
957 | if (READ_ONCE(sysctl_netrom_reset_circuit) && |
958 | (frametype != NR_RESET || flags != 0)) |
959 | nr_transmit_reset(skb, 1); |
960 | |
961 | return 0; |
962 | } |
963 | |
964 | sk = nr_find_listener(addr: dest); |
965 | |
966 | user = (ax25_address *)(skb->data + 21); |
967 | |
968 | if (sk == NULL || sk_acceptq_is_full(sk) || |
969 | (make = nr_make_new(osk: sk)) == NULL) { |
970 | nr_transmit_refusal(skb, 0); |
971 | if (sk) |
972 | sock_put(sk); |
973 | return 0; |
974 | } |
975 | |
976 | bh_lock_sock(sk); |
977 | |
978 | window = skb->data[20]; |
979 | |
980 | sock_hold(sk: make); |
981 | skb->sk = make; |
982 | skb->destructor = sock_efree; |
983 | make->sk_state = TCP_ESTABLISHED; |
984 | |
985 | /* Fill in his circuit details */ |
986 | nr_make = nr_sk(make); |
987 | nr_make->source_addr = *dest; |
988 | nr_make->dest_addr = *src; |
989 | nr_make->user_addr = *user; |
990 | |
991 | nr_make->your_index = circuit_index; |
992 | nr_make->your_id = circuit_id; |
993 | |
994 | bh_unlock_sock(sk); |
995 | circuit = nr_find_next_circuit(); |
996 | bh_lock_sock(sk); |
997 | |
998 | nr_make->my_index = circuit / 256; |
999 | nr_make->my_id = circuit % 256; |
1000 | |
1001 | circuit++; |
1002 | |
1003 | /* Window negotiation */ |
1004 | if (window < nr_make->window) |
1005 | nr_make->window = window; |
1006 | |
1007 | /* L4 timeout negotiation */ |
1008 | if (skb->len == 37) { |
1009 | timeout = skb->data[36] * 256 + skb->data[35]; |
1010 | if (timeout * HZ < nr_make->t1) |
1011 | nr_make->t1 = timeout * HZ; |
1012 | nr_make->bpqext = 1; |
1013 | } else { |
1014 | nr_make->bpqext = 0; |
1015 | } |
1016 | |
1017 | nr_write_internal(make, NR_CONNACK); |
1018 | |
1019 | nr_make->condition = 0x00; |
1020 | nr_make->vs = 0; |
1021 | nr_make->va = 0; |
1022 | nr_make->vr = 0; |
1023 | nr_make->vl = 0; |
1024 | nr_make->state = NR_STATE_3; |
1025 | sk_acceptq_added(sk); |
1026 | skb_queue_head(list: &sk->sk_receive_queue, newsk: skb); |
1027 | |
1028 | if (!sock_flag(sk, flag: SOCK_DEAD)) |
1029 | sk->sk_data_ready(sk); |
1030 | |
1031 | bh_unlock_sock(sk); |
1032 | sock_put(sk); |
1033 | |
1034 | nr_insert_socket(sk: make); |
1035 | |
1036 | nr_start_heartbeat(make); |
1037 | nr_start_idletimer(make); |
1038 | |
1039 | return 1; |
1040 | } |
1041 | |
1042 | static int nr_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) |
1043 | { |
1044 | struct sock *sk = sock->sk; |
1045 | struct nr_sock *nr = nr_sk(sk); |
1046 | DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name); |
1047 | int err; |
1048 | struct sockaddr_ax25 sax; |
1049 | struct sk_buff *skb; |
1050 | unsigned char *asmptr; |
1051 | int size; |
1052 | |
1053 | if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT)) |
1054 | return -EINVAL; |
1055 | |
1056 | lock_sock(sk); |
1057 | if (sock_flag(sk, flag: SOCK_ZAPPED)) { |
1058 | err = -EADDRNOTAVAIL; |
1059 | goto out; |
1060 | } |
1061 | |
1062 | if (sk->sk_shutdown & SEND_SHUTDOWN) { |
1063 | send_sig(SIGPIPE, current, 0); |
1064 | err = -EPIPE; |
1065 | goto out; |
1066 | } |
1067 | |
1068 | if (nr->device == NULL) { |
1069 | err = -ENETUNREACH; |
1070 | goto out; |
1071 | } |
1072 | |
1073 | if (usax) { |
1074 | if (msg->msg_namelen < sizeof(sax)) { |
1075 | err = -EINVAL; |
1076 | goto out; |
1077 | } |
1078 | sax = *usax; |
1079 | if (ax25cmp(&nr->dest_addr, &sax.sax25_call) != 0) { |
1080 | err = -EISCONN; |
1081 | goto out; |
1082 | } |
1083 | if (sax.sax25_family != AF_NETROM) { |
1084 | err = -EINVAL; |
1085 | goto out; |
1086 | } |
1087 | } else { |
1088 | if (sk->sk_state != TCP_ESTABLISHED) { |
1089 | err = -ENOTCONN; |
1090 | goto out; |
1091 | } |
1092 | sax.sax25_family = AF_NETROM; |
1093 | sax.sax25_call = nr->dest_addr; |
1094 | } |
1095 | |
1096 | /* Build a packet - the conventional user limit is 236 bytes. We can |
1097 | do ludicrously large NetROM frames but must not overflow */ |
1098 | if (len > 65536) { |
1099 | err = -EMSGSIZE; |
1100 | goto out; |
1101 | } |
1102 | |
1103 | size = len + NR_NETWORK_LEN + NR_TRANSPORT_LEN; |
1104 | |
1105 | if ((skb = sock_alloc_send_skb(sk, size, noblock: msg->msg_flags & MSG_DONTWAIT, errcode: &err)) == NULL) |
1106 | goto out; |
1107 | |
1108 | skb_reserve(skb, len: size - len); |
1109 | skb_reset_transport_header(skb); |
1110 | |
1111 | /* |
1112 | * Push down the NET/ROM header |
1113 | */ |
1114 | |
1115 | asmptr = skb_push(skb, NR_TRANSPORT_LEN); |
1116 | |
1117 | /* Build a NET/ROM Transport header */ |
1118 | |
1119 | *asmptr++ = nr->your_index; |
1120 | *asmptr++ = nr->your_id; |
1121 | *asmptr++ = 0; /* To be filled in later */ |
1122 | *asmptr++ = 0; /* Ditto */ |
1123 | *asmptr++ = NR_INFO; |
1124 | |
1125 | /* |
1126 | * Put the data on the end |
1127 | */ |
1128 | skb_put(skb, len); |
1129 | |
1130 | /* User data follows immediately after the NET/ROM transport header */ |
1131 | if (memcpy_from_msg(data: skb_transport_header(skb), msg, len)) { |
1132 | kfree_skb(skb); |
1133 | err = -EFAULT; |
1134 | goto out; |
1135 | } |
1136 | |
1137 | if (sk->sk_state != TCP_ESTABLISHED) { |
1138 | kfree_skb(skb); |
1139 | err = -ENOTCONN; |
1140 | goto out; |
1141 | } |
1142 | |
1143 | nr_output(sk, skb); /* Shove it onto the queue */ |
1144 | |
1145 | err = len; |
1146 | out: |
1147 | release_sock(sk); |
1148 | return err; |
1149 | } |
1150 | |
1151 | static int nr_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, |
1152 | int flags) |
1153 | { |
1154 | struct sock *sk = sock->sk; |
1155 | DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name); |
1156 | size_t copied; |
1157 | struct sk_buff *skb; |
1158 | int er; |
1159 | |
1160 | /* |
1161 | * This works for seqpacket too. The receiver has ordered the queue for |
1162 | * us! We do one quick check first though |
1163 | */ |
1164 | |
1165 | lock_sock(sk); |
1166 | if (sk->sk_state != TCP_ESTABLISHED) { |
1167 | release_sock(sk); |
1168 | return -ENOTCONN; |
1169 | } |
1170 | |
1171 | /* Now we can treat all alike */ |
1172 | skb = skb_recv_datagram(sk, flags, err: &er); |
1173 | if (!skb) { |
1174 | release_sock(sk); |
1175 | return er; |
1176 | } |
1177 | |
1178 | skb_reset_transport_header(skb); |
1179 | copied = skb->len; |
1180 | |
1181 | if (copied > size) { |
1182 | copied = size; |
1183 | msg->msg_flags |= MSG_TRUNC; |
1184 | } |
1185 | |
1186 | er = skb_copy_datagram_msg(from: skb, offset: 0, msg, size: copied); |
1187 | if (er < 0) { |
1188 | skb_free_datagram(sk, skb); |
1189 | release_sock(sk); |
1190 | return er; |
1191 | } |
1192 | |
1193 | if (sax != NULL) { |
1194 | memset(sax, 0, sizeof(*sax)); |
1195 | sax->sax25_family = AF_NETROM; |
1196 | skb_copy_from_linear_data_offset(skb, offset: 7, to: sax->sax25_call.ax25_call, |
1197 | AX25_ADDR_LEN); |
1198 | msg->msg_namelen = sizeof(*sax); |
1199 | } |
1200 | |
1201 | skb_free_datagram(sk, skb); |
1202 | |
1203 | release_sock(sk); |
1204 | return copied; |
1205 | } |
1206 | |
1207 | |
1208 | static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) |
1209 | { |
1210 | struct sock *sk = sock->sk; |
1211 | void __user *argp = (void __user *)arg; |
1212 | |
1213 | switch (cmd) { |
1214 | case TIOCOUTQ: { |
1215 | long amount; |
1216 | |
1217 | lock_sock(sk); |
1218 | amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); |
1219 | if (amount < 0) |
1220 | amount = 0; |
1221 | release_sock(sk); |
1222 | return put_user(amount, (int __user *)argp); |
1223 | } |
1224 | |
1225 | case TIOCINQ: { |
1226 | struct sk_buff *skb; |
1227 | long amount = 0L; |
1228 | |
1229 | lock_sock(sk); |
1230 | /* These two are safe on a single CPU system as only user tasks fiddle here */ |
1231 | if ((skb = skb_peek(list_: &sk->sk_receive_queue)) != NULL) |
1232 | amount = skb->len; |
1233 | release_sock(sk); |
1234 | return put_user(amount, (int __user *)argp); |
1235 | } |
1236 | |
1237 | case SIOCGIFADDR: |
1238 | case SIOCSIFADDR: |
1239 | case SIOCGIFDSTADDR: |
1240 | case SIOCSIFDSTADDR: |
1241 | case SIOCGIFBRDADDR: |
1242 | case SIOCSIFBRDADDR: |
1243 | case SIOCGIFNETMASK: |
1244 | case SIOCSIFNETMASK: |
1245 | case SIOCGIFMETRIC: |
1246 | case SIOCSIFMETRIC: |
1247 | return -EINVAL; |
1248 | |
1249 | case SIOCADDRT: |
1250 | case SIOCDELRT: |
1251 | case SIOCNRDECOBS: |
1252 | if (!capable(CAP_NET_ADMIN)) |
1253 | return -EPERM; |
1254 | return nr_rt_ioctl(cmd, argp); |
1255 | |
1256 | default: |
1257 | return -ENOIOCTLCMD; |
1258 | } |
1259 | |
1260 | return 0; |
1261 | } |
1262 | |
1263 | #ifdef CONFIG_PROC_FS |
1264 | |
1265 | static void *nr_info_start(struct seq_file *seq, loff_t *pos) |
1266 | __acquires(&nr_list_lock) |
1267 | { |
1268 | spin_lock_bh(lock: &nr_list_lock); |
1269 | return seq_hlist_start_head(head: &nr_list, pos: *pos); |
1270 | } |
1271 | |
1272 | static void *nr_info_next(struct seq_file *seq, void *v, loff_t *pos) |
1273 | { |
1274 | return seq_hlist_next(v, head: &nr_list, ppos: pos); |
1275 | } |
1276 | |
1277 | static void nr_info_stop(struct seq_file *seq, void *v) |
1278 | __releases(&nr_list_lock) |
1279 | { |
1280 | spin_unlock_bh(lock: &nr_list_lock); |
1281 | } |
1282 | |
1283 | static int nr_info_show(struct seq_file *seq, void *v) |
1284 | { |
1285 | struct sock *s = sk_entry(node: v); |
1286 | struct net_device *dev; |
1287 | struct nr_sock *nr; |
1288 | const char *devname; |
1289 | char buf[11]; |
1290 | |
1291 | if (v == SEQ_START_TOKEN) |
1292 | seq_puts(m: seq, |
1293 | s: "user_addr dest_node src_node dev my your st vs vr va t1 t2 t4 idle n2 wnd Snd-Q Rcv-Q inode\n" ); |
1294 | |
1295 | else { |
1296 | |
1297 | bh_lock_sock(s); |
1298 | nr = nr_sk(s); |
1299 | |
1300 | if ((dev = nr->device) == NULL) |
1301 | devname = "???" ; |
1302 | else |
1303 | devname = dev->name; |
1304 | |
1305 | seq_printf(m: seq, fmt: "%-9s " , ax2asc(buf, &nr->user_addr)); |
1306 | seq_printf(m: seq, fmt: "%-9s " , ax2asc(buf, &nr->dest_addr)); |
1307 | seq_printf(m: seq, |
1308 | fmt: "%-9s %-3s %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ld\n" , |
1309 | ax2asc(buf, &nr->source_addr), |
1310 | devname, |
1311 | nr->my_index, |
1312 | nr->my_id, |
1313 | nr->your_index, |
1314 | nr->your_id, |
1315 | nr->state, |
1316 | nr->vs, |
1317 | nr->vr, |
1318 | nr->va, |
1319 | ax25_display_timer(&nr->t1timer) / HZ, |
1320 | nr->t1 / HZ, |
1321 | ax25_display_timer(&nr->t2timer) / HZ, |
1322 | nr->t2 / HZ, |
1323 | ax25_display_timer(&nr->t4timer) / HZ, |
1324 | nr->t4 / HZ, |
1325 | ax25_display_timer(&nr->idletimer) / (60 * HZ), |
1326 | nr->idle / (60 * HZ), |
1327 | nr->n2count, |
1328 | nr->n2, |
1329 | nr->window, |
1330 | sk_wmem_alloc_get(sk: s), |
1331 | sk_rmem_alloc_get(sk: s), |
1332 | s->sk_socket ? SOCK_INODE(socket: s->sk_socket)->i_ino : 0L); |
1333 | |
1334 | bh_unlock_sock(s); |
1335 | } |
1336 | return 0; |
1337 | } |
1338 | |
1339 | static const struct seq_operations nr_info_seqops = { |
1340 | .start = nr_info_start, |
1341 | .next = nr_info_next, |
1342 | .stop = nr_info_stop, |
1343 | .show = nr_info_show, |
1344 | }; |
1345 | #endif /* CONFIG_PROC_FS */ |
1346 | |
1347 | static const struct net_proto_family nr_family_ops = { |
1348 | .family = PF_NETROM, |
1349 | .create = nr_create, |
1350 | .owner = THIS_MODULE, |
1351 | }; |
1352 | |
1353 | static const struct proto_ops nr_proto_ops = { |
1354 | .family = PF_NETROM, |
1355 | .owner = THIS_MODULE, |
1356 | .release = nr_release, |
1357 | .bind = nr_bind, |
1358 | .connect = nr_connect, |
1359 | .socketpair = sock_no_socketpair, |
1360 | .accept = nr_accept, |
1361 | .getname = nr_getname, |
1362 | .poll = datagram_poll, |
1363 | .ioctl = nr_ioctl, |
1364 | .gettstamp = sock_gettstamp, |
1365 | .listen = nr_listen, |
1366 | .shutdown = sock_no_shutdown, |
1367 | .setsockopt = nr_setsockopt, |
1368 | .getsockopt = nr_getsockopt, |
1369 | .sendmsg = nr_sendmsg, |
1370 | .recvmsg = nr_recvmsg, |
1371 | .mmap = sock_no_mmap, |
1372 | }; |
1373 | |
1374 | static struct notifier_block nr_dev_notifier = { |
1375 | .notifier_call = nr_device_event, |
1376 | }; |
1377 | |
1378 | static struct net_device **dev_nr; |
1379 | |
1380 | static struct ax25_protocol nr_pid = { |
1381 | .pid = AX25_P_NETROM, |
1382 | .func = nr_route_frame |
1383 | }; |
1384 | |
1385 | static struct ax25_linkfail nr_linkfail_notifier = { |
1386 | .func = nr_link_failed, |
1387 | }; |
1388 | |
1389 | static int __init nr_proto_init(void) |
1390 | { |
1391 | int i; |
1392 | int rc = proto_register(prot: &nr_proto, alloc_slab: 0); |
1393 | |
1394 | if (rc) |
1395 | return rc; |
1396 | |
1397 | if (nr_ndevs > 0x7fffffff/sizeof(struct net_device *)) { |
1398 | pr_err("NET/ROM: %s - nr_ndevs parameter too large\n" , |
1399 | __func__); |
1400 | rc = -EINVAL; |
1401 | goto unregister_proto; |
1402 | } |
1403 | |
1404 | dev_nr = kcalloc(n: nr_ndevs, size: sizeof(struct net_device *), GFP_KERNEL); |
1405 | if (!dev_nr) { |
1406 | pr_err("NET/ROM: %s - unable to allocate device array\n" , |
1407 | __func__); |
1408 | rc = -ENOMEM; |
1409 | goto unregister_proto; |
1410 | } |
1411 | |
1412 | for (i = 0; i < nr_ndevs; i++) { |
1413 | char name[IFNAMSIZ]; |
1414 | struct net_device *dev; |
1415 | |
1416 | sprintf(buf: name, fmt: "nr%d" , i); |
1417 | dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, nr_setup); |
1418 | if (!dev) { |
1419 | rc = -ENOMEM; |
1420 | goto fail; |
1421 | } |
1422 | |
1423 | dev->base_addr = i; |
1424 | rc = register_netdev(dev); |
1425 | if (rc) { |
1426 | free_netdev(dev); |
1427 | goto fail; |
1428 | } |
1429 | nr_set_lockdep_key(dev); |
1430 | dev_nr[i] = dev; |
1431 | } |
1432 | |
1433 | rc = sock_register(fam: &nr_family_ops); |
1434 | if (rc) |
1435 | goto fail; |
1436 | |
1437 | rc = register_netdevice_notifier(nb: &nr_dev_notifier); |
1438 | if (rc) |
1439 | goto out_sock; |
1440 | |
1441 | ax25_register_pid(ap: &nr_pid); |
1442 | ax25_linkfail_register(lf: &nr_linkfail_notifier); |
1443 | |
1444 | #ifdef CONFIG_SYSCTL |
1445 | rc = nr_register_sysctl(); |
1446 | if (rc) |
1447 | goto out_sysctl; |
1448 | #endif |
1449 | |
1450 | nr_loopback_init(); |
1451 | |
1452 | rc = -ENOMEM; |
1453 | if (!proc_create_seq("nr" , 0444, init_net.proc_net, &nr_info_seqops)) |
1454 | goto proc_remove1; |
1455 | if (!proc_create_seq("nr_neigh" , 0444, init_net.proc_net, |
1456 | &nr_neigh_seqops)) |
1457 | goto proc_remove2; |
1458 | if (!proc_create_seq("nr_nodes" , 0444, init_net.proc_net, |
1459 | &nr_node_seqops)) |
1460 | goto proc_remove3; |
1461 | |
1462 | return 0; |
1463 | |
1464 | proc_remove3: |
1465 | remove_proc_entry("nr_neigh" , init_net.proc_net); |
1466 | proc_remove2: |
1467 | remove_proc_entry("nr" , init_net.proc_net); |
1468 | proc_remove1: |
1469 | |
1470 | nr_loopback_clear(); |
1471 | nr_rt_free(); |
1472 | |
1473 | #ifdef CONFIG_SYSCTL |
1474 | nr_unregister_sysctl(); |
1475 | out_sysctl: |
1476 | #endif |
1477 | ax25_linkfail_release(lf: &nr_linkfail_notifier); |
1478 | ax25_protocol_release(AX25_P_NETROM); |
1479 | unregister_netdevice_notifier(nb: &nr_dev_notifier); |
1480 | out_sock: |
1481 | sock_unregister(PF_NETROM); |
1482 | fail: |
1483 | while (--i >= 0) { |
1484 | unregister_netdev(dev: dev_nr[i]); |
1485 | free_netdev(dev: dev_nr[i]); |
1486 | } |
1487 | kfree(objp: dev_nr); |
1488 | unregister_proto: |
1489 | proto_unregister(prot: &nr_proto); |
1490 | return rc; |
1491 | } |
1492 | |
1493 | module_init(nr_proto_init); |
1494 | |
1495 | module_param(nr_ndevs, int, 0); |
1496 | MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices" ); |
1497 | |
1498 | MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>" ); |
1499 | MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol" ); |
1500 | MODULE_LICENSE("GPL" ); |
1501 | MODULE_ALIAS_NETPROTO(PF_NETROM); |
1502 | |
1503 | static void __exit nr_exit(void) |
1504 | { |
1505 | int i; |
1506 | |
1507 | remove_proc_entry("nr" , init_net.proc_net); |
1508 | remove_proc_entry("nr_neigh" , init_net.proc_net); |
1509 | remove_proc_entry("nr_nodes" , init_net.proc_net); |
1510 | nr_loopback_clear(); |
1511 | |
1512 | nr_rt_free(); |
1513 | |
1514 | #ifdef CONFIG_SYSCTL |
1515 | nr_unregister_sysctl(); |
1516 | #endif |
1517 | |
1518 | ax25_linkfail_release(lf: &nr_linkfail_notifier); |
1519 | ax25_protocol_release(AX25_P_NETROM); |
1520 | |
1521 | unregister_netdevice_notifier(nb: &nr_dev_notifier); |
1522 | |
1523 | sock_unregister(PF_NETROM); |
1524 | |
1525 | for (i = 0; i < nr_ndevs; i++) { |
1526 | struct net_device *dev = dev_nr[i]; |
1527 | if (dev) { |
1528 | unregister_netdev(dev); |
1529 | free_netdev(dev); |
1530 | } |
1531 | } |
1532 | |
1533 | kfree(objp: dev_nr); |
1534 | proto_unregister(prot: &nr_proto); |
1535 | } |
1536 | module_exit(nr_exit); |
1537 | |