blob: 53ae14c35f70865eb4a224e9b51425d8add8d19a [file] [log] [blame]
Jennifer Hunteac37312007-02-08 13:51:54 -08001/*
2 * linux/net/iucv/af_iucv.c
3 *
4 * IUCV protocol stack for Linux on zSeries
5 *
6 * Copyright 2006 IBM Corporation
7 *
8 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com>
9 */
10
11#include <linux/module.h>
12#include <linux/types.h>
13#include <linux/list.h>
14#include <linux/errno.h>
15#include <linux/kernel.h>
16#include <linux/sched.h>
17#include <linux/slab.h>
18#include <linux/skbuff.h>
19#include <linux/init.h>
20#include <linux/poll.h>
21#include <net/sock.h>
22#include <asm/ebcdic.h>
23#include <asm/cpcmd.h>
24#include <linux/kmod.h>
25
26#include <net/iucv/iucv.h>
27#include <net/iucv/af_iucv.h>
28
29#define CONFIG_IUCV_SOCK_DEBUG 1
30
31#define IPRMDATA 0x80
32#define VERSION "1.0"
33
34static char iucv_userid[80];
35
36static struct proto_ops iucv_sock_ops;
37
38static struct proto iucv_proto = {
39 .name = "AF_IUCV",
40 .owner = THIS_MODULE,
41 .obj_size = sizeof(struct iucv_sock),
42};
43
44/* Call Back functions */
45static void iucv_callback_rx(struct iucv_path *, struct iucv_message *);
46static void iucv_callback_txdone(struct iucv_path *, struct iucv_message *);
47static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
Heiko Carstensda99f052007-05-04 12:23:27 -070048static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8],
49 u8 ipuser[16]);
Jennifer Hunteac37312007-02-08 13:51:54 -080050static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
51
52static struct iucv_sock_list iucv_sk_list = {
53 .lock = RW_LOCK_UNLOCKED,
54 .autobind_name = ATOMIC_INIT(0)
55};
56
57static struct iucv_handler af_iucv_handler = {
58 .path_pending = iucv_callback_connreq,
59 .path_complete = iucv_callback_connack,
60 .path_severed = iucv_callback_connrej,
61 .message_pending = iucv_callback_rx,
62 .message_complete = iucv_callback_txdone
63};
64
65static inline void high_nmcpy(unsigned char *dst, char *src)
66{
67 memcpy(dst, src, 8);
68}
69
70static inline void low_nmcpy(unsigned char *dst, char *src)
71{
72 memcpy(&dst[8], src, 8);
73}
74
75/* Timers */
76static void iucv_sock_timeout(unsigned long arg)
77{
78 struct sock *sk = (struct sock *)arg;
79
80 bh_lock_sock(sk);
81 sk->sk_err = ETIMEDOUT;
82 sk->sk_state_change(sk);
83 bh_unlock_sock(sk);
84
85 iucv_sock_kill(sk);
86 sock_put(sk);
87}
88
89static void iucv_sock_clear_timer(struct sock *sk)
90{
91 sk_stop_timer(sk, &sk->sk_timer);
92}
93
94static void iucv_sock_init_timer(struct sock *sk)
95{
96 init_timer(&sk->sk_timer);
97 sk->sk_timer.function = iucv_sock_timeout;
98 sk->sk_timer.data = (unsigned long)sk;
99}
100
101static struct sock *__iucv_get_sock_by_name(char *nm)
102{
103 struct sock *sk;
104 struct hlist_node *node;
105
106 sk_for_each(sk, node, &iucv_sk_list.head)
107 if (!memcmp(&iucv_sk(sk)->src_name, nm, 8))
108 return sk;
109
110 return NULL;
111}
112
113static void iucv_sock_destruct(struct sock *sk)
114{
115 skb_queue_purge(&sk->sk_receive_queue);
116 skb_queue_purge(&sk->sk_write_queue);
117}
118
119/* Cleanup Listen */
120static void iucv_sock_cleanup_listen(struct sock *parent)
121{
122 struct sock *sk;
123
124 /* Close non-accepted connections */
125 while ((sk = iucv_accept_dequeue(parent, NULL))) {
126 iucv_sock_close(sk);
127 iucv_sock_kill(sk);
128 }
129
130 parent->sk_state = IUCV_CLOSED;
131 sock_set_flag(parent, SOCK_ZAPPED);
132}
133
134/* Kill socket */
135static void iucv_sock_kill(struct sock *sk)
136{
137 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
138 return;
139
140 iucv_sock_unlink(&iucv_sk_list, sk);
141 sock_set_flag(sk, SOCK_DEAD);
142 sock_put(sk);
143}
144
145/* Close an IUCV socket */
146static void iucv_sock_close(struct sock *sk)
147{
148 unsigned char user_data[16];
149 struct iucv_sock *iucv = iucv_sk(sk);
150 int err;
Jennifer Hunt561e0362007-05-04 12:22:07 -0700151 unsigned long timeo;
Jennifer Hunteac37312007-02-08 13:51:54 -0800152
153 iucv_sock_clear_timer(sk);
154 lock_sock(sk);
155
Heiko Carstensda99f052007-05-04 12:23:27 -0700156 switch (sk->sk_state) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800157 case IUCV_LISTEN:
158 iucv_sock_cleanup_listen(sk);
159 break;
160
161 case IUCV_CONNECTED:
162 case IUCV_DISCONN:
163 err = 0;
Jennifer Hunt561e0362007-05-04 12:22:07 -0700164
165 sk->sk_state = IUCV_CLOSING;
166 sk->sk_state_change(sk);
167
Heiko Carstensda99f052007-05-04 12:23:27 -0700168 if (!skb_queue_empty(&iucv->send_skb_q)) {
Jennifer Hunt561e0362007-05-04 12:22:07 -0700169 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
170 timeo = sk->sk_lingertime;
171 else
172 timeo = IUCV_DISCONN_TIMEOUT;
173 err = iucv_sock_wait_state(sk, IUCV_CLOSED, 0, timeo);
174 }
175
176 sk->sk_state = IUCV_CLOSED;
177 sk->sk_state_change(sk);
178
Jennifer Hunteac37312007-02-08 13:51:54 -0800179 if (iucv->path) {
180 low_nmcpy(user_data, iucv->src_name);
181 high_nmcpy(user_data, iucv->dst_name);
182 ASCEBC(user_data, sizeof(user_data));
183 err = iucv_path_sever(iucv->path, user_data);
184 iucv_path_free(iucv->path);
185 iucv->path = NULL;
186 }
187
Jennifer Hunteac37312007-02-08 13:51:54 -0800188 sk->sk_err = ECONNRESET;
189 sk->sk_state_change(sk);
190
191 skb_queue_purge(&iucv->send_skb_q);
Jennifer Hunt561e0362007-05-04 12:22:07 -0700192 skb_queue_purge(&iucv->backlog_skb_q);
Jennifer Hunteac37312007-02-08 13:51:54 -0800193
194 sock_set_flag(sk, SOCK_ZAPPED);
195 break;
196
197 default:
198 sock_set_flag(sk, SOCK_ZAPPED);
199 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700200 }
Jennifer Hunteac37312007-02-08 13:51:54 -0800201
202 release_sock(sk);
203 iucv_sock_kill(sk);
204}
205
206static void iucv_sock_init(struct sock *sk, struct sock *parent)
207{
208 if (parent)
209 sk->sk_type = parent->sk_type;
210}
211
212static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio)
213{
214 struct sock *sk;
215
216 sk = sk_alloc(PF_IUCV, prio, &iucv_proto, 1);
217 if (!sk)
218 return NULL;
219
220 sock_init_data(sock, sk);
221 INIT_LIST_HEAD(&iucv_sk(sk)->accept_q);
Ursula Braunfebca282007-07-14 19:04:25 -0700222 spin_lock_init(&iucv_sk(sk)->accept_q_lock);
Jennifer Hunteac37312007-02-08 13:51:54 -0800223 skb_queue_head_init(&iucv_sk(sk)->send_skb_q);
Jennifer Hunt561e0362007-05-04 12:22:07 -0700224 skb_queue_head_init(&iucv_sk(sk)->backlog_skb_q);
Jennifer Hunteac37312007-02-08 13:51:54 -0800225 iucv_sk(sk)->send_tag = 0;
226
227 sk->sk_destruct = iucv_sock_destruct;
228 sk->sk_sndtimeo = IUCV_CONN_TIMEOUT;
229 sk->sk_allocation = GFP_DMA;
230
231 sock_reset_flag(sk, SOCK_ZAPPED);
232
233 sk->sk_protocol = proto;
234 sk->sk_state = IUCV_OPEN;
235
236 iucv_sock_init_timer(sk);
237
238 iucv_sock_link(&iucv_sk_list, sk);
239 return sk;
240}
241
242/* Create an IUCV socket */
243static int iucv_sock_create(struct socket *sock, int protocol)
244{
245 struct sock *sk;
246
247 if (sock->type != SOCK_STREAM)
248 return -ESOCKTNOSUPPORT;
249
250 sock->state = SS_UNCONNECTED;
251 sock->ops = &iucv_sock_ops;
252
253 sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
254 if (!sk)
255 return -ENOMEM;
256
257 iucv_sock_init(sk, NULL);
258
259 return 0;
260}
261
262void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk)
263{
264 write_lock_bh(&l->lock);
265 sk_add_node(sk, &l->head);
266 write_unlock_bh(&l->lock);
267}
268
269void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk)
270{
271 write_lock_bh(&l->lock);
272 sk_del_node_init(sk);
273 write_unlock_bh(&l->lock);
274}
275
276void iucv_accept_enqueue(struct sock *parent, struct sock *sk)
277{
Ursula Braunfebca282007-07-14 19:04:25 -0700278 unsigned long flags;
279 struct iucv_sock *par = iucv_sk(parent);
280
Jennifer Hunteac37312007-02-08 13:51:54 -0800281 sock_hold(sk);
Ursula Braunfebca282007-07-14 19:04:25 -0700282 spin_lock_irqsave(&par->accept_q_lock, flags);
283 list_add_tail(&iucv_sk(sk)->accept_q, &par->accept_q);
284 spin_unlock_irqrestore(&par->accept_q_lock, flags);
Jennifer Hunteac37312007-02-08 13:51:54 -0800285 iucv_sk(sk)->parent = parent;
286 parent->sk_ack_backlog++;
287}
288
289void iucv_accept_unlink(struct sock *sk)
290{
Ursula Braunfebca282007-07-14 19:04:25 -0700291 unsigned long flags;
292 struct iucv_sock *par = iucv_sk(iucv_sk(sk)->parent);
293
294 spin_lock_irqsave(&par->accept_q_lock, flags);
Jennifer Hunteac37312007-02-08 13:51:54 -0800295 list_del_init(&iucv_sk(sk)->accept_q);
Ursula Braunfebca282007-07-14 19:04:25 -0700296 spin_unlock_irqrestore(&par->accept_q_lock, flags);
Jennifer Hunteac37312007-02-08 13:51:54 -0800297 iucv_sk(sk)->parent->sk_ack_backlog--;
298 iucv_sk(sk)->parent = NULL;
299 sock_put(sk);
300}
301
302struct sock *iucv_accept_dequeue(struct sock *parent, struct socket *newsock)
303{
304 struct iucv_sock *isk, *n;
305 struct sock *sk;
306
Heiko Carstensda99f052007-05-04 12:23:27 -0700307 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800308 sk = (struct sock *) isk;
309 lock_sock(sk);
310
311 if (sk->sk_state == IUCV_CLOSED) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800312 iucv_accept_unlink(sk);
Ursula Braunfebca282007-07-14 19:04:25 -0700313 release_sock(sk);
Jennifer Hunteac37312007-02-08 13:51:54 -0800314 continue;
315 }
316
317 if (sk->sk_state == IUCV_CONNECTED ||
318 sk->sk_state == IUCV_SEVERED ||
319 !newsock) {
320 iucv_accept_unlink(sk);
321 if (newsock)
322 sock_graft(sk, newsock);
323
324 if (sk->sk_state == IUCV_SEVERED)
325 sk->sk_state = IUCV_DISCONN;
326
327 release_sock(sk);
328 return sk;
329 }
330
331 release_sock(sk);
332 }
333 return NULL;
334}
335
336int iucv_sock_wait_state(struct sock *sk, int state, int state2,
337 unsigned long timeo)
338{
339 DECLARE_WAITQUEUE(wait, current);
340 int err = 0;
341
342 add_wait_queue(sk->sk_sleep, &wait);
343 while (sk->sk_state != state && sk->sk_state != state2) {
344 set_current_state(TASK_INTERRUPTIBLE);
345
346 if (!timeo) {
347 err = -EAGAIN;
348 break;
349 }
350
351 if (signal_pending(current)) {
352 err = sock_intr_errno(timeo);
353 break;
354 }
355
356 release_sock(sk);
357 timeo = schedule_timeout(timeo);
358 lock_sock(sk);
359
360 err = sock_error(sk);
361 if (err)
362 break;
363 }
364 set_current_state(TASK_RUNNING);
365 remove_wait_queue(sk->sk_sleep, &wait);
366 return err;
367}
368
369/* Bind an unbound socket */
370static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr,
371 int addr_len)
372{
373 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
374 struct sock *sk = sock->sk;
375 struct iucv_sock *iucv;
376 int err;
377
378 /* Verify the input sockaddr */
379 if (!addr || addr->sa_family != AF_IUCV)
380 return -EINVAL;
381
382 lock_sock(sk);
383 if (sk->sk_state != IUCV_OPEN) {
384 err = -EBADFD;
385 goto done;
386 }
387
388 write_lock_bh(&iucv_sk_list.lock);
389
390 iucv = iucv_sk(sk);
391 if (__iucv_get_sock_by_name(sa->siucv_name)) {
392 err = -EADDRINUSE;
393 goto done_unlock;
394 }
395 if (iucv->path) {
396 err = 0;
397 goto done_unlock;
398 }
399
400 /* Bind the socket */
401 memcpy(iucv->src_name, sa->siucv_name, 8);
402
403 /* Copy the user id */
404 memcpy(iucv->src_user_id, iucv_userid, 8);
405 sk->sk_state = IUCV_BOUND;
406 err = 0;
407
408done_unlock:
409 /* Release the socket list lock */
410 write_unlock_bh(&iucv_sk_list.lock);
411done:
412 release_sock(sk);
413 return err;
414}
415
416/* Automatically bind an unbound socket */
417static int iucv_sock_autobind(struct sock *sk)
418{
419 struct iucv_sock *iucv = iucv_sk(sk);
420 char query_buffer[80];
421 char name[12];
422 int err = 0;
423
424 /* Set the userid and name */
425 cpcmd("QUERY USERID", query_buffer, sizeof(query_buffer), &err);
426 if (unlikely(err))
427 return -EPROTO;
428
429 memcpy(iucv->src_user_id, query_buffer, 8);
430
431 write_lock_bh(&iucv_sk_list.lock);
432
433 sprintf(name, "%08x", atomic_inc_return(&iucv_sk_list.autobind_name));
434 while (__iucv_get_sock_by_name(name)) {
435 sprintf(name, "%08x",
436 atomic_inc_return(&iucv_sk_list.autobind_name));
437 }
438
439 write_unlock_bh(&iucv_sk_list.lock);
440
441 memcpy(&iucv->src_name, name, 8);
442
443 return err;
444}
445
446/* Connect an unconnected socket */
447static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
448 int alen, int flags)
449{
450 struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
451 struct sock *sk = sock->sk;
452 struct iucv_sock *iucv;
453 unsigned char user_data[16];
454 int err;
455
456 if (addr->sa_family != AF_IUCV || alen < sizeof(struct sockaddr_iucv))
457 return -EINVAL;
458
459 if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
460 return -EBADFD;
461
462 if (sk->sk_type != SOCK_STREAM)
463 return -EINVAL;
464
465 iucv = iucv_sk(sk);
466
467 if (sk->sk_state == IUCV_OPEN) {
468 err = iucv_sock_autobind(sk);
469 if (unlikely(err))
470 return err;
471 }
472
473 lock_sock(sk);
474
475 /* Set the destination information */
476 memcpy(iucv_sk(sk)->dst_user_id, sa->siucv_user_id, 8);
477 memcpy(iucv_sk(sk)->dst_name, sa->siucv_name, 8);
478
479 high_nmcpy(user_data, sa->siucv_name);
480 low_nmcpy(user_data, iucv_sk(sk)->src_name);
481 ASCEBC(user_data, sizeof(user_data));
482
483 iucv = iucv_sk(sk);
484 /* Create path. */
485 iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT,
486 IPRMDATA, GFP_KERNEL);
487 err = iucv_path_connect(iucv->path, &af_iucv_handler,
488 sa->siucv_user_id, NULL, user_data, sk);
489 if (err) {
490 iucv_path_free(iucv->path);
491 iucv->path = NULL;
492 err = -ECONNREFUSED;
493 goto done;
494 }
495
496 if (sk->sk_state != IUCV_CONNECTED) {
497 err = iucv_sock_wait_state(sk, IUCV_CONNECTED, IUCV_DISCONN,
498 sock_sndtimeo(sk, flags & O_NONBLOCK));
499 }
500
501 if (sk->sk_state == IUCV_DISCONN) {
502 release_sock(sk);
503 return -ECONNREFUSED;
504 }
505done:
506 release_sock(sk);
507 return err;
508}
509
510/* Move a socket into listening state. */
511static int iucv_sock_listen(struct socket *sock, int backlog)
512{
513 struct sock *sk = sock->sk;
514 int err;
515
516 lock_sock(sk);
517
518 err = -EINVAL;
519 if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM)
520 goto done;
521
522 sk->sk_max_ack_backlog = backlog;
523 sk->sk_ack_backlog = 0;
524 sk->sk_state = IUCV_LISTEN;
525 err = 0;
526
527done:
528 release_sock(sk);
529 return err;
530}
531
532/* Accept a pending connection */
533static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
534 int flags)
535{
536 DECLARE_WAITQUEUE(wait, current);
537 struct sock *sk = sock->sk, *nsk;
538 long timeo;
539 int err = 0;
540
Jennifer Hunt561e0362007-05-04 12:22:07 -0700541 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
Jennifer Hunteac37312007-02-08 13:51:54 -0800542
543 if (sk->sk_state != IUCV_LISTEN) {
544 err = -EBADFD;
545 goto done;
546 }
547
548 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
549
550 /* Wait for an incoming connection */
551 add_wait_queue_exclusive(sk->sk_sleep, &wait);
Heiko Carstensda99f052007-05-04 12:23:27 -0700552 while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800553 set_current_state(TASK_INTERRUPTIBLE);
554 if (!timeo) {
555 err = -EAGAIN;
556 break;
557 }
558
559 release_sock(sk);
560 timeo = schedule_timeout(timeo);
Jennifer Hunt561e0362007-05-04 12:22:07 -0700561 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
Jennifer Hunteac37312007-02-08 13:51:54 -0800562
563 if (sk->sk_state != IUCV_LISTEN) {
564 err = -EBADFD;
565 break;
566 }
567
568 if (signal_pending(current)) {
569 err = sock_intr_errno(timeo);
570 break;
571 }
572 }
573
574 set_current_state(TASK_RUNNING);
575 remove_wait_queue(sk->sk_sleep, &wait);
576
577 if (err)
578 goto done;
579
580 newsock->state = SS_CONNECTED;
581
582done:
583 release_sock(sk);
584 return err;
585}
586
587static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
588 int *len, int peer)
589{
590 struct sockaddr_iucv *siucv = (struct sockaddr_iucv *) addr;
591 struct sock *sk = sock->sk;
592
593 addr->sa_family = AF_IUCV;
594 *len = sizeof(struct sockaddr_iucv);
595
596 if (peer) {
597 memcpy(siucv->siucv_user_id, iucv_sk(sk)->dst_user_id, 8);
598 memcpy(siucv->siucv_name, &iucv_sk(sk)->dst_name, 8);
599 } else {
600 memcpy(siucv->siucv_user_id, iucv_sk(sk)->src_user_id, 8);
601 memcpy(siucv->siucv_name, iucv_sk(sk)->src_name, 8);
602 }
603 memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port));
604 memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr));
605 memset(siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid));
606
607 return 0;
608}
609
610static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
611 struct msghdr *msg, size_t len)
612{
613 struct sock *sk = sock->sk;
614 struct iucv_sock *iucv = iucv_sk(sk);
615 struct sk_buff *skb;
616 struct iucv_message txmsg;
617 int err;
618
619 err = sock_error(sk);
620 if (err)
621 return err;
622
623 if (msg->msg_flags & MSG_OOB)
624 return -EOPNOTSUPP;
625
626 lock_sock(sk);
627
628 if (sk->sk_shutdown & SEND_SHUTDOWN) {
629 err = -EPIPE;
630 goto out;
631 }
632
Heiko Carstensda99f052007-05-04 12:23:27 -0700633 if (sk->sk_state == IUCV_CONNECTED) {
634 if (!(skb = sock_alloc_send_skb(sk, len,
635 msg->msg_flags & MSG_DONTWAIT,
636 &err)))
Jennifer Hunt561e0362007-05-04 12:22:07 -0700637 goto out;
Jennifer Hunteac37312007-02-08 13:51:54 -0800638
Heiko Carstensda99f052007-05-04 12:23:27 -0700639 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800640 err = -EFAULT;
641 goto fail;
642 }
643
644 txmsg.class = 0;
645 txmsg.tag = iucv->send_tag++;
646 memcpy(skb->cb, &txmsg.tag, 4);
647 skb_queue_tail(&iucv->send_skb_q, skb);
648 err = iucv_message_send(iucv->path, &txmsg, 0, 0,
649 (void *) skb->data, skb->len);
650 if (err) {
651 if (err == 3)
652 printk(KERN_ERR "AF_IUCV msg limit exceeded\n");
653 skb_unlink(skb, &iucv->send_skb_q);
654 err = -EPIPE;
655 goto fail;
656 }
657
658 } else {
659 err = -ENOTCONN;
660 goto out;
661 }
662
663 release_sock(sk);
664 return len;
665
666fail:
667 kfree_skb(skb);
668out:
669 release_sock(sk);
670 return err;
671}
672
673static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
674 struct msghdr *msg, size_t len, int flags)
675{
676 int noblock = flags & MSG_DONTWAIT;
677 struct sock *sk = sock->sk;
Jennifer Hunt561e0362007-05-04 12:22:07 -0700678 struct iucv_sock *iucv = iucv_sk(sk);
Jennifer Hunteac37312007-02-08 13:51:54 -0800679 int target, copied = 0;
Jennifer Hunt561e0362007-05-04 12:22:07 -0700680 struct sk_buff *skb, *rskb, *cskb;
Jennifer Hunteac37312007-02-08 13:51:54 -0800681 int err = 0;
682
Jennifer Hunt561e0362007-05-04 12:22:07 -0700683 if ((sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED) &&
684 skb_queue_empty(&iucv->backlog_skb_q) &&
685 skb_queue_empty(&sk->sk_receive_queue))
686 return 0;
687
Jennifer Hunteac37312007-02-08 13:51:54 -0800688 if (flags & (MSG_OOB))
689 return -EOPNOTSUPP;
690
691 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
692
693 skb = skb_recv_datagram(sk, flags, noblock, &err);
694 if (!skb) {
695 if (sk->sk_shutdown & RCV_SHUTDOWN)
696 return 0;
697 return err;
698 }
699
700 copied = min_t(unsigned int, skb->len, len);
701
Jennifer Hunt561e0362007-05-04 12:22:07 -0700702 cskb = skb;
703 if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800704 skb_queue_head(&sk->sk_receive_queue, skb);
705 if (copied == 0)
706 return -EFAULT;
Jennifer Hunt561e0362007-05-04 12:22:07 -0700707 goto done;
Jennifer Hunteac37312007-02-08 13:51:54 -0800708 }
709
710 len -= copied;
711
712 /* Mark read part of skb as used */
713 if (!(flags & MSG_PEEK)) {
714 skb_pull(skb, copied);
715
716 if (skb->len) {
717 skb_queue_head(&sk->sk_receive_queue, skb);
718 goto done;
719 }
720
721 kfree_skb(skb);
Jennifer Hunt561e0362007-05-04 12:22:07 -0700722
723 /* Queue backlog skbs */
724 rskb = skb_dequeue(&iucv_sk(sk)->backlog_skb_q);
Heiko Carstensda99f052007-05-04 12:23:27 -0700725 while (rskb) {
Jennifer Hunt561e0362007-05-04 12:22:07 -0700726 if (sock_queue_rcv_skb(sk, rskb)) {
727 skb_queue_head(&iucv_sk(sk)->backlog_skb_q,
728 rskb);
729 break;
730 } else {
731 rskb = skb_dequeue(&iucv_sk(sk)->backlog_skb_q);
732 }
733 }
Jennifer Hunteac37312007-02-08 13:51:54 -0800734 } else
735 skb_queue_head(&sk->sk_receive_queue, skb);
736
737done:
738 return err ? : copied;
739}
740
741static inline unsigned int iucv_accept_poll(struct sock *parent)
742{
743 struct iucv_sock *isk, *n;
744 struct sock *sk;
745
Heiko Carstensda99f052007-05-04 12:23:27 -0700746 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800747 sk = (struct sock *) isk;
748
749 if (sk->sk_state == IUCV_CONNECTED)
750 return POLLIN | POLLRDNORM;
751 }
752
753 return 0;
754}
755
756unsigned int iucv_sock_poll(struct file *file, struct socket *sock,
757 poll_table *wait)
758{
759 struct sock *sk = sock->sk;
760 unsigned int mask = 0;
761
762 poll_wait(file, sk->sk_sleep, wait);
763
764 if (sk->sk_state == IUCV_LISTEN)
765 return iucv_accept_poll(sk);
766
767 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
768 mask |= POLLERR;
769
770 if (sk->sk_shutdown & RCV_SHUTDOWN)
771 mask |= POLLRDHUP;
772
773 if (sk->sk_shutdown == SHUTDOWN_MASK)
774 mask |= POLLHUP;
775
776 if (!skb_queue_empty(&sk->sk_receive_queue) ||
Heiko Carstensda99f052007-05-04 12:23:27 -0700777 (sk->sk_shutdown & RCV_SHUTDOWN))
Jennifer Hunteac37312007-02-08 13:51:54 -0800778 mask |= POLLIN | POLLRDNORM;
779
780 if (sk->sk_state == IUCV_CLOSED)
781 mask |= POLLHUP;
782
Jennifer Hunt561e0362007-05-04 12:22:07 -0700783 if (sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED)
784 mask |= POLLIN;
785
Jennifer Hunteac37312007-02-08 13:51:54 -0800786 if (sock_writeable(sk))
787 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
788 else
789 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
790
791 return mask;
792}
793
794static int iucv_sock_shutdown(struct socket *sock, int how)
795{
796 struct sock *sk = sock->sk;
797 struct iucv_sock *iucv = iucv_sk(sk);
798 struct iucv_message txmsg;
799 int err = 0;
800 u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
801
802 how++;
803
804 if ((how & ~SHUTDOWN_MASK) || !how)
805 return -EINVAL;
806
807 lock_sock(sk);
Heiko Carstensda99f052007-05-04 12:23:27 -0700808 switch (sk->sk_state) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800809 case IUCV_CLOSED:
810 err = -ENOTCONN;
811 goto fail;
812
813 default:
814 sk->sk_shutdown |= how;
815 break;
816 }
817
818 if (how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) {
819 txmsg.class = 0;
820 txmsg.tag = 0;
821 err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0,
822 (void *) prmmsg, 8);
823 if (err) {
Heiko Carstensda99f052007-05-04 12:23:27 -0700824 switch (err) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800825 case 1:
826 err = -ENOTCONN;
827 break;
828 case 2:
829 err = -ECONNRESET;
830 break;
831 default:
832 err = -ENOTCONN;
833 break;
834 }
835 }
836 }
837
838 if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) {
839 err = iucv_path_quiesce(iucv_sk(sk)->path, NULL);
840 if (err)
841 err = -ENOTCONN;
842
843 skb_queue_purge(&sk->sk_receive_queue);
844 }
845
846 /* Wake up anyone sleeping in poll */
847 sk->sk_state_change(sk);
848
849fail:
850 release_sock(sk);
851 return err;
852}
853
854static int iucv_sock_release(struct socket *sock)
855{
856 struct sock *sk = sock->sk;
857 int err = 0;
858
859 if (!sk)
860 return 0;
861
862 iucv_sock_close(sk);
863
864 /* Unregister with IUCV base support */
865 if (iucv_sk(sk)->path) {
866 iucv_path_sever(iucv_sk(sk)->path, NULL);
867 iucv_path_free(iucv_sk(sk)->path);
868 iucv_sk(sk)->path = NULL;
869 }
870
Jennifer Hunteac37312007-02-08 13:51:54 -0800871 sock_orphan(sk);
872 iucv_sock_kill(sk);
873 return err;
874}
875
876/* Callback wrappers - called from iucv base support */
877static int iucv_callback_connreq(struct iucv_path *path,
878 u8 ipvmid[8], u8 ipuser[16])
879{
880 unsigned char user_data[16];
881 unsigned char nuser_data[16];
882 unsigned char src_name[8];
883 struct hlist_node *node;
884 struct sock *sk, *nsk;
885 struct iucv_sock *iucv, *niucv;
886 int err;
887
888 memcpy(src_name, ipuser, 8);
889 EBCASC(src_name, 8);
890 /* Find out if this path belongs to af_iucv. */
891 read_lock(&iucv_sk_list.lock);
892 iucv = NULL;
Ursula Braunfebca282007-07-14 19:04:25 -0700893 sk = NULL;
Jennifer Hunteac37312007-02-08 13:51:54 -0800894 sk_for_each(sk, node, &iucv_sk_list.head)
895 if (sk->sk_state == IUCV_LISTEN &&
896 !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) {
897 /*
898 * Found a listening socket with
899 * src_name == ipuser[0-7].
900 */
901 iucv = iucv_sk(sk);
902 break;
903 }
904 read_unlock(&iucv_sk_list.lock);
905 if (!iucv)
906 /* No socket found, not one of our paths. */
907 return -EINVAL;
908
909 bh_lock_sock(sk);
910
911 /* Check if parent socket is listening */
912 low_nmcpy(user_data, iucv->src_name);
913 high_nmcpy(user_data, iucv->dst_name);
914 ASCEBC(user_data, sizeof(user_data));
915 if (sk->sk_state != IUCV_LISTEN) {
916 err = iucv_path_sever(path, user_data);
917 goto fail;
918 }
919
920 /* Check for backlog size */
921 if (sk_acceptq_is_full(sk)) {
922 err = iucv_path_sever(path, user_data);
923 goto fail;
924 }
925
926 /* Create the new socket */
927 nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC);
Heiko Carstensda99f052007-05-04 12:23:27 -0700928 if (!nsk) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800929 err = iucv_path_sever(path, user_data);
930 goto fail;
931 }
932
933 niucv = iucv_sk(nsk);
934 iucv_sock_init(nsk, sk);
935
936 /* Set the new iucv_sock */
937 memcpy(niucv->dst_name, ipuser + 8, 8);
938 EBCASC(niucv->dst_name, 8);
939 memcpy(niucv->dst_user_id, ipvmid, 8);
940 memcpy(niucv->src_name, iucv->src_name, 8);
941 memcpy(niucv->src_user_id, iucv->src_user_id, 8);
942 niucv->path = path;
943
944 /* Call iucv_accept */
945 high_nmcpy(nuser_data, ipuser + 8);
946 memcpy(nuser_data + 8, niucv->src_name, 8);
947 ASCEBC(nuser_data + 8, 8);
948
949 path->msglim = IUCV_QUEUELEN_DEFAULT;
950 err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk);
Heiko Carstensda99f052007-05-04 12:23:27 -0700951 if (err) {
Jennifer Hunteac37312007-02-08 13:51:54 -0800952 err = iucv_path_sever(path, user_data);
953 goto fail;
954 }
955
956 iucv_accept_enqueue(sk, nsk);
957
958 /* Wake up accept */
959 nsk->sk_state = IUCV_CONNECTED;
960 sk->sk_data_ready(sk, 1);
961 err = 0;
962fail:
963 bh_unlock_sock(sk);
964 return 0;
965}
966
967static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
968{
969 struct sock *sk = path->private;
970
971 sk->sk_state = IUCV_CONNECTED;
972 sk->sk_state_change(sk);
973}
974
Jennifer Hunt561e0362007-05-04 12:22:07 -0700975static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len,
Heiko Carstensaf7cd372007-05-05 11:41:18 -0700976 struct sk_buff_head *fragmented_skb_q)
Jennifer Hunt561e0362007-05-04 12:22:07 -0700977{
978 int dataleft, size, copied = 0;
979 struct sk_buff *nskb;
980
981 dataleft = len;
Heiko Carstensda99f052007-05-04 12:23:27 -0700982 while (dataleft) {
Jennifer Hunt561e0362007-05-04 12:22:07 -0700983 if (dataleft >= sk->sk_rcvbuf / 4)
984 size = sk->sk_rcvbuf / 4;
985 else
986 size = dataleft;
987
988 nskb = alloc_skb(size, GFP_ATOMIC | GFP_DMA);
989 if (!nskb)
990 return -ENOMEM;
991
992 memcpy(nskb->data, skb->data + copied, size);
993 copied += size;
994 dataleft -= size;
995
Heiko Carstensaf7cd372007-05-05 11:41:18 -0700996 skb_reset_transport_header(nskb);
997 skb_reset_network_header(nskb);
Jennifer Hunt561e0362007-05-04 12:22:07 -0700998 nskb->len = size;
999
1000 skb_queue_tail(fragmented_skb_q, nskb);
1001 }
1002
1003 return 0;
1004}
Heiko Carstensda99f052007-05-04 12:23:27 -07001005
Jennifer Hunteac37312007-02-08 13:51:54 -08001006static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
1007{
1008 struct sock *sk = path->private;
Jennifer Hunt561e0362007-05-04 12:22:07 -07001009 struct iucv_sock *iucv = iucv_sk(sk);
1010 struct sk_buff *skb, *fskb;
1011 struct sk_buff_head fragmented_skb_q;
Jennifer Hunteac37312007-02-08 13:51:54 -08001012 int rc;
1013
Jennifer Hunt561e0362007-05-04 12:22:07 -07001014 skb_queue_head_init(&fragmented_skb_q);
1015
Jennifer Hunteac37312007-02-08 13:51:54 -08001016 if (sk->sk_shutdown & RCV_SHUTDOWN)
1017 return;
1018
1019 skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA);
1020 if (!skb) {
Jennifer Hunt561e0362007-05-04 12:22:07 -07001021 iucv_path_sever(path, NULL);
Jennifer Hunteac37312007-02-08 13:51:54 -08001022 return;
1023 }
1024
1025 if (msg->flags & IPRMDATA) {
1026 skb->data = NULL;
1027 skb->len = 0;
1028 } else {
1029 rc = iucv_message_receive(path, msg, 0, skb->data,
1030 msg->length, NULL);
1031 if (rc) {
1032 kfree_skb(skb);
1033 return;
1034 }
Jennifer Hunt561e0362007-05-04 12:22:07 -07001035 if (skb->truesize >= sk->sk_rcvbuf / 4) {
1036 rc = iucv_fragment_skb(sk, skb, msg->length,
1037 &fragmented_skb_q);
1038 kfree_skb(skb);
1039 skb = NULL;
1040 if (rc) {
1041 iucv_path_sever(path, NULL);
1042 return;
1043 }
1044 } else {
1045 skb_reset_transport_header(skb);
1046 skb_reset_network_header(skb);
1047 skb->len = msg->length;
1048 }
1049 }
1050 /* Queue the fragmented skb */
1051 fskb = skb_dequeue(&fragmented_skb_q);
Heiko Carstensda99f052007-05-04 12:23:27 -07001052 while (fskb) {
Jennifer Hunt561e0362007-05-04 12:22:07 -07001053 if (!skb_queue_empty(&iucv->backlog_skb_q))
1054 skb_queue_tail(&iucv->backlog_skb_q, fskb);
1055 else if (sock_queue_rcv_skb(sk, fskb))
1056 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, fskb);
1057 fskb = skb_dequeue(&fragmented_skb_q);
Jennifer Hunteac37312007-02-08 13:51:54 -08001058 }
1059
Jennifer Hunt561e0362007-05-04 12:22:07 -07001060 /* Queue the original skb if it exists (was not fragmented) */
1061 if (skb) {
1062 if (!skb_queue_empty(&iucv->backlog_skb_q))
1063 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1064 else if (sock_queue_rcv_skb(sk, skb))
1065 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1066 }
1067
Jennifer Hunteac37312007-02-08 13:51:54 -08001068}
1069
1070static void iucv_callback_txdone(struct iucv_path *path,
1071 struct iucv_message *msg)
1072{
1073 struct sock *sk = path->private;
1074 struct sk_buff *this;
1075 struct sk_buff_head *list = &iucv_sk(sk)->send_skb_q;
1076 struct sk_buff *list_skb = list->next;
1077 unsigned long flags;
1078
Jennifer Hunt561e0362007-05-04 12:22:07 -07001079 if (list_skb) {
1080 spin_lock_irqsave(&list->lock, flags);
Jennifer Hunteac37312007-02-08 13:51:54 -08001081
Jennifer Hunt561e0362007-05-04 12:22:07 -07001082 do {
1083 this = list_skb;
1084 list_skb = list_skb->next;
1085 } while (memcmp(&msg->tag, this->cb, 4) && list_skb);
Jennifer Hunteac37312007-02-08 13:51:54 -08001086
Jennifer Hunt561e0362007-05-04 12:22:07 -07001087 spin_unlock_irqrestore(&list->lock, flags);
Jennifer Hunteac37312007-02-08 13:51:54 -08001088
Jennifer Hunt561e0362007-05-04 12:22:07 -07001089 skb_unlink(this, &iucv_sk(sk)->send_skb_q);
1090 kfree_skb(this);
1091 }
1092
Heiko Carstensda99f052007-05-04 12:23:27 -07001093 if (sk->sk_state == IUCV_CLOSING) {
Jennifer Hunt561e0362007-05-04 12:22:07 -07001094 if (skb_queue_empty(&iucv_sk(sk)->send_skb_q)) {
1095 sk->sk_state = IUCV_CLOSED;
1096 sk->sk_state_change(sk);
1097 }
1098 }
1099
Jennifer Hunteac37312007-02-08 13:51:54 -08001100}
1101
1102static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
1103{
1104 struct sock *sk = path->private;
1105
1106 if (!list_empty(&iucv_sk(sk)->accept_q))
1107 sk->sk_state = IUCV_SEVERED;
1108 else
1109 sk->sk_state = IUCV_DISCONN;
1110
1111 sk->sk_state_change(sk);
1112}
1113
1114static struct proto_ops iucv_sock_ops = {
1115 .family = PF_IUCV,
1116 .owner = THIS_MODULE,
1117 .release = iucv_sock_release,
1118 .bind = iucv_sock_bind,
1119 .connect = iucv_sock_connect,
1120 .listen = iucv_sock_listen,
1121 .accept = iucv_sock_accept,
1122 .getname = iucv_sock_getname,
1123 .sendmsg = iucv_sock_sendmsg,
1124 .recvmsg = iucv_sock_recvmsg,
1125 .poll = iucv_sock_poll,
1126 .ioctl = sock_no_ioctl,
1127 .mmap = sock_no_mmap,
1128 .socketpair = sock_no_socketpair,
1129 .shutdown = iucv_sock_shutdown,
1130 .setsockopt = sock_no_setsockopt,
1131 .getsockopt = sock_no_getsockopt
1132};
1133
1134static struct net_proto_family iucv_sock_family_ops = {
1135 .family = AF_IUCV,
1136 .owner = THIS_MODULE,
1137 .create = iucv_sock_create,
1138};
1139
Heiko Carstensda99f052007-05-04 12:23:27 -07001140static int __init afiucv_init(void)
Jennifer Hunteac37312007-02-08 13:51:54 -08001141{
1142 int err;
1143
1144 if (!MACHINE_IS_VM) {
1145 printk(KERN_ERR "AF_IUCV connection needs VM as base\n");
1146 err = -EPROTONOSUPPORT;
1147 goto out;
1148 }
1149 cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err);
1150 if (unlikely(err)) {
1151 printk(KERN_ERR "AF_IUCV needs the VM userid\n");
1152 err = -EPROTONOSUPPORT;
1153 goto out;
1154 }
1155
1156 err = iucv_register(&af_iucv_handler, 0);
1157 if (err)
1158 goto out;
1159 err = proto_register(&iucv_proto, 0);
1160 if (err)
1161 goto out_iucv;
1162 err = sock_register(&iucv_sock_family_ops);
1163 if (err)
1164 goto out_proto;
1165 printk(KERN_INFO "AF_IUCV lowlevel driver initialized\n");
1166 return 0;
1167
1168out_proto:
1169 proto_unregister(&iucv_proto);
1170out_iucv:
1171 iucv_unregister(&af_iucv_handler, 0);
1172out:
1173 return err;
1174}
1175
1176static void __exit afiucv_exit(void)
1177{
1178 sock_unregister(PF_IUCV);
1179 proto_unregister(&iucv_proto);
1180 iucv_unregister(&af_iucv_handler, 0);
1181
1182 printk(KERN_INFO "AF_IUCV lowlevel driver unloaded\n");
1183}
1184
1185module_init(afiucv_init);
1186module_exit(afiucv_exit);
1187
1188MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
1189MODULE_DESCRIPTION("IUCV Sockets ver " VERSION);
1190MODULE_VERSION(VERSION);
1191MODULE_LICENSE("GPL");
1192MODULE_ALIAS_NETPROTO(PF_IUCV);