3 * DECnet An implementation of the DECnet protocol suite for the LINUX
4 * operating system. DECnet is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
7 * DECnet Socket Layer Interface
9 * Authors: Eduardo Marcelo Serrat <emserrat@geocities.com>
10 * Patrick Caulfield <patrick@pandh.demon.co.uk>
13 * Steve Whitehouse: Copied from Eduardo Serrat and Patrick Caulfield's
14 * version of the code. Original copyright preserved
16 * Steve Whitehouse: Some bug fixes, cleaning up some code to make it
17 * compatible with my routing layer.
18 * Steve Whitehouse: Merging changes from Eduardo Serrat and Patrick
20 * Steve Whitehouse: Further bug fixes, checking module code still works
21 * with new routing layer.
22 * Steve Whitehouse: Additional set/get_sockopt() calls.
23 * Steve Whitehouse: Fixed TIOCINQ ioctl to be same as Eduardo's new
25 * Steve Whitehouse: recvmsg() changed to try and behave in a POSIX like
26 * way. Didn't manage it entirely, but its better.
27 * Steve Whitehouse: ditto for sendmsg().
28 * Steve Whitehouse: A selection of bug fixes to various things.
29 * Steve Whitehouse: Added TIOCOUTQ ioctl.
30 * Steve Whitehouse: Fixes to username2sockaddr & sockaddr2username.
31 * Steve Whitehouse: Fixes to connect() error returns.
32 * Patrick Caulfield: Fixes to delayed acceptance logic.
33 * David S. Miller: New socket locking
34 * Steve Whitehouse: Socket list hashing/locking
35 * Arnaldo C. Melo: use capable, not suser
36 * Steve Whitehouse: Removed unused code. Fix to use sk->allocation
38 * Patrick Caulfield: /proc/net/decnet now has object name/number
39 * Steve Whitehouse: Fixed local port allocation, hashed sk list
40 * Matthew Wilcox: Fixes for dn_ioctl()
41 * Steve Whitehouse: New connect/accept logic to allow timeouts and
42 * prepare for sendpage etc.
46 /******************************************************************************
47 (c) 1995-1998 E.M. Serrat emserrat@geocities.com
49 This program is free software; you can redistribute it and/or modify
50 it under the terms of the GNU General Public License as published by
51 the Free Software Foundation; either version 2 of the License, or
54 This program is distributed in the hope that it will be useful,
55 but WITHOUT ANY WARRANTY; without even the implied warranty of
56 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
57 GNU General Public License for more details.
61 Version Kernel Date Author/Comments
62 ------- ------ ---- ---------------
63 Version 0.0.1 2.0.30 01-dic-97 Eduardo Marcelo Serrat
64 (emserrat@geocities.com)
66 First Development of DECnet Socket La-
67 yer for Linux. Only supports outgoing
70 Version 0.0.2 2.1.105 20-jun-98 Patrick J. Caulfield
71 (patrick@pandh.demon.co.uk)
73 Port to new kernel development version.
75 Version 0.0.3 2.1.106 25-jun-98 Eduardo Marcelo Serrat
76 (emserrat@geocities.com)
78 Added support for incoming connections
79 so we can start developing server apps
83 Version 0.0.4 2.1.109 21-jul-98 Eduardo Marcelo Serrat
84 (emserrat@geocities.com)
86 Added support for X11R6.4. Now we can
87 use DECnet transport for X on Linux!!!
89 Version 0.0.5 2.1.110 01-aug-98 Eduardo Marcelo Serrat
90 (emserrat@geocities.com)
91 Removed bugs on flow control
92 Removed bugs on incoming accessdata
95 Version 0.0.6 2.1.110 07-aug-98 Eduardo Marcelo Serrat
100 *******************************************************************************/
102 #include <linux/config.h>
103 #include <linux/module.h>
104 #include <linux/errno.h>
105 #include <linux/types.h>
106 #include <linux/slab.h>
107 #include <linux/socket.h>
108 #include <linux/in.h>
109 #include <linux/kernel.h>
110 #include <linux/sched.h>
111 #include <linux/timer.h>
112 #include <linux/string.h>
113 #include <linux/sockios.h>
114 #include <linux/net.h>
115 #include <linux/netdevice.h>
116 #include <linux/inet.h>
117 #include <linux/route.h>
118 #include <linux/netfilter.h>
119 #include <linux/seq_file.h>
120 #include <net/sock.h>
121 #include <net/tcp_states.h>
122 #include <net/flow.h>
123 #include <asm/system.h>
124 #include <asm/ioctls.h>
125 #include <linux/mm.h>
126 #include <linux/interrupt.h>
127 #include <linux/proc_fs.h>
128 #include <linux/stat.h>
129 #include <linux/init.h>
130 #include <linux/poll.h>
131 #include <net/neighbour.h>
134 #include <net/dn_nsp.h>
135 #include <net/dn_dev.h>
136 #include <net/dn_route.h>
137 #include <net/dn_fib.h>
138 #include <net/dn_neigh.h>
145 static void dn_keepalive(struct sock
*sk
);
147 #define DN_SK_HASH_SHIFT 8
148 #define DN_SK_HASH_SIZE (1 << DN_SK_HASH_SHIFT)
149 #define DN_SK_HASH_MASK (DN_SK_HASH_SIZE - 1)
152 static struct proto_ops dn_proto_ops
;
153 static DEFINE_RWLOCK(dn_hash_lock
);
154 static struct hlist_head dn_sk_hash
[DN_SK_HASH_SIZE
];
155 static struct hlist_head dn_wild_sk
;
157 static int __dn_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int optlen
, int flags
);
158 static int __dn_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
, int flags
);
160 static struct hlist_head
*dn_find_list(struct sock
*sk
)
162 struct dn_scp
*scp
= DN_SK(sk
);
164 if (scp
->addr
.sdn_flags
& SDF_WILD
)
165 return hlist_empty(&dn_wild_sk
) ? &dn_wild_sk
: NULL
;
167 return &dn_sk_hash
[scp
->addrloc
& DN_SK_HASH_MASK
];
171 * Valid ports are those greater than zero and not already in use.
173 static int check_port(unsigned short port
)
176 struct hlist_node
*node
;
181 sk_for_each(sk
, node
, &dn_sk_hash
[port
& DN_SK_HASH_MASK
]) {
182 struct dn_scp
*scp
= DN_SK(sk
);
183 if (scp
->addrloc
== port
)
189 static unsigned short port_alloc(struct sock
*sk
)
191 struct dn_scp
*scp
= DN_SK(sk
);
192 static unsigned short port
= 0x2000;
193 unsigned short i_port
= port
;
195 while(check_port(++port
) != 0) {
206 * Since this is only ever called from user
207 * level, we don't need a write_lock() version
210 static int dn_hash_sock(struct sock
*sk
)
212 struct dn_scp
*scp
= DN_SK(sk
);
213 struct hlist_head
*list
;
216 BUG_ON(sk_hashed(sk
));
218 write_lock_bh(&dn_hash_lock
);
220 if (!scp
->addrloc
&& !port_alloc(sk
))
224 if ((list
= dn_find_list(sk
)) == NULL
)
227 sk_add_node(sk
, list
);
230 write_unlock_bh(&dn_hash_lock
);
234 static void dn_unhash_sock(struct sock
*sk
)
236 write_lock(&dn_hash_lock
);
237 sk_del_node_init(sk
);
238 write_unlock(&dn_hash_lock
);
241 static void dn_unhash_sock_bh(struct sock
*sk
)
243 write_lock_bh(&dn_hash_lock
);
244 sk_del_node_init(sk
);
245 write_unlock_bh(&dn_hash_lock
);
248 static struct hlist_head
*listen_hash(struct sockaddr_dn
*addr
)
251 unsigned hash
= addr
->sdn_objnum
;
254 hash
= addr
->sdn_objnamel
;
255 for(i
= 0; i
< dn_ntohs(addr
->sdn_objnamel
); i
++) {
256 hash
^= addr
->sdn_objname
[i
];
261 return &dn_sk_hash
[hash
& DN_SK_HASH_MASK
];
265 * Called to transform a socket from bound (i.e. with a local address)
266 * into a listening socket (doesn't need a local port number) and rehashes
267 * based upon the object name/number.
269 static void dn_rehash_sock(struct sock
*sk
)
271 struct hlist_head
*list
;
272 struct dn_scp
*scp
= DN_SK(sk
);
274 if (scp
->addr
.sdn_flags
& SDF_WILD
)
277 write_lock_bh(&dn_hash_lock
);
278 sk_del_node_init(sk
);
279 DN_SK(sk
)->addrloc
= 0;
280 list
= listen_hash(&DN_SK(sk
)->addr
);
281 sk_add_node(sk
, list
);
282 write_unlock_bh(&dn_hash_lock
);
285 int dn_sockaddr2username(struct sockaddr_dn
*sdn
, unsigned char *buf
, unsigned char type
)
293 *buf
++ = sdn
->sdn_objnum
;
297 *buf
++ = dn_ntohs(sdn
->sdn_objnamel
);
298 memcpy(buf
, sdn
->sdn_objname
, dn_ntohs(sdn
->sdn_objnamel
));
299 len
= 3 + dn_ntohs(sdn
->sdn_objnamel
);
304 *buf
++ = dn_ntohs(sdn
->sdn_objnamel
);
305 memcpy(buf
, sdn
->sdn_objname
, dn_ntohs(sdn
->sdn_objnamel
));
306 len
= 7 + dn_ntohs(sdn
->sdn_objnamel
);
314 * On reception of usernames, we handle types 1 and 0 for destination
315 * addresses only. Types 2 and 4 are used for source addresses, but the
316 * UIC, GIC are ignored and they are both treated the same way. Type 3
317 * is never used as I've no idea what its purpose might be or what its
320 int dn_username2sockaddr(unsigned char *data
, int len
, struct sockaddr_dn
*sdn
, unsigned char *fmt
)
327 sdn
->sdn_objnamel
= dn_htons(0);
328 memset(sdn
->sdn_objname
, 0, DN_MAXOBJL
);
339 sdn
->sdn_objnum
= type
;
361 sdn
->sdn_objnamel
= dn_htons(*data
++);
362 len
-= dn_ntohs(sdn
->sdn_objnamel
);
364 if ((len
< 0) || (dn_ntohs(sdn
->sdn_objnamel
) > namel
))
367 memcpy(sdn
->sdn_objname
, data
, dn_ntohs(sdn
->sdn_objnamel
));
372 struct sock
*dn_sklist_find_listener(struct sockaddr_dn
*addr
)
374 struct hlist_head
*list
= listen_hash(addr
);
375 struct hlist_node
*node
;
378 read_lock(&dn_hash_lock
);
379 sk_for_each(sk
, node
, list
) {
380 struct dn_scp
*scp
= DN_SK(sk
);
381 if (sk
->sk_state
!= TCP_LISTEN
)
383 if (scp
->addr
.sdn_objnum
) {
384 if (scp
->addr
.sdn_objnum
!= addr
->sdn_objnum
)
387 if (addr
->sdn_objnum
)
389 if (scp
->addr
.sdn_objnamel
!= addr
->sdn_objnamel
)
391 if (memcmp(scp
->addr
.sdn_objname
, addr
->sdn_objname
, dn_ntohs(addr
->sdn_objnamel
)) != 0)
395 read_unlock(&dn_hash_lock
);
399 sk
= sk_head(&dn_wild_sk
);
401 if (sk
->sk_state
== TCP_LISTEN
)
407 read_unlock(&dn_hash_lock
);
411 struct sock
*dn_find_by_skb(struct sk_buff
*skb
)
413 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
415 struct hlist_node
*node
;
418 read_lock(&dn_hash_lock
);
419 sk_for_each(sk
, node
, &dn_sk_hash
[cb
->dst_port
& DN_SK_HASH_MASK
]) {
421 if (cb
->src
!= dn_saddr2dn(&scp
->peer
))
423 if (cb
->dst_port
!= scp
->addrloc
)
425 if (scp
->addrrem
&& (cb
->src_port
!= scp
->addrrem
))
432 read_unlock(&dn_hash_lock
);
438 static void dn_destruct(struct sock
*sk
)
440 struct dn_scp
*scp
= DN_SK(sk
);
442 skb_queue_purge(&scp
->data_xmit_queue
);
443 skb_queue_purge(&scp
->other_xmit_queue
);
444 skb_queue_purge(&scp
->other_receive_queue
);
446 dst_release(xchg(&sk
->sk_dst_cache
, NULL
));
449 static struct proto dn_proto
= {
451 .owner
= THIS_MODULE
,
452 .obj_size
= sizeof(struct dn_sock
),
455 static struct sock
*dn_alloc_sock(struct socket
*sock
,
456 unsigned int __nocast gfp
)
459 struct sock
*sk
= sk_alloc(PF_DECnet
, gfp
, &dn_proto
, 1);
465 sock
->ops
= &dn_proto_ops
;
466 sock_init_data(sock
, sk
);
468 sk
->sk_backlog_rcv
= dn_nsp_backlog_rcv
;
469 sk
->sk_destruct
= dn_destruct
;
471 sk
->sk_family
= PF_DECnet
;
473 sk
->sk_allocation
= gfp
;
475 /* Initialization of DECnet Session Control Port */
477 scp
->state
= DN_O
; /* Open */
478 scp
->numdat
= 1; /* Next data seg to tx */
479 scp
->numoth
= 1; /* Next oth data to tx */
480 scp
->ackxmt_dat
= 0; /* Last data seg ack'ed */
481 scp
->ackxmt_oth
= 0; /* Last oth data ack'ed */
482 scp
->ackrcv_dat
= 0; /* Highest data ack recv*/
483 scp
->ackrcv_oth
= 0; /* Last oth data ack rec*/
484 scp
->flowrem_sw
= DN_SEND
;
485 scp
->flowloc_sw
= DN_SEND
;
486 scp
->flowrem_dat
= 0;
487 scp
->flowrem_oth
= 1;
488 scp
->flowloc_dat
= 0;
489 scp
->flowloc_oth
= 1;
490 scp
->services_rem
= 0;
491 scp
->services_loc
= 1 | NSP_FC_NONE
;
493 scp
->info_loc
= 0x03; /* NSP version 4.1 */
494 scp
->segsize_rem
= 230 - DN_MAX_NSP_DATA_HEADER
; /* Default: Updated by remote segsize */
497 scp
->accept_mode
= ACC_IMMED
;
498 scp
->addr
.sdn_family
= AF_DECnet
;
499 scp
->peer
.sdn_family
= AF_DECnet
;
500 scp
->accessdata
.acc_accl
= 5;
501 memcpy(scp
->accessdata
.acc_acc
, "LINUX", 5);
503 scp
->max_window
= NSP_MAX_WINDOW
;
504 scp
->snd_window
= NSP_MIN_WINDOW
;
505 scp
->nsp_srtt
= NSP_INITIAL_SRTT
;
506 scp
->nsp_rttvar
= NSP_INITIAL_RTTVAR
;
507 scp
->nsp_rxtshift
= 0;
509 skb_queue_head_init(&scp
->data_xmit_queue
);
510 skb_queue_head_init(&scp
->other_xmit_queue
);
511 skb_queue_head_init(&scp
->other_receive_queue
);
514 scp
->persist_fxn
= NULL
;
515 scp
->keepalive
= 10 * HZ
;
516 scp
->keepalive_fxn
= dn_keepalive
;
518 init_timer(&scp
->delack_timer
);
519 scp
->delack_pending
= 0;
520 scp
->delack_fxn
= dn_nsp_delayed_ack
;
522 dn_start_slow_timer(sk
);
529 * FIXME: Should respond to SO_KEEPALIVE etc.
531 static void dn_keepalive(struct sock
*sk
)
533 struct dn_scp
*scp
= DN_SK(sk
);
536 * By checking the other_data transmit queue is empty
537 * we are double checking that we are not sending too
538 * many of these keepalive frames.
540 if (skb_queue_empty(&scp
->other_xmit_queue
))
541 dn_nsp_send_link(sk
, DN_NOCHANGE
, 0);
546 * Timer for shutdown/destroyed sockets.
547 * When socket is dead & no packets have been sent for a
548 * certain amount of time, they are removed by this
549 * routine. Also takes care of sending out DI & DC
550 * frames at correct times.
552 int dn_destroy_timer(struct sock
*sk
)
554 struct dn_scp
*scp
= DN_SK(sk
);
556 scp
->persist
= dn_nsp_persist(sk
);
560 dn_nsp_send_disc(sk
, NSP_DISCINIT
, 0, GFP_ATOMIC
);
561 if (scp
->nsp_rxtshift
>= decnet_di_count
)
566 dn_nsp_send_disc(sk
, NSP_DISCINIT
, 0, GFP_ATOMIC
);
567 if (scp
->nsp_rxtshift
>= decnet_dr_count
)
572 if (scp
->nsp_rxtshift
< decnet_dn_count
) {
573 /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
574 dn_nsp_send_disc(sk
, NSP_DISCCONF
, NSP_REASON_DC
, GFP_ATOMIC
);
579 scp
->persist
= (HZ
* decnet_time_wait
);
584 if ((jiffies
- scp
->stamp
) >= (HZ
* decnet_time_wait
)) {
593 static void dn_destroy_sock(struct sock
*sk
)
595 struct dn_scp
*scp
= DN_SK(sk
);
597 scp
->nsp_rxtshift
= 0; /* reset back off */
600 if (sk
->sk_socket
->state
!= SS_UNCONNECTED
)
601 sk
->sk_socket
->state
= SS_DISCONNECTING
;
604 sk
->sk_state
= TCP_CLOSE
;
608 dn_nsp_send_disc(sk
, NSP_DISCCONF
, NSP_REASON_DC
,
610 scp
->persist_fxn
= dn_destroy_timer
;
611 scp
->persist
= dn_nsp_persist(sk
);
621 dn_nsp_send_disc(sk
, NSP_DISCINIT
, 0, sk
->sk_allocation
);
630 scp
->persist_fxn
= dn_destroy_timer
;
631 scp
->persist
= dn_nsp_persist(sk
);
634 printk(KERN_DEBUG
"DECnet: dn_destroy_sock passed socket in invalid state\n");
636 dn_stop_slow_timer(sk
);
638 dn_unhash_sock_bh(sk
);
645 char *dn_addr2asc(dn_address addr
, char *buf
)
647 unsigned short node
, area
;
649 node
= addr
& 0x03ff;
651 sprintf(buf
, "%hd.%hd", area
, node
);
658 static int dn_create(struct socket
*sock
, int protocol
)
664 if (protocol
!= DNPROTO_NSP
)
665 return -EPROTONOSUPPORT
;
670 return -ESOCKTNOSUPPORT
;
674 if ((sk
= dn_alloc_sock(sock
, GFP_KERNEL
)) == NULL
)
677 sk
->sk_protocol
= protocol
;
684 dn_release(struct socket
*sock
)
686 struct sock
*sk
= sock
->sk
;
700 static int dn_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
702 struct sock
*sk
= sock
->sk
;
703 struct dn_scp
*scp
= DN_SK(sk
);
704 struct sockaddr_dn
*saddr
= (struct sockaddr_dn
*)uaddr
;
705 struct net_device
*dev
;
708 if (addr_len
!= sizeof(struct sockaddr_dn
))
711 if (saddr
->sdn_family
!= AF_DECnet
)
714 if (dn_ntohs(saddr
->sdn_nodeaddrl
) && (dn_ntohs(saddr
->sdn_nodeaddrl
) != 2))
717 if (dn_ntohs(saddr
->sdn_objnamel
) > DN_MAXOBJL
)
720 if (saddr
->sdn_flags
& ~SDF_WILD
)
724 if (!capable(CAP_NET_BIND_SERVICE
) && (saddr
->sdn_objnum
||
725 (saddr
->sdn_flags
& SDF_WILD
)))
729 * Maybe put the default actions in the default security ops for
730 * dn_prot_sock ? Would be nice if the capable call would go there
733 if (security_dn_prot_sock(saddr
) &&
734 !capable(CAP_NET_BIND_SERVICE
) ||
735 saddr
->sdn_objnum
|| (saddr
->sdn_flags
& SDF_WILD
))
740 if (!(saddr
->sdn_flags
& SDF_WILD
)) {
741 if (dn_ntohs(saddr
->sdn_nodeaddrl
)) {
742 read_lock(&dev_base_lock
);
743 for(dev
= dev_base
; dev
; dev
= dev
->next
) {
746 if (dn_dev_islocal(dev
, dn_saddr2dn(saddr
)))
749 read_unlock(&dev_base_lock
);
751 return -EADDRNOTAVAIL
;
757 if (sock_flag(sk
, SOCK_ZAPPED
)) {
758 memcpy(&scp
->addr
, saddr
, addr_len
);
759 sock_reset_flag(sk
, SOCK_ZAPPED
);
761 rv
= dn_hash_sock(sk
);
763 sock_set_flag(sk
, SOCK_ZAPPED
);
771 static int dn_auto_bind(struct socket
*sock
)
773 struct sock
*sk
= sock
->sk
;
774 struct dn_scp
*scp
= DN_SK(sk
);
777 sock_reset_flag(sk
, SOCK_ZAPPED
);
779 scp
->addr
.sdn_flags
= 0;
780 scp
->addr
.sdn_objnum
= 0;
783 * This stuff is to keep compatibility with Eduardo's
784 * patch. I hope I can dispense with it shortly...
786 if ((scp
->accessdata
.acc_accl
!= 0) &&
787 (scp
->accessdata
.acc_accl
<= 12)) {
789 scp
->addr
.sdn_objnamel
= dn_htons(scp
->accessdata
.acc_accl
);
790 memcpy(scp
->addr
.sdn_objname
, scp
->accessdata
.acc_acc
, dn_ntohs(scp
->addr
.sdn_objnamel
));
792 scp
->accessdata
.acc_accl
= 0;
793 memset(scp
->accessdata
.acc_acc
, 0, 40);
795 /* End of compatibility stuff */
797 scp
->addr
.sdn_add
.a_len
= dn_htons(2);
798 rv
= dn_dev_bind_default((dn_address
*)scp
->addr
.sdn_add
.a_addr
);
800 rv
= dn_hash_sock(sk
);
802 sock_set_flag(sk
, SOCK_ZAPPED
);
808 static int dn_confirm_accept(struct sock
*sk
, long *timeo
,
809 unsigned int __nocast allocation
)
811 struct dn_scp
*scp
= DN_SK(sk
);
815 if (scp
->state
!= DN_CR
)
819 scp
->segsize_loc
= dst_metric(__sk_dst_get(sk
), RTAX_ADVMSS
);
820 dn_send_conn_conf(sk
, allocation
);
822 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
825 if (scp
->state
== DN_CC
)
826 *timeo
= schedule_timeout(*timeo
);
829 if (scp
->state
== DN_RUN
)
831 err
= sock_error(sk
);
834 err
= sock_intr_errno(*timeo
);
835 if (signal_pending(current
))
840 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
842 finish_wait(sk
->sk_sleep
, &wait
);
844 sk
->sk_socket
->state
= SS_CONNECTED
;
845 } else if (scp
->state
!= DN_CC
) {
846 sk
->sk_socket
->state
= SS_UNCONNECTED
;
851 static int dn_wait_run(struct sock
*sk
, long *timeo
)
853 struct dn_scp
*scp
= DN_SK(sk
);
857 if (scp
->state
== DN_RUN
)
863 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
866 if (scp
->state
== DN_CI
|| scp
->state
== DN_CC
)
867 *timeo
= schedule_timeout(*timeo
);
870 if (scp
->state
== DN_RUN
)
872 err
= sock_error(sk
);
875 err
= sock_intr_errno(*timeo
);
876 if (signal_pending(current
))
881 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
883 finish_wait(sk
->sk_sleep
, &wait
);
886 sk
->sk_socket
->state
= SS_CONNECTED
;
887 } else if (scp
->state
!= DN_CI
&& scp
->state
!= DN_CC
) {
888 sk
->sk_socket
->state
= SS_UNCONNECTED
;
893 static int __dn_connect(struct sock
*sk
, struct sockaddr_dn
*addr
, int addrlen
, long *timeo
, int flags
)
895 struct socket
*sock
= sk
->sk_socket
;
896 struct dn_scp
*scp
= DN_SK(sk
);
900 if (sock
->state
== SS_CONNECTED
)
903 if (sock
->state
== SS_CONNECTING
) {
905 if (scp
->state
== DN_RUN
) {
906 sock
->state
= SS_CONNECTED
;
910 if (scp
->state
!= DN_CI
&& scp
->state
!= DN_CC
) {
911 sock
->state
= SS_UNCONNECTED
;
914 return dn_wait_run(sk
, timeo
);
918 if (scp
->state
!= DN_O
)
921 if (addr
== NULL
|| addrlen
!= sizeof(struct sockaddr_dn
))
923 if (addr
->sdn_family
!= AF_DECnet
)
925 if (addr
->sdn_flags
& SDF_WILD
)
928 if (sock_flag(sk
, SOCK_ZAPPED
)) {
929 err
= dn_auto_bind(sk
->sk_socket
);
934 memcpy(&scp
->peer
, addr
, sizeof(struct sockaddr_dn
));
937 memset(&fl
, 0, sizeof(fl
));
938 fl
.oif
= sk
->sk_bound_dev_if
;
939 fl
.fld_dst
= dn_saddr2dn(&scp
->peer
);
940 fl
.fld_src
= dn_saddr2dn(&scp
->addr
);
941 dn_sk_ports_copy(&fl
, scp
);
942 fl
.proto
= DNPROTO_NSP
;
943 if (dn_route_output_sock(&sk
->sk_dst_cache
, &fl
, sk
, flags
) < 0)
945 sk
->sk_route_caps
= sk
->sk_dst_cache
->dev
->features
;
946 sock
->state
= SS_CONNECTING
;
948 scp
->segsize_loc
= dst_metric(sk
->sk_dst_cache
, RTAX_ADVMSS
);
950 dn_nsp_send_conninit(sk
, NSP_CI
);
953 err
= dn_wait_run(sk
, timeo
);
959 static int dn_connect(struct socket
*sock
, struct sockaddr
*uaddr
, int addrlen
, int flags
)
961 struct sockaddr_dn
*addr
= (struct sockaddr_dn
*)uaddr
;
962 struct sock
*sk
= sock
->sk
;
964 long timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
967 err
= __dn_connect(sk
, addr
, addrlen
, &timeo
, 0);
973 static inline int dn_check_state(struct sock
*sk
, struct sockaddr_dn
*addr
, int addrlen
, long *timeo
, int flags
)
975 struct dn_scp
*scp
= DN_SK(sk
);
981 return dn_confirm_accept(sk
, timeo
, sk
->sk_allocation
);
984 return dn_wait_run(sk
, timeo
);
986 return __dn_connect(sk
, addr
, addrlen
, timeo
, flags
);
993 static void dn_access_copy(struct sk_buff
*skb
, struct accessdata_dn
*acc
)
995 unsigned char *ptr
= skb
->data
;
997 acc
->acc_userl
= *ptr
++;
998 memcpy(&acc
->acc_user
, ptr
, acc
->acc_userl
);
999 ptr
+= acc
->acc_userl
;
1001 acc
->acc_passl
= *ptr
++;
1002 memcpy(&acc
->acc_pass
, ptr
, acc
->acc_passl
);
1003 ptr
+= acc
->acc_passl
;
1005 acc
->acc_accl
= *ptr
++;
1006 memcpy(&acc
->acc_acc
, ptr
, acc
->acc_accl
);
1008 skb_pull(skb
, acc
->acc_accl
+ acc
->acc_passl
+ acc
->acc_userl
+ 3);
1012 static void dn_user_copy(struct sk_buff
*skb
, struct optdata_dn
*opt
)
1014 unsigned char *ptr
= skb
->data
;
1016 opt
->opt_optl
= *ptr
++;
1017 opt
->opt_status
= 0;
1018 memcpy(opt
->opt_data
, ptr
, opt
->opt_optl
);
1019 skb_pull(skb
, opt
->opt_optl
+ 1);
1023 static struct sk_buff
*dn_wait_for_connect(struct sock
*sk
, long *timeo
)
1026 struct sk_buff
*skb
= NULL
;
1029 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
1032 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1034 *timeo
= schedule_timeout(*timeo
);
1035 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1041 if (sk
->sk_state
!= TCP_LISTEN
)
1043 err
= sock_intr_errno(*timeo
);
1044 if (signal_pending(current
))
1049 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
1051 finish_wait(sk
->sk_sleep
, &wait
);
1053 return skb
== NULL
? ERR_PTR(err
) : skb
;
1056 static int dn_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
1058 struct sock
*sk
= sock
->sk
, *newsk
;
1059 struct sk_buff
*skb
= NULL
;
1060 struct dn_skb_cb
*cb
;
1061 unsigned char menuver
;
1064 long timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
1068 if (sk
->sk_state
!= TCP_LISTEN
|| DN_SK(sk
)->state
!= DN_O
) {
1073 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1075 skb
= dn_wait_for_connect(sk
, &timeo
);
1078 return PTR_ERR(skb
);
1082 cb
= DN_SKB_CB(skb
);
1083 sk
->sk_ack_backlog
--;
1084 newsk
= dn_alloc_sock(newsock
, sk
->sk_allocation
);
1085 if (newsk
== NULL
) {
1092 dst_release(xchg(&newsk
->sk_dst_cache
, skb
->dst
));
1095 DN_SK(newsk
)->state
= DN_CR
;
1096 DN_SK(newsk
)->addrrem
= cb
->src_port
;
1097 DN_SK(newsk
)->services_rem
= cb
->services
;
1098 DN_SK(newsk
)->info_rem
= cb
->info
;
1099 DN_SK(newsk
)->segsize_rem
= cb
->segsize
;
1100 DN_SK(newsk
)->accept_mode
= DN_SK(sk
)->accept_mode
;
1102 if (DN_SK(newsk
)->segsize_rem
< 230)
1103 DN_SK(newsk
)->segsize_rem
= 230;
1105 if ((DN_SK(newsk
)->services_rem
& NSP_FC_MASK
) == NSP_FC_NONE
)
1106 DN_SK(newsk
)->max_window
= decnet_no_fc_max_cwnd
;
1108 newsk
->sk_state
= TCP_LISTEN
;
1109 memcpy(&(DN_SK(newsk
)->addr
), &(DN_SK(sk
)->addr
), sizeof(struct sockaddr_dn
));
1112 * If we are listening on a wild socket, we don't want
1113 * the newly created socket on the wrong hash queue.
1115 DN_SK(newsk
)->addr
.sdn_flags
&= ~SDF_WILD
;
1117 skb_pull(skb
, dn_username2sockaddr(skb
->data
, skb
->len
, &(DN_SK(newsk
)->addr
), &type
));
1118 skb_pull(skb
, dn_username2sockaddr(skb
->data
, skb
->len
, &(DN_SK(newsk
)->peer
), &type
));
1119 *(dn_address
*)(DN_SK(newsk
)->peer
.sdn_add
.a_addr
) = cb
->src
;
1120 *(dn_address
*)(DN_SK(newsk
)->addr
.sdn_add
.a_addr
) = cb
->dst
;
1122 menuver
= *skb
->data
;
1125 if (menuver
& DN_MENUVER_ACC
)
1126 dn_access_copy(skb
, &(DN_SK(newsk
)->accessdata
));
1128 if (menuver
& DN_MENUVER_USR
)
1129 dn_user_copy(skb
, &(DN_SK(newsk
)->conndata_in
));
1131 if (menuver
& DN_MENUVER_PRX
)
1132 DN_SK(newsk
)->peer
.sdn_flags
|= SDF_PROXY
;
1134 if (menuver
& DN_MENUVER_UIC
)
1135 DN_SK(newsk
)->peer
.sdn_flags
|= SDF_UICPROXY
;
1139 memcpy(&(DN_SK(newsk
)->conndata_out
), &(DN_SK(sk
)->conndata_out
),
1140 sizeof(struct optdata_dn
));
1141 memcpy(&(DN_SK(newsk
)->discdata_out
), &(DN_SK(sk
)->discdata_out
),
1142 sizeof(struct optdata_dn
));
1145 err
= dn_hash_sock(newsk
);
1147 sock_reset_flag(newsk
, SOCK_ZAPPED
);
1148 dn_send_conn_ack(newsk
);
1151 * Here we use sk->sk_allocation since although the conn conf is
1152 * for the newsk, the context is the old socket.
1154 if (DN_SK(newsk
)->accept_mode
== ACC_IMMED
)
1155 err
= dn_confirm_accept(newsk
, &timeo
,
1158 release_sock(newsk
);
1163 static int dn_getname(struct socket
*sock
, struct sockaddr
*uaddr
,int *uaddr_len
,int peer
)
1165 struct sockaddr_dn
*sa
= (struct sockaddr_dn
*)uaddr
;
1166 struct sock
*sk
= sock
->sk
;
1167 struct dn_scp
*scp
= DN_SK(sk
);
1169 *uaddr_len
= sizeof(struct sockaddr_dn
);
1174 if ((sock
->state
!= SS_CONNECTED
&&
1175 sock
->state
!= SS_CONNECTING
) &&
1176 scp
->accept_mode
== ACC_IMMED
)
1179 memcpy(sa
, &scp
->peer
, sizeof(struct sockaddr_dn
));
1181 memcpy(sa
, &scp
->addr
, sizeof(struct sockaddr_dn
));
1190 static unsigned int dn_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
1192 struct sock
*sk
= sock
->sk
;
1193 struct dn_scp
*scp
= DN_SK(sk
);
1194 int mask
= datagram_poll(file
, sock
, wait
);
1196 if (!skb_queue_empty(&scp
->other_receive_queue
))
1202 static int dn_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1204 struct sock
*sk
= sock
->sk
;
1205 struct dn_scp
*scp
= DN_SK(sk
);
1206 int err
= -EOPNOTSUPP
;
1208 struct sk_buff
*skb
;
1215 return dn_dev_ioctl(cmd
, (void __user
*)arg
);
1219 val
= !skb_queue_empty(&scp
->other_receive_queue
);
1220 if (scp
->state
!= DN_RUN
)
1226 amount
= sk
->sk_sndbuf
- atomic_read(&sk
->sk_wmem_alloc
);
1229 err
= put_user(amount
, (int __user
*)arg
);
1234 if ((skb
= skb_peek(&scp
->other_receive_queue
)) != NULL
) {
1237 struct sk_buff
*skb
= sk
->sk_receive_queue
.next
;
1240 (struct sk_buff
*)&sk
->sk_receive_queue
)
1247 err
= put_user(amount
, (int __user
*)arg
);
1251 err
= dev_ioctl(cmd
, (void __user
*)arg
);
1258 static int dn_listen(struct socket
*sock
, int backlog
)
1260 struct sock
*sk
= sock
->sk
;
1265 if (sock_flag(sk
, SOCK_ZAPPED
))
1268 if ((DN_SK(sk
)->state
!= DN_O
) || (sk
->sk_state
== TCP_LISTEN
))
1271 sk
->sk_max_ack_backlog
= backlog
;
1272 sk
->sk_ack_backlog
= 0;
1273 sk
->sk_state
= TCP_LISTEN
;
1284 static int dn_shutdown(struct socket
*sock
, int how
)
1286 struct sock
*sk
= sock
->sk
;
1287 struct dn_scp
*scp
= DN_SK(sk
);
1288 int err
= -ENOTCONN
;
1292 if (sock
->state
== SS_UNCONNECTED
)
1296 if (sock
->state
== SS_DISCONNECTING
)
1300 if (scp
->state
== DN_O
)
1303 if (how
!= SHUTDOWN_MASK
)
1306 sk
->sk_shutdown
= how
;
1307 dn_destroy_sock(sk
);
1316 static int dn_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int optlen
)
1318 struct sock
*sk
= sock
->sk
;
1322 err
= __dn_setsockopt(sock
, level
, optname
, optval
, optlen
, 0);
1328 static int __dn_setsockopt(struct socket
*sock
, int level
,int optname
, char __user
*optval
, int optlen
, int flags
)
1330 struct sock
*sk
= sock
->sk
;
1331 struct dn_scp
*scp
= DN_SK(sk
);
1334 struct optdata_dn opt
;
1335 struct accessdata_dn acc
;
1339 unsigned char services
;
1344 if (optlen
&& !optval
)
1347 if (optlen
> sizeof(u
))
1350 if (copy_from_user(&u
, optval
, optlen
))
1355 if (sock
->state
== SS_CONNECTED
)
1357 if ((scp
->state
!= DN_O
) && (scp
->state
!= DN_CR
))
1360 if (optlen
!= sizeof(struct optdata_dn
))
1363 if (u
.opt
.opt_optl
> 16)
1366 memcpy(&scp
->conndata_out
, &u
.opt
, optlen
);
1370 if (sock
->state
!= SS_CONNECTED
&& scp
->accept_mode
== ACC_IMMED
)
1373 if (optlen
!= sizeof(struct optdata_dn
))
1376 if (u
.opt
.opt_optl
> 16)
1379 memcpy(&scp
->discdata_out
, &u
.opt
, optlen
);
1383 if (sock
->state
== SS_CONNECTED
)
1385 if (scp
->state
!= DN_O
)
1388 if (optlen
!= sizeof(struct accessdata_dn
))
1391 if ((u
.acc
.acc_accl
> DN_MAXACCL
) ||
1392 (u
.acc
.acc_passl
> DN_MAXACCL
) ||
1393 (u
.acc
.acc_userl
> DN_MAXACCL
))
1396 memcpy(&scp
->accessdata
, &u
.acc
, optlen
);
1399 case DSO_ACCEPTMODE
:
1400 if (sock
->state
== SS_CONNECTED
)
1402 if (scp
->state
!= DN_O
)
1405 if (optlen
!= sizeof(int))
1408 if ((u
.mode
!= ACC_IMMED
) && (u
.mode
!= ACC_DEFER
))
1411 scp
->accept_mode
= (unsigned char)u
.mode
;
1416 if (scp
->state
!= DN_CR
)
1418 timeo
= sock_rcvtimeo(sk
, 0);
1419 err
= dn_confirm_accept(sk
, &timeo
, sk
->sk_allocation
);
1424 if (scp
->state
!= DN_CR
)
1428 sk
->sk_shutdown
= SHUTDOWN_MASK
;
1429 dn_nsp_send_disc(sk
, 0x38, 0, sk
->sk_allocation
);
1433 #ifdef CONFIG_NETFILTER
1434 return nf_setsockopt(sk
, PF_DECnet
, optname
, optval
, optlen
);
1439 return -ENOPROTOOPT
;
1442 if (optlen
!= sizeof(unsigned long))
1444 if (u
.win
> NSP_MAX_WINDOW
)
1445 u
.win
= NSP_MAX_WINDOW
;
1448 scp
->max_window
= u
.win
;
1449 if (scp
->snd_window
> u
.win
)
1450 scp
->snd_window
= u
.win
;
1454 if (optlen
!= sizeof(int))
1456 if (scp
->nonagle
== 2)
1458 scp
->nonagle
= (u
.val
== 0) ? 0 : 1;
1459 /* if (scp->nonagle == 1) { Push pending frames } */
1463 if (optlen
!= sizeof(int))
1465 if (scp
->nonagle
== 1)
1467 scp
->nonagle
= (u
.val
== 0) ? 0 : 2;
1468 /* if (scp->nonagle == 0) { Push pending frames } */
1472 if (optlen
!= sizeof(unsigned char))
1474 if ((u
.services
& ~NSP_FC_MASK
) != 0x01)
1476 if ((u
.services
& NSP_FC_MASK
) == NSP_FC_MASK
)
1478 scp
->services_loc
= u
.services
;
1482 if (optlen
!= sizeof(unsigned char))
1486 scp
->info_loc
= u
.info
;
1493 static int dn_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
1495 struct sock
*sk
= sock
->sk
;
1499 err
= __dn_getsockopt(sock
, level
, optname
, optval
, optlen
, 0);
1505 static int __dn_getsockopt(struct socket
*sock
, int level
,int optname
, char __user
*optval
,int __user
*optlen
, int flags
)
1507 struct sock
*sk
= sock
->sk
;
1508 struct dn_scp
*scp
= DN_SK(sk
);
1509 struct linkinfo_dn link
;
1511 void *r_data
= NULL
;
1514 if(get_user(r_len
, optlen
))
1519 if (r_len
> sizeof(struct optdata_dn
))
1520 r_len
= sizeof(struct optdata_dn
);
1521 r_data
= &scp
->conndata_in
;
1525 if (r_len
> sizeof(struct optdata_dn
))
1526 r_len
= sizeof(struct optdata_dn
);
1527 r_data
= &scp
->discdata_in
;
1531 if (r_len
> sizeof(struct accessdata_dn
))
1532 r_len
= sizeof(struct accessdata_dn
);
1533 r_data
= &scp
->accessdata
;
1536 case DSO_ACCEPTMODE
:
1537 if (r_len
> sizeof(unsigned char))
1538 r_len
= sizeof(unsigned char);
1539 r_data
= &scp
->accept_mode
;
1543 if (r_len
> sizeof(struct linkinfo_dn
))
1544 r_len
= sizeof(struct linkinfo_dn
);
1546 switch(sock
->state
) {
1548 link
.idn_linkstate
= LL_CONNECTING
;
1550 case SS_DISCONNECTING
:
1551 link
.idn_linkstate
= LL_DISCONNECTING
;
1554 link
.idn_linkstate
= LL_RUNNING
;
1557 link
.idn_linkstate
= LL_INACTIVE
;
1560 link
.idn_segsize
= scp
->segsize_rem
;
1565 #ifdef CONFIG_NETFILTER
1569 if(get_user(len
, optlen
))
1572 val
= nf_getsockopt(sk
, PF_DECnet
, optname
,
1575 val
= put_user(len
, optlen
);
1583 return -ENOPROTOOPT
;
1586 if (r_len
> sizeof(unsigned long))
1587 r_len
= sizeof(unsigned long);
1588 r_data
= &scp
->max_window
;
1592 if (r_len
> sizeof(int))
1593 r_len
= sizeof(int);
1594 val
= (scp
->nonagle
== 1);
1599 if (r_len
> sizeof(int))
1600 r_len
= sizeof(int);
1601 val
= (scp
->nonagle
== 2);
1606 if (r_len
> sizeof(unsigned char))
1607 r_len
= sizeof(unsigned char);
1608 r_data
= &scp
->services_rem
;
1612 if (r_len
> sizeof(unsigned char))
1613 r_len
= sizeof(unsigned char);
1614 r_data
= &scp
->info_rem
;
1619 if (copy_to_user(optval
, r_data
, r_len
))
1621 if (put_user(r_len
, optlen
))
1629 static int dn_data_ready(struct sock
*sk
, struct sk_buff_head
*q
, int flags
, int target
)
1631 struct sk_buff
*skb
= q
->next
;
1634 if (flags
& MSG_OOB
)
1635 return !skb_queue_empty(q
) ? 1 : 0;
1637 while(skb
!= (struct sk_buff
*)q
) {
1638 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
1641 if (cb
->nsp_flags
& 0x40) {
1642 /* SOCK_SEQPACKET reads to EOM */
1643 if (sk
->sk_type
== SOCK_SEQPACKET
)
1645 /* so does SOCK_STREAM unless WAITALL is specified */
1646 if (!(flags
& MSG_WAITALL
))
1650 /* minimum data length for read exceeded */
1661 static int dn_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1662 struct msghdr
*msg
, size_t size
, int flags
)
1664 struct sock
*sk
= sock
->sk
;
1665 struct dn_scp
*scp
= DN_SK(sk
);
1666 struct sk_buff_head
*queue
= &sk
->sk_receive_queue
;
1667 size_t target
= size
> 1 ? 1 : 0;
1670 struct sk_buff
*skb
, *nskb
;
1671 struct dn_skb_cb
*cb
= NULL
;
1672 unsigned char eor
= 0;
1673 long timeo
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
1677 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1678 rv
= -EADDRNOTAVAIL
;
1682 rv
= dn_check_state(sk
, NULL
, 0, &timeo
, flags
);
1686 if (sk
->sk_shutdown
& RCV_SHUTDOWN
) {
1687 if (!(flags
& MSG_NOSIGNAL
))
1688 send_sig(SIGPIPE
, current
, 0);
1693 if (flags
& ~(MSG_PEEK
|MSG_OOB
|MSG_WAITALL
|MSG_DONTWAIT
|MSG_NOSIGNAL
)) {
1698 if (flags
& MSG_OOB
)
1699 queue
= &scp
->other_receive_queue
;
1701 if (flags
& MSG_WAITALL
)
1706 * See if there is data ready to read, sleep if there isn't
1712 if (!skb_queue_empty(&scp
->other_receive_queue
)) {
1713 if (!(flags
& MSG_OOB
)) {
1714 msg
->msg_flags
|= MSG_OOB
;
1715 if (!scp
->other_report
) {
1716 scp
->other_report
= 1;
1722 if (scp
->state
!= DN_RUN
)
1725 if (signal_pending(current
)) {
1726 rv
= sock_intr_errno(timeo
);
1730 if (dn_data_ready(sk
, queue
, flags
, target
))
1733 if (flags
& MSG_DONTWAIT
) {
1738 set_bit(SOCK_ASYNC_WAITDATA
, &sock
->flags
);
1741 if (!dn_data_ready(sk
, queue
, flags
, target
))
1745 clear_bit(SOCK_ASYNC_WAITDATA
, &sock
->flags
);
1748 for(skb
= queue
->next
; skb
!= (struct sk_buff
*)queue
; skb
= nskb
) {
1749 unsigned int chunk
= skb
->len
;
1750 cb
= DN_SKB_CB(skb
);
1752 if ((chunk
+ copied
) > size
)
1753 chunk
= size
- copied
;
1755 if (memcpy_toiovec(msg
->msg_iov
, skb
->data
, chunk
)) {
1761 if (!(flags
& MSG_PEEK
))
1762 skb_pull(skb
, chunk
);
1764 eor
= cb
->nsp_flags
& 0x40;
1767 if (skb
->len
== 0) {
1768 skb_unlink(skb
, queue
);
1771 * N.B. Don't refer to skb or cb after this point
1774 if ((scp
->flowloc_sw
== DN_DONTSEND
) && !dn_congested(sk
)) {
1775 scp
->flowloc_sw
= DN_SEND
;
1776 dn_nsp_send_link(sk
, DN_SEND
, 0);
1781 if (sk
->sk_type
== SOCK_SEQPACKET
)
1783 if (!(flags
& MSG_WAITALL
))
1787 if (flags
& MSG_OOB
)
1790 if (copied
>= target
)
1797 if (eor
&& (sk
->sk_type
== SOCK_SEQPACKET
))
1798 msg
->msg_flags
|= MSG_EOR
;
1802 rv
= (flags
& MSG_PEEK
) ? -sk
->sk_err
: sock_error(sk
);
1804 if ((rv
>= 0) && msg
->msg_name
) {
1805 memcpy(msg
->msg_name
, &scp
->peer
, sizeof(struct sockaddr_dn
));
1806 msg
->msg_namelen
= sizeof(struct sockaddr_dn
);
1815 static inline int dn_queue_too_long(struct dn_scp
*scp
, struct sk_buff_head
*queue
, int flags
)
1817 unsigned char fctype
= scp
->services_rem
& NSP_FC_MASK
;
1818 if (skb_queue_len(queue
) >= scp
->snd_window
)
1820 if (fctype
!= NSP_FC_NONE
) {
1821 if (flags
& MSG_OOB
) {
1822 if (scp
->flowrem_oth
== 0)
1825 if (scp
->flowrem_dat
== 0)
1833 * The DECnet spec requires the the "routing layer" accepts packets which
1834 * are at least 230 bytes in size. This excludes any headers which the NSP
1835 * layer might add, so we always assume that we'll be using the maximal
1836 * length header on data packets. The variation in length is due to the
1837 * inclusion (or not) of the two 16 bit acknowledgement fields so it doesn't
1838 * make much practical difference.
1840 unsigned dn_mss_from_pmtu(struct net_device
*dev
, int mtu
)
1842 unsigned mss
= 230 - DN_MAX_NSP_DATA_HEADER
;
1844 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1845 mtu
-= LL_RESERVED_SPACE(dev
);
1846 if (dn_db
->use_long
)
1850 mtu
-= DN_MAX_NSP_DATA_HEADER
;
1853 * 21 = long header, 16 = guess at MAC header length
1855 mtu
-= (21 + DN_MAX_NSP_DATA_HEADER
+ 16);
1862 static inline unsigned int dn_current_mss(struct sock
*sk
, int flags
)
1864 struct dst_entry
*dst
= __sk_dst_get(sk
);
1865 struct dn_scp
*scp
= DN_SK(sk
);
1866 int mss_now
= min_t(int, scp
->segsize_loc
, scp
->segsize_rem
);
1868 /* Other data messages are limited to 16 bytes per packet */
1869 if (flags
& MSG_OOB
)
1872 /* This works out the maximum size of segment we can send out */
1874 u32 mtu
= dst_mtu(dst
);
1875 mss_now
= min_t(int, dn_mss_from_pmtu(dst
->dev
, mtu
), mss_now
);
1882 * N.B. We get the timeout wrong here, but then we always did get it
1883 * wrong before and this is another step along the road to correcting
1884 * it. It ought to get updated each time we pass through the routine,
1885 * but in practise it probably doesn't matter too much for now.
1887 static inline struct sk_buff
*dn_alloc_send_pskb(struct sock
*sk
,
1888 unsigned long datalen
, int noblock
,
1891 struct sk_buff
*skb
= sock_alloc_send_skb(sk
, datalen
,
1894 skb
->protocol
= __constant_htons(ETH_P_DNA_RT
);
1895 skb
->pkt_type
= PACKET_OUTGOING
;
1900 static int dn_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1901 struct msghdr
*msg
, size_t size
)
1903 struct sock
*sk
= sock
->sk
;
1904 struct dn_scp
*scp
= DN_SK(sk
);
1906 struct sk_buff_head
*queue
= &scp
->data_xmit_queue
;
1907 int flags
= msg
->msg_flags
;
1910 int addr_len
= msg
->msg_namelen
;
1911 struct sockaddr_dn
*addr
= (struct sockaddr_dn
*)msg
->msg_name
;
1912 struct sk_buff
*skb
= NULL
;
1913 struct dn_skb_cb
*cb
;
1915 unsigned char fctype
;
1918 if (flags
& ~(MSG_TRYHARD
|MSG_OOB
|MSG_DONTWAIT
|MSG_EOR
|MSG_NOSIGNAL
|MSG_MORE
|MSG_CMSG_COMPAT
))
1921 if (addr_len
&& (addr_len
!= sizeof(struct sockaddr_dn
)))
1925 timeo
= sock_sndtimeo(sk
, flags
& MSG_DONTWAIT
);
1927 * The only difference between stream sockets and sequenced packet
1928 * sockets is that the stream sockets always behave as if MSG_EOR
1931 if (sock
->type
== SOCK_STREAM
) {
1932 if (flags
& MSG_EOR
) {
1940 err
= dn_check_state(sk
, addr
, addr_len
, &timeo
, flags
);
1944 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1949 if ((flags
& MSG_TRYHARD
) && sk
->sk_dst_cache
)
1950 dst_negative_advice(&sk
->sk_dst_cache
);
1952 mss
= scp
->segsize_rem
;
1953 fctype
= scp
->services_rem
& NSP_FC_MASK
;
1955 mss
= dn_current_mss(sk
, flags
);
1957 if (flags
& MSG_OOB
) {
1958 queue
= &scp
->other_xmit_queue
;
1965 scp
->persist_fxn
= dn_nsp_xmit_timeout
;
1967 while(sent
< size
) {
1968 err
= sock_error(sk
);
1972 if (signal_pending(current
)) {
1973 err
= sock_intr_errno(timeo
);
1978 * Calculate size that we wish to send.
1986 * Wait for queue size to go down below the window
1989 if (dn_queue_too_long(scp
, queue
, flags
)) {
1990 if (flags
& MSG_DONTWAIT
) {
1997 if (dn_queue_too_long(scp
, queue
, flags
))
2006 * Get a suitably sized skb.
2007 * 64 is a bit of a hack really, but its larger than any
2008 * link-layer headers and has served us well as a good
2009 * guess as to their real length.
2011 skb
= dn_alloc_send_pskb(sk
, len
+ 64 + DN_MAX_NSP_DATA_HEADER
,
2012 flags
& MSG_DONTWAIT
, &err
);
2020 cb
= DN_SKB_CB(skb
);
2022 skb_reserve(skb
, 64 + DN_MAX_NSP_DATA_HEADER
);
2024 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
2029 if (flags
& MSG_OOB
) {
2030 cb
->nsp_flags
= 0x30;
2031 if (fctype
!= NSP_FC_NONE
)
2034 cb
->nsp_flags
= 0x00;
2035 if (scp
->seg_total
== 0)
2036 cb
->nsp_flags
|= 0x20;
2038 scp
->seg_total
+= len
;
2040 if (((sent
+ len
) == size
) && (flags
& MSG_EOR
)) {
2041 cb
->nsp_flags
|= 0x40;
2043 if (fctype
== NSP_FC_SCMC
)
2046 if (fctype
== NSP_FC_SRC
)
2051 dn_nsp_queue_xmit(sk
, skb
, sk
->sk_allocation
, flags
& MSG_OOB
);
2054 scp
->persist
= dn_nsp_persist(sk
);
2064 return sent
? sent
: err
;
2067 err
= sk_stream_error(sk
, flags
, err
);
2072 static int dn_device_event(struct notifier_block
*this, unsigned long event
,
2075 struct net_device
*dev
= (struct net_device
*)ptr
;
2091 static struct notifier_block dn_dev_notifier
= {
2092 .notifier_call
= dn_device_event
,
2095 extern int dn_route_rcv(struct sk_buff
*, struct net_device
*, struct packet_type
*, struct net_device
*);
2097 static struct packet_type dn_dix_packet_type
= {
2098 .type
= __constant_htons(ETH_P_DNA_RT
),
2099 .dev
= NULL
, /* All devices */
2100 .func
= dn_route_rcv
,
2103 #ifdef CONFIG_PROC_FS
2104 struct dn_iter_state
{
2108 static struct sock
*dn_socket_get_first(struct seq_file
*seq
)
2110 struct dn_iter_state
*state
= seq
->private;
2111 struct sock
*n
= NULL
;
2113 for(state
->bucket
= 0;
2114 state
->bucket
< DN_SK_HASH_SIZE
;
2116 n
= sk_head(&dn_sk_hash
[state
->bucket
]);
2124 static struct sock
*dn_socket_get_next(struct seq_file
*seq
,
2127 struct dn_iter_state
*state
= seq
->private;
2133 if (++state
->bucket
>= DN_SK_HASH_SIZE
)
2135 n
= sk_head(&dn_sk_hash
[state
->bucket
]);
2141 static struct sock
*socket_get_idx(struct seq_file
*seq
, loff_t
*pos
)
2143 struct sock
*sk
= dn_socket_get_first(seq
);
2146 while(*pos
&& (sk
= dn_socket_get_next(seq
, sk
)))
2149 return *pos
? NULL
: sk
;
2152 static void *dn_socket_get_idx(struct seq_file
*seq
, loff_t pos
)
2155 read_lock_bh(&dn_hash_lock
);
2156 rc
= socket_get_idx(seq
, &pos
);
2158 read_unlock_bh(&dn_hash_lock
);
2163 static void *dn_socket_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2165 return *pos
? dn_socket_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2168 static void *dn_socket_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2172 if (v
== SEQ_START_TOKEN
) {
2173 rc
= dn_socket_get_idx(seq
, 0);
2177 rc
= dn_socket_get_next(seq
, v
);
2180 read_unlock_bh(&dn_hash_lock
);
2186 static void dn_socket_seq_stop(struct seq_file
*seq
, void *v
)
2188 if (v
&& v
!= SEQ_START_TOKEN
)
2189 read_unlock_bh(&dn_hash_lock
);
2192 #define IS_NOT_PRINTABLE(x) ((x) < 32 || (x) > 126)
2194 static void dn_printable_object(struct sockaddr_dn
*dn
, unsigned char *buf
)
2198 switch (dn_ntohs(dn
->sdn_objnamel
)) {
2200 sprintf(buf
, "%d", dn
->sdn_objnum
);
2203 for (i
= 0; i
< dn_ntohs(dn
->sdn_objnamel
); i
++) {
2204 buf
[i
] = dn
->sdn_objname
[i
];
2205 if (IS_NOT_PRINTABLE(buf
[i
]))
2212 static char *dn_state2asc(unsigned char state
)
2252 static inline void dn_socket_format_entry(struct seq_file
*seq
, struct sock
*sk
)
2254 struct dn_scp
*scp
= DN_SK(sk
);
2255 char buf1
[DN_ASCBUF_LEN
];
2256 char buf2
[DN_ASCBUF_LEN
];
2257 char local_object
[DN_MAXOBJL
+3];
2258 char remote_object
[DN_MAXOBJL
+3];
2260 dn_printable_object(&scp
->addr
, local_object
);
2261 dn_printable_object(&scp
->peer
, remote_object
);
2264 "%6s/%04X %04d:%04d %04d:%04d %01d %-16s "
2265 "%6s/%04X %04d:%04d %04d:%04d %01d %-16s %4s %s\n",
2266 dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp
->addr
)), buf1
),
2274 dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp
->peer
)), buf2
),
2282 dn_state2asc(scp
->state
),
2283 ((scp
->accept_mode
== ACC_IMMED
) ? "IMMED" : "DEFER"));
2286 static int dn_socket_seq_show(struct seq_file
*seq
, void *v
)
2288 if (v
== SEQ_START_TOKEN
) {
2289 seq_puts(seq
, "Local Remote\n");
2291 dn_socket_format_entry(seq
, v
);
2296 static struct seq_operations dn_socket_seq_ops
= {
2297 .start
= dn_socket_seq_start
,
2298 .next
= dn_socket_seq_next
,
2299 .stop
= dn_socket_seq_stop
,
2300 .show
= dn_socket_seq_show
,
2303 static int dn_socket_seq_open(struct inode
*inode
, struct file
*file
)
2305 struct seq_file
*seq
;
2307 struct dn_iter_state
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
2312 rc
= seq_open(file
, &dn_socket_seq_ops
);
2316 seq
= file
->private_data
;
2318 memset(s
, 0, sizeof(*s
));
2326 static struct file_operations dn_socket_seq_fops
= {
2327 .owner
= THIS_MODULE
,
2328 .open
= dn_socket_seq_open
,
2330 .llseek
= seq_lseek
,
2331 .release
= seq_release_private
,
2335 static struct net_proto_family dn_family_ops
= {
2336 .family
= AF_DECnet
,
2337 .create
= dn_create
,
2338 .owner
= THIS_MODULE
,
2341 static struct proto_ops dn_proto_ops
= {
2342 .family
= AF_DECnet
,
2343 .owner
= THIS_MODULE
,
2344 .release
= dn_release
,
2346 .connect
= dn_connect
,
2347 .socketpair
= sock_no_socketpair
,
2348 .accept
= dn_accept
,
2349 .getname
= dn_getname
,
2352 .listen
= dn_listen
,
2353 .shutdown
= dn_shutdown
,
2354 .setsockopt
= dn_setsockopt
,
2355 .getsockopt
= dn_getsockopt
,
2356 .sendmsg
= dn_sendmsg
,
2357 .recvmsg
= dn_recvmsg
,
2358 .mmap
= sock_no_mmap
,
2359 .sendpage
= sock_no_sendpage
,
2362 void dn_register_sysctl(void);
2363 void dn_unregister_sysctl(void);
2365 MODULE_DESCRIPTION("The Linux DECnet Network Protocol");
2366 MODULE_AUTHOR("Linux DECnet Project Team");
2367 MODULE_LICENSE("GPL");
2368 MODULE_ALIAS_NETPROTO(PF_DECnet
);
2370 static char banner
[] __initdata
= KERN_INFO
"NET4: DECnet for Linux: V.2.5.68s (C) 1995-2003 Linux DECnet Project Team\n";
2372 static int __init
decnet_init(void)
2378 rc
= proto_register(&dn_proto
, 1);
2387 sock_register(&dn_family_ops
);
2388 dev_add_pack(&dn_dix_packet_type
);
2389 register_netdevice_notifier(&dn_dev_notifier
);
2391 proc_net_fops_create("decnet", S_IRUGO
, &dn_socket_seq_fops
);
2392 dn_register_sysctl();
2397 module_init(decnet_init
);
2400 * Prevent DECnet module unloading until its fixed properly.
2401 * Requires an audit of the code to check for memory leaks and
2402 * initialisation problems etc.
2405 static void __exit
decnet_exit(void)
2407 sock_unregister(AF_DECnet
);
2408 dev_remove_pack(&dn_dix_packet_type
);
2410 dn_unregister_sysctl();
2412 unregister_netdevice_notifier(&dn_dev_notifier
);
2419 proc_net_remove("decnet");
2421 proto_unregister(&dn_proto
);
2423 module_exit(decnet_exit
);