2 * X.25 Packet Layer release 002
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.
8 * This code REQUIRES 2.1.15 or higher
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.
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 * 2005-04-02 Shaun Pereira Selective sub address matching
34 * 2005-04-15 Shaun Pereira Fast select with no restriction on
38 #define pr_fmt(fmt) "X25: " fmt
40 #include <linux/module.h>
41 #include <linux/capability.h>
42 #include <linux/errno.h>
43 #include <linux/kernel.h>
44 #include <linux/sched/signal.h>
45 #include <linux/timer.h>
46 #include <linux/string.h>
47 #include <linux/net.h>
48 #include <linux/netdevice.h>
49 #include <linux/if_arp.h>
50 #include <linux/skbuff.h>
51 #include <linux/slab.h>
53 #include <net/tcp_states.h>
54 #include <linux/uaccess.h>
55 #include <linux/fcntl.h>
56 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
57 #include <linux/notifier.h>
58 #include <linux/init.h>
59 #include <linux/compat.h>
60 #include <linux/ctype.h>
63 #include <net/compat.h>
65 int sysctl_x25_restart_request_timeout
= X25_DEFAULT_T20
;
66 int sysctl_x25_call_request_timeout
= X25_DEFAULT_T21
;
67 int sysctl_x25_reset_request_timeout
= X25_DEFAULT_T22
;
68 int sysctl_x25_clear_request_timeout
= X25_DEFAULT_T23
;
69 int sysctl_x25_ack_holdback_timeout
= X25_DEFAULT_T2
;
70 int sysctl_x25_forward
= 0;
73 DEFINE_RWLOCK(x25_list_lock
);
75 static const struct proto_ops x25_proto_ops
;
77 static const struct x25_address null_x25_address
= {" "};
80 struct compat_x25_subscrip_struct
{
81 char device
[200-sizeof(compat_ulong_t
)];
82 compat_ulong_t global_facil_mask
;
83 compat_uint_t extended
;
88 int x25_parse_address_block(struct sk_buff
*skb
,
89 struct x25_address
*called_addr
,
90 struct x25_address
*calling_addr
)
96 if (!pskb_may_pull(skb
, 1)) {
97 /* packet has no address block */
103 needed
= 1 + (len
>> 4) + (len
& 0x0f);
105 if (!pskb_may_pull(skb
, needed
)) {
106 /* packet is too short to hold the addresses it claims
112 return x25_addr_ntoa(skb
->data
, called_addr
, calling_addr
);
115 *called_addr
->x25_addr
= 0;
116 *calling_addr
->x25_addr
= 0;
122 int x25_addr_ntoa(unsigned char *p
, struct x25_address
*called_addr
,
123 struct x25_address
*calling_addr
)
125 unsigned int called_len
, calling_len
;
126 char *called
, *calling
;
129 called_len
= (*p
>> 0) & 0x0F;
130 calling_len
= (*p
>> 4) & 0x0F;
132 called
= called_addr
->x25_addr
;
133 calling
= calling_addr
->x25_addr
;
136 for (i
= 0; i
< (called_len
+ calling_len
); i
++) {
137 if (i
< called_len
) {
139 *called
++ = ((*p
>> 0) & 0x0F) + '0';
142 *called
++ = ((*p
>> 4) & 0x0F) + '0';
146 *calling
++ = ((*p
>> 0) & 0x0F) + '0';
149 *calling
++ = ((*p
>> 4) & 0x0F) + '0';
154 *called
= *calling
= '\0';
156 return 1 + (called_len
+ calling_len
+ 1) / 2;
159 int x25_addr_aton(unsigned char *p
, struct x25_address
*called_addr
,
160 struct x25_address
*calling_addr
)
162 unsigned int called_len
, calling_len
;
163 char *called
, *calling
;
166 called
= called_addr
->x25_addr
;
167 calling
= calling_addr
->x25_addr
;
169 called_len
= strlen(called
);
170 calling_len
= strlen(calling
);
172 *p
++ = (calling_len
<< 4) | (called_len
<< 0);
174 for (i
= 0; i
< (called_len
+ calling_len
); i
++) {
175 if (i
< called_len
) {
177 *p
|= (*called
++ - '0') << 0;
181 *p
|= (*called
++ - '0') << 4;
185 *p
|= (*calling
++ - '0') << 0;
189 *p
|= (*calling
++ - '0') << 4;
194 return 1 + (called_len
+ calling_len
+ 1) / 2;
198 * Socket removal during an interrupt is now safe.
200 static void x25_remove_socket(struct sock
*sk
)
202 write_lock_bh(&x25_list_lock
);
203 sk_del_node_init(sk
);
204 write_unlock_bh(&x25_list_lock
);
208 * Kill all bound sockets on a dropped device.
210 static void x25_kill_by_device(struct net_device
*dev
)
214 write_lock_bh(&x25_list_lock
);
216 sk_for_each(s
, &x25_list
)
217 if (x25_sk(s
)->neighbour
&& x25_sk(s
)->neighbour
->dev
== dev
)
218 x25_disconnect(s
, ENETUNREACH
, 0, 0);
220 write_unlock_bh(&x25_list_lock
);
224 * Handle device status changes.
226 static int x25_device_event(struct notifier_block
*this, unsigned long event
,
229 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
230 struct x25_neigh
*nb
;
232 if (!net_eq(dev_net(dev
), &init_net
))
235 if (dev
->type
== ARPHRD_X25
236 #if IS_ENABLED(CONFIG_LLC)
237 || dev
->type
== ARPHRD_ETHER
242 x25_link_device_up(dev
);
244 case NETDEV_GOING_DOWN
:
245 nb
= x25_get_neigh(dev
);
247 x25_terminate_link(nb
);
252 x25_kill_by_device(dev
);
253 x25_route_device_down(dev
);
254 x25_link_device_down(dev
);
263 * Add a socket to the bound sockets list.
265 static void x25_insert_socket(struct sock
*sk
)
267 write_lock_bh(&x25_list_lock
);
268 sk_add_node(sk
, &x25_list
);
269 write_unlock_bh(&x25_list_lock
);
273 * Find a socket that wants to accept the Call Request we just
274 * received. Check the full list for an address/cud match.
275 * If no cuds match return the next_best thing, an address match.
276 * Note: if a listening socket has cud set it must only get calls
279 static struct sock
*x25_find_listener(struct x25_address
*addr
,
283 struct sock
*next_best
;
285 read_lock_bh(&x25_list_lock
);
288 sk_for_each(s
, &x25_list
)
289 if ((!strcmp(addr
->x25_addr
,
290 x25_sk(s
)->source_addr
.x25_addr
) ||
291 !strcmp(addr
->x25_addr
,
292 null_x25_address
.x25_addr
)) &&
293 s
->sk_state
== TCP_LISTEN
) {
295 * Found a listening socket, now check the incoming
296 * call user data vs this sockets call user data
298 if (x25_sk(s
)->cudmatchlength
> 0 &&
299 skb
->len
>= x25_sk(s
)->cudmatchlength
) {
300 if((memcmp(x25_sk(s
)->calluserdata
.cuddata
,
302 x25_sk(s
)->cudmatchlength
)) == 0) {
316 read_unlock_bh(&x25_list_lock
);
321 * Find a connected X.25 socket given my LCI and neighbour.
323 static struct sock
*__x25_find_socket(unsigned int lci
, struct x25_neigh
*nb
)
327 sk_for_each(s
, &x25_list
)
328 if (x25_sk(s
)->lci
== lci
&& x25_sk(s
)->neighbour
== nb
) {
337 struct sock
*x25_find_socket(unsigned int lci
, struct x25_neigh
*nb
)
341 read_lock_bh(&x25_list_lock
);
342 s
= __x25_find_socket(lci
, nb
);
343 read_unlock_bh(&x25_list_lock
);
348 * Find a unique LCI for a given device.
350 static unsigned int x25_new_lci(struct x25_neigh
*nb
)
352 unsigned int lci
= 1;
355 while ((sk
= x25_find_socket(lci
, nb
)) != NULL
) {
370 static void __x25_destroy_socket(struct sock
*);
373 * handler for deferred kills.
375 static void x25_destroy_timer(unsigned long data
)
377 x25_destroy_socket_from_timer((struct sock
*)data
);
381 * This is called from user mode and the timers. Thus it protects itself
382 * against interrupt users but doesn't worry about being called during
383 * work. Once it is removed from the queue no interrupt or bottom half
384 * will touch it and we are (fairly 8-) ) safe.
385 * Not static as it's used by the timer
387 static void __x25_destroy_socket(struct sock
*sk
)
391 x25_stop_heartbeat(sk
);
394 x25_remove_socket(sk
);
395 x25_clear_queues(sk
); /* Flush the queues */
397 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)) != NULL
) {
398 if (skb
->sk
!= sk
) { /* A pending connection */
400 * Queue the unaccepted socket for death
402 skb
->sk
->sk_state
= TCP_LISTEN
;
403 sock_set_flag(skb
->sk
, SOCK_DEAD
);
404 x25_start_heartbeat(skb
->sk
);
405 x25_sk(skb
->sk
)->state
= X25_STATE_0
;
411 if (sk_has_allocations(sk
)) {
412 /* Defer: outstanding buffers */
413 sk
->sk_timer
.expires
= jiffies
+ 10 * HZ
;
414 sk
->sk_timer
.function
= x25_destroy_timer
;
415 sk
->sk_timer
.data
= (unsigned long)sk
;
416 add_timer(&sk
->sk_timer
);
418 /* drop last reference so sock_put will free */
423 void x25_destroy_socket_from_timer(struct sock
*sk
)
427 __x25_destroy_socket(sk
);
433 * Handling for system calls applied via the various interfaces to a
434 * X.25 socket object.
437 static int x25_setsockopt(struct socket
*sock
, int level
, int optname
,
438 char __user
*optval
, unsigned int optlen
)
441 struct sock
*sk
= sock
->sk
;
442 int rc
= -ENOPROTOOPT
;
444 if (level
!= SOL_X25
|| optname
!= X25_QBITINCL
)
448 if (optlen
< sizeof(int))
452 if (get_user(opt
, (int __user
*)optval
))
456 set_bit(X25_Q_BIT_FLAG
, &x25_sk(sk
)->flags
);
458 clear_bit(X25_Q_BIT_FLAG
, &x25_sk(sk
)->flags
);
464 static int x25_getsockopt(struct socket
*sock
, int level
, int optname
,
465 char __user
*optval
, int __user
*optlen
)
467 struct sock
*sk
= sock
->sk
;
468 int val
, len
, rc
= -ENOPROTOOPT
;
470 if (level
!= SOL_X25
|| optname
!= X25_QBITINCL
)
474 if (get_user(len
, optlen
))
477 len
= min_t(unsigned int, len
, sizeof(int));
484 if (put_user(len
, optlen
))
487 val
= test_bit(X25_Q_BIT_FLAG
, &x25_sk(sk
)->flags
);
488 rc
= copy_to_user(optval
, &val
, len
) ? -EFAULT
: 0;
493 static int x25_listen(struct socket
*sock
, int backlog
)
495 struct sock
*sk
= sock
->sk
;
496 int rc
= -EOPNOTSUPP
;
499 if (sk
->sk_state
!= TCP_LISTEN
) {
500 memset(&x25_sk(sk
)->dest_addr
, 0, X25_ADDR_LEN
);
501 sk
->sk_max_ack_backlog
= backlog
;
502 sk
->sk_state
= TCP_LISTEN
;
510 static struct proto x25_proto
= {
512 .owner
= THIS_MODULE
,
513 .obj_size
= sizeof(struct x25_sock
),
516 static struct sock
*x25_alloc_socket(struct net
*net
, int kern
)
518 struct x25_sock
*x25
;
519 struct sock
*sk
= sk_alloc(net
, AF_X25
, GFP_ATOMIC
, &x25_proto
, kern
);
524 sock_init_data(NULL
, sk
);
527 skb_queue_head_init(&x25
->ack_queue
);
528 skb_queue_head_init(&x25
->fragment_queue
);
529 skb_queue_head_init(&x25
->interrupt_in_queue
);
530 skb_queue_head_init(&x25
->interrupt_out_queue
);
535 static int x25_create(struct net
*net
, struct socket
*sock
, int protocol
,
539 struct x25_sock
*x25
;
540 int rc
= -EAFNOSUPPORT
;
542 if (!net_eq(net
, &init_net
))
545 rc
= -ESOCKTNOSUPPORT
;
546 if (sock
->type
!= SOCK_SEQPACKET
)
554 if ((sk
= x25_alloc_socket(net
, kern
)) == NULL
)
559 sock_init_data(sock
, sk
);
563 sock
->ops
= &x25_proto_ops
;
564 sk
->sk_protocol
= protocol
;
565 sk
->sk_backlog_rcv
= x25_backlog_rcv
;
567 x25
->t21
= sysctl_x25_call_request_timeout
;
568 x25
->t22
= sysctl_x25_reset_request_timeout
;
569 x25
->t23
= sysctl_x25_clear_request_timeout
;
570 x25
->t2
= sysctl_x25_ack_holdback_timeout
;
571 x25
->state
= X25_STATE_0
;
572 x25
->cudmatchlength
= 0;
573 set_bit(X25_ACCPT_APPRV_FLAG
, &x25
->flags
); /* normally no cud */
576 x25
->facilities
.winsize_in
= X25_DEFAULT_WINDOW_SIZE
;
577 x25
->facilities
.winsize_out
= X25_DEFAULT_WINDOW_SIZE
;
578 x25
->facilities
.pacsize_in
= X25_DEFAULT_PACKET_SIZE
;
579 x25
->facilities
.pacsize_out
= X25_DEFAULT_PACKET_SIZE
;
580 x25
->facilities
.throughput
= 0; /* by default don't negotiate
582 x25
->facilities
.reverse
= X25_DEFAULT_REVERSE
;
583 x25
->dte_facilities
.calling_len
= 0;
584 x25
->dte_facilities
.called_len
= 0;
585 memset(x25
->dte_facilities
.called_ae
, '\0',
586 sizeof(x25
->dte_facilities
.called_ae
));
587 memset(x25
->dte_facilities
.calling_ae
, '\0',
588 sizeof(x25
->dte_facilities
.calling_ae
));
595 static struct sock
*x25_make_new(struct sock
*osk
)
597 struct sock
*sk
= NULL
;
598 struct x25_sock
*x25
, *ox25
;
600 if (osk
->sk_type
!= SOCK_SEQPACKET
)
603 if ((sk
= x25_alloc_socket(sock_net(osk
), 0)) == NULL
)
608 sk
->sk_type
= osk
->sk_type
;
609 sk
->sk_priority
= osk
->sk_priority
;
610 sk
->sk_protocol
= osk
->sk_protocol
;
611 sk
->sk_rcvbuf
= osk
->sk_rcvbuf
;
612 sk
->sk_sndbuf
= osk
->sk_sndbuf
;
613 sk
->sk_state
= TCP_ESTABLISHED
;
614 sk
->sk_backlog_rcv
= osk
->sk_backlog_rcv
;
615 sock_copy_flags(sk
, osk
);
618 x25
->t21
= ox25
->t21
;
619 x25
->t22
= ox25
->t22
;
620 x25
->t23
= ox25
->t23
;
622 x25
->flags
= ox25
->flags
;
623 x25
->facilities
= ox25
->facilities
;
624 x25
->dte_facilities
= ox25
->dte_facilities
;
625 x25
->cudmatchlength
= ox25
->cudmatchlength
;
627 clear_bit(X25_INTERRUPT_FLAG
, &x25
->flags
);
633 static int x25_release(struct socket
*sock
)
635 struct sock
*sk
= sock
->sk
;
636 struct x25_sock
*x25
;
645 switch (x25
->state
) {
649 x25_disconnect(sk
, 0, 0, 0);
650 __x25_destroy_socket(sk
);
656 x25_clear_queues(sk
);
657 x25_write_internal(sk
, X25_CLEAR_REQUEST
);
658 x25_start_t23timer(sk
);
659 x25
->state
= X25_STATE_2
;
660 sk
->sk_state
= TCP_CLOSE
;
661 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
662 sk
->sk_state_change(sk
);
663 sock_set_flag(sk
, SOCK_DEAD
);
664 sock_set_flag(sk
, SOCK_DESTROY
);
675 static int x25_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
677 struct sock
*sk
= sock
->sk
;
678 struct sockaddr_x25
*addr
= (struct sockaddr_x25
*)uaddr
;
681 if (!sock_flag(sk
, SOCK_ZAPPED
) ||
682 addr_len
!= sizeof(struct sockaddr_x25
) ||
683 addr
->sx25_family
!= AF_X25
) {
688 len
= strlen(addr
->sx25_addr
.x25_addr
);
689 for (i
= 0; i
< len
; i
++) {
690 if (!isdigit(addr
->sx25_addr
.x25_addr
[i
])) {
697 x25_sk(sk
)->source_addr
= addr
->sx25_addr
;
698 x25_insert_socket(sk
);
699 sock_reset_flag(sk
, SOCK_ZAPPED
);
701 SOCK_DEBUG(sk
, "x25_bind: socket is bound\n");
706 static int x25_wait_for_connection_establishment(struct sock
*sk
)
708 DECLARE_WAITQUEUE(wait
, current
);
711 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
713 __set_current_state(TASK_INTERRUPTIBLE
);
715 if (signal_pending(current
))
719 sk
->sk_socket
->state
= SS_UNCONNECTED
;
723 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
730 __set_current_state(TASK_RUNNING
);
731 remove_wait_queue(sk_sleep(sk
), &wait
);
735 static int x25_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
736 int addr_len
, int flags
)
738 struct sock
*sk
= sock
->sk
;
739 struct x25_sock
*x25
= x25_sk(sk
);
740 struct sockaddr_x25
*addr
= (struct sockaddr_x25
*)uaddr
;
741 struct x25_route
*rt
;
745 if (sk
->sk_state
== TCP_ESTABLISHED
&& sock
->state
== SS_CONNECTING
) {
746 sock
->state
= SS_CONNECTED
;
747 goto out
; /* Connect completed during a ERESTARTSYS event */
751 if (sk
->sk_state
== TCP_CLOSE
&& sock
->state
== SS_CONNECTING
) {
752 sock
->state
= SS_UNCONNECTED
;
756 rc
= -EISCONN
; /* No reconnect on a seqpacket socket */
757 if (sk
->sk_state
== TCP_ESTABLISHED
)
760 sk
->sk_state
= TCP_CLOSE
;
761 sock
->state
= SS_UNCONNECTED
;
764 if (addr_len
!= sizeof(struct sockaddr_x25
) ||
765 addr
->sx25_family
!= AF_X25
)
769 rt
= x25_get_route(&addr
->sx25_addr
);
773 x25
->neighbour
= x25_get_neigh(rt
->dev
);
777 x25_limit_facilities(&x25
->facilities
, x25
->neighbour
);
779 x25
->lci
= x25_new_lci(x25
->neighbour
);
784 if (sock_flag(sk
, SOCK_ZAPPED
)) /* Must bind first - autobinding does not work */
787 if (!strcmp(x25
->source_addr
.x25_addr
, null_x25_address
.x25_addr
))
788 memset(&x25
->source_addr
, '\0', X25_ADDR_LEN
);
790 x25
->dest_addr
= addr
->sx25_addr
;
792 /* Move to connecting socket, start sending Connect Requests */
793 sock
->state
= SS_CONNECTING
;
794 sk
->sk_state
= TCP_SYN_SENT
;
796 x25
->state
= X25_STATE_1
;
798 x25_write_internal(sk
, X25_CALL_REQUEST
);
800 x25_start_heartbeat(sk
);
801 x25_start_t21timer(sk
);
805 if (sk
->sk_state
!= TCP_ESTABLISHED
&& (flags
& O_NONBLOCK
))
808 rc
= x25_wait_for_connection_establishment(sk
);
812 sock
->state
= SS_CONNECTED
;
816 read_lock_bh(&x25_list_lock
);
817 x25_neigh_put(x25
->neighbour
);
818 x25
->neighbour
= NULL
;
819 read_unlock_bh(&x25_list_lock
);
828 static int x25_wait_for_data(struct sock
*sk
, long timeout
)
830 DECLARE_WAITQUEUE(wait
, current
);
833 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
835 __set_current_state(TASK_INTERRUPTIBLE
);
836 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
839 if (signal_pending(current
))
845 if (skb_queue_empty(&sk
->sk_receive_queue
)) {
847 timeout
= schedule_timeout(timeout
);
852 __set_current_state(TASK_RUNNING
);
853 remove_wait_queue(sk_sleep(sk
), &wait
);
857 static int x25_accept(struct socket
*sock
, struct socket
*newsock
, int flags
,
860 struct sock
*sk
= sock
->sk
;
869 if (sk
->sk_type
!= SOCK_SEQPACKET
)
874 if (sk
->sk_state
!= TCP_LISTEN
)
877 rc
= x25_wait_for_data(sk
, sk
->sk_rcvtimeo
);
880 skb
= skb_dequeue(&sk
->sk_receive_queue
);
885 sock_graft(newsk
, newsock
);
887 /* Now attach up the new socket */
890 sk
->sk_ack_backlog
--;
891 newsock
->state
= SS_CONNECTED
;
899 static int x25_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
900 int *uaddr_len
, int peer
)
902 struct sockaddr_x25
*sx25
= (struct sockaddr_x25
*)uaddr
;
903 struct sock
*sk
= sock
->sk
;
904 struct x25_sock
*x25
= x25_sk(sk
);
908 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
912 sx25
->sx25_addr
= x25
->dest_addr
;
914 sx25
->sx25_addr
= x25
->source_addr
;
916 sx25
->sx25_family
= AF_X25
;
917 *uaddr_len
= sizeof(*sx25
);
923 int x25_rx_call_request(struct sk_buff
*skb
, struct x25_neigh
*nb
,
928 struct x25_sock
*makex25
;
929 struct x25_address source_addr
, dest_addr
;
930 struct x25_facilities facilities
;
931 struct x25_dte_facilities dte_facilities
;
932 int len
, addr_len
, rc
;
935 * Remove the LCI and frame type.
937 skb_pull(skb
, X25_STD_MIN_LEN
);
940 * Extract the X.25 addresses and convert them to ASCII strings,
943 * Address block is mandatory in call request packets
945 addr_len
= x25_parse_address_block(skb
, &source_addr
, &dest_addr
);
947 goto out_clear_request
;
948 skb_pull(skb
, addr_len
);
951 * Get the length of the facilities, skip past them for the moment
952 * get the call user data because this is needed to determine
953 * the correct listener
955 * Facilities length is mandatory in call request packets
957 if (!pskb_may_pull(skb
, 1))
958 goto out_clear_request
;
959 len
= skb
->data
[0] + 1;
960 if (!pskb_may_pull(skb
, len
))
961 goto out_clear_request
;
965 * Ensure that the amount of call user data is valid.
967 if (skb
->len
> X25_MAX_CUD_LEN
)
968 goto out_clear_request
;
971 * Get all the call user data so it can be used in
972 * x25_find_listener and skb_copy_from_linear_data up ahead.
974 if (!pskb_may_pull(skb
, skb
->len
))
975 goto out_clear_request
;
978 * Find a listener for the particular address/cud pair.
980 sk
= x25_find_listener(&source_addr
,skb
);
983 if (sk
!= NULL
&& sk_acceptq_is_full(sk
)) {
988 * We dont have any listeners for this incoming call.
992 skb_push(skb
, addr_len
+ X25_STD_MIN_LEN
);
993 if (sysctl_x25_forward
&&
994 x25_forward_call(&dest_addr
, nb
, skb
, lci
) > 0)
996 /* Call was forwarded, dont process it any more */
1001 /* No listeners, can't forward, clear the call */
1002 goto out_clear_request
;
1007 * Try to reach a compromise on the requested facilities.
1009 len
= x25_negotiate_facilities(skb
, sk
, &facilities
, &dte_facilities
);
1014 * current neighbour/link might impose additional limits
1015 * on certain facilties
1018 x25_limit_facilities(&facilities
, nb
);
1021 * Try to create a new socket.
1023 make
= x25_make_new(sk
);
1028 * Remove the facilities
1033 make
->sk_state
= TCP_ESTABLISHED
;
1035 makex25
= x25_sk(make
);
1037 makex25
->dest_addr
= dest_addr
;
1038 makex25
->source_addr
= source_addr
;
1039 makex25
->neighbour
= nb
;
1040 makex25
->facilities
= facilities
;
1041 makex25
->dte_facilities
= dte_facilities
;
1042 makex25
->vc_facil_mask
= x25_sk(sk
)->vc_facil_mask
;
1043 /* ensure no reverse facil on accept */
1044 makex25
->vc_facil_mask
&= ~X25_MASK_REVERSE
;
1045 /* ensure no calling address extension on accept */
1046 makex25
->vc_facil_mask
&= ~X25_MASK_CALLING_AE
;
1047 makex25
->cudmatchlength
= x25_sk(sk
)->cudmatchlength
;
1049 /* Normally all calls are accepted immediately */
1050 if (test_bit(X25_ACCPT_APPRV_FLAG
, &makex25
->flags
)) {
1051 x25_write_internal(make
, X25_CALL_ACCEPTED
);
1052 makex25
->state
= X25_STATE_3
;
1056 * Incoming Call User Data.
1058 skb_copy_from_linear_data(skb
, makex25
->calluserdata
.cuddata
, skb
->len
);
1059 makex25
->calluserdata
.cudlength
= skb
->len
;
1061 sk
->sk_ack_backlog
++;
1063 x25_insert_socket(make
);
1065 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1067 x25_start_heartbeat(make
);
1069 if (!sock_flag(sk
, SOCK_DEAD
))
1070 sk
->sk_data_ready(sk
);
1079 x25_transmit_clear_request(nb
, lci
, 0x01);
1083 static int x25_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
)
1085 struct sock
*sk
= sock
->sk
;
1086 struct x25_sock
*x25
= x25_sk(sk
);
1087 DECLARE_SOCKADDR(struct sockaddr_x25
*, usx25
, msg
->msg_name
);
1088 struct sockaddr_x25 sx25
;
1089 struct sk_buff
*skb
;
1090 unsigned char *asmptr
;
1091 int noblock
= msg
->msg_flags
& MSG_DONTWAIT
;
1093 int qbit
= 0, rc
= -EINVAL
;
1096 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_OOB
|MSG_EOR
|MSG_CMSG_COMPAT
))
1099 /* we currently don't support segmented records at the user interface */
1100 if (!(msg
->msg_flags
& (MSG_EOR
|MSG_OOB
)))
1103 rc
= -EADDRNOTAVAIL
;
1104 if (sock_flag(sk
, SOCK_ZAPPED
))
1108 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1109 send_sig(SIGPIPE
, current
, 0);
1114 if (!x25
->neighbour
)
1119 if (msg
->msg_namelen
< sizeof(sx25
))
1121 memcpy(&sx25
, usx25
, sizeof(sx25
));
1123 if (strcmp(x25
->dest_addr
.x25_addr
, sx25
.sx25_addr
.x25_addr
))
1126 if (sx25
.sx25_family
!= AF_X25
)
1130 * FIXME 1003.1g - if the socket is like this because
1131 * it has become closed (not started closed) we ought
1132 * to SIGPIPE, EPIPE;
1135 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1138 sx25
.sx25_family
= AF_X25
;
1139 sx25
.sx25_addr
= x25
->dest_addr
;
1142 /* Sanity check the packet size */
1148 SOCK_DEBUG(sk
, "x25_sendmsg: sendto: Addresses built.\n");
1150 /* Build a packet */
1151 SOCK_DEBUG(sk
, "x25_sendmsg: sendto: building packet.\n");
1153 if ((msg
->msg_flags
& MSG_OOB
) && len
> 32)
1156 size
= len
+ X25_MAX_L2_LEN
+ X25_EXT_MIN_LEN
;
1159 skb
= sock_alloc_send_skb(sk
, size
, noblock
, &rc
);
1163 X25_SKB_CB(skb
)->flags
= msg
->msg_flags
;
1165 skb_reserve(skb
, X25_MAX_L2_LEN
+ X25_EXT_MIN_LEN
);
1168 * Put the data on the end
1170 SOCK_DEBUG(sk
, "x25_sendmsg: Copying user data\n");
1172 skb_reset_transport_header(skb
);
1175 rc
= memcpy_from_msg(skb_transport_header(skb
), msg
, len
);
1180 * If the Q BIT Include socket option is in force, the first
1181 * byte of the user data is the logical value of the Q Bit.
1183 if (test_bit(X25_Q_BIT_FLAG
, &x25
->flags
)) {
1184 if (!pskb_may_pull(skb
, 1))
1187 qbit
= skb
->data
[0];
1192 * Push down the X.25 header
1194 SOCK_DEBUG(sk
, "x25_sendmsg: Building X.25 Header.\n");
1196 if (msg
->msg_flags
& MSG_OOB
) {
1197 if (x25
->neighbour
->extended
) {
1198 asmptr
= skb_push(skb
, X25_STD_MIN_LEN
);
1199 *asmptr
++ = ((x25
->lci
>> 8) & 0x0F) | X25_GFI_EXTSEQ
;
1200 *asmptr
++ = (x25
->lci
>> 0) & 0xFF;
1201 *asmptr
++ = X25_INTERRUPT
;
1203 asmptr
= skb_push(skb
, X25_STD_MIN_LEN
);
1204 *asmptr
++ = ((x25
->lci
>> 8) & 0x0F) | X25_GFI_STDSEQ
;
1205 *asmptr
++ = (x25
->lci
>> 0) & 0xFF;
1206 *asmptr
++ = X25_INTERRUPT
;
1209 if (x25
->neighbour
->extended
) {
1210 /* Build an Extended X.25 header */
1211 asmptr
= skb_push(skb
, X25_EXT_MIN_LEN
);
1212 *asmptr
++ = ((x25
->lci
>> 8) & 0x0F) | X25_GFI_EXTSEQ
;
1213 *asmptr
++ = (x25
->lci
>> 0) & 0xFF;
1214 *asmptr
++ = X25_DATA
;
1215 *asmptr
++ = X25_DATA
;
1217 /* Build an Standard X.25 header */
1218 asmptr
= skb_push(skb
, X25_STD_MIN_LEN
);
1219 *asmptr
++ = ((x25
->lci
>> 8) & 0x0F) | X25_GFI_STDSEQ
;
1220 *asmptr
++ = (x25
->lci
>> 0) & 0xFF;
1221 *asmptr
++ = X25_DATA
;
1225 skb
->data
[0] |= X25_Q_BIT
;
1228 SOCK_DEBUG(sk
, "x25_sendmsg: Built header.\n");
1229 SOCK_DEBUG(sk
, "x25_sendmsg: Transmitting buffer\n");
1232 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1235 if (msg
->msg_flags
& MSG_OOB
)
1236 skb_queue_tail(&x25
->interrupt_out_queue
, skb
);
1238 rc
= x25_output(sk
, skb
);
1242 else if (test_bit(X25_Q_BIT_FLAG
, &x25
->flags
))
1257 static int x25_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1260 struct sock
*sk
= sock
->sk
;
1261 struct x25_sock
*x25
= x25_sk(sk
);
1262 DECLARE_SOCKADDR(struct sockaddr_x25
*, sx25
, msg
->msg_name
);
1264 int qbit
, header_len
;
1265 struct sk_buff
*skb
;
1266 unsigned char *asmptr
;
1271 if (x25
->neighbour
== NULL
)
1274 header_len
= x25
->neighbour
->extended
?
1275 X25_EXT_MIN_LEN
: X25_STD_MIN_LEN
;
1278 * This works for seqpacket too. The receiver has ordered the queue for
1279 * us! We do one quick check first though
1281 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1284 if (flags
& MSG_OOB
) {
1286 if (sock_flag(sk
, SOCK_URGINLINE
) ||
1287 !skb_peek(&x25
->interrupt_in_queue
))
1290 skb
= skb_dequeue(&x25
->interrupt_in_queue
);
1292 if (!pskb_may_pull(skb
, X25_STD_MIN_LEN
))
1293 goto out_free_dgram
;
1295 skb_pull(skb
, X25_STD_MIN_LEN
);
1298 * No Q bit information on Interrupt data.
1300 if (test_bit(X25_Q_BIT_FLAG
, &x25
->flags
)) {
1301 asmptr
= skb_push(skb
, 1);
1305 msg
->msg_flags
|= MSG_OOB
;
1307 /* Now we can treat all alike */
1309 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1310 flags
& MSG_DONTWAIT
, &rc
);
1315 if (!pskb_may_pull(skb
, header_len
))
1316 goto out_free_dgram
;
1318 qbit
= (skb
->data
[0] & X25_Q_BIT
) == X25_Q_BIT
;
1320 skb_pull(skb
, header_len
);
1322 if (test_bit(X25_Q_BIT_FLAG
, &x25
->flags
)) {
1323 asmptr
= skb_push(skb
, 1);
1328 skb_reset_transport_header(skb
);
1331 if (copied
> size
) {
1333 msg
->msg_flags
|= MSG_TRUNC
;
1336 /* Currently, each datagram always contains a complete record */
1337 msg
->msg_flags
|= MSG_EOR
;
1339 rc
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
1341 goto out_free_dgram
;
1344 sx25
->sx25_family
= AF_X25
;
1345 sx25
->sx25_addr
= x25
->dest_addr
;
1346 msg
->msg_namelen
= sizeof(*sx25
);
1352 skb_free_datagram(sk
, skb
);
1359 static int x25_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1361 struct sock
*sk
= sock
->sk
;
1362 struct x25_sock
*x25
= x25_sk(sk
);
1363 void __user
*argp
= (void __user
*)arg
;
1370 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1373 rc
= put_user(amount
, (unsigned int __user
*)argp
);
1378 struct sk_buff
*skb
;
1381 * These two are safe on a single CPU system as
1382 * only user tasks fiddle here
1385 if ((skb
= skb_peek(&sk
->sk_receive_queue
)) != NULL
)
1388 rc
= put_user(amount
, (unsigned int __user
*)argp
);
1395 rc
= sock_get_timestamp(sk
,
1396 (struct timeval __user
*)argp
);
1401 rc
= sock_get_timestampns(sk
,
1402 (struct timespec __user
*)argp
);
1406 case SIOCGIFDSTADDR
:
1407 case SIOCSIFDSTADDR
:
1408 case SIOCGIFBRDADDR
:
1409 case SIOCSIFBRDADDR
:
1410 case SIOCGIFNETMASK
:
1411 case SIOCSIFNETMASK
:
1419 if (!capable(CAP_NET_ADMIN
))
1421 rc
= x25_route_ioctl(cmd
, argp
);
1423 case SIOCX25GSUBSCRIP
:
1424 rc
= x25_subscr_ioctl(cmd
, argp
);
1426 case SIOCX25SSUBSCRIP
:
1428 if (!capable(CAP_NET_ADMIN
))
1430 rc
= x25_subscr_ioctl(cmd
, argp
);
1432 case SIOCX25GFACILITIES
: {
1434 rc
= copy_to_user(argp
, &x25
->facilities
,
1435 sizeof(x25
->facilities
))
1441 case SIOCX25SFACILITIES
: {
1442 struct x25_facilities facilities
;
1444 if (copy_from_user(&facilities
, argp
, sizeof(facilities
)))
1448 if (sk
->sk_state
!= TCP_LISTEN
&&
1449 sk
->sk_state
!= TCP_CLOSE
)
1450 goto out_fac_release
;
1451 if (facilities
.pacsize_in
< X25_PS16
||
1452 facilities
.pacsize_in
> X25_PS4096
)
1453 goto out_fac_release
;
1454 if (facilities
.pacsize_out
< X25_PS16
||
1455 facilities
.pacsize_out
> X25_PS4096
)
1456 goto out_fac_release
;
1457 if (facilities
.winsize_in
< 1 ||
1458 facilities
.winsize_in
> 127)
1459 goto out_fac_release
;
1460 if (facilities
.throughput
) {
1461 int out
= facilities
.throughput
& 0xf0;
1462 int in
= facilities
.throughput
& 0x0f;
1464 facilities
.throughput
|=
1465 X25_DEFAULT_THROUGHPUT
<< 4;
1466 else if (out
< 0x30 || out
> 0xD0)
1467 goto out_fac_release
;
1469 facilities
.throughput
|=
1470 X25_DEFAULT_THROUGHPUT
;
1471 else if (in
< 0x03 || in
> 0x0D)
1472 goto out_fac_release
;
1474 if (facilities
.reverse
&&
1475 (facilities
.reverse
& 0x81) != 0x81)
1476 goto out_fac_release
;
1477 x25
->facilities
= facilities
;
1484 case SIOCX25GDTEFACILITIES
: {
1486 rc
= copy_to_user(argp
, &x25
->dte_facilities
,
1487 sizeof(x25
->dte_facilities
));
1494 case SIOCX25SDTEFACILITIES
: {
1495 struct x25_dte_facilities dtefacs
;
1497 if (copy_from_user(&dtefacs
, argp
, sizeof(dtefacs
)))
1501 if (sk
->sk_state
!= TCP_LISTEN
&&
1502 sk
->sk_state
!= TCP_CLOSE
)
1503 goto out_dtefac_release
;
1504 if (dtefacs
.calling_len
> X25_MAX_AE_LEN
)
1505 goto out_dtefac_release
;
1506 if (dtefacs
.called_len
> X25_MAX_AE_LEN
)
1507 goto out_dtefac_release
;
1508 x25
->dte_facilities
= dtefacs
;
1515 case SIOCX25GCALLUSERDATA
: {
1517 rc
= copy_to_user(argp
, &x25
->calluserdata
,
1518 sizeof(x25
->calluserdata
))
1524 case SIOCX25SCALLUSERDATA
: {
1525 struct x25_calluserdata calluserdata
;
1528 if (copy_from_user(&calluserdata
, argp
, sizeof(calluserdata
)))
1531 if (calluserdata
.cudlength
> X25_MAX_CUD_LEN
)
1534 x25
->calluserdata
= calluserdata
;
1540 case SIOCX25GCAUSEDIAG
: {
1542 rc
= copy_to_user(argp
, &x25
->causediag
, sizeof(x25
->causediag
))
1548 case SIOCX25SCAUSEDIAG
: {
1549 struct x25_causediag causediag
;
1551 if (copy_from_user(&causediag
, argp
, sizeof(causediag
)))
1554 x25
->causediag
= causediag
;
1561 case SIOCX25SCUDMATCHLEN
: {
1562 struct x25_subaddr sub_addr
;
1565 if(sk
->sk_state
!= TCP_CLOSE
)
1566 goto out_cud_release
;
1568 if (copy_from_user(&sub_addr
, argp
,
1570 goto out_cud_release
;
1572 if (sub_addr
.cudmatchlength
> X25_MAX_CUD_LEN
)
1573 goto out_cud_release
;
1574 x25
->cudmatchlength
= sub_addr
.cudmatchlength
;
1581 case SIOCX25CALLACCPTAPPRV
: {
1584 if (sk
->sk_state
== TCP_CLOSE
) {
1585 clear_bit(X25_ACCPT_APPRV_FLAG
, &x25
->flags
);
1592 case SIOCX25SENDCALLACCPT
: {
1595 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1596 goto out_sendcallaccpt_release
;
1597 /* must call accptapprv above */
1598 if (test_bit(X25_ACCPT_APPRV_FLAG
, &x25
->flags
))
1599 goto out_sendcallaccpt_release
;
1600 x25_write_internal(sk
, X25_CALL_ACCEPTED
);
1601 x25
->state
= X25_STATE_3
;
1603 out_sendcallaccpt_release
:
1616 static const struct net_proto_family x25_family_ops
= {
1618 .create
= x25_create
,
1619 .owner
= THIS_MODULE
,
1622 #ifdef CONFIG_COMPAT
1623 static int compat_x25_subscr_ioctl(unsigned int cmd
,
1624 struct compat_x25_subscrip_struct __user
*x25_subscr32
)
1626 struct compat_x25_subscrip_struct x25_subscr
;
1627 struct x25_neigh
*nb
;
1628 struct net_device
*dev
;
1632 if (copy_from_user(&x25_subscr
, x25_subscr32
, sizeof(*x25_subscr32
)))
1636 dev
= x25_dev_get(x25_subscr
.device
);
1640 nb
= x25_get_neigh(dev
);
1646 if (cmd
== SIOCX25GSUBSCRIP
) {
1647 read_lock_bh(&x25_neigh_list_lock
);
1648 x25_subscr
.extended
= nb
->extended
;
1649 x25_subscr
.global_facil_mask
= nb
->global_facil_mask
;
1650 read_unlock_bh(&x25_neigh_list_lock
);
1651 rc
= copy_to_user(x25_subscr32
, &x25_subscr
,
1652 sizeof(*x25_subscr32
)) ? -EFAULT
: 0;
1655 if (x25_subscr
.extended
== 0 || x25_subscr
.extended
== 1) {
1657 write_lock_bh(&x25_neigh_list_lock
);
1658 nb
->extended
= x25_subscr
.extended
;
1659 nb
->global_facil_mask
= x25_subscr
.global_facil_mask
;
1660 write_unlock_bh(&x25_neigh_list_lock
);
1671 static int compat_x25_ioctl(struct socket
*sock
, unsigned int cmd
,
1674 void __user
*argp
= compat_ptr(arg
);
1675 struct sock
*sk
= sock
->sk
;
1677 int rc
= -ENOIOCTLCMD
;
1682 rc
= x25_ioctl(sock
, cmd
, (unsigned long)argp
);
1687 rc
= compat_sock_get_timestamp(sk
,
1688 (struct timeval __user
*)argp
);
1693 rc
= compat_sock_get_timestampns(sk
,
1694 (struct timespec __user
*)argp
);
1698 case SIOCGIFDSTADDR
:
1699 case SIOCSIFDSTADDR
:
1700 case SIOCGIFBRDADDR
:
1701 case SIOCSIFBRDADDR
:
1702 case SIOCGIFNETMASK
:
1703 case SIOCSIFNETMASK
:
1711 if (!capable(CAP_NET_ADMIN
))
1713 rc
= x25_route_ioctl(cmd
, argp
);
1715 case SIOCX25GSUBSCRIP
:
1716 rc
= compat_x25_subscr_ioctl(cmd
, argp
);
1718 case SIOCX25SSUBSCRIP
:
1720 if (!capable(CAP_NET_ADMIN
))
1722 rc
= compat_x25_subscr_ioctl(cmd
, argp
);
1724 case SIOCX25GFACILITIES
:
1725 case SIOCX25SFACILITIES
:
1726 case SIOCX25GDTEFACILITIES
:
1727 case SIOCX25SDTEFACILITIES
:
1728 case SIOCX25GCALLUSERDATA
:
1729 case SIOCX25SCALLUSERDATA
:
1730 case SIOCX25GCAUSEDIAG
:
1731 case SIOCX25SCAUSEDIAG
:
1732 case SIOCX25SCUDMATCHLEN
:
1733 case SIOCX25CALLACCPTAPPRV
:
1734 case SIOCX25SENDCALLACCPT
:
1735 rc
= x25_ioctl(sock
, cmd
, (unsigned long)argp
);
1745 static const struct proto_ops x25_proto_ops
= {
1747 .owner
= THIS_MODULE
,
1748 .release
= x25_release
,
1750 .connect
= x25_connect
,
1751 .socketpair
= sock_no_socketpair
,
1752 .accept
= x25_accept
,
1753 .getname
= x25_getname
,
1754 .poll
= datagram_poll
,
1756 #ifdef CONFIG_COMPAT
1757 .compat_ioctl
= compat_x25_ioctl
,
1759 .listen
= x25_listen
,
1760 .shutdown
= sock_no_shutdown
,
1761 .setsockopt
= x25_setsockopt
,
1762 .getsockopt
= x25_getsockopt
,
1763 .sendmsg
= x25_sendmsg
,
1764 .recvmsg
= x25_recvmsg
,
1765 .mmap
= sock_no_mmap
,
1766 .sendpage
= sock_no_sendpage
,
1769 static struct packet_type x25_packet_type __read_mostly
= {
1770 .type
= cpu_to_be16(ETH_P_X25
),
1771 .func
= x25_lapb_receive_frame
,
1774 static struct notifier_block x25_dev_notifier
= {
1775 .notifier_call
= x25_device_event
,
1778 void x25_kill_by_neigh(struct x25_neigh
*nb
)
1782 write_lock_bh(&x25_list_lock
);
1784 sk_for_each(s
, &x25_list
)
1785 if (x25_sk(s
)->neighbour
== nb
)
1786 x25_disconnect(s
, ENETUNREACH
, 0, 0);
1788 write_unlock_bh(&x25_list_lock
);
1790 /* Remove any related forwards */
1791 x25_clear_forward_by_dev(nb
->dev
);
1794 static int __init
x25_init(void)
1798 rc
= proto_register(&x25_proto
, 0);
1802 rc
= sock_register(&x25_family_ops
);
1806 dev_add_pack(&x25_packet_type
);
1808 rc
= register_netdevice_notifier(&x25_dev_notifier
);
1812 rc
= x25_register_sysctl();
1816 rc
= x25_proc_init();
1820 pr_info("Linux Version 0.2\n");
1825 x25_unregister_sysctl();
1827 unregister_netdevice_notifier(&x25_dev_notifier
);
1829 dev_remove_pack(&x25_packet_type
);
1830 sock_unregister(AF_X25
);
1832 proto_unregister(&x25_proto
);
1835 module_init(x25_init
);
1837 static void __exit
x25_exit(void)
1843 x25_unregister_sysctl();
1845 unregister_netdevice_notifier(&x25_dev_notifier
);
1847 dev_remove_pack(&x25_packet_type
);
1849 sock_unregister(AF_X25
);
1850 proto_unregister(&x25_proto
);
1852 module_exit(x25_exit
);
1854 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
1855 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol");
1856 MODULE_LICENSE("GPL");
1857 MODULE_ALIAS_NETPROTO(PF_X25
);