1
2 /*
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.
6 *
7 * DECnet Socket Layer Interface
8 *
9 * Authors: Eduardo Marcelo Serrat <emserrat@geocities.com>
10 * Patrick Caulfield <patrick@pandh.demon.co.uk>
11 *
12 * Changes:
13 * Steve Whitehouse: Copied from Eduardo Serrat and Patrick Caulfield's
14 * version of the code. Original copyright preserved
15 * below.
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
19 * Caulfield.
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
24 * code.
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
37 * when required.
38 */
39
40
41 /******************************************************************************
42 (c) 1995-1998 E.M. Serrat emserrat@geocities.com
43
44 This program is free software; you can redistribute it and/or modify
45 it under the terms of the GNU General Public License as published by
46 the Free Software Foundation; either version 2 of the License, or
47 any later version.
48
49 This program is distributed in the hope that it will be useful,
50 but WITHOUT ANY WARRANTY; without even the implied warranty of
51 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
52 GNU General Public License for more details.
53
54 HISTORY:
55
56 Version Kernel Date Author/Comments
57 ------- ------ ---- ---------------
58 Version 0.0.1 2.0.30 01-dic-97 Eduardo Marcelo Serrat
59 (emserrat@geocities.com)
60
61 First Development of DECnet Socket La-
62 yer for Linux. Only supports outgoing
63 connections.
64
65 Version 0.0.2 2.1.105 20-jun-98 Patrick J. Caulfield
66 (patrick@pandh.demon.co.uk)
67
68 Port to new kernel development version.
69
70 Version 0.0.3 2.1.106 25-jun-98 Eduardo Marcelo Serrat
71 (emserrat@geocities.com)
72 _
73 Added support for incoming connections
74 so we can start developing server apps
75 on Linux.
76 -
77 Module Support
78 Version 0.0.4 2.1.109 21-jul-98 Eduardo Marcelo Serrat
79 (emserrat@geocities.com)
80 _
81 Added support for X11R6.4. Now we can
82 use DECnet transport for X on Linux!!!
83 -
84 Version 0.0.5 2.1.110 01-aug-98 Eduardo Marcelo Serrat
85 (emserrat@geocities.com)
86 Removed bugs on flow control
87 Removed bugs on incoming accessdata
88 order
89 -
90 Version 0.0.6 2.1.110 07-aug-98 Eduardo Marcelo Serrat
91 dn_recvmsg fixes
92
93 Patrick J. Caulfield
94 dn_bind fixes
95 *******************************************************************************/
96
97 #include <linux/config.h>
98 #include <linux/module.h>
99 #include <linux/errno.h>
100 #include <linux/types.h>
101 #include <linux/socket.h>
102 #include <linux/in.h>
103 #include <linux/kernel.h>
104 #include <linux/sched.h>
105 #include <linux/timer.h>
106 #include <linux/string.h>
107 #include <linux/sockios.h>
108 #include <linux/net.h>
109 #include <linux/netdevice.h>
110 #include <linux/inet.h>
111 #include <linux/route.h>
112 #include <linux/netfilter.h>
113 #include <net/sock.h>
114 #include <asm/segment.h>
115 #include <asm/system.h>
116 #include <linux/mm.h>
117 #include <linux/interrupt.h>
118 #include <linux/proc_fs.h>
119 #include <linux/stat.h>
120 #include <linux/init.h>
121 #include <linux/poll.h>
122 #include <net/neighbour.h>
123 #include <net/dst.h>
124 #include <net/dn.h>
125 #include <net/dn_nsp.h>
126 #include <net/dn_dev.h>
127 #include <net/dn_route.h>
128 #include <net/dn_fib.h>
129 #include <net/dn_neigh.h>
130
131 #define MAX(a,b) ((a)>(b)?(a):(b))
132
133 static void dn_keepalive(struct sock *sk);
134
135 /*
136 * decnet_address is kept in network order, decnet_ether_address is kept
137 * as a string of bytes.
138 */
139 dn_address decnet_address = 0;
140 unsigned char decnet_ether_address[ETH_ALEN] = { 0xAA, 0x00, 0x04, 0x00, 0x00, 0x00 };
141
142 static struct proto_ops dn_proto_ops;
143 rwlock_t dn_hash_lock = RW_LOCK_UNLOCKED;
144 static struct sock *dn_sklist = NULL;
145 static struct sock *dn_wild_sk = NULL;
146
147 static int __dn_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen, int flags);
148 static int __dn_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen, int flags);
149
150 static struct sock **dn_find_list(struct sock *sk)
151 {
152 struct dn_scp *scp = &sk->protinfo.dn;
153
154 if (scp->addr.sdn_flags & SDF_WILD)
155 return dn_wild_sk ? NULL : &dn_wild_sk;
156
157 return &dn_sklist;
158 }
159
160 static unsigned short port_alloc(struct sock *sk)
161 {
162 struct dn_scp *scp = &sk->protinfo.dn;
163 static unsigned short port = 0x2000;
164
165 if (port == 0)
166 port++;
167
168 scp->addrloc = port++;
169
170 return 1;
171 }
172
173 /*
174 * Since this is only ever called from user
175 * level, we don't need a write_lock() version
176 * of this.
177 */
178 static int dn_hash_sock(struct sock *sk)
179 {
180 struct dn_scp *scp = &sk->protinfo.dn;
181 struct sock **skp;
182 int rv = -EUSERS;
183
184 write_lock_bh(&dn_hash_lock);
185
186 if (!scp->addrloc && !port_alloc(sk))
187 goto out;
188
189 rv = -EADDRINUSE;
190 if ((skp = dn_find_list(sk)) == NULL)
191 goto out;
192
193 sk->next = *skp;
194 sk->pprev = skp;
195 *skp = sk;
196 rv = 0;
197 out:
198 write_unlock_bh(&dn_hash_lock);
199 return rv;
200 }
201
202 static void dn_unhash_sock(struct sock *sk)
203 {
204 struct sock **skp = sk->pprev;
205
206 if (skp == NULL)
207 return;
208
209 write_lock(&dn_hash_lock);
210 while(*skp != sk)
211 skp = &((*skp)->next);
212 *skp = sk->next;
213 write_unlock(&dn_hash_lock);
214
215 sk->next = NULL;
216 sk->pprev = NULL;
217 }
218
219 static void dn_unhash_sock_bh(struct sock *sk)
220 {
221 struct sock **skp = sk->pprev;
222
223 if (skp == NULL)
224 return;
225
226 write_lock_bh(&dn_hash_lock);
227 while(*skp != sk)
228 skp = &((*skp)->next);
229 *skp = sk->next;
230 write_unlock_bh(&dn_hash_lock);
231
232 sk->next = NULL;
233 sk->pprev = NULL;
234 }
235
236
237 int dn_sockaddr2username(struct sockaddr_dn *sdn, unsigned char *buf, unsigned char type)
238 {
239 int len = 2;
240
241 *buf++ = type;
242
243 switch(type) {
244 case 0:
245 *buf++ = sdn->sdn_objnum;
246 break;
247 case 1:
248 *buf++ = 0;
249 *buf++ = dn_ntohs(sdn->sdn_objnamel);
250 memcpy(buf, sdn->sdn_objname, dn_ntohs(sdn->sdn_objnamel));
251 len = 3 + dn_ntohs(sdn->sdn_objnamel);
252 break;
253 case 2:
254 memset(buf, 0, 5);
255 buf += 5;
256 *buf++ = dn_ntohs(sdn->sdn_objnamel);
257 memcpy(buf, sdn->sdn_objname, dn_ntohs(sdn->sdn_objnamel));
258 len = 7 + dn_ntohs(sdn->sdn_objnamel);
259 break;
260 }
261
262 return len;
263 }
264
265 /*
266 * On reception of usernames, we handle types 1 and 0 for destination
267 * addresses only. Types 2 and 4 are used for source addresses, but the
268 * UIC, GIC are ignored and they are both treated the same way. Type 3
269 * is never used as I've no idea what its purpose might be or what its
270 * format is.
271 */
272 int dn_username2sockaddr(unsigned char *data, int len, struct sockaddr_dn *sdn, unsigned char *fmt)
273 {
274 unsigned char type;
275 int size = len;
276 int namel = 12;
277
278 sdn->sdn_objnum = 0;
279 sdn->sdn_objnamel = dn_htons(0);
280 memset(sdn->sdn_objname, 0, DN_MAXOBJL);
281
282 if (len < 2)
283 return -1;
284
285 len -= 2;
286 *fmt = *data++;
287 type = *data++;
288
289 switch(*fmt) {
290 case 0:
291 sdn->sdn_objnum = type;
292 return 2;
293 case 1:
294 namel = 16;
295 break;
296 case 2:
297 len -= 4;
298 data += 4;
299 break;
300 case 4:
301 len -= 8;
302 data += 8;
303 break;
304 default:
305 return -1;
306 }
307
308 len -= 1;
309
310 if (len < 0)
311 return -1;
312
313 sdn->sdn_objnamel = dn_htons(*data++);
314 len -= dn_ntohs(sdn->sdn_objnamel);
315
316 if ((len < 0) || (dn_ntohs(sdn->sdn_objnamel) > namel))
317 return -1;
318
319 memcpy(sdn->sdn_objname, data, dn_ntohs(sdn->sdn_objnamel));
320
321 return size - len;
322 }
323
324 struct sock *dn_sklist_find_listener(struct sockaddr_dn *addr)
325 {
326 struct sock *sk;
327
328 read_lock(&dn_hash_lock);
329 for(sk = dn_sklist; sk != NULL; sk = sk->next) {
330 struct dn_scp *scp = &sk->protinfo.dn;
331 if (sk->state != TCP_LISTEN)
332 continue;
333 if (scp->addr.sdn_objnum) {
334 if (scp->addr.sdn_objnum != addr->sdn_objnum)
335 continue;
336 } else {
337 if (addr->sdn_objnum)
338 continue;
339 if (scp->addr.sdn_objnamel != addr->sdn_objnamel)
340 continue;
341 if (memcmp(scp->addr.sdn_objname, addr->sdn_objname, dn_ntohs(addr->sdn_objnamel)) != 0)
342 continue;
343 }
344 sock_hold(sk);
345 read_unlock(&dn_hash_lock);
346 return sk;
347 }
348
349 if (dn_wild_sk && (dn_wild_sk->state == TCP_LISTEN))
350 sock_hold((sk = dn_wild_sk));
351
352 read_unlock(&dn_hash_lock);
353 return sk;
354 }
355
356 struct sock *dn_find_by_skb(struct sk_buff *skb)
357 {
358 struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
359 struct sock *sk;
360 struct dn_scp *scp;
361
362 read_lock(&dn_hash_lock);
363 for(sk = dn_sklist; sk != NULL; sk = sk->next) {
364 scp = &sk->protinfo.dn;
365 if (cb->src != dn_saddr2dn(&scp->peer))
366 continue;
367 if (cb->dst_port != scp->addrloc)
368 continue;
369 if (scp->addrrem && (cb->src_port != scp->addrrem))
370 continue;
371 break;
372 }
373
374 if (sk)
375 sock_hold(sk);
376
377 read_unlock(&dn_hash_lock);
378
379 return sk;
380 }
381
382
383
384 static void dn_destruct(struct sock *sk)
385 {
386 struct dn_scp *scp = &sk->protinfo.dn;
387
388 skb_queue_purge(&scp->data_xmit_queue);
389 skb_queue_purge(&scp->other_xmit_queue);
390 skb_queue_purge(&scp->other_receive_queue);
391
392 dst_release(xchg(&sk->dst_cache, NULL));
393
394 MOD_DEC_USE_COUNT;
395 }
396
397 struct sock *dn_alloc_sock(struct socket *sock, int flags)
398 {
399 struct sock *sk;
400 struct dn_scp *scp;
401
402 if ((sk = sk_alloc(PF_DECnet, flags, 1)) == NULL)
403 goto no_sock;
404
405 if (sock) {
406 sock->ops = &dn_proto_ops;
407 }
408 sock_init_data(sock,sk);
409 scp = &sk->protinfo.dn;
410
411 sk->backlog_rcv = dn_nsp_backlog_rcv;
412 sk->destruct = dn_destruct;
413 sk->no_check = 1;
414 sk->family = PF_DECnet;
415 sk->protocol = 0;
416
417 /* Initialization of DECnet Session Control Port */
418 scp->state = DN_O; /* Open */
419 scp->numdat = 1; /* Next data seg to tx */
420 scp->numoth = 1; /* Next oth data to tx */
421 scp->ackxmt_dat = 0; /* Last data seg ack'ed */
422 scp->ackxmt_oth = 0; /* Last oth data ack'ed */
423 scp->ackrcv_dat = 0; /* Highest data ack recv*/
424 scp->ackrcv_oth = 0; /* Last oth data ack rec*/
425 scp->flowrem_sw = DN_SEND;
426 scp->flowloc_sw = DN_SEND;
427 scp->accept_mode = ACC_IMMED;
428 scp->addr.sdn_family = AF_DECnet;
429 scp->peer.sdn_family = AF_DECnet;
430 scp->accessdata.acc_accl = 5;
431 memcpy(scp->accessdata.acc_acc, "LINUX", 5);
432 scp->mss = 1460;
433
434 scp->snd_window = NSP_MIN_WINDOW;
435 scp->nsp_srtt = NSP_INITIAL_SRTT;
436 scp->nsp_rttvar = NSP_INITIAL_RTTVAR;
437 scp->nsp_rxtshift = 0;
438
439 skb_queue_head_init(&scp->data_xmit_queue);
440 skb_queue_head_init(&scp->other_xmit_queue);
441 skb_queue_head_init(&scp->other_receive_queue);
442
443 scp->persist = 0;
444 scp->persist_fxn = NULL;
445 scp->keepalive = 10 * HZ;
446 scp->keepalive_fxn = dn_keepalive;
447
448 init_timer(&scp->delack_timer);
449 scp->delack_pending = 0;
450 scp->delack_fxn = dn_nsp_delayed_ack;
451
452 dn_start_slow_timer(sk);
453
454 MOD_INC_USE_COUNT;
455
456 return sk;
457 no_sock:
458 return NULL;
459 }
460
461 /*
462 * Keepalive timer.
463 * FIXME: Should respond to SO_KEEPALIVE etc.
464 */
465 static void dn_keepalive(struct sock *sk)
466 {
467 struct dn_scp *scp = &sk->protinfo.dn;
468
469 /*
470 * By checking the other_data transmit queue is empty
471 * we are double checking that we are not sending too
472 * many of these keepalive frames.
473 */
474 if (skb_queue_len(&scp->other_xmit_queue) == 0)
475 dn_nsp_send_lnk(sk, DN_NOCHANGE);
476 }
477
478
479 /*
480 * Timer for shutdown/destroyed sockets.
481 * When socket is dead & no packets have been sent for a
482 * certain amount of time, they are removed by this
483 * routine. Also takes care of sending out DI & DC
484 * frames at correct times.
485 */
486 int dn_destroy_timer(struct sock *sk)
487 {
488 struct dn_scp *scp = &sk->protinfo.dn;
489
490 scp->persist = dn_nsp_persist(sk);
491
492 switch(scp->state) {
493 case DN_DI:
494 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
495 if (scp->nsp_rxtshift >= decnet_di_count)
496 scp->state = DN_CN;
497 return 0;
498
499 case DN_DR:
500 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
501 if (scp->nsp_rxtshift >= decnet_dr_count)
502 scp->state = DN_DRC;
503 return 0;
504
505 case DN_DN:
506 if (scp->nsp_rxtshift < decnet_dn_count) {
507 /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
508 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC);
509 return 0;
510 }
511 }
512
513 scp->persist = (HZ * decnet_time_wait);
514
515 if (sk->socket)
516 return 0;
517
518 dn_stop_fast_timer(sk); /* unlikely, but possible that this is runninng */
519 if ((jiffies - scp->stamp) >= (HZ * decnet_time_wait)) {
520 dn_unhash_sock(sk);
521 sock_put(sk);
522 return 1;
523 }
524
525 return 0;
526 }
527
528 static void dn_destroy_sock(struct sock *sk)
529 {
530 struct dn_scp *scp = &sk->protinfo.dn;
531
532 scp->nsp_rxtshift = 0; /* reset back off */
533
534 if (sk->socket) {
535 if (sk->socket->state != SS_UNCONNECTED)
536 sk->socket->state = SS_DISCONNECTING;
537 }
538
539 sk->state = TCP_CLOSE;
540
541 switch(scp->state) {
542 case DN_DN:
543 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, sk->allocation);
544 scp->persist_fxn = dn_destroy_timer;
545 scp->persist = dn_nsp_persist(sk);
546 break;
547 case DN_CR:
548 scp->state = DN_DR;
549 goto disc_reject;
550 case DN_RUN:
551 scp->state = DN_DI;
552 case DN_DI:
553 case DN_DR:
554 disc_reject:
555 dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->allocation);
556 case DN_NC:
557 case DN_NR:
558 case DN_RJ:
559 case DN_DIC:
560 case DN_CN:
561 case DN_DRC:
562 case DN_CI:
563 case DN_CD:
564 scp->persist_fxn = dn_destroy_timer;
565 scp->persist = dn_nsp_persist(sk);
566 break;
567 default:
568 printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n");
569 case DN_O:
570 dn_stop_fast_timer(sk);
571 dn_stop_slow_timer(sk);
572
573 dn_unhash_sock_bh(sk);
574 sock_put(sk);
575
576 break;
577 }
578 }
579
580 char *dn_addr2asc(dn_address addr, char *buf)
581 {
582 unsigned short node, area;
583
584 node = addr & 0x03ff;
585 area = addr >> 10;
586 sprintf(buf, "%hd.%hd", area, node);
587
588 return buf;
589 }
590
591
592 static char *dn_state2asc(unsigned char state)
593 {
594 switch(state) {
595 case DN_O:
596 return "OPEN";
597 case DN_CR:
598 return " CR";
599 case DN_DR:
600 return " DR";
601 case DN_DRC:
602 return " DRC";
603 case DN_CC:
604 return " CC";
605 case DN_CI:
606 return " CI";
607 case DN_NR:
608 return " NR";
609 case DN_NC:
610 return " NC";
611 case DN_CD:
612 return " CD";
613 case DN_RJ:
614 return " RJ";
615 case DN_RUN:
616 return " RUN";
617 case DN_DI:
618 return " DI";
619 case DN_DIC:
620 return " DIC";
621 case DN_DN:
622 return " DN";
623 case DN_CL:
624 return " CL";
625 case DN_CN:
626 return " CN";
627 }
628
629 return "????";
630 }
631
632 static int dn_create(struct socket *sock, int protocol)
633 {
634 struct sock *sk;
635
636 switch(sock->type) {
637 case SOCK_SEQPACKET:
638 if (protocol != DNPROTO_NSP)
639 return -EPROTONOSUPPORT;
640 break;
641 case SOCK_STREAM:
642 break;
643 default:
644 return -ESOCKTNOSUPPORT;
645 }
646
647
648 if ((sk = dn_alloc_sock(sock, GFP_KERNEL)) == NULL)
649 return -ENOBUFS;
650
651 sk->protocol = protocol;
652
653 return 0;
654 }
655
656
657 static int
658 dn_release(struct socket *sock)
659 {
660 struct sock *sk = sock->sk;
661
662 if (sk) {
663 sock_orphan(sk);
664 sock_hold(sk);
665 lock_sock(sk);
666 dn_destroy_sock(sk);
667 release_sock(sk);
668 sock_put(sk);
669 }
670
671 return 0;
672 }
673
674 static int dn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
675 {
676 struct sock *sk = sock->sk;
677 struct dn_scp *scp = &sk->protinfo.dn;
678 struct sockaddr_dn *saddr = (struct sockaddr_dn *)uaddr;
679 struct net_device *dev;
680 int rv;
681
682 if (sk->zapped == 0)
683 return -EINVAL;
684
685 if (addr_len != sizeof(struct sockaddr_dn))
686 return -EINVAL;
687
688 if (saddr->sdn_family != AF_DECnet)
689 return -EINVAL;
690
691 if (dn_ntohs(saddr->sdn_nodeaddrl) && (dn_ntohs(saddr->sdn_nodeaddrl) != 2))
692 return -EINVAL;
693
694 if (saddr->sdn_objnum && !capable(CAP_NET_BIND_SERVICE))
695 return -EPERM;
696
697 if (dn_ntohs(saddr->sdn_objnamel) > DN_MAXOBJL)
698 return -EINVAL;
699
700 if (saddr->sdn_flags & ~SDF_WILD)
701 return -EINVAL;
702
703 if (saddr->sdn_flags & SDF_WILD) {
704 if (!capable(CAP_NET_BIND_SERVICE))
705 return -EPERM;
706 } else {
707 if (dn_ntohs(saddr->sdn_nodeaddrl)) {
708 read_lock(&dev_base_lock);
709 for(dev = dev_base; dev; dev = dev->next) {
710 if (!dev->dn_ptr)
711 continue;
712 if (dn_dev_islocal(dev, dn_saddr2dn(saddr)))
713 break;
714 }
715 read_unlock(&dev_base_lock);
716 if (dev == NULL)
717 return -EADDRNOTAVAIL;
718 }
719 }
720
721
722 memcpy(&scp->addr, saddr, addr_len);
723 sk->zapped = 0;
724
725 if ((rv = dn_hash_sock(sk)) == 0)
726 goto out;
727
728 sk->zapped = 1;
729 out:
730
731 return rv;
732 }
733
734
735 static int dn_auto_bind(struct socket *sock)
736 {
737 struct sock *sk = sock->sk;
738 struct dn_scp *scp = &sk->protinfo.dn;
739
740 sk->zapped = 0;
741
742 scp->addr.sdn_flags = 0;
743 scp->addr.sdn_objnum = 0;
744
745 /*
746 * This stuff is to keep compatibility with Eduardo's
747 * patch. I hope I can dispense with it shortly...
748 */
749 if ((scp->accessdata.acc_accl != 0) &&
750 (scp->accessdata.acc_accl <= 12)) {
751
752 scp->addr.sdn_objnamel = dn_htons(scp->accessdata.acc_accl);
753 memcpy(scp->addr.sdn_objname, scp->accessdata.acc_acc, dn_ntohs(scp->addr.sdn_objnamel));
754
755 scp->accessdata.acc_accl = 0;
756 memset(scp->accessdata.acc_acc, 0, 40);
757 }
758
759 scp->addr.sdn_add.a_len = dn_htons(2);
760 *(dn_address *)scp->addr.sdn_add.a_addr = decnet_address;
761
762 dn_hash_sock(sk);
763
764 return 0;
765 }
766
767
768 static int dn_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
769 {
770 struct sockaddr_dn *addr = (struct sockaddr_dn *)uaddr;
771 struct sock *sk = sock->sk;
772 struct dn_scp *scp = &sk->protinfo.dn;
773 int err = -EISCONN;
774
775 lock_sock(sk);
776
777 if (sock->state == SS_CONNECTED)
778 goto out;
779
780 if (sock->state == SS_CONNECTING) {
781 err = 0;
782 if (sk->state == TCP_ESTABLISHED)
783 goto out;
784
785 err = -ECONNREFUSED;
786 if (sk->state == TCP_CLOSE)
787 goto out;
788 }
789
790 err = -EINVAL;
791 if (sk->protinfo.dn.state != DN_O)
792 goto out;
793
794 if (addr_len != sizeof(struct sockaddr_dn))
795 goto out;
796
797 if (addr->sdn_family != AF_DECnet)
798 goto out;
799
800 if (addr->sdn_flags & SDF_WILD)
801 goto out;
802
803 err = -EADDRNOTAVAIL;
804 if (sk->zapped && (err = dn_auto_bind(sock)))
805 goto out;
806
807 memcpy(&scp->peer, addr, addr_len);
808
809 err = -EHOSTUNREACH;
810 if (dn_route_output(&sk->dst_cache, dn_saddr2dn(&scp->peer), dn_saddr2dn(&scp->addr), 0) < 0)
811 goto out;
812
813 sk->state = TCP_SYN_SENT;
814 sock->state = SS_CONNECTING;
815 sk->protinfo.dn.state = DN_CI;
816
817 dn_nsp_send_conninit(sk, NSP_CI);
818
819 err = -EINPROGRESS;
820 if ((sk->state == TCP_SYN_SENT) && (flags & O_NONBLOCK))
821 goto out;
822
823 while(sk->state == TCP_SYN_SENT) {
824
825 err = -ERESTARTSYS;
826 if (signal_pending(current))
827 goto out;
828
829 if ((err = sock_error(sk)) != 0) {
830 sock->state = SS_UNCONNECTED;
831 goto out;
832 }
833
834 SOCK_SLEEP_PRE(sk);
835
836 if (sk->state == TCP_SYN_SENT)
837 schedule();
838
839 SOCK_SLEEP_POST(sk);
840 }
841
842 if (sk->state != TCP_ESTABLISHED) {
843 sock->state = SS_UNCONNECTED;
844 err = sock_error(sk);
845 goto out;
846 }
847
848 err = 0;
849 sock->state = SS_CONNECTED;
850 out:
851 release_sock(sk);
852
853 return err;
854 }
855
856 static int dn_access_copy(struct sk_buff *skb, struct accessdata_dn *acc)
857 {
858 unsigned char *ptr = skb->data;
859
860 acc->acc_userl = *ptr++;
861 memcpy(&acc->acc_user, ptr, acc->acc_userl);
862 ptr += acc->acc_userl;
863
864 acc->acc_passl = *ptr++;
865 memcpy(&acc->acc_pass, ptr, acc->acc_passl);
866 ptr += acc->acc_passl;
867
868 acc->acc_accl = *ptr++;
869 memcpy(&acc->acc_acc, ptr, acc->acc_accl);
870
871 skb_pull(skb, acc->acc_accl + acc->acc_passl + acc->acc_userl + 3);
872
873 return 0;
874 }
875
876 static int dn_user_copy(struct sk_buff *skb, struct optdata_dn *opt)
877 {
878 unsigned char *ptr = skb->data;
879
880 opt->opt_optl = *ptr++;
881 opt->opt_status = 0;
882 memcpy(opt->opt_data, ptr, opt->opt_optl);
883 skb_pull(skb, opt->opt_optl + 1);
884
885 return 0;
886 }
887
888
889 /*
890 * This is here for use in the sockopt() call as well as
891 * in accept(). Must be called with a locked socket.
892 */
893 static int dn_wait_accept(struct socket *sock, int flags)
894 {
895 struct sock *sk = sock->sk;
896
897 while(sk->state == TCP_LISTEN) {
898 if (flags & O_NONBLOCK) {
899 return -EAGAIN;
900 }
901
902 SOCK_SLEEP_PRE(sk)
903
904 if (sk->state == TCP_LISTEN)
905 schedule();
906
907 SOCK_SLEEP_POST(sk)
908
909 if (signal_pending(current))
910 return -ERESTARTSYS; /* But of course you don't! */
911 }
912
913 if ((sk->protinfo.dn.state != DN_RUN) && (sk->protinfo.dn.state != DN_DRC)) {
914 sock->state = SS_UNCONNECTED;
915 return sock_error(sk);
916 }
917
918 sock->state = SS_CONNECTED;
919
920 return 0;
921 }
922
923
924 static int dn_accept(struct socket *sock, struct socket *newsock, int flags)
925 {
926 struct sock *sk = sock->sk, *newsk;
927 struct sk_buff *skb = NULL;
928 struct dn_skb_cb *cb;
929 unsigned char menuver;
930 int err = 0;
931 unsigned char type;
932
933 lock_sock(sk);
934
935 if (sk->state != TCP_LISTEN) {
936 release_sock(sk);
937 return -EINVAL;
938 }
939
940 if (sk->protinfo.dn.state != DN_O) {
941 release_sock(sk);
942 return -EINVAL;
943 }
944
945 do
946 {
947 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL)
948 {
949 if (flags & O_NONBLOCK)
950 {
951 release_sock(sk);
952 return -EAGAIN;
953 }
954
955 SOCK_SLEEP_PRE(sk);
956
957 if (!skb_peek(&sk->receive_queue))
958 schedule();
959
960 SOCK_SLEEP_POST(sk);
961
962 if (signal_pending(current))
963 {
964 release_sock(sk);
965 return -ERESTARTSYS;
966 }
967 }
968 } while (skb == NULL);
969
970 cb = (struct dn_skb_cb *)skb->cb;
971
972 if ((newsk = dn_alloc_sock(newsock, sk->allocation)) == NULL) {
973 release_sock(sk);
974 kfree_skb(skb);
975 return -ENOBUFS;
976 }
977 sk->ack_backlog--;
978 release_sock(sk);
979
980 dst_release(xchg(&newsk->dst_cache, skb->dst));
981 skb->dst = NULL;
982
983 newsk->protinfo.dn.state = DN_CR;
984 newsk->protinfo.dn.addrrem = cb->src_port;
985 newsk->protinfo.dn.mss = cb->segsize;
986 newsk->protinfo.dn.accept_mode = sk->protinfo.dn.accept_mode;
987
988 if (newsk->protinfo.dn.mss < 230)
989 newsk->protinfo.dn.mss = 230;
990
991 newsk->state = TCP_LISTEN;
992 newsk->zapped = 0;
993
994 memcpy(&newsk->protinfo.dn.addr, &sk->protinfo.dn.addr, sizeof(struct sockaddr_dn));
995
996 /*
997 * If we are listening on a wild socket, we don't want
998 * the newly created socket on the wrong hash queue.
999 */
1000 newsk->protinfo.dn.addr.sdn_flags &= ~SDF_WILD;
1001
1002 skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &newsk->protinfo.dn.addr, &type));
1003 skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &newsk->protinfo.dn.peer, &type));
1004 *(dn_address *)newsk->protinfo.dn.peer.sdn_add.a_addr = cb->src;
1005 *(dn_address *)newsk->protinfo.dn.addr.sdn_add.a_addr = cb->dst;
1006
1007 menuver = *skb->data;
1008 skb_pull(skb, 1);
1009
1010 if (menuver & DN_MENUVER_ACC)
1011 dn_access_copy(skb, &newsk->protinfo.dn.accessdata);
1012
1013 if (menuver & DN_MENUVER_USR)
1014 dn_user_copy(skb, &newsk->protinfo.dn.conndata_in);
1015
1016 if (menuver & DN_MENUVER_PRX)
1017 newsk->protinfo.dn.peer.sdn_flags |= SDF_PROXY;
1018
1019 if (menuver & DN_MENUVER_UIC)
1020 newsk->protinfo.dn.peer.sdn_flags |= SDF_UICPROXY;
1021
1022 kfree_skb(skb);
1023
1024 memcpy(&newsk->protinfo.dn.conndata_out, &sk->protinfo.dn.conndata_out,
1025 sizeof(struct optdata_dn));
1026 memcpy(&newsk->protinfo.dn.discdata_out, &sk->protinfo.dn.discdata_out,
1027 sizeof(struct optdata_dn));
1028
1029 lock_sock(newsk);
1030 dn_hash_sock(newsk);
1031
1032 dn_send_conn_ack(newsk);
1033
1034 if (newsk->protinfo.dn.accept_mode == ACC_IMMED) {
1035 newsk->protinfo.dn.state = DN_CC;
1036 dn_send_conn_conf(newsk, newsk->allocation);
1037 err = dn_wait_accept(newsock, flags);
1038 }
1039
1040 release_sock(newsk);
1041 return err;
1042 }
1043
1044
1045 static int dn_getname(struct socket *sock, struct sockaddr *uaddr,int *uaddr_len,int peer)
1046 {
1047 struct sockaddr_dn *sa = (struct sockaddr_dn *)uaddr;
1048 struct sock *sk = sock->sk;
1049 struct dn_scp *scp = &sk->protinfo.dn;
1050
1051 *uaddr_len = sizeof(struct sockaddr_dn);
1052
1053 lock_sock(sk);
1054
1055 if (peer) {
1056 if (sock->state != SS_CONNECTED && scp->accept_mode == ACC_IMMED)
1057 return -ENOTCONN;
1058
1059 memcpy(sa, &scp->peer, sizeof(struct sockaddr_dn));
1060 } else {
1061 memcpy(sa, &scp->addr, sizeof(struct sockaddr_dn));
1062 }
1063
1064 release_sock(sk);
1065
1066 return 0;
1067 }
1068
1069
1070 static unsigned int dn_poll(struct file *file, struct socket *sock, poll_table *wait)
1071 {
1072 struct sock *sk = sock->sk;
1073 struct dn_scp *scp = &sk->protinfo.dn;
1074 int mask = datagram_poll(file, sock, wait);
1075
1076 if (skb_queue_len(&scp->other_receive_queue))
1077 mask |= POLLRDBAND;
1078
1079 return mask;
1080 }
1081
1082 static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1083 {
1084 struct sock *sk = sock->sk;
1085 struct dn_scp *scp = &sk->protinfo.dn;
1086 int err = -EOPNOTSUPP;
1087 unsigned long amount = 0;
1088 struct sk_buff *skb;
1089
1090 #if 0
1091 struct dn_naddr dnaddr;
1092 #endif
1093 switch(cmd)
1094 {
1095 case SIOCGIFADDR:
1096 case SIOCSIFADDR:
1097 return dn_dev_ioctl(cmd, (void *)arg);
1098
1099 #ifdef CONFIG_DECNET_ROUTER
1100 case SIOCADDRT:
1101 case SIOCDELRT:
1102 return dn_fib_ioctl(sock, cmd, arg);
1103 #endif /* CONFIG_DECNET_ROUTER */
1104
1105 #if 0
1106 case SIOCSIFADDR:
1107 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1108
1109 if ((err = copy_from_user(devname, ioarg->devname, 5)) != 0)
1110 break;
1111 if ((err = copy_from_user(addr, ioarg->exec_addr, 6)) != 0)
1112 break;
1113 if ((dev = dev_get(devname)) == NULL) {
1114 err = -ENODEV;
1115 break;
1116 }
1117 if (dev->dn_ptr == NULL) {
1118 err = -ENODEV;
1119 break;
1120 }
1121
1122 dn_dev_devices_off();
1123
1124 decnet_default_device = dev;
1125 memcpy(decnet_ether_address, addr, ETH_ALEN);
1126 decnet_address = dn_htons(dn_eth2dn(decnet_ether_address));
1127
1128 dn_dev_devices_on();
1129
1130 break;
1131
1132 case SIOCGIFADDR:
1133 if (decnet_default_device)
1134 strcpy(devname, decnet_default_device->name);
1135 else
1136 memset(devname, 0, 6);
1137
1138 if ((err = copy_to_user(ioarg->devname, devname, 5)) != 0)
1139 break;
1140
1141 if ((err = copy_to_user(ioarg->exec_addr, decnet_ether_address, 6)) != 0)
1142 break;
1143
1144 break;
1145 #endif
1146
1147 #if 0
1148 case SIOCSNETADDR:
1149 if (!capable(CAP_NET_ADMIN)) {
1150 err = -EPERM;
1151 break;
1152 }
1153
1154 if ((err = copy_from_user(&dnaddr, (void *)arg, sizeof(struct dn_naddr))) != 0)
1155 break;
1156
1157 if (dnaddr.a_len != ETH_ALEN) {
1158 err = -EINVAL;
1159 break;
1160 }
1161
1162 dn_dev_devices_off();
1163
1164 memcpy(decnet_ether_address, dnaddr.a_addr, ETH_ALEN);
1165 decnet_address = dn_htons(dn_eth2dn(decnet_ether_address));
1166
1167 dn_dev_devices_on();
1168 break;
1169
1170 case SIOCGNETADDR:
1171 dnaddr.a_len = ETH_ALEN;
1172 memcpy(dnaddr.a_addr, decnet_ether_address, ETH_ALEN);
1173
1174 if ((err = copy_to_user((void *)arg, &dnaddr, sizeof(struct dn_naddr))) != 0)
1175 break;
1176
1177 break;
1178 #endif
1179 case OSIOCSNETADDR:
1180 if (!capable(CAP_NET_ADMIN)) {
1181 err = -EPERM;
1182 break;
1183 }
1184
1185 dn_dev_devices_off();
1186
1187 decnet_address = (unsigned short)arg;
1188 dn_dn2eth(decnet_ether_address, dn_ntohs(decnet_address));
1189
1190 dn_dev_devices_on();
1191 err = 0;
1192 break;
1193
1194 case OSIOCGNETADDR:
1195 err = put_user(decnet_address, (unsigned short *)arg);
1196 break;
1197 case SIOCGIFCONF:
1198 case SIOCGIFFLAGS:
1199 case SIOCGIFBRDADDR:
1200 return dev_ioctl(cmd,(void *)arg);
1201
1202 case TIOCOUTQ:
1203 amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
1204 if (amount < 0)
1205 amount = 0;
1206 err = put_user(amount, (int *)arg);
1207 break;
1208
1209 case TIOCINQ:
1210 lock_sock(sk);
1211 if ((skb = skb_peek(&scp->other_receive_queue)) != NULL) {
1212 amount = skb->len;
1213 } else {
1214 struct sk_buff *skb = sk->receive_queue.next;
1215 for(;;) {
1216 if (skb == (struct sk_buff *)&sk->receive_queue)
1217 break;
1218 amount += skb->len;
1219 skb = skb->next;
1220 }
1221 }
1222 release_sock(sk);
1223 err = put_user(amount, (int *)arg);
1224 break;
1225 }
1226
1227 return err;
1228 }
1229
1230 static int dn_listen(struct socket *sock, int backlog)
1231 {
1232 struct sock *sk = sock->sk;
1233 int err = -EINVAL;
1234
1235 lock_sock(sk);
1236
1237 if (sk->zapped)
1238 goto out;
1239
1240 if ((sk->protinfo.dn.state != DN_O) || (sk->state == TCP_LISTEN))
1241 goto out;
1242
1243 sk->max_ack_backlog = backlog;
1244 sk->ack_backlog = 0;
1245 sk->state = TCP_LISTEN;
1246 err = 0;
1247
1248 out:
1249 release_sock(sk);
1250
1251 return err;
1252 }
1253
1254
1255 static int dn_shutdown(struct socket *sock, int how)
1256 {
1257 struct sock *sk = sock->sk;
1258 struct dn_scp *scp = &sk->protinfo.dn;
1259 int err = -ENOTCONN;
1260
1261 lock_sock(sk);
1262
1263 if (sock->state == SS_UNCONNECTED)
1264 goto out;
1265
1266 err = 0;
1267 if (sock->state == SS_DISCONNECTING)
1268 goto out;
1269
1270 err = -EINVAL;
1271 if (scp->state == DN_O)
1272 goto out;
1273
1274 if (how != SHUTDOWN_MASK)
1275 goto out;
1276
1277
1278 sk->shutdown = how;
1279 dn_destroy_sock(sk);
1280 err = 0;
1281
1282 out:
1283 release_sock(sk);
1284
1285 return err;
1286 }
1287
1288 static int dn_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
1289 {
1290 struct sock *sk = sock->sk;
1291 int err;
1292
1293 lock_sock(sk);
1294 err = __dn_setsockopt(sock, level, optname, optval, optlen, 0);
1295 release_sock(sk);
1296
1297 return err;
1298 }
1299
1300 static int __dn_setsockopt(struct socket *sock, int level,int optname, char *optval, int optlen, int flags)
1301 {
1302 struct sock *sk = sock->sk;
1303 struct dn_scp *scp = &sk->protinfo.dn;
1304 struct optdata_dn opt;
1305 struct accessdata_dn acc;
1306 int err;
1307
1308 if (optlen && !optval)
1309 return -EINVAL;
1310
1311 switch(optname) {
1312 case DSO_CONDATA:
1313 if (sock->state == SS_CONNECTED)
1314 return -EISCONN;
1315 if ((scp->state != DN_O) && (scp->state != DN_CR))
1316 return -EINVAL;
1317
1318 if (optlen != sizeof(struct optdata_dn))
1319 return -EINVAL;
1320
1321 if (copy_from_user(&opt, optval, optlen))
1322 return -EFAULT;
1323
1324 if (opt.opt_optl > 16)
1325 return -EINVAL;
1326
1327 memcpy(&scp->conndata_out, &opt, sizeof(struct optdata_dn));
1328 break;
1329
1330 case DSO_DISDATA:
1331 if (sock->state != SS_CONNECTED && sk->protinfo.dn.accept_mode == ACC_IMMED)
1332 return -ENOTCONN;
1333
1334 if (optlen != sizeof(struct optdata_dn))
1335 return -EINVAL;
1336
1337 if (copy_from_user(&opt, optval, sizeof(struct optdata_dn)))
1338 return -EFAULT;
1339
1340 if (opt.opt_optl > 16)
1341 return -EINVAL;
1342
1343 memcpy(&scp->discdata_out, &opt, sizeof(struct optdata_dn));
1344 break;
1345
1346 case DSO_CONACCESS:
1347 if (sock->state == SS_CONNECTED)
1348 return -EISCONN;
1349 if (scp->state != DN_O)
1350 return -EINVAL;
1351
1352 if (optlen != sizeof(struct accessdata_dn))
1353 return -EINVAL;
1354
1355 if (copy_from_user(&acc, optval, sizeof(struct accessdata_dn)))
1356 return -EFAULT;
1357
1358 if ((acc.acc_accl > DN_MAXACCL) ||
1359 (acc.acc_passl > DN_MAXACCL) ||
1360 (acc.acc_userl > DN_MAXACCL))
1361 return -EINVAL;
1362
1363 memcpy(&scp->accessdata, &acc, sizeof(struct accessdata_dn));
1364 break;
1365
1366 case DSO_ACCEPTMODE:
1367 if (sock->state == SS_CONNECTED)
1368 return -EISCONN;
1369 if (scp->state != DN_O)
1370 return -EINVAL;
1371
1372 if (optlen != sizeof(int))
1373 return -EINVAL;
1374
1375 {
1376 int mode;
1377
1378 if (get_user(mode, optval))
1379 return -EFAULT;
1380 if ((mode != ACC_IMMED) && (mode != ACC_DEFER))
1381 return -EINVAL;
1382
1383 scp->accept_mode = (unsigned char)mode;
1384 }
1385 break;
1386
1387 case DSO_CONACCEPT:
1388
1389 if (scp->state != DN_CR)
1390 return -EINVAL;
1391
1392 scp->state = DN_CC;
1393 dn_send_conn_conf(sk, sk->allocation);
1394 err = dn_wait_accept(sock, sock->file->f_flags);
1395 return err;
1396
1397 case DSO_CONREJECT:
1398
1399 if (scp->state != DN_CR)
1400 return -EINVAL;
1401
1402 scp->state = DN_DR;
1403 sk->shutdown = SHUTDOWN_MASK;
1404 dn_nsp_send_disc(sk, 0x38, 0, sk->allocation);
1405 break;
1406
1407 default:
1408 #ifdef CONFIG_NETFILTER
1409 return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
1410 #endif
1411 case DSO_LINKINFO:
1412 case DSO_STREAM:
1413 case DSO_SEQPACKET:
1414
1415 return -ENOPROTOOPT;
1416 }
1417
1418 return 0;
1419 }
1420
1421 static int dn_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
1422 {
1423 struct sock *sk = sock->sk;
1424 int err;
1425
1426 lock_sock(sk);
1427 err = __dn_getsockopt(sock, level, optname, optval, optlen, 0);
1428 release_sock(sk);
1429
1430 return err;
1431 }
1432
1433 static int __dn_getsockopt(struct socket *sock, int level,int optname, char *optval,int *optlen, int flags)
1434 {
1435 struct sock *sk = sock->sk;
1436 struct dn_scp *scp = &sk->protinfo.dn;
1437 struct linkinfo_dn link;
1438 int mode = scp->accept_mode;
1439
1440 switch(optname) {
1441 case DSO_CONDATA:
1442 if (*optlen != sizeof(struct optdata_dn))
1443 return -EINVAL;
1444
1445 if (copy_to_user(optval, &scp->conndata_in, sizeof(struct optdata_dn)))
1446 return -EFAULT;
1447 break;
1448
1449 case DSO_DISDATA:
1450 if (*optlen != sizeof(struct optdata_dn))
1451 return -EINVAL;
1452
1453 if (copy_to_user(optval, &scp->discdata_in, sizeof(struct optdata_dn)))
1454 return -EFAULT;
1455
1456 break;
1457
1458 case DSO_CONACCESS:
1459 if (*optlen != sizeof(struct accessdata_dn))
1460 return -EINVAL;
1461
1462 if (copy_to_user(optval, &scp->accessdata, sizeof(struct accessdata_dn)))
1463 return -EFAULT;
1464 break;
1465
1466 case DSO_ACCEPTMODE:
1467 if (put_user(mode, optval))
1468 return -EFAULT;
1469 break;
1470
1471 case DSO_LINKINFO:
1472 if (*optlen != sizeof(struct linkinfo_dn))
1473 return -EINVAL;
1474
1475 switch(sock->state) {
1476 case SS_CONNECTING:
1477 link.idn_linkstate = LL_CONNECTING;
1478 break;
1479 case SS_DISCONNECTING:
1480 link.idn_linkstate = LL_DISCONNECTING;
1481 break;
1482 case SS_CONNECTED:
1483 link.idn_linkstate = LL_RUNNING;
1484 break;
1485 default:
1486 link.idn_linkstate = LL_INACTIVE;
1487 }
1488
1489 link.idn_segsize = scp->mss;
1490
1491 if (copy_to_user(optval, &link, sizeof(struct linkinfo_dn)))
1492 return -EFAULT;
1493 break;
1494
1495 default:
1496 #ifdef CONFIG_NETFILTER
1497 {
1498 int val, len = *optlen;
1499 val = nf_getsockopt(sk, PF_DECnet, optname,
1500 optval, &len);
1501 if (val >= 0)
1502 val = put_user(len, optlen);
1503 return val;
1504 }
1505 #endif
1506 case DSO_STREAM:
1507 case DSO_SEQPACKET:
1508 case DSO_CONACCEPT:
1509 case DSO_CONREJECT:
1510 return -ENOPROTOOPT;
1511 }
1512
1513 return 0;
1514 }
1515
1516
1517 /*
1518 * Used by send/recvmsg to wait until the socket is connected
1519 * before passing data.
1520 */
1521 static int dn_wait_run(struct sock *sk, int flags)
1522 {
1523 struct dn_scp *scp = &sk->protinfo.dn;
1524 int err = 0;
1525
1526 switch(scp->state) {
1527 case DN_RUN:
1528 return 0;
1529
1530 case DN_CR:
1531 scp->state = DN_CC;
1532 dn_send_conn_conf(sk, sk->allocation);
1533 return dn_wait_accept(sk->socket, (flags & MSG_DONTWAIT) ? O_NONBLOCK : 0);
1534 case DN_CI:
1535 case DN_CC:
1536 break;
1537 default:
1538 return -ENOTCONN;
1539 }
1540
1541 if (flags & MSG_DONTWAIT)
1542 return -EWOULDBLOCK;
1543
1544 do {
1545 if ((err = sock_error(sk)) != 0)
1546 break;
1547
1548 if (signal_pending(current)) {
1549 err = -ERESTARTSYS;
1550 break;
1551 }
1552
1553 SOCK_SLEEP_PRE(sk)
1554
1555 if (scp->state != DN_RUN)
1556 schedule();
1557
1558 SOCK_SLEEP_POST(sk)
1559
1560 } while(scp->state != DN_RUN);
1561
1562 return 0;
1563 }
1564
1565
1566 static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int target)
1567 {
1568 struct sk_buff *skb = q->next;
1569 int len = 0;
1570
1571 if (flags & MSG_OOB)
1572 return skb_queue_len(q) ? 1 : 0;
1573
1574 while(skb != (struct sk_buff *)q) {
1575 struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
1576 len += skb->len;
1577
1578 if (cb->nsp_flags & 0x40) {
1579 /* SOCK_SEQPACKET reads to EOM */
1580 if (sk->type == SOCK_SEQPACKET)
1581 return 1;
1582 /* so does SOCK_STREAM unless WAITALL is specified */
1583 if (!(flags & MSG_WAITALL))
1584 return 1;
1585 }
1586
1587 /* minimum data length for read exceeded */
1588 if (len >= target)
1589 return 1;
1590
1591 skb = skb->next;
1592 }
1593
1594 return 0;
1595 }
1596
1597
1598 static int dn_recvmsg(struct socket *sock, struct msghdr *msg, int size,
1599 int flags, struct scm_cookie *scm)
1600 {
1601 struct sock *sk = sock->sk;
1602 struct dn_scp *scp = &sk->protinfo.dn;
1603 struct sk_buff_head *queue = &sk->receive_queue;
1604 int target = size > 1 ? 1 : 0;
1605 int copied = 0;
1606 int rv = 0;
1607 struct sk_buff *skb, *nskb;
1608 struct dn_skb_cb *cb = NULL;
1609 unsigned char eor = 0;
1610
1611 lock_sock(sk);
1612
1613 if (sk->zapped) {
1614 rv = -EADDRNOTAVAIL;
1615 goto out;
1616 }
1617
1618 if ((rv = dn_wait_run(sk, flags)) != 0)
1619 goto out;
1620
1621 if (sk->shutdown & RCV_SHUTDOWN) {
1622 send_sig(SIGPIPE, current, 0);
1623 rv = -EPIPE;
1624 goto out;
1625 }
1626
1627 if (flags & ~(MSG_PEEK|MSG_OOB|MSG_WAITALL|MSG_DONTWAIT)) {
1628 rv = -EOPNOTSUPP;
1629 goto out;
1630 }
1631
1632 if (flags & MSG_OOB)
1633 queue = &scp->other_receive_queue;
1634
1635 if (flags & MSG_WAITALL)
1636 target = size;
1637
1638
1639 /*
1640 * See if there is data ready to read, sleep if there isn't
1641 */
1642 for(;;) {
1643 if (sk->err)
1644 goto out;
1645
1646 if (skb_queue_len(&scp->other_receive_queue)) {
1647 if (!(flags & MSG_OOB)) {
1648 msg->msg_flags |= MSG_OOB;
1649 if (!scp->other_report) {
1650 scp->other_report = 1;
1651 goto out;
1652 }
1653 }
1654 }
1655
1656 if (scp->state != DN_RUN)
1657 goto out;
1658
1659 if (signal_pending(current)) {
1660 rv = -ERESTARTSYS;
1661 goto out;
1662 }
1663
1664 if (dn_data_ready(sk, queue, flags, target))
1665 break;
1666
1667 if (flags & MSG_DONTWAIT) {
1668 rv = -EWOULDBLOCK;
1669 goto out;
1670 }
1671
1672 set_bit(SOCK_ASYNC_WAITDATA, &sock->flags);
1673 SOCK_SLEEP_PRE(sk)
1674
1675 if (!dn_data_ready(sk, queue, flags, target))
1676 schedule();
1677
1678 SOCK_SLEEP_POST(sk)
1679 clear_bit(SOCK_ASYNC_WAITDATA, &sock->flags);
1680 }
1681
1682 for(skb = queue->next; skb != (struct sk_buff *)queue; skb = nskb) {
1683 int chunk = skb->len;
1684 cb = (struct dn_skb_cb *)skb->cb;
1685
1686 if ((chunk + copied) > size)
1687 chunk = size - copied;
1688
1689 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
1690 rv = -EFAULT;
1691 break;
1692 }
1693 copied += chunk;
1694
1695 if (!(flags & MSG_PEEK))
1696 skb->len -= chunk;
1697
1698 eor = cb->nsp_flags & 0x40;
1699 nskb = skb->next;
1700
1701 if (skb->len == 0) {
1702 skb_unlink(skb);
1703 kfree_skb(skb);
1704 /*
1705 * N.B. Don't refer to skb or cb after this point
1706 * in loop.
1707 */
1708 if ((scp->flowloc_sw == DN_DONTSEND) && !dn_congested(sk)) {
1709 scp->flowloc_sw = DN_SEND;
1710 dn_nsp_send_lnk(sk, DN_SEND);
1711 }
1712 }
1713
1714 if (eor) {
1715 if (sk->type == SOCK_SEQPACKET)
1716 break;
1717 if (!(flags & MSG_WAITALL))
1718 break;
1719 }
1720
1721 if (flags & MSG_OOB)
1722 break;
1723
1724 if (copied >= target)
1725 break;
1726 }
1727
1728 rv = copied;
1729
1730 if (eor && (sk->type == SOCK_SEQPACKET))
1731 msg->msg_flags |= MSG_EOR;
1732
1733 out:
1734 if (rv == 0)
1735 rv = (flags & MSG_PEEK) ? -sk->err : sock_error(sk);
1736
1737 if ((rv >= 0) && msg->msg_name) {
1738 memcpy(msg->msg_name, &scp->peer, sizeof(struct sockaddr_dn));
1739 msg->msg_namelen = sizeof(struct sockaddr_dn);
1740 }
1741
1742 release_sock(sk);
1743
1744 return rv;
1745 }
1746
1747
1748 static int dn_sendmsg(struct socket *sock, struct msghdr *msg, int size,
1749 struct scm_cookie *scm)
1750 {
1751 struct sock *sk = sock->sk;
1752 struct dn_scp *scp = &sk->protinfo.dn;
1753 int mss = scp->mss;
1754 int mtu = 230 - 11; /* maximum value thats always safe */
1755 struct sk_buff_head *queue = &scp->data_xmit_queue;
1756 int flags = msg->msg_flags;
1757 unsigned short numseg = 0;
1758 int err = 0;
1759 int sent = 0;
1760 int addr_len = msg->msg_namelen;
1761 struct sockaddr_dn *addr = (struct sockaddr_dn *)msg->msg_name;
1762 struct sk_buff *skb = NULL;
1763 struct dn_skb_cb *cb;
1764 unsigned char msgflg;
1765 unsigned char *ptr;
1766 unsigned short ack;
1767 int len;
1768
1769 if (flags & ~(MSG_TRYHARD|MSG_OOB|MSG_DONTWAIT|MSG_EOR))
1770 return -EOPNOTSUPP;
1771
1772 if (addr_len && (addr_len != sizeof(struct sockaddr_dn)))
1773 return -EINVAL;
1774
1775 if (sk->zapped && dn_auto_bind(sock)) {
1776 err = -EADDRNOTAVAIL;
1777 goto out;
1778 }
1779
1780 if (scp->state == DN_O) {
1781 if (!addr_len || !addr) {
1782 err = -ENOTCONN;
1783 goto out;
1784 }
1785
1786 if ((err = dn_connect(sock, (struct sockaddr *)addr, addr_len, (flags & MSG_DONTWAIT) ? O_NONBLOCK : 0)) < 0)
1787 goto out;
1788 }
1789
1790 lock_sock(sk);
1791
1792 if ((err = dn_wait_run(sk, flags)) < 0)
1793 goto out;
1794
1795 if (sk->shutdown & SEND_SHUTDOWN) {
1796 send_sig(SIGPIPE, current, 0);
1797 err = -EPIPE;
1798 goto out;
1799 }
1800
1801 if ((flags & MSG_TRYHARD) && sk->dst_cache)
1802 dst_negative_advice(&sk->dst_cache);
1803
1804 if (sk->dst_cache && sk->dst_cache->neighbour) {
1805 struct dn_neigh *dn = (struct dn_neigh *)sk->dst_cache->neighbour;
1806 if (dn->blksize > 230)
1807 mtu = dn->blksize - 11;
1808 }
1809
1810 /*
1811 * The only difference between SEQPACKET & STREAM sockets under DECnet
1812 * AFAIK is that SEQPACKET sockets set the MSG_EOR flag for the last
1813 * session control message segment.
1814 */
1815
1816 if (flags & MSG_OOB) {
1817 mss = 16;
1818 queue = &scp->other_xmit_queue;
1819 if (size > mss) {
1820 err = -EMSGSIZE;
1821 goto out;
1822 }
1823 }
1824
1825 if (mss < mtu)
1826 mtu = mss;
1827
1828 scp->persist_fxn = dn_nsp_xmit_timeout;
1829
1830 while(sent < size) {
1831 err = sock_error(sk);
1832 if (err)
1833 goto out;
1834
1835 if (signal_pending(current)) {
1836 err = -ERESTARTSYS;
1837 goto out;
1838 }
1839
1840 /*
1841 * Calculate size that we wish to send.
1842 */
1843 len = size - sent;
1844
1845 if (len > mtu)
1846 len = mtu;
1847
1848 /*
1849 * Wait for queue size to go down below the window
1850 * size.
1851 */
1852 if (skb_queue_len(queue) >= scp->snd_window) {
1853 if (flags & MSG_DONTWAIT) {
1854 err = -EWOULDBLOCK;
1855 goto out;
1856 }
1857
1858 SOCK_SLEEP_PRE(sk)
1859
1860 if (skb_queue_len(queue) >= scp->snd_window)
1861 schedule();
1862
1863 SOCK_SLEEP_POST(sk)
1864
1865 continue;
1866 }
1867
1868 /*
1869 * Get a suitably sized skb.
1870 */
1871 skb = dn_alloc_send_skb(sk, &len, flags & MSG_DONTWAIT, &err);
1872
1873 if (err)
1874 break;
1875
1876 if (!skb)
1877 continue;
1878
1879 cb = (struct dn_skb_cb *)skb->cb;
1880
1881 ptr = skb_put(skb, 9);
1882
1883 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1884 err = -EFAULT;
1885 goto out;
1886 }
1887
1888 if (flags & MSG_OOB) {
1889 cb->segnum = scp->numoth++;
1890 scp->numoth &= 0x0fff;
1891 msgflg = 0x30;
1892 ack = scp->ackxmt_oth | 0x8000;
1893 } else {
1894 cb->segnum = scp->numdat++;
1895 scp->numdat &= 0x0fff;
1896 msgflg = 0x00;
1897 if (sock->type == SOCK_STREAM)
1898 msgflg = 0x60;
1899 if (scp->seg_size == 0)
1900 msgflg |= 0x20;
1901
1902 scp->seg_size += len;
1903
1904 if (((sent + len) == size) && (flags & MSG_EOR)) {
1905 msgflg |= 0x40;
1906 scp->seg_size = 0;
1907 }
1908 ack = scp->ackxmt_dat | 0x8000;
1909 }
1910
1911 *ptr++ = msgflg;
1912 *(__u16 *)ptr = scp->addrrem;
1913 ptr += 2;
1914 *(__u16 *)ptr = scp->addrloc;
1915 ptr += 2;
1916 *(__u16 *)ptr = dn_htons(ack);
1917 ptr += 2;
1918 *(__u16 *)ptr = dn_htons(cb->segnum);
1919
1920 sent += len;
1921 dn_nsp_queue_xmit(sk, skb, flags & MSG_OOB);
1922 numseg++;
1923 skb = NULL;
1924
1925 scp->persist = dn_nsp_persist(sk);
1926
1927 }
1928 out:
1929
1930 if (skb)
1931 kfree_skb(skb);
1932
1933 release_sock(sk);
1934
1935 return sent ? sent : err;
1936 }
1937
1938 static int dn_device_event(struct notifier_block *this, unsigned long event,
1939 void *ptr)
1940 {
1941 struct net_device *dev = (struct net_device *)ptr;
1942
1943 switch(event) {
1944 case NETDEV_UP:
1945 dn_dev_up(dev);
1946 break;
1947 case NETDEV_DOWN:
1948 dn_dev_down(dev);
1949 break;
1950 default:
1951 break;
1952 }
1953
1954 return NOTIFY_DONE;
1955 }
1956
1957 static struct notifier_block dn_dev_notifier = {
1958 dn_device_event,
1959 0
1960 };
1961
1962 extern int dn_route_rcv(struct sk_buff *, struct net_device *, struct packet_type *);
1963
1964 static struct packet_type dn_dix_packet_type =
1965 {
1966 __constant_htons(ETH_P_DNA_RT),
1967 NULL, /* All devices */
1968 dn_route_rcv,
1969 (void*)1,
1970 NULL,
1971 };
1972
1973 static int dn_get_info(char *buffer, char **start, off_t offset, int length)
1974 {
1975 struct sock *sk;
1976 struct dn_scp *scp;
1977 int len = 0;
1978 off_t pos = 0;
1979 off_t begin = 0;
1980 char buf1[DN_ASCBUF_LEN];
1981 char buf2[DN_ASCBUF_LEN];
1982
1983 len += sprintf(buffer + len, "Local Remote\n");
1984
1985 read_lock(&dn_hash_lock);
1986 for(sk = dn_sklist; sk != NULL; sk = sk->next) {
1987 scp = &sk->protinfo.dn;
1988
1989 len += sprintf(buffer + len,
1990 "%6s/%04X %04d:%04d %04d:%04d %01d %6s/%04X %04d:%04d %04d:%04d %01d %4s %s\n",
1991 dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp->addr)), buf1),
1992 scp->addrloc,
1993 scp->numdat,
1994 scp->numoth,
1995 scp->ackxmt_dat,
1996 scp->ackxmt_oth,
1997 scp->flowloc_sw,
1998 dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp->peer)), buf2),
1999 scp->addrrem,
2000 scp->numdat_rcv,
2001 scp->numoth_rcv,
2002 scp->ackrcv_dat,
2003 scp->ackrcv_oth,
2004 scp->flowrem_sw,
2005 dn_state2asc(scp->state),
2006 ((scp->accept_mode == ACC_IMMED) ? "IMMED" : "DEFER"));
2007
2008 pos = begin + len;
2009 if (pos < offset) {
2010 len = 0;
2011 begin = pos;
2012 }
2013 if (pos > (offset + length))
2014 break;
2015 }
2016 read_unlock(&dn_hash_lock);
2017
2018 *start = buffer + (offset - begin);
2019 len -= (offset - begin);
2020
2021 if (len > length)
2022 len = length;
2023
2024 return len;
2025 }
2026
2027
2028 static struct net_proto_family dn_family_ops = {
2029 AF_DECnet,
2030 dn_create
2031 };
2032
2033 static struct proto_ops dn_proto_ops = {
2034 family: AF_DECnet,
2035
2036 release: dn_release,
2037 bind: dn_bind,
2038 connect: dn_connect,
2039 socketpair: sock_no_socketpair,
2040 accept: dn_accept,
2041 getname: dn_getname,
2042 poll: dn_poll,
2043 ioctl: dn_ioctl,
2044 listen: dn_listen,
2045 shutdown: dn_shutdown,
2046 setsockopt: dn_setsockopt,
2047 getsockopt: dn_getsockopt,
2048 sendmsg: dn_sendmsg,
2049 recvmsg: dn_recvmsg,
2050 mmap: sock_no_mmap,
2051 };
2052
2053 #ifdef CONFIG_SYSCTL
2054 void dn_register_sysctl(void);
2055 void dn_unregister_sysctl(void);
2056 #endif
2057
2058
2059 #ifdef MODULE
2060 EXPORT_NO_SYMBOLS;
2061 MODULE_DESCRIPTION("The Linux DECnet Network Protocol");
2062 MODULE_AUTHOR("Linux DECnet Project Team");
2063
2064 static int addr[2] = {0, 0};
2065
2066 MODULE_PARM(addr, "2i");
2067 MODULE_PARM_DESC(addr, "The DECnet address of this machine: area,node");
2068 #endif
2069
2070
2071 static int __init decnet_init(void)
2072 {
2073 #ifdef MODULE
2074 if (addr[0] > 63 || addr[0] < 0) {
2075 printk(KERN_ERR "DECnet: Area must be between 0 and 63");
2076 return 1;
2077 }
2078
2079 if (addr[1] > 1023 || addr[1] < 0) {
2080 printk(KERN_ERR "DECnet: Node must be between 0 and 1023");
2081 return 1;
2082 }
2083
2084 decnet_address = dn_htons((addr[0] << 10) | addr[1]);
2085 dn_dn2eth(decnet_ether_address, dn_ntohs(decnet_address));
2086 #endif
2087
2088 printk(KERN_INFO "NET4: DECnet for Linux: V.2.4.0-test10s (C) 1995-2000 Linux DECnet Project Team\n");
2089
2090 sock_register(&dn_family_ops);
2091 dev_add_pack(&dn_dix_packet_type);
2092 register_netdevice_notifier(&dn_dev_notifier);
2093
2094 proc_net_create("decnet", 0, dn_get_info);
2095
2096 dn_neigh_init();
2097 dn_dev_init();
2098 dn_route_init();
2099
2100 #ifdef CONFIG_DECNET_ROUTER
2101 dn_fib_init();
2102 #endif /* CONFIG_DECNET_ROUTER */
2103
2104 #ifdef CONFIG_SYSCTL
2105 dn_register_sysctl();
2106 #endif /* CONFIG_SYSCTL */
2107
2108 /*
2109 * Prevent DECnet module unloading until its fixed properly.
2110 * Requires an audit of the code to check for memory leaks and
2111 * initialisation problems etc.
2112 */
2113 MOD_INC_USE_COUNT;
2114
2115 return 0;
2116
2117 }
2118
2119 #ifndef MODULE
2120 static int __init decnet_setup(char *str)
2121 {
2122 unsigned short area = simple_strtoul(str, &str, 0);
2123 unsigned short node = simple_strtoul(*str > 0 ? ++str : str, &str, 0);
2124
2125 decnet_address = dn_htons(area << 10 | node);
2126 dn_dn2eth(decnet_ether_address, dn_ntohs(decnet_address));
2127
2128 return 1;
2129 }
2130
2131 __setup("decnet=", decnet_setup);
2132 #endif
2133
2134 static void __exit decnet_exit(void)
2135 {
2136 sock_unregister(AF_DECnet);
2137 dev_remove_pack(&dn_dix_packet_type);
2138
2139 #ifdef CONFIG_SYSCTL
2140 dn_unregister_sysctl();
2141 #endif /* CONFIG_SYSCTL */
2142
2143 unregister_netdevice_notifier(&dn_dev_notifier);
2144
2145 dn_route_cleanup();
2146 dn_dev_cleanup();
2147 dn_neigh_cleanup();
2148
2149 #ifdef CONFIG_DECNET_ROUTER
2150 dn_fib_cleanup();
2151 #endif /* CONFIG_DECNET_ROUTER */
2152
2153 proc_net_remove("decnet");
2154 }
2155
2156 module_init(decnet_init);
2157 module_exit(decnet_exit);
2158
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.