?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NTFS: Correct sparse file handling. The compressed values need to be
[linux-2.6/cjktty.git] / net / rose / af_rose.c
blob7eb6a5bf93ea1961bc0c35e70843a646c106596f
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
9 * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
10 * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
11 */
12 #include <linux/config.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/init.h>
16 #include <linux/errno.h>
17 #include <linux/types.h>
18 #include <linux/socket.h>
19 #include <linux/in.h>
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/spinlock.h>
23 #include <linux/timer.h>
24 #include <linux/string.h>
25 #include <linux/sockios.h>
26 #include <linux/net.h>
27 #include <linux/stat.h>
28 #include <net/ax25.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
33 #include <net/sock.h>
34 #include <asm/system.h>
35 #include <asm/uaccess.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h>
38 #include <linux/mm.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <net/rose.h>
42 #include <linux/proc_fs.h>
43 #include <linux/seq_file.h>
44 #include <net/tcp.h>
45 #include <net/ip.h>
46 #include <net/arp.h>
47
48 static int rose_ndevs = 10;
49
50 int sysctl_rose_restart_request_timeout = ROSE_DEFAULT_T0;
51 int sysctl_rose_call_request_timeout = ROSE_DEFAULT_T1;
52 int sysctl_rose_reset_request_timeout = ROSE_DEFAULT_T2;
53 int sysctl_rose_clear_request_timeout = ROSE_DEFAULT_T3;
54 int sysctl_rose_no_activity_timeout = ROSE_DEFAULT_IDLE;
55 int sysctl_rose_ack_hold_back_timeout = ROSE_DEFAULT_HB;
56 int sysctl_rose_routing_control = ROSE_DEFAULT_ROUTING;
57 int sysctl_rose_link_fail_timeout = ROSE_DEFAULT_FAIL_TIMEOUT;
58 int sysctl_rose_maximum_vcs = ROSE_DEFAULT_MAXVC;
59 int sysctl_rose_window_size = ROSE_DEFAULT_WINDOW_SIZE;
60
61 static HLIST_HEAD(rose_list);
62 static DEFINE_SPINLOCK(rose_list_lock);
63
64 static struct proto_ops rose_proto_ops;
65
66 ax25_address rose_callsign;
67
68 /*
69 * Convert a ROSE address into text.
70 */
71 const char *rose2asc(const rose_address *addr)
72 {
73 static char buffer[11];
74
75 if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
76 addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
77 addr->rose_addr[4] == 0x00) {
78 strcpy(buffer, "*");
79 } else {
80 sprintf(buffer, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xFF,
81 addr->rose_addr[1] & 0xFF,
82 addr->rose_addr[2] & 0xFF,
83 addr->rose_addr[3] & 0xFF,
84 addr->rose_addr[4] & 0xFF);
85 }
86
87 return buffer;
88 }
89
90 /*
91 * Compare two ROSE addresses, 0 == equal.
92 */
93 int rosecmp(rose_address *addr1, rose_address *addr2)
94 {
95 int i;
96
97 for (i = 0; i < 5; i++)
98 if (addr1->rose_addr[i] != addr2->rose_addr[i])
99 return 1;
100
101 return 0;
102 }
103
104 /*
105 * Compare two ROSE addresses for only mask digits, 0 == equal.
106 */
107 int rosecmpm(rose_address *addr1, rose_address *addr2, unsigned short mask)
108 {
109 int i, j;
110
111 if (mask > 10)
112 return 1;
113
114 for (i = 0; i < mask; i++) {
115 j = i / 2;
116
117 if ((i % 2) != 0) {
118 if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
119 return 1;
120 } else {
121 if ((addr1->rose_addr[j] & 0xF0) != (addr2->rose_addr[j] & 0xF0))
122 return 1;
123 }
124 }
125
126 return 0;
127 }
128
129 /*
130 * Socket removal during an interrupt is now safe.
131 */
132 static void rose_remove_socket(struct sock *sk)
133 {
134 spin_lock_bh(&rose_list_lock);
135 sk_del_node_init(sk);
136 spin_unlock_bh(&rose_list_lock);
137 }
138
139 /*
140 * Kill all bound sockets on a broken link layer connection to a
141 * particular neighbour.
142 */
143 void rose_kill_by_neigh(struct rose_neigh *neigh)
144 {
145 struct sock *s;
146 struct hlist_node *node;
147
148 spin_lock_bh(&rose_list_lock);
149 sk_for_each(s, node, &rose_list) {
150 struct rose_sock *rose = rose_sk(s);
151
152 if (rose->neighbour == neigh) {
153 rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
154 rose->neighbour->use--;
155 rose->neighbour = NULL;
156 }
157 }
158 spin_unlock_bh(&rose_list_lock);
159 }
160
161 /*
162 * Kill all bound sockets on a dropped device.
163 */
164 static void rose_kill_by_device(struct net_device *dev)
165 {
166 struct sock *s;
167 struct hlist_node *node;
168
169 spin_lock_bh(&rose_list_lock);
170 sk_for_each(s, node, &rose_list) {
171 struct rose_sock *rose = rose_sk(s);
172
173 if (rose->device == dev) {
174 rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
175 rose->neighbour->use--;
176 rose->device = NULL;
177 }
178 }
179 spin_unlock_bh(&rose_list_lock);
180 }
181
182 /*
183 * Handle device status changes.
184 */
185 static int rose_device_event(struct notifier_block *this, unsigned long event,
186 void *ptr)
187 {
188 struct net_device *dev = (struct net_device *)ptr;
189
190 if (event != NETDEV_DOWN)
191 return NOTIFY_DONE;
192
193 switch (dev->type) {
194 case ARPHRD_ROSE:
195 rose_kill_by_device(dev);
196 break;
197 case ARPHRD_AX25:
198 rose_link_device_down(dev);
199 rose_rt_device_down(dev);
200 break;
201 }
202
203 return NOTIFY_DONE;
204 }
205
206 /*
207 * Add a socket to the bound sockets list.
208 */
209 static void rose_insert_socket(struct sock *sk)
210 {
211
212 spin_lock_bh(&rose_list_lock);
213 sk_add_node(sk, &rose_list);
214 spin_unlock_bh(&rose_list_lock);
215 }
216
217 /*
218 * Find a socket that wants to accept the Call Request we just
219 * received.
220 */
221 static struct sock *rose_find_listener(rose_address *addr, ax25_address *call)
222 {
223 struct sock *s;
224 struct hlist_node *node;
225
226 spin_lock_bh(&rose_list_lock);
227 sk_for_each(s, node, &rose_list) {
228 struct rose_sock *rose = rose_sk(s);
229
230 if (!rosecmp(&rose->source_addr, addr) &&
231 !ax25cmp(&rose->source_call, call) &&
232 !rose->source_ndigis && s->sk_state == TCP_LISTEN)
233 goto found;
234 }
235
236 sk_for_each(s, node, &rose_list) {
237 struct rose_sock *rose = rose_sk(s);
238
239 if (!rosecmp(&rose->source_addr, addr) &&
240 !ax25cmp(&rose->source_call, &null_ax25_address) &&
241 s->sk_state == TCP_LISTEN)
242 goto found;
243 }
244 s = NULL;
245 found:
246 spin_unlock_bh(&rose_list_lock);
247 return s;
248 }
249
250 /*
251 * Find a connected ROSE socket given my LCI and device.
252 */
253 struct sock *rose_find_socket(unsigned int lci, struct rose_neigh *neigh)
254 {
255 struct sock *s;
256 struct hlist_node *node;
257
258 spin_lock_bh(&rose_list_lock);
259 sk_for_each(s, node, &rose_list) {
260 struct rose_sock *rose = rose_sk(s);
261
262 if (rose->lci == lci && rose->neighbour == neigh)
263 goto found;
264 }
265 s = NULL;
266 found:
267 spin_unlock_bh(&rose_list_lock);
268 return s;
269 }
270
271 /*
272 * Find a unique LCI for a given device.
273 */
274 unsigned int rose_new_lci(struct rose_neigh *neigh)
275 {
276 int lci;
277
278 if (neigh->dce_mode) {
279 for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
280 if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
281 return lci;
282 } else {
283 for (lci = sysctl_rose_maximum_vcs; lci > 0; lci--)
284 if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
285 return lci;
286 }
287
288 return 0;
289 }
290
291 /*
292 * Deferred destroy.
293 */
294 void rose_destroy_socket(struct sock *);
295
296 /*
297 * Handler for deferred kills.
298 */
299 static void rose_destroy_timer(unsigned long data)
300 {
301 rose_destroy_socket((struct sock *)data);
302 }
303
304 /*
305 * This is called from user mode and the timers. Thus it protects itself
306 * against interrupt users but doesn't worry about being called during
307 * work. Once it is removed from the queue no interrupt or bottom half
308 * will touch it and we are (fairly 8-) ) safe.
309 */
310 void rose_destroy_socket(struct sock *sk)
311 {
312 struct sk_buff *skb;
313
314 rose_remove_socket(sk);
315 rose_stop_heartbeat(sk);
316 rose_stop_idletimer(sk);
317 rose_stop_timer(sk);
318
319 rose_clear_queues(sk); /* Flush the queues */
320
321 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
322 if (skb->sk != sk) { /* A pending connection */
323 /* Queue the unaccepted socket for death */
324 sock_set_flag(skb->sk, SOCK_DEAD);
325 rose_start_heartbeat(skb->sk);
326 rose_sk(skb->sk)->state = ROSE_STATE_0;
327 }
328
329 kfree_skb(skb);
330 }
331
332 if (atomic_read(&sk->sk_wmem_alloc) ||
333 atomic_read(&sk->sk_rmem_alloc)) {
334 /* Defer: outstanding buffers */
335 init_timer(&sk->sk_timer);
336 sk->sk_timer.expires = jiffies + 10 * HZ;
337 sk->sk_timer.function = rose_destroy_timer;
338 sk->sk_timer.data = (unsigned long)sk;
339 add_timer(&sk->sk_timer);
340 } else
341 sock_put(sk);
342 }
343
344 /*
345 * Handling for system calls applied via the various interfaces to a
346 * ROSE socket object.
347 */
348
349 static int rose_setsockopt(struct socket *sock, int level, int optname,
350 char __user *optval, int optlen)
351 {
352 struct sock *sk = sock->sk;
353 struct rose_sock *rose = rose_sk(sk);
354 int opt;
355
356 if (level != SOL_ROSE)
357 return -ENOPROTOOPT;
358
359 if (optlen < sizeof(int))
360 return -EINVAL;
361
362 if (get_user(opt, (int __user *)optval))
363 return -EFAULT;
364
365 switch (optname) {
366 case ROSE_DEFER:
367 rose->defer = opt ? 1 : 0;
368 return 0;
369
370 case ROSE_T1:
371 if (opt < 1)
372 return -EINVAL;
373 rose->t1 = opt * HZ;
374 return 0;
375
376 case ROSE_T2:
377 if (opt < 1)
378 return -EINVAL;
379 rose->t2 = opt * HZ;
380 return 0;
381
382 case ROSE_T3:
383 if (opt < 1)
384 return -EINVAL;
385 rose->t3 = opt * HZ;
386 return 0;
387
388 case ROSE_HOLDBACK:
389 if (opt < 1)
390 return -EINVAL;
391 rose->hb = opt * HZ;
392 return 0;
393
394 case ROSE_IDLE:
395 if (opt < 0)
396 return -EINVAL;
397 rose->idle = opt * 60 * HZ;
398 return 0;
399
400 case ROSE_QBITINCL:
401 rose->qbitincl = opt ? 1 : 0;
402 return 0;
403
404 default:
405 return -ENOPROTOOPT;
406 }
407 }
408
409 static int rose_getsockopt(struct socket *sock, int level, int optname,
410 char __user *optval, int __user *optlen)
411 {
412 struct sock *sk = sock->sk;
413 struct rose_sock *rose = rose_sk(sk);
414 int val = 0;
415 int len;
416
417 if (level != SOL_ROSE)
418 return -ENOPROTOOPT;
419
420 if (get_user(len, optlen))
421 return -EFAULT;
422
423 if (len < 0)
424 return -EINVAL;
425
426 switch (optname) {
427 case ROSE_DEFER:
428 val = rose->defer;
429 break;
430
431 case ROSE_T1:
432 val = rose->t1 / HZ;
433 break;
434
435 case ROSE_T2:
436 val = rose->t2 / HZ;
437 break;
438
439 case ROSE_T3:
440 val = rose->t3 / HZ;
441 break;
442
443 case ROSE_HOLDBACK:
444 val = rose->hb / HZ;
445 break;
446
447 case ROSE_IDLE:
448 val = rose->idle / (60 * HZ);
449 break;
450
451 case ROSE_QBITINCL:
452 val = rose->qbitincl;
453 break;
454
455 default:
456 return -ENOPROTOOPT;
457 }
458
459 len = min_t(unsigned int, len, sizeof(int));
460
461 if (put_user(len, optlen))
462 return -EFAULT;
463
464 return copy_to_user(optval, &val, len) ? -EFAULT : 0;
465 }
466
467 static int rose_listen(struct socket *sock, int backlog)
468 {
469 struct sock *sk = sock->sk;
470
471 if (sk->sk_state != TCP_LISTEN) {
472 struct rose_sock *rose = rose_sk(sk);
473
474 rose->dest_ndigis = 0;
475 memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
476 memset(&rose->dest_call, 0, AX25_ADDR_LEN);
477 memset(rose->dest_digis, 0, AX25_ADDR_LEN * ROSE_MAX_DIGIS);
478 sk->sk_max_ack_backlog = backlog;
479 sk->sk_state = TCP_LISTEN;
480 return 0;
481 }
482
483 return -EOPNOTSUPP;
484 }
485
486 static struct proto rose_proto = {
487 .name = "ROSE",
488 .owner = THIS_MODULE,
489 .obj_size = sizeof(struct rose_sock),
490 };
491
492 static int rose_create(struct socket *sock, int protocol)
493 {
494 struct sock *sk;
495 struct rose_sock *rose;
496
497 if (sock->type != SOCK_SEQPACKET || protocol != 0)
498 return -ESOCKTNOSUPPORT;
499
500 if ((sk = sk_alloc(PF_ROSE, GFP_ATOMIC, &rose_proto, 1)) == NULL)
501 return -ENOMEM;
502
503 rose = rose_sk(sk);
504
505 sock_init_data(sock, sk);
506
507 skb_queue_head_init(&rose->ack_queue);
508 #ifdef M_BIT
509 skb_queue_head_init(&rose->frag_queue);
510 rose->fraglen = 0;
511 #endif
512
513 sock->ops = &rose_proto_ops;
514 sk->sk_protocol = protocol;
515
516 init_timer(&rose->timer);
517 init_timer(&rose->idletimer);
518
519 rose->t1 = sysctl_rose_call_request_timeout;
520 rose->t2 = sysctl_rose_reset_request_timeout;
521 rose->t3 = sysctl_rose_clear_request_timeout;
522 rose->hb = sysctl_rose_ack_hold_back_timeout;
523 rose->idle = sysctl_rose_no_activity_timeout;
524
525 rose->state = ROSE_STATE_0;
526
527 return 0;
528 }
529
530 static struct sock *rose_make_new(struct sock *osk)
531 {
532 struct sock *sk;
533 struct rose_sock *rose, *orose;
534
535 if (osk->sk_type != SOCK_SEQPACKET)
536 return NULL;
537
538 if ((sk = sk_alloc(PF_ROSE, GFP_ATOMIC, &rose_proto, 1)) == NULL)
539 return NULL;
540
541 rose = rose_sk(sk);
542
543 sock_init_data(NULL, sk);
544
545 skb_queue_head_init(&rose->ack_queue);
546 #ifdef M_BIT
547 skb_queue_head_init(&rose->frag_queue);
548 rose->fraglen = 0;
549 #endif
550
551 sk->sk_type = osk->sk_type;
552 sk->sk_socket = osk->sk_socket;
553 sk->sk_priority = osk->sk_priority;
554 sk->sk_protocol = osk->sk_protocol;
555 sk->sk_rcvbuf = osk->sk_rcvbuf;
556 sk->sk_sndbuf = osk->sk_sndbuf;
557 sk->sk_state = TCP_ESTABLISHED;
558 sk->sk_sleep = osk->sk_sleep;
559
560 if (sock_flag(osk, SOCK_ZAPPED))
561 sock_set_flag(sk, SOCK_ZAPPED);
562
563 if (sock_flag(osk, SOCK_DBG))
564 sock_set_flag(sk, SOCK_DBG);
565
566 init_timer(&rose->timer);
567 init_timer(&rose->idletimer);
568
569 orose = rose_sk(osk);
570 rose->t1 = orose->t1;
571 rose->t2 = orose->t2;
572 rose->t3 = orose->t3;
573 rose->hb = orose->hb;
574 rose->idle = orose->idle;
575 rose->defer = orose->defer;
576 rose->device = orose->device;
577 rose->qbitincl = orose->qbitincl;
578
579 return sk;
580 }
581
582 static int rose_release(struct socket *sock)
583 {
584 struct sock *sk = sock->sk;
585 struct rose_sock *rose;
586
587 if (sk == NULL) return 0;
588
589 rose = rose_sk(sk);
590
591 switch (rose->state) {
592 case ROSE_STATE_0:
593 rose_disconnect(sk, 0, -1, -1);
594 rose_destroy_socket(sk);
595 break;
596
597 case ROSE_STATE_2:
598 rose->neighbour->use--;
599 rose_disconnect(sk, 0, -1, -1);
600 rose_destroy_socket(sk);
601 break;
602
603 case ROSE_STATE_1:
604 case ROSE_STATE_3:
605 case ROSE_STATE_4:
606 case ROSE_STATE_5:
607 rose_clear_queues(sk);
608 rose_stop_idletimer(sk);
609 rose_write_internal(sk, ROSE_CLEAR_REQUEST);
610 rose_start_t3timer(sk);
611 rose->state = ROSE_STATE_2;
612 sk->sk_state = TCP_CLOSE;
613 sk->sk_shutdown |= SEND_SHUTDOWN;
614 sk->sk_state_change(sk);
615 sock_set_flag(sk, SOCK_DEAD);
616 sock_set_flag(sk, SOCK_DESTROY);
617 break;
618
619 default:
620 break;
621 }
622
623 sock->sk = NULL;
624
625 return 0;
626 }
627
628 static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
629 {
630 struct sock *sk = sock->sk;
631 struct rose_sock *rose = rose_sk(sk);
632 struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
633 struct net_device *dev;
634 ax25_address *user, *source;
635 int n;
636
637 if (!sock_flag(sk, SOCK_ZAPPED))
638 return -EINVAL;
639
640 if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
641 return -EINVAL;
642
643 if (addr->srose_family != AF_ROSE)
644 return -EINVAL;
645
646 if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
647 return -EINVAL;
648
649 if (addr->srose_ndigis > ROSE_MAX_DIGIS)
650 return -EINVAL;
651
652 if ((dev = rose_dev_get(&addr->srose_addr)) == NULL) {
653 SOCK_DEBUG(sk, "ROSE: bind failed: invalid address\n");
654 return -EADDRNOTAVAIL;
655 }
656
657 source = &addr->srose_call;
658
659 if ((user = ax25_findbyuid(current->euid)) == NULL) {
660 if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
661 return -EACCES;
662 user = source;
663 }
664
665 rose->source_addr = addr->srose_addr;
666 rose->source_call = *user;
667 rose->device = dev;
668 rose->source_ndigis = addr->srose_ndigis;
669
670 if (addr_len == sizeof(struct full_sockaddr_rose)) {
671 struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
672 for (n = 0 ; n < addr->srose_ndigis ; n++)
673 rose->source_digis[n] = full_addr->srose_digis[n];
674 } else {
675 if (rose->source_ndigis == 1) {
676 rose->source_digis[0] = addr->srose_digi;
677 }
678 }
679
680 rose_insert_socket(sk);
681
682 sock_reset_flag(sk, SOCK_ZAPPED);
683 SOCK_DEBUG(sk, "ROSE: socket is bound\n");
684 return 0;
685 }
686
687 static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
688 {
689 struct sock *sk = sock->sk;
690 struct rose_sock *rose = rose_sk(sk);
691 struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
692 unsigned char cause, diagnostic;
693 ax25_address *user;
694 struct net_device *dev;
695 int n;
696
697 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
698 sock->state = SS_CONNECTED;
699 return 0; /* Connect completed during a ERESTARTSYS event */
700 }
701
702 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
703 sock->state = SS_UNCONNECTED;
704 return -ECONNREFUSED;
705 }
706
707 if (sk->sk_state == TCP_ESTABLISHED)
708 return -EISCONN; /* No reconnect on a seqpacket socket */
709
710 sk->sk_state = TCP_CLOSE;
711 sock->state = SS_UNCONNECTED;
712
713 if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
714 return -EINVAL;
715
716 if (addr->srose_family != AF_ROSE)
717 return -EINVAL;
718
719 if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
720 return -EINVAL;
721
722 if (addr->srose_ndigis > ROSE_MAX_DIGIS)
723 return -EINVAL;
724
725 /* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
726 if ((rose->source_ndigis + addr->srose_ndigis) > ROSE_MAX_DIGIS)
727 return -EINVAL;
728
729 rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause,
730 &diagnostic);
731 if (!rose->neighbour)
732 return -ENETUNREACH;
733
734 rose->lci = rose_new_lci(rose->neighbour);
735 if (!rose->lci)
736 return -ENETUNREACH;
737
738 if (sock_flag(sk, SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */
739 sock_reset_flag(sk, SOCK_ZAPPED);
740
741 if ((dev = rose_dev_first()) == NULL)
742 return -ENETUNREACH;
743
744 if ((user = ax25_findbyuid(current->euid)) == NULL)
745 return -EINVAL;
746
747 memcpy(&rose->source_addr, dev->dev_addr, ROSE_ADDR_LEN);
748 rose->source_call = *user;
749 rose->device = dev;
750
751 rose_insert_socket(sk); /* Finish the bind */
752 }
753
754 rose->dest_addr = addr->srose_addr;
755 rose->dest_call = addr->srose_call;
756 rose->rand = ((long)rose & 0xFFFF) + rose->lci;
757 rose->dest_ndigis = addr->srose_ndigis;
758
759 if (addr_len == sizeof(struct full_sockaddr_rose)) {
760 struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
761 for (n = 0 ; n < addr->srose_ndigis ; n++)
762 rose->dest_digis[n] = full_addr->srose_digis[n];
763 } else {
764 if (rose->dest_ndigis == 1) {
765 rose->dest_digis[0] = addr->srose_digi;
766 }
767 }
768
769 /* Move to connecting socket, start sending Connect Requests */
770 sock->state = SS_CONNECTING;
771 sk->sk_state = TCP_SYN_SENT;
772
773 rose->state = ROSE_STATE_1;
774
775 rose->neighbour->use++;
776
777 rose_write_internal(sk, ROSE_CALL_REQUEST);
778 rose_start_heartbeat(sk);
779 rose_start_t1timer(sk);
780
781 /* Now the loop */
782 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
783 return -EINPROGRESS;
784
785 /*
786 * A Connect Ack with Choke or timeout or failed routing will go to
787 * closed.
788 */
789 if (sk->sk_state == TCP_SYN_SENT) {
790 struct task_struct *tsk = current;
791 DECLARE_WAITQUEUE(wait, tsk);
792
793 add_wait_queue(sk->sk_sleep, &wait);
794 for (;;) {
795 set_current_state(TASK_INTERRUPTIBLE);
796 if (sk->sk_state != TCP_SYN_SENT)
797 break;
798 if (!signal_pending(tsk)) {
799 schedule();
800 continue;
801 }
802 current->state = TASK_RUNNING;
803 remove_wait_queue(sk->sk_sleep, &wait);
804 return -ERESTARTSYS;
805 }
806 current->state = TASK_RUNNING;
807 remove_wait_queue(sk->sk_sleep, &wait);
808 }
809
810 if (sk->sk_state != TCP_ESTABLISHED) {
811 sock->state = SS_UNCONNECTED;
812 return sock_error(sk); /* Always set at this point */
813 }
814
815 sock->state = SS_CONNECTED;
816
817 return 0;
818 }
819
820 static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
821 {
822 struct task_struct *tsk = current;
823 DECLARE_WAITQUEUE(wait, tsk);
824 struct sk_buff *skb;
825 struct sock *newsk;
826 struct sock *sk;
827 int err = 0;
828
829 if ((sk = sock->sk) == NULL)
830 return -EINVAL;
831
832 lock_sock(sk);
833 if (sk->sk_type != SOCK_SEQPACKET) {
834 err = -EOPNOTSUPP;
835 goto out;
836 }
837
838 if (sk->sk_state != TCP_LISTEN) {
839 err = -EINVAL;
840 goto out;
841 }
842
843 /*
844 * The write queue this time is holding sockets ready to use
845 * hooked into the SABM we saved
846 */
847 add_wait_queue(sk->sk_sleep, &wait);
848 for (;;) {
849 skb = skb_dequeue(&sk->sk_receive_queue);
850 if (skb)
851 break;
852
853 current->state = TASK_INTERRUPTIBLE;
854 release_sock(sk);
855 if (flags & O_NONBLOCK) {
856 current->state = TASK_RUNNING;
857 remove_wait_queue(sk->sk_sleep, &wait);
858 return -EWOULDBLOCK;
859 }
860 if (!signal_pending(tsk)) {
861 schedule();
862 lock_sock(sk);
863 continue;
864 }
865 return -ERESTARTSYS;
866 }
867 current->state = TASK_RUNNING;
868 remove_wait_queue(sk->sk_sleep, &wait);
869
870 newsk = skb->sk;
871 newsk->sk_socket = newsock;
872 newsk->sk_sleep = &newsock->wait;
873
874 /* Now attach up the new socket */
875 skb->sk = NULL;
876 kfree_skb(skb);
877 sk->sk_ack_backlog--;
878 newsock->sk = newsk;
879
880 out:
881 release_sock(sk);
882
883 return err;
884 }
885
886 static int rose_getname(struct socket *sock, struct sockaddr *uaddr,
887 int *uaddr_len, int peer)
888 {
889 struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
890 struct sock *sk = sock->sk;
891 struct rose_sock *rose = rose_sk(sk);
892 int n;
893
894 if (peer != 0) {
895 if (sk->sk_state != TCP_ESTABLISHED)
896 return -ENOTCONN;
897 srose->srose_family = AF_ROSE;
898 srose->srose_addr = rose->dest_addr;
899 srose->srose_call = rose->dest_call;
900 srose->srose_ndigis = rose->dest_ndigis;
901 for (n = 0; n < rose->dest_ndigis; n++)
902 srose->srose_digis[n] = rose->dest_digis[n];
903 } else {
904 srose->srose_family = AF_ROSE;
905 srose->srose_addr = rose->source_addr;
906 srose->srose_call = rose->source_call;
907 srose->srose_ndigis = rose->source_ndigis;
908 for (n = 0; n < rose->source_ndigis; n++)
909 srose->srose_digis[n] = rose->source_digis[n];
910 }
911
912 *uaddr_len = sizeof(struct full_sockaddr_rose);
913 return 0;
914 }
915
916 int rose_rx_call_request(struct sk_buff *skb, struct net_device *dev, struct rose_neigh *neigh, unsigned int lci)
917 {
918 struct sock *sk;
919 struct sock *make;
920 struct rose_sock *make_rose;
921 struct rose_facilities_struct facilities;
922 int n, len;
923
924 skb->sk = NULL; /* Initially we don't know who it's for */
925
926 /*
927 * skb->data points to the rose frame start
928 */
929 memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
930
931 len = (((skb->data[3] >> 4) & 0x0F) + 1) / 2;
932 len += (((skb->data[3] >> 0) & 0x0F) + 1) / 2;
933 if (!rose_parse_facilities(skb->data + len + 4, &facilities)) {
934 rose_transmit_clear_request(neigh, lci, ROSE_INVALID_FACILITY, 76);
935 return 0;
936 }
937
938 sk = rose_find_listener(&facilities.source_addr, &facilities.source_call);
939
940 /*
941 * We can't accept the Call Request.
942 */
943 if (sk == NULL || sk_acceptq_is_full(sk) ||
944 (make = rose_make_new(sk)) == NULL) {
945 rose_transmit_clear_request(neigh, lci, ROSE_NETWORK_CONGESTION, 120);
946 return 0;
947 }
948
949 skb->sk = make;
950 make->sk_state = TCP_ESTABLISHED;
951 make_rose = rose_sk(make);
952
953 make_rose->lci = lci;
954 make_rose->dest_addr = facilities.dest_addr;
955 make_rose->dest_call = facilities.dest_call;
956 make_rose->dest_ndigis = facilities.dest_ndigis;
957 for (n = 0 ; n < facilities.dest_ndigis ; n++)
958 make_rose->dest_digis[n] = facilities.dest_digis[n];
959 make_rose->source_addr = facilities.source_addr;
960 make_rose->source_call = facilities.source_call;
961 make_rose->source_ndigis = facilities.source_ndigis;
962 for (n = 0 ; n < facilities.source_ndigis ; n++)
963 make_rose->source_digis[n]= facilities.source_digis[n];
964 make_rose->neighbour = neigh;
965 make_rose->device = dev;
966 make_rose->facilities = facilities;
967
968 make_rose->neighbour->use++;
969
970 if (rose_sk(sk)->defer) {
971 make_rose->state = ROSE_STATE_5;
972 } else {
973 rose_write_internal(make, ROSE_CALL_ACCEPTED);
974 make_rose->state = ROSE_STATE_3;
975 rose_start_idletimer(make);
976 }
977
978 make_rose->condition = 0x00;
979 make_rose->vs = 0;
980 make_rose->va = 0;
981 make_rose->vr = 0;
982 make_rose->vl = 0;
983 sk->sk_ack_backlog++;
984
985 rose_insert_socket(make);
986
987 skb_queue_head(&sk->sk_receive_queue, skb);
988
989 rose_start_heartbeat(make);
990
991 if (!sock_flag(sk, SOCK_DEAD))
992 sk->sk_data_ready(sk, skb->len);
993
994 return 1;
995 }
996
997 static int rose_sendmsg(struct kiocb *iocb, struct socket *sock,
998 struct msghdr *msg, size_t len)
999 {
1000 struct sock *sk = sock->sk;
1001 struct rose_sock *rose = rose_sk(sk);
1002 struct sockaddr_rose *usrose = (struct sockaddr_rose *)msg->msg_name;
1003 int err;
1004 struct full_sockaddr_rose srose;
1005 struct sk_buff *skb;
1006 unsigned char *asmptr;
1007 int n, size, qbit = 0;
1008
1009 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1010 return -EINVAL;
1011
1012 if (sock_flag(sk, SOCK_ZAPPED))
1013 return -EADDRNOTAVAIL;
1014
1015 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1016 send_sig(SIGPIPE, current, 0);
1017 return -EPIPE;
1018 }
1019
1020 if (rose->neighbour == NULL || rose->device == NULL)
1021 return -ENETUNREACH;
1022
1023 if (usrose != NULL) {
1024 if (msg->msg_namelen != sizeof(struct sockaddr_rose) && msg->msg_namelen != sizeof(struct full_sockaddr_rose))
1025 return -EINVAL;
1026 memset(&srose, 0, sizeof(struct full_sockaddr_rose));
1027 memcpy(&srose, usrose, msg->msg_namelen);
1028 if (rosecmp(&rose->dest_addr, &srose.srose_addr) != 0 ||
1029 ax25cmp(&rose->dest_call, &srose.srose_call) != 0)
1030 return -EISCONN;
1031 if (srose.srose_ndigis != rose->dest_ndigis)
1032 return -EISCONN;
1033 if (srose.srose_ndigis == rose->dest_ndigis) {
1034 for (n = 0 ; n < srose.srose_ndigis ; n++)
1035 if (ax25cmp(&rose->dest_digis[n],
1036 &srose.srose_digis[n]))
1037 return -EISCONN;
1038 }
1039 if (srose.srose_family != AF_ROSE)
1040 return -EINVAL;
1041 } else {
1042 if (sk->sk_state != TCP_ESTABLISHED)
1043 return -ENOTCONN;
1044
1045 srose.srose_family = AF_ROSE;
1046 srose.srose_addr = rose->dest_addr;
1047 srose.srose_call = rose->dest_call;
1048 srose.srose_ndigis = rose->dest_ndigis;
1049 for (n = 0 ; n < rose->dest_ndigis ; n++)
1050 srose.srose_digis[n] = rose->dest_digis[n];
1051 }
1052
1053 SOCK_DEBUG(sk, "ROSE: sendto: Addresses built.\n");
1054
1055 /* Build a packet */
1056 SOCK_DEBUG(sk, "ROSE: sendto: building packet.\n");
1057 size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
1058
1059 if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1060 return err;
1061
1062 skb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN);
1063
1064 /*
1065 * Put the data on the end
1066 */
1067 SOCK_DEBUG(sk, "ROSE: Appending user data\n");
1068
1069 asmptr = skb->h.raw = skb_put(skb, len);
1070
1071 err = memcpy_fromiovec(asmptr, msg->msg_iov, len);
1072 if (err) {
1073 kfree_skb(skb);
1074 return err;
1075 }
1076
1077 /*
1078 * If the Q BIT Include socket option is in force, the first
1079 * byte of the user data is the logical value of the Q Bit.
1080 */
1081 if (rose->qbitincl) {
1082 qbit = skb->data[0];
1083 skb_pull(skb, 1);
1084 }
1085
1086 /*
1087 * Push down the ROSE header
1088 */
1089 asmptr = skb_push(skb, ROSE_MIN_LEN);
1090
1091 SOCK_DEBUG(sk, "ROSE: Building Network Header.\n");
1092
1093 /* Build a ROSE Network header */
1094 asmptr[0] = ((rose->lci >> 8) & 0x0F) | ROSE_GFI;
1095 asmptr[1] = (rose->lci >> 0) & 0xFF;
1096 asmptr[2] = ROSE_DATA;
1097
1098 if (qbit)
1099 asmptr[0] |= ROSE_Q_BIT;
1100
1101 SOCK_DEBUG(sk, "ROSE: Built header.\n");
1102
1103 SOCK_DEBUG(sk, "ROSE: Transmitting buffer\n");
1104
1105 if (sk->sk_state != TCP_ESTABLISHED) {
1106 kfree_skb(skb);
1107 return -ENOTCONN;
1108 }
1109
1110 #ifdef M_BIT
1111 #define ROSE_PACLEN (256-ROSE_MIN_LEN)
1112 if (skb->len - ROSE_MIN_LEN > ROSE_PACLEN) {
1113 unsigned char header[ROSE_MIN_LEN];
1114 struct sk_buff *skbn;
1115 int frontlen;
1116 int lg;
1117
1118 /* Save a copy of the Header */
1119 memcpy(header, skb->data, ROSE_MIN_LEN);
1120 skb_pull(skb, ROSE_MIN_LEN);
1121
1122 frontlen = skb_headroom(skb);
1123
1124 while (skb->len > 0) {
1125 if ((skbn = sock_alloc_send_skb(sk, frontlen + ROSE_PACLEN, 0, &err)) == NULL) {
1126 kfree_skb(skb);
1127 return err;
1128 }
1129
1130 skbn->sk = sk;
1131 skbn->free = 1;
1132 skbn->arp = 1;
1133
1134 skb_reserve(skbn, frontlen);
1135
1136 lg = (ROSE_PACLEN > skb->len) ? skb->len : ROSE_PACLEN;
1137
1138 /* Copy the user data */
1139 memcpy(skb_put(skbn, lg), skb->data, lg);
1140 skb_pull(skb, lg);
1141
1142 /* Duplicate the Header */
1143 skb_push(skbn, ROSE_MIN_LEN);
1144 memcpy(skbn->data, header, ROSE_MIN_LEN);
1145
1146 if (skb->len > 0)
1147 skbn->data[2] |= M_BIT;
1148
1149 skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
1150 }
1151
1152 skb->free = 1;
1153 kfree_skb(skb);
1154 } else {
1155 skb_queue_tail(&sk->sk_write_queue, skb); /* Throw it on the queue */
1156 }
1157 #else
1158 skb_queue_tail(&sk->sk_write_queue, skb); /* Shove it onto the queue */
1159 #endif
1160
1161 rose_kick(sk);
1162
1163 return len;
1164 }
1165
1166
1167 static int rose_recvmsg(struct kiocb *iocb, struct socket *sock,
1168 struct msghdr *msg, size_t size, int flags)
1169 {
1170 struct sock *sk = sock->sk;
1171 struct rose_sock *rose = rose_sk(sk);
1172 struct sockaddr_rose *srose = (struct sockaddr_rose *)msg->msg_name;
1173 size_t copied;
1174 unsigned char *asmptr;
1175 struct sk_buff *skb;
1176 int n, er, qbit;
1177
1178 /*
1179 * This works for seqpacket too. The receiver has ordered the queue for
1180 * us! We do one quick check first though
1181 */
1182 if (sk->sk_state != TCP_ESTABLISHED)
1183 return -ENOTCONN;
1184
1185 /* Now we can treat all alike */
1186 if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
1187 return er;
1188
1189 qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
1190
1191 skb_pull(skb, ROSE_MIN_LEN);
1192
1193 if (rose->qbitincl) {
1194 asmptr = skb_push(skb, 1);
1195 *asmptr = qbit;
1196 }
1197
1198 skb->h.raw = skb->data;
1199 copied = skb->len;
1200
1201 if (copied > size) {
1202 copied = size;
1203 msg->msg_flags |= MSG_TRUNC;
1204 }
1205
1206 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1207
1208 if (srose != NULL) {
1209 srose->srose_family = AF_ROSE;
1210 srose->srose_addr = rose->dest_addr;
1211 srose->srose_call = rose->dest_call;
1212 srose->srose_ndigis = rose->dest_ndigis;
1213 if (msg->msg_namelen >= sizeof(struct full_sockaddr_rose)) {
1214 struct full_sockaddr_rose *full_srose = (struct full_sockaddr_rose *)msg->msg_name;
1215 for (n = 0 ; n < rose->dest_ndigis ; n++)
1216 full_srose->srose_digis[n] = rose->dest_digis[n];
1217 msg->msg_namelen = sizeof(struct full_sockaddr_rose);
1218 } else {
1219 if (rose->dest_ndigis >= 1) {
1220 srose->srose_ndigis = 1;
1221 srose->srose_digi = rose->dest_digis[0];
1222 }
1223 msg->msg_namelen = sizeof(struct sockaddr_rose);
1224 }
1225 }
1226
1227 skb_free_datagram(sk, skb);
1228
1229 return copied;
1230 }
1231
1232
1233 static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1234 {
1235 struct sock *sk = sock->sk;
1236 struct rose_sock *rose = rose_sk(sk);
1237 void __user *argp = (void __user *)arg;
1238
1239 switch (cmd) {
1240 case TIOCOUTQ: {
1241 long amount;
1242 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1243 if (amount < 0)
1244 amount = 0;
1245 return put_user(amount, (unsigned int __user *)argp);
1246 }
1247
1248 case TIOCINQ: {
1249 struct sk_buff *skb;
1250 long amount = 0L;
1251 /* These two are safe on a single CPU system as only user tasks fiddle here */
1252 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1253 amount = skb->len;
1254 return put_user(amount, (unsigned int __user *)argp);
1255 }
1256
1257 case SIOCGSTAMP:
1258 if (sk != NULL)
1259 return sock_get_timestamp(sk, (struct timeval __user *)argp);
1260 return -EINVAL;
1261
1262 case SIOCGIFADDR:
1263 case SIOCSIFADDR:
1264 case SIOCGIFDSTADDR:
1265 case SIOCSIFDSTADDR:
1266 case SIOCGIFBRDADDR:
1267 case SIOCSIFBRDADDR:
1268 case SIOCGIFNETMASK:
1269 case SIOCSIFNETMASK:
1270 case SIOCGIFMETRIC:
1271 case SIOCSIFMETRIC:
1272 return -EINVAL;
1273
1274 case SIOCADDRT:
1275 case SIOCDELRT:
1276 case SIOCRSCLRRT:
1277 if (!capable(CAP_NET_ADMIN))
1278 return -EPERM;
1279 return rose_rt_ioctl(cmd, argp);
1280
1281 case SIOCRSGCAUSE: {
1282 struct rose_cause_struct rose_cause;
1283 rose_cause.cause = rose->cause;
1284 rose_cause.diagnostic = rose->diagnostic;
1285 return copy_to_user(argp, &rose_cause, sizeof(struct rose_cause_struct)) ? -EFAULT : 0;
1286 }
1287
1288 case SIOCRSSCAUSE: {
1289 struct rose_cause_struct rose_cause;
1290 if (copy_from_user(&rose_cause, argp, sizeof(struct rose_cause_struct)))
1291 return -EFAULT;
1292 rose->cause = rose_cause.cause;
1293 rose->diagnostic = rose_cause.diagnostic;
1294 return 0;
1295 }
1296
1297 case SIOCRSSL2CALL:
1298 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1299 if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1300 ax25_listen_release(&rose_callsign, NULL);
1301 if (copy_from_user(&rose_callsign, argp, sizeof(ax25_address)))
1302 return -EFAULT;
1303 if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1304 ax25_listen_register(&rose_callsign, NULL);
1305 return 0;
1306
1307 case SIOCRSGL2CALL:
1308 return copy_to_user(argp, &rose_callsign, sizeof(ax25_address)) ? -EFAULT : 0;
1309
1310 case SIOCRSACCEPT:
1311 if (rose->state == ROSE_STATE_5) {
1312 rose_write_internal(sk, ROSE_CALL_ACCEPTED);
1313 rose_start_idletimer(sk);
1314 rose->condition = 0x00;
1315 rose->vs = 0;
1316 rose->va = 0;
1317 rose->vr = 0;
1318 rose->vl = 0;
1319 rose->state = ROSE_STATE_3;
1320 }
1321 return 0;
1322
1323 default:
1324 return dev_ioctl(cmd, argp);
1325 }
1326
1327 return 0;
1328 }
1329
1330 #ifdef CONFIG_PROC_FS
1331 static void *rose_info_start(struct seq_file *seq, loff_t *pos)
1332 {
1333 int i;
1334 struct sock *s;
1335 struct hlist_node *node;
1336
1337 spin_lock_bh(&rose_list_lock);
1338 if (*pos == 0)
1339 return SEQ_START_TOKEN;
1340
1341 i = 1;
1342 sk_for_each(s, node, &rose_list) {
1343 if (i == *pos)
1344 return s;
1345 ++i;
1346 }
1347 return NULL;
1348 }
1349
1350 static void *rose_info_next(struct seq_file *seq, void *v, loff_t *pos)
1351 {
1352 ++*pos;
1353
1354 return (v == SEQ_START_TOKEN) ? sk_head(&rose_list)
1355 : sk_next((struct sock *)v);
1356 }
1357
1358 static void rose_info_stop(struct seq_file *seq, void *v)
1359 {
1360 spin_unlock_bh(&rose_list_lock);
1361 }
1362
1363 static int rose_info_show(struct seq_file *seq, void *v)
1364 {
1365 if (v == SEQ_START_TOKEN)
1366 seq_puts(seq,
1367 "dest_addr dest_call src_addr src_call dev lci neigh st vs vr va t t1 t2 t3 hb idle Snd-Q Rcv-Q inode\n");
1368
1369 else {
1370 struct sock *s = v;
1371 struct rose_sock *rose = rose_sk(s);
1372 const char *devname, *callsign;
1373 const struct net_device *dev = rose->device;
1374
1375 if (!dev)
1376 devname = "???";
1377 else
1378 devname = dev->name;
1379
1380 seq_printf(seq, "%-10s %-9s ",
1381 rose2asc(&rose->dest_addr),
1382 ax2asc(&rose->dest_call));
1383
1384 if (ax25cmp(&rose->source_call, &null_ax25_address) == 0)
1385 callsign = "??????-?";
1386 else
1387 callsign = ax2asc(&rose->source_call);
1388
1389 seq_printf(seq,
1390 "%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
1391 rose2asc(&rose->source_addr),
1392 callsign,
1393 devname,
1394 rose->lci & 0x0FFF,
1395 (rose->neighbour) ? rose->neighbour->number : 0,
1396 rose->state,
1397 rose->vs,
1398 rose->vr,
1399 rose->va,
1400 ax25_display_timer(&rose->timer) / HZ,
1401 rose->t1 / HZ,
1402 rose->t2 / HZ,
1403 rose->t3 / HZ,
1404 rose->hb / HZ,
1405 ax25_display_timer(&rose->idletimer) / (60 * HZ),
1406 rose->idle / (60 * HZ),
1407 atomic_read(&s->sk_wmem_alloc),
1408 atomic_read(&s->sk_rmem_alloc),
1409 s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1410 }
1411
1412 return 0;
1413 }
1414
1415 static struct seq_operations rose_info_seqops = {
1416 .start = rose_info_start,
1417 .next = rose_info_next,
1418 .stop = rose_info_stop,
1419 .show = rose_info_show,
1420 };
1421
1422 static int rose_info_open(struct inode *inode, struct file *file)
1423 {
1424 return seq_open(file, &rose_info_seqops);
1425 }
1426
1427 static struct file_operations rose_info_fops = {
1428 .owner = THIS_MODULE,
1429 .open = rose_info_open,
1430 .read = seq_read,
1431 .llseek = seq_lseek,
1432 .release = seq_release,
1433 };
1434 #endif /* CONFIG_PROC_FS */
1435
1436 static struct net_proto_family rose_family_ops = {
1437 .family = PF_ROSE,
1438 .create = rose_create,
1439 .owner = THIS_MODULE,
1440 };
1441
1442 static struct proto_ops rose_proto_ops = {
1443 .family = PF_ROSE,
1444 .owner = THIS_MODULE,
1445 .release = rose_release,
1446 .bind = rose_bind,
1447 .connect = rose_connect,
1448 .socketpair = sock_no_socketpair,
1449 .accept = rose_accept,
1450 .getname = rose_getname,
1451 .poll = datagram_poll,
1452 .ioctl = rose_ioctl,
1453 .listen = rose_listen,
1454 .shutdown = sock_no_shutdown,
1455 .setsockopt = rose_setsockopt,
1456 .getsockopt = rose_getsockopt,
1457 .sendmsg = rose_sendmsg,
1458 .recvmsg = rose_recvmsg,
1459 .mmap = sock_no_mmap,
1460 .sendpage = sock_no_sendpage,
1461 };
1462
1463 static struct notifier_block rose_dev_notifier = {
1464 .notifier_call = rose_device_event,
1465 };
1466
1467 static struct net_device **dev_rose;
1468
1469 static const char banner[] = KERN_INFO "F6FBB/G4KLX ROSE for Linux. Version 0.62 for AX25.037 Linux 2.4\n";
1470
1471 static int __init rose_proto_init(void)
1472 {
1473 int i;
1474 int rc = proto_register(&rose_proto, 0);
1475
1476 if (rc != 0)
1477 goto out;
1478
1479 rose_callsign = null_ax25_address;
1480
1481 if (rose_ndevs > 0x7FFFFFFF/sizeof(struct net_device *)) {
1482 printk(KERN_ERR "ROSE: rose_proto_init - rose_ndevs parameter to large\n");
1483 return -1;
1484 }
1485
1486 dev_rose = kmalloc(rose_ndevs * sizeof(struct net_device *), GFP_KERNEL);
1487 if (dev_rose == NULL) {
1488 printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n");
1489 return -1;
1490 }
1491
1492 memset(dev_rose, 0x00, rose_ndevs * sizeof(struct net_device*));
1493 for (i = 0; i < rose_ndevs; i++) {
1494 struct net_device *dev;
1495 char name[IFNAMSIZ];
1496
1497 sprintf(name, "rose%d", i);
1498 dev = alloc_netdev(sizeof(struct net_device_stats),
1499 name, rose_setup);
1500 if (!dev) {
1501 printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate memory\n");
1502 goto fail;
1503 }
1504 if (register_netdev(dev)) {
1505 printk(KERN_ERR "ROSE: netdevice regeistration failed\n");
1506 free_netdev(dev);
1507 goto fail;
1508 }
1509 dev_rose[i] = dev;
1510 }
1511
1512 sock_register(&rose_family_ops);
1513 register_netdevice_notifier(&rose_dev_notifier);
1514 printk(banner);
1515
1516 ax25_protocol_register(AX25_P_ROSE, rose_route_frame);
1517 ax25_linkfail_register(rose_link_failed);
1518
1519 #ifdef CONFIG_SYSCTL
1520 rose_register_sysctl();
1521 #endif
1522 rose_loopback_init();
1523
1524 rose_add_loopback_neigh();
1525
1526 proc_net_fops_create("rose", S_IRUGO, &rose_info_fops);
1527 proc_net_fops_create("rose_neigh", S_IRUGO, &rose_neigh_fops);
1528 proc_net_fops_create("rose_nodes", S_IRUGO, &rose_nodes_fops);
1529 proc_net_fops_create("rose_routes", S_IRUGO, &rose_routes_fops);
1530 out:
1531 return rc;
1532 fail:
1533 while (--i >= 0) {
1534 unregister_netdev(dev_rose[i]);
1535 free_netdev(dev_rose[i]);
1536 }
1537 kfree(dev_rose);
1538 proto_unregister(&rose_proto);
1539 return -ENOMEM;
1540 }
1541 module_init(rose_proto_init);
1542
1543 module_param(rose_ndevs, int, 0);
1544 MODULE_PARM_DESC(rose_ndevs, "number of ROSE devices");
1545
1546 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1547 MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
1548 MODULE_LICENSE("GPL");
1549 MODULE_ALIAS_NETPROTO(PF_ROSE);
1550
1551 static void __exit rose_exit(void)
1552 {
1553 int i;
1554
1555 proc_net_remove("rose");
1556 proc_net_remove("rose_neigh");
1557 proc_net_remove("rose_nodes");
1558 proc_net_remove("rose_routes");
1559 rose_loopback_clear();
1560
1561 rose_rt_free();
1562
1563 ax25_protocol_release(AX25_P_ROSE);
1564 ax25_linkfail_release(rose_link_failed);
1565
1566 if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1567 ax25_listen_release(&rose_callsign, NULL);
1568
1569 #ifdef CONFIG_SYSCTL
1570 rose_unregister_sysctl();
1571 #endif
1572 unregister_netdevice_notifier(&rose_dev_notifier);
1573
1574 sock_unregister(PF_ROSE);
1575
1576 for (i = 0; i < rose_ndevs; i++) {
1577 struct net_device *dev = dev_rose[i];
1578
1579 if (dev) {
1580 unregister_netdev(dev);
1581 free_netdev(dev);
1582 }
1583 }
1584
1585 kfree(dev_rose);
1586 proto_unregister(&rose_proto);
1587 }
1588
1589 module_exit(rose_exit);
CJK support for tty framebuffer vt