1 /*
2 * X.25 Packet Layer release 002
3 *
4 * This is ALPHA test software. This code may break your machine,
5 * randomly fail to work with new releases, misbehave and/or generally
6 * screw up. It might even work.
7 *
8 * This code REQUIRES 2.1.15 or higher
9 *
10 * This module:
11 * This module is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * History
17 * X.25 001 Jonathan Naylor Started coding.
18 * X.25 002 Jonathan Naylor Centralised disconnect handling.
19 * New timer architecture.
20 * 2000-03-11 Henner Eisen MSG_EOR handling more POSIX compliant.
21 * 2000-03-22 Daniela Squassoni Allowed disabling/enabling of
22 * facilities negotiation and increased
23 * the throughput upper limit.
24 * 2000-08-27 Arnaldo C. Melo s/suser/capable/ + micro cleanups
25 * 2000-09-04 Henner Eisen Set sock->state in x25_accept().
26 * Fixed x25_output() related skb leakage.
27 * 2000-10-02 Henner Eisen Made x25_kick() single threaded per socket.
28 * 2000-10-27 Henner Eisen MSG_DONTWAIT for fragment allocation.
29 * 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN
30 * 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
31 * x25_proc.c, using seq_file
32 */
33
34 #include <linux/config.h>
35 #include <linux/module.h>
36 #include <linux/errno.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/timer.h>
40 #include <linux/string.h>
41 #include <linux/net.h>
42 #include <linux/netdevice.h>
43 #include <linux/if_arp.h>
44 #include <linux/skbuff.h>
45 #include <net/sock.h>
46 #include <net/tcp.h>
47 #include <asm/uaccess.h>
48 #include <linux/fcntl.h>
49 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
50 #include <linux/notifier.h>
51 #include <linux/init.h>
52 #include <net/x25.h>
53
54 int sysctl_x25_restart_request_timeout = X25_DEFAULT_T20;
55 int sysctl_x25_call_request_timeout = X25_DEFAULT_T21;
56 int sysctl_x25_reset_request_timeout = X25_DEFAULT_T22;
57 int sysctl_x25_clear_request_timeout = X25_DEFAULT_T23;
58 int sysctl_x25_ack_holdback_timeout = X25_DEFAULT_T2;
59
60 HLIST_HEAD(x25_list);
61 DEFINE_RWLOCK(x25_list_lock);
62
63 static struct proto_ops x25_proto_ops;
64
65 static struct x25_address null_x25_address = {" "};
66
67 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
68 struct x25_address *calling_addr)
69 {
70 int called_len, calling_len;
71 char *called, *calling;
72 int i;
73
74 called_len = (*p >> 0) & 0x0F;
75 calling_len = (*p >> 4) & 0x0F;
76
77 called = called_addr->x25_addr;
78 calling = calling_addr->x25_addr;
79 p++;
80
81 for (i = 0; i < (called_len + calling_len); i++) {
82 if (i < called_len) {
83 if (i % 2 != 0) {
84 *called++ = ((*p >> 0) & 0x0F) + '';
85 p++;
86 } else {
87 *called++ = ((*p >> 4) & 0x0F) + '';
88 }
89 } else {
90 if (i % 2 != 0) {
91 *calling++ = ((*p >> 0) & 0x0F) + '';
92 p++;
93 } else {
94 *calling++ = ((*p >> 4) & 0x0F) + '';
95 }
96 }
97 }
98
99 *called = *calling = '\0';
100
101 return 1 + (called_len + calling_len + 1) / 2;
102 }
103
104 int x25_addr_aton(unsigned char *p, struct x25_address *called_addr,
105 struct x25_address *calling_addr)
106 {
107 unsigned int called_len, calling_len;
108 char *called, *calling;
109 int i;
110
111 called = called_addr->x25_addr;
112 calling = calling_addr->x25_addr;
113
114 called_len = strlen(called);
115 calling_len = strlen(calling);
116
117 *p++ = (calling_len << 4) | (called_len << 0);
118
119 for (i = 0; i < (called_len + calling_len); i++) {
120 if (i < called_len) {
121 if (i % 2 != 0) {
122 *p |= (*called++ - '') << 0;
123 p++;
124 } else {
125 *p = 0x00;
126 *p |= (*called++ - '') << 4;
127 }
128 } else {
129 if (i % 2 != 0) {
130 *p |= (*calling++ - '') << 0;
131 p++;
132 } else {
133 *p = 0x00;
134 *p |= (*calling++ - '') << 4;
135 }
136 }
137 }
138
139 return 1 + (called_len + calling_len + 1) / 2;
140 }
141
142 /*
143 * Socket removal during an interrupt is now safe.
144 */
145 static void x25_remove_socket(struct sock *sk)
146 {
147 write_lock_bh(&x25_list_lock);
148 sk_del_node_init(sk);
149 write_unlock_bh(&x25_list_lock);
150 }
151
152 /*
153 * Kill all bound sockets on a dropped device.
154 */
155 static void x25_kill_by_device(struct net_device *dev)
156 {
157 struct sock *s;
158 struct hlist_node *node;
159
160 write_lock_bh(&x25_list_lock);
161
162 sk_for_each(s, node, &x25_list)
163 if (x25_sk(s)->neighbour && x25_sk(s)->neighbour->dev == dev)
164 x25_disconnect(s, ENETUNREACH, 0, 0);
165
166 write_unlock_bh(&x25_list_lock);
167 }
168
169 /*
170 * Handle device status changes.
171 */
172 static int x25_device_event(struct notifier_block *this, unsigned long event,
173 void *ptr)
174 {
175 struct net_device *dev = ptr;
176 struct x25_neigh *nb;
177
178 if (dev->type == ARPHRD_X25
179 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
180 || dev->type == ARPHRD_ETHER
181 #endif
182 ) {
183 switch (event) {
184 case NETDEV_UP:
185 x25_link_device_up(dev);
186 break;
187 case NETDEV_GOING_DOWN:
188 nb = x25_get_neigh(dev);
189 if (nb) {
190 x25_terminate_link(nb);
191 x25_neigh_put(nb);
192 }
193 break;
194 case NETDEV_DOWN:
195 x25_kill_by_device(dev);
196 x25_route_device_down(dev);
197 x25_link_device_down(dev);
198 break;
199 }
200 }
201
202 return NOTIFY_DONE;
203 }
204
205 /*
206 * Add a socket to the bound sockets list.
207 */
208 static void x25_insert_socket(struct sock *sk)
209 {
210 write_lock_bh(&x25_list_lock);
211 sk_add_node(sk, &x25_list);
212 write_unlock_bh(&x25_list_lock);
213 }
214
215 /*
216 * Find a socket that wants to accept the Call Request we just
217 * received. Check the full list for an address/cud match.
218 * If no cuds match return the next_best thing, an address match.
219 * Note: if a listening socket has cud set it must only get calls
220 * with matching cud.
221 */
222 static struct sock *x25_find_listener(struct x25_address *addr, struct x25_calluserdata *calluserdata)
223 {
224 struct sock *s;
225 struct sock *next_best;
226 struct hlist_node *node;
227
228 read_lock_bh(&x25_list_lock);
229 next_best = NULL;
230
231 sk_for_each(s, node, &x25_list)
232 if ((!strcmp(addr->x25_addr,
233 x25_sk(s)->source_addr.x25_addr) ||
234 !strcmp(addr->x25_addr,
235 null_x25_address.x25_addr)) &&
236 s->sk_state == TCP_LISTEN) {
237
238 /*
239 * Found a listening socket, now check the incoming
240 * call user data vs this sockets call user data
241 */
242 if (x25_check_calluserdata(&x25_sk(s)->calluserdata, calluserdata)) {
243 sock_hold(s);
244 goto found;
245 }
246 if (x25_sk(s)->calluserdata.cudlength == 0) {
247 next_best = s;
248 }
249 }
250 if (next_best) {
251 s = next_best;
252 sock_hold(s);
253 goto found;
254 }
255 s = NULL;
256 found:
257 read_unlock_bh(&x25_list_lock);
258 return s;
259 }
260
261 /*
262 * Find a connected X.25 socket given my LCI and neighbour.
263 */
264 static struct sock *__x25_find_socket(unsigned int lci, struct x25_neigh *nb)
265 {
266 struct sock *s;
267 struct hlist_node *node;
268
269 sk_for_each(s, node, &x25_list)
270 if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) {
271 sock_hold(s);
272 goto found;
273 }
274 s = NULL;
275 found:
276 return s;
277 }
278
279 struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb)
280 {
281 struct sock *s;
282
283 read_lock_bh(&x25_list_lock);
284 s = __x25_find_socket(lci, nb);
285 read_unlock_bh(&x25_list_lock);
286 return s;
287 }
288
289 /*
290 * Find a unique LCI for a given device.
291 */
292 static unsigned int x25_new_lci(struct x25_neigh *nb)
293 {
294 unsigned int lci = 1;
295 struct sock *sk;
296
297 read_lock_bh(&x25_list_lock);
298
299 while ((sk = __x25_find_socket(lci, nb)) != NULL) {
300 sock_put(sk);
301 if (++lci == 4096) {
302 lci = 0;
303 break;
304 }
305 }
306
307 read_unlock_bh(&x25_list_lock);
308 return lci;
309 }
310
311 /*
312 * Deferred destroy.
313 */
314 void x25_destroy_socket(struct sock *);
315
316 /*
317 * handler for deferred kills.
318 */
319 static void x25_destroy_timer(unsigned long data)
320 {
321 x25_destroy_socket((struct sock *)data);
322 }
323
324 /*
325 * This is called from user mode and the timers. Thus it protects itself
326 * against interrupt users but doesn't worry about being called during
327 * work. Once it is removed from the queue no interrupt or bottom half
328 * will touch it and we are (fairly 8-) ) safe.
329 * Not static as it's used by the timer
330 */
331 void x25_destroy_socket(struct sock *sk)
332 {
333 struct sk_buff *skb;
334
335 sock_hold(sk);
336 lock_sock(sk);
337 x25_stop_heartbeat(sk);
338 x25_stop_timer(sk);
339
340 x25_remove_socket(sk);
341 x25_clear_queues(sk); /* Flush the queues */
342
343 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
344 if (skb->sk != sk) { /* A pending connection */
345 /*
346 * Queue the unaccepted socket for death
347 */
348 sock_set_flag(skb->sk, SOCK_DEAD);
349 x25_start_heartbeat(skb->sk);
350 x25_sk(skb->sk)->state = X25_STATE_0;
351 }
352
353 kfree_skb(skb);
354 }
355
356 if (atomic_read(&sk->sk_wmem_alloc) ||
357 atomic_read(&sk->sk_rmem_alloc)) {
358 /* Defer: outstanding buffers */
359 sk->sk_timer.expires = jiffies + 10 * HZ;
360 sk->sk_timer.function = x25_destroy_timer;
361 sk->sk_timer.data = (unsigned long)sk;
362 add_timer(&sk->sk_timer);
363 } else {
364 /* drop last reference so sock_put will free */
365 __sock_put(sk);
366 }
367
368 release_sock(sk);
369 sock_put(sk);
370 }
371
372 /*
373 * Handling for system calls applied via the various interfaces to a
374 * X.25 socket object.
375 */
376
377 static int x25_setsockopt(struct socket *sock, int level, int optname,
378 char __user *optval, int optlen)
379 {
380 int opt;
381 struct sock *sk = sock->sk;
382 int rc = -ENOPROTOOPT;
383
384 if (level != SOL_X25 || optname != X25_QBITINCL)
385 goto out;
386
387 rc = -EINVAL;
388 if (optlen < sizeof(int))
389 goto out;
390
391 rc = -EFAULT;
392 if (get_user(opt, (int __user *)optval))
393 goto out;
394
395 x25_sk(sk)->qbitincl = !!opt;
396 rc = 0;
397 out:
398 return rc;
399 }
400
401 static int x25_getsockopt(struct socket *sock, int level, int optname,
402 char __user *optval, int __user *optlen)
403 {
404 struct sock *sk = sock->sk;
405 int val, len, rc = -ENOPROTOOPT;
406
407 if (level != SOL_X25 || optname != X25_QBITINCL)
408 goto out;
409
410 rc = -EFAULT;
411 if (get_user(len, optlen))
412 goto out;
413
414 len = min_t(unsigned int, len, sizeof(int));
415
416 rc = -EINVAL;
417 if (len < 0)
418 goto out;
419
420 rc = -EFAULT;
421 if (put_user(len, optlen))
422 goto out;
423
424 val = x25_sk(sk)->qbitincl;
425 rc = copy_to_user(optval, &val, len) ? -EFAULT : 0;
426 out:
427 return rc;
428 }
429
430 static int x25_listen(struct socket *sock, int backlog)
431 {
432 struct sock *sk = sock->sk;
433 int rc = -EOPNOTSUPP;
434
435 if (sk->sk_state != TCP_LISTEN) {
436 memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN);
437 sk->sk_max_ack_backlog = backlog;
438 sk->sk_state = TCP_LISTEN;
439 rc = 0;
440 }
441
442 return rc;
443 }
444
445 static struct sock *x25_alloc_socket(void)
446 {
447 struct x25_opt *x25;
448 struct sock *sk = sk_alloc(AF_X25, GFP_ATOMIC, 1, NULL);
449
450 if (!sk)
451 goto out;
452
453 x25 = sk->sk_protinfo = kmalloc(sizeof(*x25), GFP_ATOMIC);
454 if (!x25)
455 goto frees;
456
457 memset(x25, 0, sizeof(*x25));
458
459 x25->sk = sk;
460
461 sock_init_data(NULL, sk);
462 sk_set_owner(sk, THIS_MODULE);
463
464 skb_queue_head_init(&x25->ack_queue);
465 skb_queue_head_init(&x25->fragment_queue);
466 skb_queue_head_init(&x25->interrupt_in_queue);
467 skb_queue_head_init(&x25->interrupt_out_queue);
468 out:
469 return sk;
470 frees:
471 sk_free(sk);
472 sk = NULL;
473 goto out;
474 }
475
476 void x25_init_timers(struct sock *sk);
477
478 static int x25_create(struct socket *sock, int protocol)
479 {
480 struct sock *sk;
481 struct x25_opt *x25;
482 int rc = -ESOCKTNOSUPPORT;
483
484 if (sock->type != SOCK_SEQPACKET || protocol)
485 goto out;
486
487 rc = -ENOMEM;
488 if ((sk = x25_alloc_socket()) == NULL)
489 goto out;
490
491 x25 = x25_sk(sk);
492
493 sock_init_data(sock, sk);
494 sk_set_owner(sk, THIS_MODULE);
495
496 x25_init_timers(sk);
497
498 sock->ops = &x25_proto_ops;
499 sk->sk_protocol = protocol;
500 sk->sk_backlog_rcv = x25_backlog_rcv;
501
502 x25->t21 = sysctl_x25_call_request_timeout;
503 x25->t22 = sysctl_x25_reset_request_timeout;
504 x25->t23 = sysctl_x25_clear_request_timeout;
505 x25->t2 = sysctl_x25_ack_holdback_timeout;
506 x25->state = X25_STATE_0;
507
508 x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE;
509 x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
510 x25->facilities.pacsize_in = X25_DEFAULT_PACKET_SIZE;
511 x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE;
512 x25->facilities.throughput = X25_DEFAULT_THROUGHPUT;
513 x25->facilities.reverse = X25_DEFAULT_REVERSE;
514 rc = 0;
515 out:
516 return rc;
517 }
518
519 static struct sock *x25_make_new(struct sock *osk)
520 {
521 struct sock *sk = NULL;
522 struct x25_opt *x25, *ox25;
523
524 if (osk->sk_type != SOCK_SEQPACKET)
525 goto out;
526
527 if ((sk = x25_alloc_socket()) == NULL)
528 goto out;
529
530 x25 = x25_sk(sk);
531
532 sk->sk_type = osk->sk_type;
533 sk->sk_socket = osk->sk_socket;
534 sk->sk_priority = osk->sk_priority;
535 sk->sk_protocol = osk->sk_protocol;
536 sk->sk_rcvbuf = osk->sk_rcvbuf;
537 sk->sk_sndbuf = osk->sk_sndbuf;
538 sk->sk_debug = osk->sk_debug;
539 sk->sk_state = TCP_ESTABLISHED;
540 sk->sk_sleep = osk->sk_sleep;
541 sk->sk_zapped = osk->sk_zapped;
542 sk->sk_backlog_rcv = osk->sk_backlog_rcv;
543
544 ox25 = x25_sk(osk);
545 x25->t21 = ox25->t21;
546 x25->t22 = ox25->t22;
547 x25->t23 = ox25->t23;
548 x25->t2 = ox25->t2;
549 x25->facilities = ox25->facilities;
550 x25->qbitincl = ox25->qbitincl;
551
552 x25_init_timers(sk);
553 out:
554 return sk;
555 }
556
557 static int x25_release(struct socket *sock)
558 {
559 struct sock *sk = sock->sk;
560 struct x25_opt *x25;
561
562 if (!sk)
563 goto out;
564
565 x25 = x25_sk(sk);
566
567 switch (x25->state) {
568
569 case X25_STATE_0:
570 case X25_STATE_2:
571 x25_disconnect(sk, 0, 0, 0);
572 x25_destroy_socket(sk);
573 goto out;
574
575 case X25_STATE_1:
576 case X25_STATE_3:
577 case X25_STATE_4:
578 x25_clear_queues(sk);
579 x25_write_internal(sk, X25_CLEAR_REQUEST);
580 x25_start_t23timer(sk);
581 x25->state = X25_STATE_2;
582 sk->sk_state = TCP_CLOSE;
583 sk->sk_shutdown |= SEND_SHUTDOWN;
584 sk->sk_state_change(sk);
585 sock_set_flag(sk, SOCK_DEAD);
586 sock_set_flag(sk, SOCK_DESTROY);
587 break;
588 }
589
590 sock->sk = NULL;
591 sk->sk_socket = NULL; /* Not used, but we should do this */
592 out:
593 return 0;
594 }
595
596 static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
597 {
598 struct sock *sk = sock->sk;
599 struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
600
601 if (!sk->sk_zapped ||
602 addr_len != sizeof(struct sockaddr_x25) ||
603 addr->sx25_family != AF_X25)
604 return -EINVAL;
605
606 x25_sk(sk)->source_addr = addr->sx25_addr;
607 x25_insert_socket(sk);
608 sk->sk_zapped = 0;
609 SOCK_DEBUG(sk, "x25_bind: socket is bound\n");
610
611 return 0;
612 }
613
614 static int x25_wait_for_connection_establishment(struct sock *sk)
615 {
616 DECLARE_WAITQUEUE(wait, current);
617 int rc;
618
619 add_wait_queue_exclusive(sk->sk_sleep, &wait);
620 for (;;) {
621 __set_current_state(TASK_INTERRUPTIBLE);
622 rc = -ERESTARTSYS;
623 if (signal_pending(current))
624 break;
625 rc = sock_error(sk);
626 if (rc) {
627 sk->sk_socket->state = SS_UNCONNECTED;
628 break;
629 }
630 rc = 0;
631 if (sk->sk_state != TCP_ESTABLISHED) {
632 release_sock(sk);
633 schedule();
634 lock_sock(sk);
635 } else
636 break;
637 }
638 __set_current_state(TASK_RUNNING);
639 remove_wait_queue(sk->sk_sleep, &wait);
640 return rc;
641 }
642
643 static int x25_connect(struct socket *sock, struct sockaddr *uaddr,
644 int addr_len, int flags)
645 {
646 struct sock *sk = sock->sk;
647 struct x25_opt *x25 = x25_sk(sk);
648 struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
649 struct x25_route *rt;
650 int rc = 0;
651
652 lock_sock(sk);
653 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
654 sock->state = SS_CONNECTED;
655 goto out; /* Connect completed during a ERESTARTSYS event */
656 }
657
658 rc = -ECONNREFUSED;
659 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
660 sock->state = SS_UNCONNECTED;
661 goto out;
662 }
663
664 rc = -EISCONN; /* No reconnect on a seqpacket socket */
665 if (sk->sk_state == TCP_ESTABLISHED)
666 goto out;
667
668 sk->sk_state = TCP_CLOSE;
669 sock->state = SS_UNCONNECTED;
670
671 rc = -EINVAL;
672 if (addr_len != sizeof(struct sockaddr_x25) ||
673 addr->sx25_family != AF_X25)
674 goto out;
675
676 rc = -ENETUNREACH;
677 rt = x25_get_route(&addr->sx25_addr);
678 if (!rt)
679 goto out;
680
681 x25->neighbour = x25_get_neigh(rt->dev);
682 if (!x25->neighbour)
683 goto out_put_route;
684
685 x25_limit_facilities(&x25->facilities, x25->neighbour);
686
687 x25->lci = x25_new_lci(x25->neighbour);
688 if (!x25->lci)
689 goto out_put_neigh;
690
691 rc = -EINVAL;
692 if (sk->sk_zapped) /* Must bind first - autobinding does not work */
693 goto out_put_neigh;
694
695 if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr))
696 memset(&x25->source_addr, '\0', X25_ADDR_LEN);
697
698 x25->dest_addr = addr->sx25_addr;
699
700 /* Move to connecting socket, start sending Connect Requests */
701 sock->state = SS_CONNECTING;
702 sk->sk_state = TCP_SYN_SENT;
703
704 x25->state = X25_STATE_1;
705
706 x25_write_internal(sk, X25_CALL_REQUEST);
707
708 x25_start_heartbeat(sk);
709 x25_start_t21timer(sk);
710
711 /* Now the loop */
712 rc = -EINPROGRESS;
713 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
714 goto out_put_neigh;
715
716 rc = x25_wait_for_connection_establishment(sk);
717 if (rc)
718 goto out_put_neigh;
719
720 sock->state = SS_CONNECTED;
721 rc = 0;
722 out_put_neigh:
723 if (rc)
724 x25_neigh_put(x25->neighbour);
725 out_put_route:
726 x25_route_put(rt);
727 out:
728 release_sock(sk);
729 return rc;
730 }
731
732 static int x25_wait_for_data(struct sock *sk, int timeout)
733 {
734 DECLARE_WAITQUEUE(wait, current);
735 int rc = 0;
736
737 add_wait_queue_exclusive(sk->sk_sleep, &wait);
738 for (;;) {
739 __set_current_state(TASK_INTERRUPTIBLE);
740 if (sk->sk_shutdown & RCV_SHUTDOWN)
741 break;
742 rc = -ERESTARTSYS;
743 if (signal_pending(current))
744 break;
745 rc = -EAGAIN;
746 if (!timeout)
747 break;
748 rc = 0;
749 if (skb_queue_empty(&sk->sk_receive_queue)) {
750 release_sock(sk);
751 timeout = schedule_timeout(timeout);
752 lock_sock(sk);
753 } else
754 break;
755 }
756 __set_current_state(TASK_RUNNING);
757 remove_wait_queue(sk->sk_sleep, &wait);
758 return rc;
759 }
760
761 static int x25_accept(struct socket *sock, struct socket *newsock, int flags)
762 {
763 struct sock *sk = sock->sk;
764 struct sock *newsk;
765 struct sk_buff *skb;
766 int rc = -EINVAL;
767
768 if (!sk || sk->sk_state != TCP_LISTEN)
769 goto out;
770
771 rc = -EOPNOTSUPP;
772 if (sk->sk_type != SOCK_SEQPACKET)
773 goto out;
774
775 lock_sock(sk);
776 rc = x25_wait_for_data(sk, sk->sk_rcvtimeo);
777 if (rc)
778 goto out2;
779 skb = skb_dequeue(&sk->sk_receive_queue);
780 rc = -EINVAL;
781 if (!skb->sk)
782 goto out2;
783 newsk = skb->sk;
784 newsk->sk_socket = newsock;
785 newsk->sk_sleep = &newsock->wait;
786
787 /* Now attach up the new socket */
788 skb->sk = NULL;
789 kfree_skb(skb);
790 sk->sk_ack_backlog--;
791 newsock->sk = newsk;
792 newsock->state = SS_CONNECTED;
793 rc = 0;
794 out2:
795 release_sock(sk);
796 out:
797 return rc;
798 }
799
800 static int x25_getname(struct socket *sock, struct sockaddr *uaddr,
801 int *uaddr_len, int peer)
802 {
803 struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr;
804 struct sock *sk = sock->sk;
805 struct x25_opt *x25 = x25_sk(sk);
806
807 if (peer) {
808 if (sk->sk_state != TCP_ESTABLISHED)
809 return -ENOTCONN;
810 sx25->sx25_addr = x25->dest_addr;
811 } else
812 sx25->sx25_addr = x25->source_addr;
813
814 sx25->sx25_family = AF_X25;
815 *uaddr_len = sizeof(*sx25);
816
817 return 0;
818 }
819
820 int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
821 unsigned int lci)
822 {
823 struct sock *sk;
824 struct sock *make;
825 struct x25_opt *makex25;
826 struct x25_address source_addr, dest_addr;
827 struct x25_facilities facilities;
828 struct x25_calluserdata calluserdata;
829 int len, rc;
830
831 /*
832 * Remove the LCI and frame type.
833 */
834 skb_pull(skb, X25_STD_MIN_LEN);
835
836 /*
837 * Extract the X.25 addresses and convert them to ASCII strings,
838 * and remove them.
839 */
840 skb_pull(skb, x25_addr_ntoa(skb->data, &source_addr, &dest_addr));
841
842 /*
843 * Get the length of the facilities, skip past them for the moment
844 * get the call user data because this is needed to determine
845 * the correct listener
846 */
847 len = skb->data[0] + 1;
848 skb_pull(skb,len);
849
850 /*
851 * Incoming Call User Data.
852 */
853 if (skb->len >= 0) {
854 memcpy(calluserdata.cuddata, skb->data, skb->len);
855 calluserdata.cudlength = skb->len;
856 }
857
858 skb_push(skb,len);
859
860 /*
861 * Find a listener for the particular address/cud pair.
862 */
863 sk = x25_find_listener(&source_addr,&calluserdata);
864
865 /*
866 * We can't accept the Call Request.
867 */
868 if (!sk || sk->sk_ack_backlog == sk->sk_max_ack_backlog)
869 goto out_clear_request;
870
871 /*
872 * Try to reach a compromise on the requested facilities.
873 */
874 if ((len = x25_negotiate_facilities(skb, sk, &facilities)) == -1)
875 goto out_sock_put;
876
877 /*
878 * current neighbour/link might impose additional limits
879 * on certain facilties
880 */
881
882 x25_limit_facilities(&facilities, nb);
883
884 /*
885 * Try to create a new socket.
886 */
887 make = x25_make_new(sk);
888 if (!make)
889 goto out_sock_put;
890
891 /*
892 * Remove the facilities
893 */
894 skb_pull(skb, len);
895
896 skb->sk = make;
897 make->sk_state = TCP_ESTABLISHED;
898
899 makex25 = x25_sk(make);
900 makex25->lci = lci;
901 makex25->dest_addr = dest_addr;
902 makex25->source_addr = source_addr;
903 makex25->neighbour = nb;
904 makex25->facilities = facilities;
905 makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
906 makex25->calluserdata = calluserdata;
907
908 x25_write_internal(make, X25_CALL_ACCEPTED);
909
910 makex25->state = X25_STATE_3;
911
912 sk->sk_ack_backlog++;
913
914 x25_insert_socket(make);
915
916 skb_queue_head(&sk->sk_receive_queue, skb);
917
918 x25_start_heartbeat(make);
919
920 if (!sock_flag(sk, SOCK_DEAD))
921 sk->sk_data_ready(sk, skb->len);
922 rc = 1;
923 sock_put(sk);
924 out:
925 return rc;
926 out_sock_put:
927 sock_put(sk);
928 out_clear_request:
929 rc = 0;
930 x25_transmit_clear_request(nb, lci, 0x01);
931 goto out;
932 }
933
934 static int x25_sendmsg(struct kiocb *iocb, struct socket *sock,
935 struct msghdr *msg, size_t len)
936 {
937 struct sock *sk = sock->sk;
938 struct x25_opt *x25 = x25_sk(sk);
939 struct sockaddr_x25 *usx25 = (struct sockaddr_x25 *)msg->msg_name;
940 struct sockaddr_x25 sx25;
941 struct sk_buff *skb;
942 unsigned char *asmptr;
943 int noblock = msg->msg_flags & MSG_DONTWAIT;
944 size_t size;
945 int qbit = 0, rc = -EINVAL;
946
947 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_OOB|MSG_EOR|MSG_CMSG_COMPAT))
948 goto out;
949
950 /* we currently don't support segmented records at the user interface */
951 if (!(msg->msg_flags & (MSG_EOR|MSG_OOB)))
952 goto out;
953
954 rc = -EADDRNOTAVAIL;
955 if (sk->sk_zapped)
956 goto out;
957
958 rc = -EPIPE;
959 if (sk->sk_shutdown & SEND_SHUTDOWN) {
960 send_sig(SIGPIPE, current, 0);
961 goto out;
962 }
963
964 rc = -ENETUNREACH;
965 if (!x25->neighbour)
966 goto out;
967
968 if (usx25) {
969 rc = -EINVAL;
970 if (msg->msg_namelen < sizeof(sx25))
971 goto out;
972 memcpy(&sx25, usx25, sizeof(sx25));
973 rc = -EISCONN;
974 if (strcmp(x25->dest_addr.x25_addr, sx25.sx25_addr.x25_addr))
975 goto out;
976 rc = -EINVAL;
977 if (sx25.sx25_family != AF_X25)
978 goto out;
979 } else {
980 /*
981 * FIXME 1003.1g - if the socket is like this because
982 * it has become closed (not started closed) we ought
983 * to SIGPIPE, EPIPE;
984 */
985 rc = -ENOTCONN;
986 if (sk->sk_state != TCP_ESTABLISHED)
987 goto out;
988
989 sx25.sx25_family = AF_X25;
990 sx25.sx25_addr = x25->dest_addr;
991 }
992
993 SOCK_DEBUG(sk, "x25_sendmsg: sendto: Addresses built.\n");
994
995 /* Build a packet */
996 SOCK_DEBUG(sk, "x25_sendmsg: sendto: building packet.\n");
997
998 if ((msg->msg_flags & MSG_OOB) && len > 32)
999 len = 32;
1000
1001 size = len + X25_MAX_L2_LEN + X25_EXT_MIN_LEN;
1002
1003 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
1004 if (!skb)
1005 goto out;
1006 X25_SKB_CB(skb)->flags = msg->msg_flags;
1007
1008 skb_reserve(skb, X25_MAX_L2_LEN + X25_EXT_MIN_LEN);
1009
1010 /*
1011 * Put the data on the end
1012 */
1013 SOCK_DEBUG(sk, "x25_sendmsg: Copying user data\n");
1014
1015 asmptr = skb->h.raw = skb_put(skb, len);
1016
1017 rc = memcpy_fromiovec(asmptr, msg->msg_iov, len);
1018 if (rc)
1019 goto out_kfree_skb;
1020
1021 /*
1022 * If the Q BIT Include socket option is in force, the first
1023 * byte of the user data is the logical value of the Q Bit.
1024 */
1025 if (x25->qbitincl) {
1026 qbit = skb->data[0];
1027 skb_pull(skb, 1);
1028 }
1029
1030 /*
1031 * Push down the X.25 header
1032 */
1033 SOCK_DEBUG(sk, "x25_sendmsg: Building X.25 Header.\n");
1034
1035 if (msg->msg_flags & MSG_OOB) {
1036 if (x25->neighbour->extended) {
1037 asmptr = skb_push(skb, X25_STD_MIN_LEN);
1038 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1039 *asmptr++ = (x25->lci >> 0) & 0xFF;
1040 *asmptr++ = X25_INTERRUPT;
1041 } else {
1042 asmptr = skb_push(skb, X25_STD_MIN_LEN);
1043 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1044 *asmptr++ = (x25->lci >> 0) & 0xFF;
1045 *asmptr++ = X25_INTERRUPT;
1046 }
1047 } else {
1048 if (x25->neighbour->extended) {
1049 /* Build an Extended X.25 header */
1050 asmptr = skb_push(skb, X25_EXT_MIN_LEN);
1051 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1052 *asmptr++ = (x25->lci >> 0) & 0xFF;
1053 *asmptr++ = X25_DATA;
1054 *asmptr++ = X25_DATA;
1055 } else {
1056 /* Build an Standard X.25 header */
1057 asmptr = skb_push(skb, X25_STD_MIN_LEN);
1058 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1059 *asmptr++ = (x25->lci >> 0) & 0xFF;
1060 *asmptr++ = X25_DATA;
1061 }
1062
1063 if (qbit)
1064 skb->data[0] |= X25_Q_BIT;
1065 }
1066
1067 SOCK_DEBUG(sk, "x25_sendmsg: Built header.\n");
1068 SOCK_DEBUG(sk, "x25_sendmsg: Transmitting buffer\n");
1069
1070 rc = -ENOTCONN;
1071 if (sk->sk_state != TCP_ESTABLISHED)
1072 goto out_kfree_skb;
1073
1074 if (msg->msg_flags & MSG_OOB)
1075 skb_queue_tail(&x25->interrupt_out_queue, skb);
1076 else {
1077 len = x25_output(sk, skb);
1078 if (len < 0)
1079 kfree_skb(skb);
1080 else if (x25->qbitincl)
1081 len++;
1082 }
1083
1084 /*
1085 * lock_sock() is currently only used to serialize this x25_kick()
1086 * against input-driven x25_kick() calls. It currently only blocks
1087 * incoming packets for this socket and does not protect against
1088 * any other socket state changes and is not called from anywhere
1089 * else. As x25_kick() cannot block and as long as all socket
1090 * operations are BKL-wrapped, we don't need take to care about
1091 * purging the backlog queue in x25_release().
1092 *
1093 * Using lock_sock() to protect all socket operations entirely
1094 * (and making the whole x25 stack SMP aware) unfortunately would
1095 * require major changes to {send,recv}msg and skb allocation methods.
1096 * -> 2.5 ;)
1097 */
1098 lock_sock(sk);
1099 x25_kick(sk);
1100 release_sock(sk);
1101 rc = len;
1102 out:
1103 return rc;
1104 out_kfree_skb:
1105 kfree_skb(skb);
1106 goto out;
1107 }
1108
1109
1110 static int x25_recvmsg(struct kiocb *iocb, struct socket *sock,
1111 struct msghdr *msg, size_t size,
1112 int flags)
1113 {
1114 struct sock *sk = sock->sk;
1115 struct x25_opt *x25 = x25_sk(sk);
1116 struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)msg->msg_name;
1117 size_t copied;
1118 int qbit;
1119 struct sk_buff *skb;
1120 unsigned char *asmptr;
1121 int rc = -ENOTCONN;
1122
1123 /*
1124 * This works for seqpacket too. The receiver has ordered the queue for
1125 * us! We do one quick check first though
1126 */
1127 if (sk->sk_state != TCP_ESTABLISHED)
1128 goto out;
1129
1130 if (flags & MSG_OOB) {
1131 rc = -EINVAL;
1132 if (sock_flag(sk, SOCK_URGINLINE) ||
1133 !skb_peek(&x25->interrupt_in_queue))
1134 goto out;
1135
1136 skb = skb_dequeue(&x25->interrupt_in_queue);
1137
1138 skb_pull(skb, X25_STD_MIN_LEN);
1139
1140 /*
1141 * No Q bit information on Interrupt data.
1142 */
1143 if (x25->qbitincl) {
1144 asmptr = skb_push(skb, 1);
1145 *asmptr = 0x00;
1146 }
1147
1148 msg->msg_flags |= MSG_OOB;
1149 } else {
1150 /* Now we can treat all alike */
1151 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1152 flags & MSG_DONTWAIT, &rc);
1153 if (!skb)
1154 goto out;
1155
1156 qbit = (skb->data[0] & X25_Q_BIT) == X25_Q_BIT;
1157
1158 skb_pull(skb, x25->neighbour->extended ?
1159 X25_EXT_MIN_LEN : X25_STD_MIN_LEN);
1160
1161 if (x25->qbitincl) {
1162 asmptr = skb_push(skb, 1);
1163 *asmptr = qbit;
1164 }
1165 }
1166
1167 skb->h.raw = skb->data;
1168
1169 copied = skb->len;
1170
1171 if (copied > size) {
1172 copied = size;
1173 msg->msg_flags |= MSG_TRUNC;
1174 }
1175
1176 /* Currently, each datagram always contains a complete record */
1177 msg->msg_flags |= MSG_EOR;
1178
1179 rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1180 if (rc)
1181 goto out_free_dgram;
1182
1183 if (sx25) {
1184 sx25->sx25_family = AF_X25;
1185 sx25->sx25_addr = x25->dest_addr;
1186 }
1187
1188 msg->msg_namelen = sizeof(struct sockaddr_x25);
1189
1190 lock_sock(sk);
1191 x25_check_rbuf(sk);
1192 release_sock(sk);
1193 rc = copied;
1194 out_free_dgram:
1195 skb_free_datagram(sk, skb);
1196 out:
1197 return rc;
1198 }
1199
1200
1201 static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1202 {
1203 struct sock *sk = sock->sk;
1204 struct x25_opt *x25 = x25_sk(sk);
1205 void __user *argp = (void __user *)arg;
1206 int rc;
1207
1208 switch (cmd) {
1209 case TIOCOUTQ: {
1210 int amount = sk->sk_sndbuf -
1211 atomic_read(&sk->sk_wmem_alloc);
1212 if (amount < 0)
1213 amount = 0;
1214 rc = put_user(amount, (unsigned int __user *)argp);
1215 break;
1216 }
1217
1218 case TIOCINQ: {
1219 struct sk_buff *skb;
1220 int amount = 0;
1221 /*
1222 * These two are safe on a single CPU system as
1223 * only user tasks fiddle here
1224 */
1225 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1226 amount = skb->len;
1227 rc = put_user(amount, (unsigned int __user *)argp);
1228 break;
1229 }
1230
1231 case SIOCGSTAMP:
1232 rc = -EINVAL;
1233 if (sk)
1234 rc = sock_get_timestamp(sk,
1235 (struct timeval __user *)argp);
1236 break;
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 rc = -EINVAL;
1248 break;
1249 case SIOCADDRT:
1250 case SIOCDELRT:
1251 rc = -EPERM;
1252 if (!capable(CAP_NET_ADMIN))
1253 break;
1254 rc = x25_route_ioctl(cmd, argp);
1255 break;
1256 case SIOCX25GSUBSCRIP:
1257 rc = x25_subscr_ioctl(cmd, argp);
1258 break;
1259 case SIOCX25SSUBSCRIP:
1260 rc = -EPERM;
1261 if (!capable(CAP_NET_ADMIN))
1262 break;
1263 rc = x25_subscr_ioctl(cmd, argp);
1264 break;
1265 case SIOCX25GFACILITIES: {
1266 struct x25_facilities fac = x25->facilities;
1267 rc = copy_to_user(argp, &fac,
1268 sizeof(fac)) ? -EFAULT : 0;
1269 break;
1270 }
1271
1272 case SIOCX25SFACILITIES: {
1273 struct x25_facilities facilities;
1274 rc = -EFAULT;
1275 if (copy_from_user(&facilities, argp,
1276 sizeof(facilities)))
1277 break;
1278 rc = -EINVAL;
1279 if (sk->sk_state != TCP_LISTEN &&
1280 sk->sk_state != TCP_CLOSE)
1281 break;
1282 if (facilities.pacsize_in < X25_PS16 ||
1283 facilities.pacsize_in > X25_PS4096)
1284 break;
1285 if (facilities.pacsize_out < X25_PS16 ||
1286 facilities.pacsize_out > X25_PS4096)
1287 break;
1288 if (facilities.winsize_in < 1 ||
1289 facilities.winsize_in > 127)
1290 break;
1291 if (facilities.throughput < 0x03 ||
1292 facilities.throughput > 0xDD)
1293 break;
1294 if (facilities.reverse && facilities.reverse != 1)
1295 break;
1296 x25->facilities = facilities;
1297 rc = 0;
1298 break;
1299 }
1300
1301 case SIOCX25GCALLUSERDATA: {
1302 struct x25_calluserdata cud = x25->calluserdata;
1303 rc = copy_to_user(argp, &cud,
1304 sizeof(cud)) ? -EFAULT : 0;
1305 break;
1306 }
1307
1308 case SIOCX25SCALLUSERDATA: {
1309 struct x25_calluserdata calluserdata;
1310
1311 rc = -EFAULT;
1312 if (copy_from_user(&calluserdata, argp,
1313 sizeof(calluserdata)))
1314 break;
1315 rc = -EINVAL;
1316 if (calluserdata.cudlength > X25_MAX_CUD_LEN)
1317 break;
1318 x25->calluserdata = calluserdata;
1319 rc = 0;
1320 break;
1321 }
1322
1323 case SIOCX25GCAUSEDIAG: {
1324 struct x25_causediag causediag;
1325 causediag = x25->causediag;
1326 rc = copy_to_user(argp, &causediag,
1327 sizeof(causediag)) ? -EFAULT : 0;
1328 break;
1329 }
1330
1331 default:
1332 rc = dev_ioctl(cmd, argp);
1333 break;
1334 }
1335
1336 return rc;
1337 }
1338
1339 static struct net_proto_family x25_family_ops = {
1340 .family = AF_X25,
1341 .create = x25_create,
1342 .owner = THIS_MODULE,
1343 };
1344
1345 static struct proto_ops SOCKOPS_WRAPPED(x25_proto_ops) = {
1346 .family = AF_X25,
1347 .owner = THIS_MODULE,
1348 .release = x25_release,
1349 .bind = x25_bind,
1350 .connect = x25_connect,
1351 .socketpair = sock_no_socketpair,
1352 .accept = x25_accept,
1353 .getname = x25_getname,
1354 .poll = datagram_poll,
1355 .ioctl = x25_ioctl,
1356 .listen = x25_listen,
1357 .shutdown = sock_no_shutdown,
1358 .setsockopt = x25_setsockopt,
1359 .getsockopt = x25_getsockopt,
1360 .sendmsg = x25_sendmsg,
1361 .recvmsg = x25_recvmsg,
1362 .mmap = sock_no_mmap,
1363 .sendpage = sock_no_sendpage,
1364 };
1365
1366 #include <linux/smp_lock.h>
1367 SOCKOPS_WRAP(x25_proto, AF_X25);
1368
1369 static struct packet_type x25_packet_type = {
1370 .type = __constant_htons(ETH_P_X25),
1371 .func = x25_lapb_receive_frame,
1372 };
1373
1374 static struct notifier_block x25_dev_notifier = {
1375 .notifier_call = x25_device_event,
1376 };
1377
1378 void x25_kill_by_neigh(struct x25_neigh *nb)
1379 {
1380 struct sock *s;
1381 struct hlist_node *node;
1382
1383 write_lock_bh(&x25_list_lock);
1384
1385 sk_for_each(s, node, &x25_list)
1386 if (x25_sk(s)->neighbour == nb)
1387 x25_disconnect(s, ENETUNREACH, 0, 0);
1388
1389 write_unlock_bh(&x25_list_lock);
1390 }
1391
1392 static int __init x25_init(void)
1393 {
1394 sock_register(&x25_family_ops);
1395
1396 dev_add_pack(&x25_packet_type);
1397
1398 register_netdevice_notifier(&x25_dev_notifier);
1399
1400 printk(KERN_INFO "X.25 for Linux. Version 0.2 for Linux 2.1.15\n");
1401
1402 #ifdef CONFIG_SYSCTL
1403 x25_register_sysctl();
1404 #endif
1405 x25_proc_init();
1406 return 0;
1407 }
1408 module_init(x25_init);
1409
1410 static void __exit x25_exit(void)
1411 {
1412 x25_proc_exit();
1413 x25_link_free();
1414 x25_route_free();
1415
1416 #ifdef CONFIG_SYSCTL
1417 x25_unregister_sysctl();
1418 #endif
1419
1420 unregister_netdevice_notifier(&x25_dev_notifier);
1421
1422 dev_remove_pack(&x25_packet_type);
1423
1424 sock_unregister(AF_X25);
1425 }
1426 module_exit(x25_exit);
1427
1428 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
1429 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol");
1430 MODULE_LICENSE("GPL");
1431 MODULE_ALIAS_NETPROTO(PF_X25);
1432
|
This page was automatically generated by the
LXR engine.
|