xref: /openbmc/linux/net/iucv/af_iucv.c (revision 64c70b1c)
1 /*
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 
34 static char iucv_userid[80];
35 
36 static struct proto_ops iucv_sock_ops;
37 
38 static 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 */
45 static void iucv_callback_rx(struct iucv_path *, struct iucv_message *);
46 static void iucv_callback_txdone(struct iucv_path *, struct iucv_message *);
47 static void iucv_callback_connack(struct iucv_path *, u8 ipuser[16]);
48 static int iucv_callback_connreq(struct iucv_path *, u8 ipvmid[8],
49 				 u8 ipuser[16]);
50 static void iucv_callback_connrej(struct iucv_path *, u8 ipuser[16]);
51 
52 static struct iucv_sock_list iucv_sk_list = {
53 	.lock = RW_LOCK_UNLOCKED,
54 	.autobind_name = ATOMIC_INIT(0)
55 };
56 
57 static 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 
65 static inline void high_nmcpy(unsigned char *dst, char *src)
66 {
67        memcpy(dst, src, 8);
68 }
69 
70 static inline void low_nmcpy(unsigned char *dst, char *src)
71 {
72        memcpy(&dst[8], src, 8);
73 }
74 
75 /* Timers */
76 static 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 
89 static void iucv_sock_clear_timer(struct sock *sk)
90 {
91 	sk_stop_timer(sk, &sk->sk_timer);
92 }
93 
94 static 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 
101 static 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 
113 static 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 */
120 static 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 */
135 static 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 */
146 static 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;
151 	unsigned long timeo;
152 
153 	iucv_sock_clear_timer(sk);
154 	lock_sock(sk);
155 
156 	switch (sk->sk_state) {
157 	case IUCV_LISTEN:
158 		iucv_sock_cleanup_listen(sk);
159 		break;
160 
161 	case IUCV_CONNECTED:
162 	case IUCV_DISCONN:
163 		err = 0;
164 
165 		sk->sk_state = IUCV_CLOSING;
166 		sk->sk_state_change(sk);
167 
168 		if (!skb_queue_empty(&iucv->send_skb_q)) {
169 			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 
179 		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 
188 		sk->sk_err = ECONNRESET;
189 		sk->sk_state_change(sk);
190 
191 		skb_queue_purge(&iucv->send_skb_q);
192 		skb_queue_purge(&iucv->backlog_skb_q);
193 
194 		sock_set_flag(sk, SOCK_ZAPPED);
195 		break;
196 
197 	default:
198 		sock_set_flag(sk, SOCK_ZAPPED);
199 		break;
200 	}
201 
202 	release_sock(sk);
203 	iucv_sock_kill(sk);
204 }
205 
206 static void iucv_sock_init(struct sock *sk, struct sock *parent)
207 {
208 	if (parent)
209 		sk->sk_type = parent->sk_type;
210 }
211 
212 static 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);
222 	skb_queue_head_init(&iucv_sk(sk)->send_skb_q);
223 	skb_queue_head_init(&iucv_sk(sk)->backlog_skb_q);
224 	iucv_sk(sk)->send_tag = 0;
225 
226 	sk->sk_destruct = iucv_sock_destruct;
227 	sk->sk_sndtimeo = IUCV_CONN_TIMEOUT;
228 	sk->sk_allocation = GFP_DMA;
229 
230 	sock_reset_flag(sk, SOCK_ZAPPED);
231 
232 	sk->sk_protocol = proto;
233 	sk->sk_state	= IUCV_OPEN;
234 
235 	iucv_sock_init_timer(sk);
236 
237 	iucv_sock_link(&iucv_sk_list, sk);
238 	return sk;
239 }
240 
241 /* Create an IUCV socket */
242 static int iucv_sock_create(struct socket *sock, int protocol)
243 {
244 	struct sock *sk;
245 
246 	if (sock->type != SOCK_STREAM)
247 		return -ESOCKTNOSUPPORT;
248 
249 	sock->state = SS_UNCONNECTED;
250 	sock->ops = &iucv_sock_ops;
251 
252 	sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL);
253 	if (!sk)
254 		return -ENOMEM;
255 
256 	iucv_sock_init(sk, NULL);
257 
258 	return 0;
259 }
260 
261 void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk)
262 {
263 	write_lock_bh(&l->lock);
264 	sk_add_node(sk, &l->head);
265 	write_unlock_bh(&l->lock);
266 }
267 
268 void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk)
269 {
270 	write_lock_bh(&l->lock);
271 	sk_del_node_init(sk);
272 	write_unlock_bh(&l->lock);
273 }
274 
275 void iucv_accept_enqueue(struct sock *parent, struct sock *sk)
276 {
277 	sock_hold(sk);
278 	list_add_tail(&iucv_sk(sk)->accept_q, &iucv_sk(parent)->accept_q);
279 	iucv_sk(sk)->parent = parent;
280 	parent->sk_ack_backlog++;
281 }
282 
283 void iucv_accept_unlink(struct sock *sk)
284 {
285 	list_del_init(&iucv_sk(sk)->accept_q);
286 	iucv_sk(sk)->parent->sk_ack_backlog--;
287 	iucv_sk(sk)->parent = NULL;
288 	sock_put(sk);
289 }
290 
291 struct sock *iucv_accept_dequeue(struct sock *parent, struct socket *newsock)
292 {
293 	struct iucv_sock *isk, *n;
294 	struct sock *sk;
295 
296 	list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
297 		sk = (struct sock *) isk;
298 		lock_sock(sk);
299 
300 		if (sk->sk_state == IUCV_CLOSED) {
301 			release_sock(sk);
302 			iucv_accept_unlink(sk);
303 			continue;
304 		}
305 
306 		if (sk->sk_state == IUCV_CONNECTED ||
307 		    sk->sk_state == IUCV_SEVERED ||
308 		    !newsock) {
309 			iucv_accept_unlink(sk);
310 			if (newsock)
311 				sock_graft(sk, newsock);
312 
313 			if (sk->sk_state == IUCV_SEVERED)
314 				sk->sk_state = IUCV_DISCONN;
315 
316 			release_sock(sk);
317 			return sk;
318 		}
319 
320 		release_sock(sk);
321 	}
322 	return NULL;
323 }
324 
325 int iucv_sock_wait_state(struct sock *sk, int state, int state2,
326 			 unsigned long timeo)
327 {
328 	DECLARE_WAITQUEUE(wait, current);
329 	int err = 0;
330 
331 	add_wait_queue(sk->sk_sleep, &wait);
332 	while (sk->sk_state != state && sk->sk_state != state2) {
333 		set_current_state(TASK_INTERRUPTIBLE);
334 
335 		if (!timeo) {
336 			err = -EAGAIN;
337 			break;
338 		}
339 
340 		if (signal_pending(current)) {
341 			err = sock_intr_errno(timeo);
342 			break;
343 		}
344 
345 		release_sock(sk);
346 		timeo = schedule_timeout(timeo);
347 		lock_sock(sk);
348 
349 		err = sock_error(sk);
350 		if (err)
351 			break;
352 	}
353 	set_current_state(TASK_RUNNING);
354 	remove_wait_queue(sk->sk_sleep, &wait);
355 	return err;
356 }
357 
358 /* Bind an unbound socket */
359 static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr,
360 			  int addr_len)
361 {
362 	struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
363 	struct sock *sk = sock->sk;
364 	struct iucv_sock *iucv;
365 	int err;
366 
367 	/* Verify the input sockaddr */
368 	if (!addr || addr->sa_family != AF_IUCV)
369 		return -EINVAL;
370 
371 	lock_sock(sk);
372 	if (sk->sk_state != IUCV_OPEN) {
373 		err = -EBADFD;
374 		goto done;
375 	}
376 
377 	write_lock_bh(&iucv_sk_list.lock);
378 
379 	iucv = iucv_sk(sk);
380 	if (__iucv_get_sock_by_name(sa->siucv_name)) {
381 		err = -EADDRINUSE;
382 		goto done_unlock;
383 	}
384 	if (iucv->path) {
385 		err = 0;
386 		goto done_unlock;
387 	}
388 
389 	/* Bind the socket */
390 	memcpy(iucv->src_name, sa->siucv_name, 8);
391 
392 	/* Copy the user id */
393 	memcpy(iucv->src_user_id, iucv_userid, 8);
394 	sk->sk_state = IUCV_BOUND;
395 	err = 0;
396 
397 done_unlock:
398 	/* Release the socket list lock */
399 	write_unlock_bh(&iucv_sk_list.lock);
400 done:
401 	release_sock(sk);
402 	return err;
403 }
404 
405 /* Automatically bind an unbound socket */
406 static int iucv_sock_autobind(struct sock *sk)
407 {
408 	struct iucv_sock *iucv = iucv_sk(sk);
409 	char query_buffer[80];
410 	char name[12];
411 	int err = 0;
412 
413 	/* Set the userid and name */
414 	cpcmd("QUERY USERID", query_buffer, sizeof(query_buffer), &err);
415 	if (unlikely(err))
416 		return -EPROTO;
417 
418 	memcpy(iucv->src_user_id, query_buffer, 8);
419 
420 	write_lock_bh(&iucv_sk_list.lock);
421 
422 	sprintf(name, "%08x", atomic_inc_return(&iucv_sk_list.autobind_name));
423 	while (__iucv_get_sock_by_name(name)) {
424 		sprintf(name, "%08x",
425 			atomic_inc_return(&iucv_sk_list.autobind_name));
426 	}
427 
428 	write_unlock_bh(&iucv_sk_list.lock);
429 
430 	memcpy(&iucv->src_name, name, 8);
431 
432 	return err;
433 }
434 
435 /* Connect an unconnected socket */
436 static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
437 			     int alen, int flags)
438 {
439 	struct sockaddr_iucv *sa = (struct sockaddr_iucv *) addr;
440 	struct sock *sk = sock->sk;
441 	struct iucv_sock *iucv;
442 	unsigned char user_data[16];
443 	int err;
444 
445 	if (addr->sa_family != AF_IUCV || alen < sizeof(struct sockaddr_iucv))
446 		return -EINVAL;
447 
448 	if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
449 		return -EBADFD;
450 
451 	if (sk->sk_type != SOCK_STREAM)
452 		return -EINVAL;
453 
454 	iucv = iucv_sk(sk);
455 
456 	if (sk->sk_state == IUCV_OPEN) {
457 		err = iucv_sock_autobind(sk);
458 		if (unlikely(err))
459 			return err;
460 	}
461 
462 	lock_sock(sk);
463 
464 	/* Set the destination information */
465 	memcpy(iucv_sk(sk)->dst_user_id, sa->siucv_user_id, 8);
466 	memcpy(iucv_sk(sk)->dst_name, sa->siucv_name, 8);
467 
468 	high_nmcpy(user_data, sa->siucv_name);
469 	low_nmcpy(user_data, iucv_sk(sk)->src_name);
470 	ASCEBC(user_data, sizeof(user_data));
471 
472 	iucv = iucv_sk(sk);
473 	/* Create path. */
474 	iucv->path = iucv_path_alloc(IUCV_QUEUELEN_DEFAULT,
475 				     IPRMDATA, GFP_KERNEL);
476 	err = iucv_path_connect(iucv->path, &af_iucv_handler,
477 				sa->siucv_user_id, NULL, user_data, sk);
478 	if (err) {
479 		iucv_path_free(iucv->path);
480 		iucv->path = NULL;
481 		err = -ECONNREFUSED;
482 		goto done;
483 	}
484 
485 	if (sk->sk_state != IUCV_CONNECTED) {
486 		err = iucv_sock_wait_state(sk, IUCV_CONNECTED, IUCV_DISCONN,
487 				sock_sndtimeo(sk, flags & O_NONBLOCK));
488 	}
489 
490 	if (sk->sk_state == IUCV_DISCONN) {
491 		release_sock(sk);
492 		return -ECONNREFUSED;
493 	}
494 done:
495 	release_sock(sk);
496 	return err;
497 }
498 
499 /* Move a socket into listening state. */
500 static int iucv_sock_listen(struct socket *sock, int backlog)
501 {
502 	struct sock *sk = sock->sk;
503 	int err;
504 
505 	lock_sock(sk);
506 
507 	err = -EINVAL;
508 	if (sk->sk_state != IUCV_BOUND || sock->type != SOCK_STREAM)
509 		goto done;
510 
511 	sk->sk_max_ack_backlog = backlog;
512 	sk->sk_ack_backlog = 0;
513 	sk->sk_state = IUCV_LISTEN;
514 	err = 0;
515 
516 done:
517 	release_sock(sk);
518 	return err;
519 }
520 
521 /* Accept a pending connection */
522 static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
523 			    int flags)
524 {
525 	DECLARE_WAITQUEUE(wait, current);
526 	struct sock *sk = sock->sk, *nsk;
527 	long timeo;
528 	int err = 0;
529 
530 	lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
531 
532 	if (sk->sk_state != IUCV_LISTEN) {
533 		err = -EBADFD;
534 		goto done;
535 	}
536 
537 	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
538 
539 	/* Wait for an incoming connection */
540 	add_wait_queue_exclusive(sk->sk_sleep, &wait);
541 	while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
542 		set_current_state(TASK_INTERRUPTIBLE);
543 		if (!timeo) {
544 			err = -EAGAIN;
545 			break;
546 		}
547 
548 		release_sock(sk);
549 		timeo = schedule_timeout(timeo);
550 		lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
551 
552 		if (sk->sk_state != IUCV_LISTEN) {
553 			err = -EBADFD;
554 			break;
555 		}
556 
557 		if (signal_pending(current)) {
558 			err = sock_intr_errno(timeo);
559 			break;
560 		}
561 	}
562 
563 	set_current_state(TASK_RUNNING);
564 	remove_wait_queue(sk->sk_sleep, &wait);
565 
566 	if (err)
567 		goto done;
568 
569 	newsock->state = SS_CONNECTED;
570 
571 done:
572 	release_sock(sk);
573 	return err;
574 }
575 
576 static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
577 			     int *len, int peer)
578 {
579 	struct sockaddr_iucv *siucv = (struct sockaddr_iucv *) addr;
580 	struct sock *sk = sock->sk;
581 
582 	addr->sa_family = AF_IUCV;
583 	*len = sizeof(struct sockaddr_iucv);
584 
585 	if (peer) {
586 		memcpy(siucv->siucv_user_id, iucv_sk(sk)->dst_user_id, 8);
587 		memcpy(siucv->siucv_name, &iucv_sk(sk)->dst_name, 8);
588 	} else {
589 		memcpy(siucv->siucv_user_id, iucv_sk(sk)->src_user_id, 8);
590 		memcpy(siucv->siucv_name, iucv_sk(sk)->src_name, 8);
591 	}
592 	memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port));
593 	memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr));
594 	memset(siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid));
595 
596 	return 0;
597 }
598 
599 static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
600 			     struct msghdr *msg, size_t len)
601 {
602 	struct sock *sk = sock->sk;
603 	struct iucv_sock *iucv = iucv_sk(sk);
604 	struct sk_buff *skb;
605 	struct iucv_message txmsg;
606 	int err;
607 
608 	err = sock_error(sk);
609 	if (err)
610 		return err;
611 
612 	if (msg->msg_flags & MSG_OOB)
613 		return -EOPNOTSUPP;
614 
615 	lock_sock(sk);
616 
617 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
618 		err = -EPIPE;
619 		goto out;
620 	}
621 
622 	if (sk->sk_state == IUCV_CONNECTED) {
623 		if (!(skb = sock_alloc_send_skb(sk, len,
624 						msg->msg_flags & MSG_DONTWAIT,
625 						&err)))
626 			goto out;
627 
628 		if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
629 			err = -EFAULT;
630 			goto fail;
631 		}
632 
633 		txmsg.class = 0;
634 		txmsg.tag = iucv->send_tag++;
635 		memcpy(skb->cb, &txmsg.tag, 4);
636 		skb_queue_tail(&iucv->send_skb_q, skb);
637 		err = iucv_message_send(iucv->path, &txmsg, 0, 0,
638 					(void *) skb->data, skb->len);
639 		if (err) {
640 			if (err == 3)
641 				printk(KERN_ERR "AF_IUCV msg limit exceeded\n");
642 			skb_unlink(skb, &iucv->send_skb_q);
643 			err = -EPIPE;
644 			goto fail;
645 		}
646 
647 	} else {
648 		err = -ENOTCONN;
649 		goto out;
650 	}
651 
652 	release_sock(sk);
653 	return len;
654 
655 fail:
656 	kfree_skb(skb);
657 out:
658 	release_sock(sk);
659 	return err;
660 }
661 
662 static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
663 			     struct msghdr *msg, size_t len, int flags)
664 {
665 	int noblock = flags & MSG_DONTWAIT;
666 	struct sock *sk = sock->sk;
667 	struct iucv_sock *iucv = iucv_sk(sk);
668 	int target, copied = 0;
669 	struct sk_buff *skb, *rskb, *cskb;
670 	int err = 0;
671 
672 	if ((sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED) &&
673 		skb_queue_empty(&iucv->backlog_skb_q) &&
674 		skb_queue_empty(&sk->sk_receive_queue))
675 		return 0;
676 
677 	if (flags & (MSG_OOB))
678 		return -EOPNOTSUPP;
679 
680 	target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
681 
682 	skb = skb_recv_datagram(sk, flags, noblock, &err);
683 	if (!skb) {
684 		if (sk->sk_shutdown & RCV_SHUTDOWN)
685 			return 0;
686 		return err;
687 	}
688 
689 	copied = min_t(unsigned int, skb->len, len);
690 
691 	cskb = skb;
692 	if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
693 		skb_queue_head(&sk->sk_receive_queue, skb);
694 		if (copied == 0)
695 			return -EFAULT;
696 		goto done;
697 	}
698 
699 	len -= copied;
700 
701 	/* Mark read part of skb as used */
702 	if (!(flags & MSG_PEEK)) {
703 		skb_pull(skb, copied);
704 
705 		if (skb->len) {
706 			skb_queue_head(&sk->sk_receive_queue, skb);
707 			goto done;
708 		}
709 
710 		kfree_skb(skb);
711 
712 		/* Queue backlog skbs */
713 		rskb = skb_dequeue(&iucv_sk(sk)->backlog_skb_q);
714 		while (rskb) {
715 			if (sock_queue_rcv_skb(sk, rskb)) {
716 				skb_queue_head(&iucv_sk(sk)->backlog_skb_q,
717 						rskb);
718 				break;
719 			} else {
720 				rskb = skb_dequeue(&iucv_sk(sk)->backlog_skb_q);
721 			}
722 		}
723 	} else
724 		skb_queue_head(&sk->sk_receive_queue, skb);
725 
726 done:
727 	return err ? : copied;
728 }
729 
730 static inline unsigned int iucv_accept_poll(struct sock *parent)
731 {
732 	struct iucv_sock *isk, *n;
733 	struct sock *sk;
734 
735 	list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
736 		sk = (struct sock *) isk;
737 
738 		if (sk->sk_state == IUCV_CONNECTED)
739 			return POLLIN | POLLRDNORM;
740 	}
741 
742 	return 0;
743 }
744 
745 unsigned int iucv_sock_poll(struct file *file, struct socket *sock,
746 			    poll_table *wait)
747 {
748 	struct sock *sk = sock->sk;
749 	unsigned int mask = 0;
750 
751 	poll_wait(file, sk->sk_sleep, wait);
752 
753 	if (sk->sk_state == IUCV_LISTEN)
754 		return iucv_accept_poll(sk);
755 
756 	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
757 		mask |= POLLERR;
758 
759 	if (sk->sk_shutdown & RCV_SHUTDOWN)
760 		mask |= POLLRDHUP;
761 
762 	if (sk->sk_shutdown == SHUTDOWN_MASK)
763 		mask |= POLLHUP;
764 
765 	if (!skb_queue_empty(&sk->sk_receive_queue) ||
766 	    (sk->sk_shutdown & RCV_SHUTDOWN))
767 		mask |= POLLIN | POLLRDNORM;
768 
769 	if (sk->sk_state == IUCV_CLOSED)
770 		mask |= POLLHUP;
771 
772 	if (sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_SEVERED)
773 		mask |= POLLIN;
774 
775 	if (sock_writeable(sk))
776 		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
777 	else
778 		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
779 
780 	return mask;
781 }
782 
783 static int iucv_sock_shutdown(struct socket *sock, int how)
784 {
785 	struct sock *sk = sock->sk;
786 	struct iucv_sock *iucv = iucv_sk(sk);
787 	struct iucv_message txmsg;
788 	int err = 0;
789 	u8 prmmsg[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
790 
791 	how++;
792 
793 	if ((how & ~SHUTDOWN_MASK) || !how)
794 		return -EINVAL;
795 
796 	lock_sock(sk);
797 	switch (sk->sk_state) {
798 	case IUCV_CLOSED:
799 		err = -ENOTCONN;
800 		goto fail;
801 
802 	default:
803 		sk->sk_shutdown |= how;
804 		break;
805 	}
806 
807 	if (how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) {
808 		txmsg.class = 0;
809 		txmsg.tag = 0;
810 		err = iucv_message_send(iucv->path, &txmsg, IUCV_IPRMDATA, 0,
811 					(void *) prmmsg, 8);
812 		if (err) {
813 			switch (err) {
814 			case 1:
815 				err = -ENOTCONN;
816 				break;
817 			case 2:
818 				err = -ECONNRESET;
819 				break;
820 			default:
821 				err = -ENOTCONN;
822 				break;
823 			}
824 		}
825 	}
826 
827 	if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) {
828 		err = iucv_path_quiesce(iucv_sk(sk)->path, NULL);
829 		if (err)
830 			err = -ENOTCONN;
831 
832 		skb_queue_purge(&sk->sk_receive_queue);
833 	}
834 
835 	/* Wake up anyone sleeping in poll */
836 	sk->sk_state_change(sk);
837 
838 fail:
839 	release_sock(sk);
840 	return err;
841 }
842 
843 static int iucv_sock_release(struct socket *sock)
844 {
845 	struct sock *sk = sock->sk;
846 	int err = 0;
847 
848 	if (!sk)
849 		return 0;
850 
851 	iucv_sock_close(sk);
852 
853 	/* Unregister with IUCV base support */
854 	if (iucv_sk(sk)->path) {
855 		iucv_path_sever(iucv_sk(sk)->path, NULL);
856 		iucv_path_free(iucv_sk(sk)->path);
857 		iucv_sk(sk)->path = NULL;
858 	}
859 
860 	sock_orphan(sk);
861 	iucv_sock_kill(sk);
862 	return err;
863 }
864 
865 /* Callback wrappers - called from iucv base support */
866 static int iucv_callback_connreq(struct iucv_path *path,
867 				 u8 ipvmid[8], u8 ipuser[16])
868 {
869 	unsigned char user_data[16];
870 	unsigned char nuser_data[16];
871 	unsigned char src_name[8];
872 	struct hlist_node *node;
873 	struct sock *sk, *nsk;
874 	struct iucv_sock *iucv, *niucv;
875 	int err;
876 
877 	memcpy(src_name, ipuser, 8);
878 	EBCASC(src_name, 8);
879 	/* Find out if this path belongs to af_iucv. */
880 	read_lock(&iucv_sk_list.lock);
881 	iucv = NULL;
882 	sk_for_each(sk, node, &iucv_sk_list.head)
883 		if (sk->sk_state == IUCV_LISTEN &&
884 		    !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) {
885 			/*
886 			 * Found a listening socket with
887 			 * src_name == ipuser[0-7].
888 			 */
889 			iucv = iucv_sk(sk);
890 			break;
891 		}
892 	read_unlock(&iucv_sk_list.lock);
893 	if (!iucv)
894 		/* No socket found, not one of our paths. */
895 		return -EINVAL;
896 
897 	bh_lock_sock(sk);
898 
899 	/* Check if parent socket is listening */
900 	low_nmcpy(user_data, iucv->src_name);
901 	high_nmcpy(user_data, iucv->dst_name);
902 	ASCEBC(user_data, sizeof(user_data));
903 	if (sk->sk_state != IUCV_LISTEN) {
904 		err = iucv_path_sever(path, user_data);
905 		goto fail;
906 	}
907 
908 	/* Check for backlog size */
909 	if (sk_acceptq_is_full(sk)) {
910 		err = iucv_path_sever(path, user_data);
911 		goto fail;
912 	}
913 
914 	/* Create the new socket */
915 	nsk = iucv_sock_alloc(NULL, SOCK_STREAM, GFP_ATOMIC);
916 	if (!nsk) {
917 		err = iucv_path_sever(path, user_data);
918 		goto fail;
919 	}
920 
921 	niucv = iucv_sk(nsk);
922 	iucv_sock_init(nsk, sk);
923 
924 	/* Set the new iucv_sock */
925 	memcpy(niucv->dst_name, ipuser + 8, 8);
926 	EBCASC(niucv->dst_name, 8);
927 	memcpy(niucv->dst_user_id, ipvmid, 8);
928 	memcpy(niucv->src_name, iucv->src_name, 8);
929 	memcpy(niucv->src_user_id, iucv->src_user_id, 8);
930 	niucv->path = path;
931 
932 	/* Call iucv_accept */
933 	high_nmcpy(nuser_data, ipuser + 8);
934 	memcpy(nuser_data + 8, niucv->src_name, 8);
935 	ASCEBC(nuser_data + 8, 8);
936 
937 	path->msglim = IUCV_QUEUELEN_DEFAULT;
938 	err = iucv_path_accept(path, &af_iucv_handler, nuser_data, nsk);
939 	if (err) {
940 		err = iucv_path_sever(path, user_data);
941 		goto fail;
942 	}
943 
944 	iucv_accept_enqueue(sk, nsk);
945 
946 	/* Wake up accept */
947 	nsk->sk_state = IUCV_CONNECTED;
948 	sk->sk_data_ready(sk, 1);
949 	err = 0;
950 fail:
951 	bh_unlock_sock(sk);
952 	return 0;
953 }
954 
955 static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
956 {
957 	struct sock *sk = path->private;
958 
959 	sk->sk_state = IUCV_CONNECTED;
960 	sk->sk_state_change(sk);
961 }
962 
963 static int iucv_fragment_skb(struct sock *sk, struct sk_buff *skb, int len,
964 			     struct sk_buff_head *fragmented_skb_q)
965 {
966 	int dataleft, size, copied = 0;
967 	struct sk_buff *nskb;
968 
969 	dataleft = len;
970 	while (dataleft) {
971 		if (dataleft >= sk->sk_rcvbuf / 4)
972 			size = sk->sk_rcvbuf / 4;
973 		else
974 			size = dataleft;
975 
976 		nskb = alloc_skb(size, GFP_ATOMIC | GFP_DMA);
977 		if (!nskb)
978 			return -ENOMEM;
979 
980 		memcpy(nskb->data, skb->data + copied, size);
981 		copied += size;
982 		dataleft -= size;
983 
984 		skb_reset_transport_header(nskb);
985 		skb_reset_network_header(nskb);
986 		nskb->len = size;
987 
988 		skb_queue_tail(fragmented_skb_q, nskb);
989 	}
990 
991 	return 0;
992 }
993 
994 static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
995 {
996 	struct sock *sk = path->private;
997 	struct iucv_sock *iucv = iucv_sk(sk);
998 	struct sk_buff *skb, *fskb;
999 	struct sk_buff_head fragmented_skb_q;
1000 	int rc;
1001 
1002 	skb_queue_head_init(&fragmented_skb_q);
1003 
1004 	if (sk->sk_shutdown & RCV_SHUTDOWN)
1005 		return;
1006 
1007 	skb = alloc_skb(msg->length, GFP_ATOMIC | GFP_DMA);
1008 	if (!skb) {
1009 		iucv_path_sever(path, NULL);
1010 		return;
1011 	}
1012 
1013 	if (msg->flags & IPRMDATA) {
1014 		skb->data = NULL;
1015 		skb->len = 0;
1016 	} else {
1017 		rc = iucv_message_receive(path, msg, 0, skb->data,
1018 					  msg->length, NULL);
1019 		if (rc) {
1020 			kfree_skb(skb);
1021 			return;
1022 		}
1023 		if (skb->truesize >= sk->sk_rcvbuf / 4) {
1024 			rc = iucv_fragment_skb(sk, skb, msg->length,
1025 					       &fragmented_skb_q);
1026 			kfree_skb(skb);
1027 			skb = NULL;
1028 			if (rc) {
1029 				iucv_path_sever(path, NULL);
1030 				return;
1031 			}
1032 		} else {
1033 			skb_reset_transport_header(skb);
1034 			skb_reset_network_header(skb);
1035 			skb->len = msg->length;
1036 		}
1037 	}
1038 	/* Queue the fragmented skb */
1039 	fskb = skb_dequeue(&fragmented_skb_q);
1040 	while (fskb) {
1041 		if (!skb_queue_empty(&iucv->backlog_skb_q))
1042 			skb_queue_tail(&iucv->backlog_skb_q, fskb);
1043 		else if (sock_queue_rcv_skb(sk, fskb))
1044 			skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, fskb);
1045 		fskb = skb_dequeue(&fragmented_skb_q);
1046 	}
1047 
1048 	/* Queue the original skb if it exists (was not fragmented) */
1049 	if (skb) {
1050 		if (!skb_queue_empty(&iucv->backlog_skb_q))
1051 			skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1052 		else if (sock_queue_rcv_skb(sk, skb))
1053 			skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1054 	}
1055 
1056 }
1057 
1058 static void iucv_callback_txdone(struct iucv_path *path,
1059 				 struct iucv_message *msg)
1060 {
1061 	struct sock *sk = path->private;
1062 	struct sk_buff *this;
1063 	struct sk_buff_head *list = &iucv_sk(sk)->send_skb_q;
1064 	struct sk_buff *list_skb = list->next;
1065 	unsigned long flags;
1066 
1067 	if (list_skb) {
1068 		spin_lock_irqsave(&list->lock, flags);
1069 
1070 		do {
1071 			this = list_skb;
1072 			list_skb = list_skb->next;
1073 		} while (memcmp(&msg->tag, this->cb, 4) && list_skb);
1074 
1075 		spin_unlock_irqrestore(&list->lock, flags);
1076 
1077 		skb_unlink(this, &iucv_sk(sk)->send_skb_q);
1078 		kfree_skb(this);
1079 	}
1080 
1081 	if (sk->sk_state == IUCV_CLOSING) {
1082 		if (skb_queue_empty(&iucv_sk(sk)->send_skb_q)) {
1083 			sk->sk_state = IUCV_CLOSED;
1084 			sk->sk_state_change(sk);
1085 		}
1086 	}
1087 
1088 }
1089 
1090 static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
1091 {
1092 	struct sock *sk = path->private;
1093 
1094 	if (!list_empty(&iucv_sk(sk)->accept_q))
1095 		sk->sk_state = IUCV_SEVERED;
1096 	else
1097 		sk->sk_state = IUCV_DISCONN;
1098 
1099 	sk->sk_state_change(sk);
1100 }
1101 
1102 static struct proto_ops iucv_sock_ops = {
1103 	.family		= PF_IUCV,
1104 	.owner		= THIS_MODULE,
1105 	.release	= iucv_sock_release,
1106 	.bind		= iucv_sock_bind,
1107 	.connect	= iucv_sock_connect,
1108 	.listen		= iucv_sock_listen,
1109 	.accept		= iucv_sock_accept,
1110 	.getname	= iucv_sock_getname,
1111 	.sendmsg	= iucv_sock_sendmsg,
1112 	.recvmsg	= iucv_sock_recvmsg,
1113 	.poll		= iucv_sock_poll,
1114 	.ioctl		= sock_no_ioctl,
1115 	.mmap		= sock_no_mmap,
1116 	.socketpair	= sock_no_socketpair,
1117 	.shutdown	= iucv_sock_shutdown,
1118 	.setsockopt	= sock_no_setsockopt,
1119 	.getsockopt	= sock_no_getsockopt
1120 };
1121 
1122 static struct net_proto_family iucv_sock_family_ops = {
1123 	.family	= AF_IUCV,
1124 	.owner	= THIS_MODULE,
1125 	.create	= iucv_sock_create,
1126 };
1127 
1128 static int __init afiucv_init(void)
1129 {
1130 	int err;
1131 
1132 	if (!MACHINE_IS_VM) {
1133 		printk(KERN_ERR "AF_IUCV connection needs VM as base\n");
1134 		err = -EPROTONOSUPPORT;
1135 		goto out;
1136 	}
1137 	cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err);
1138 	if (unlikely(err)) {
1139 		printk(KERN_ERR "AF_IUCV needs the VM userid\n");
1140 		err = -EPROTONOSUPPORT;
1141 		goto out;
1142 	}
1143 
1144 	err = iucv_register(&af_iucv_handler, 0);
1145 	if (err)
1146 		goto out;
1147 	err = proto_register(&iucv_proto, 0);
1148 	if (err)
1149 		goto out_iucv;
1150 	err = sock_register(&iucv_sock_family_ops);
1151 	if (err)
1152 		goto out_proto;
1153 	printk(KERN_INFO "AF_IUCV lowlevel driver initialized\n");
1154 	return 0;
1155 
1156 out_proto:
1157 	proto_unregister(&iucv_proto);
1158 out_iucv:
1159 	iucv_unregister(&af_iucv_handler, 0);
1160 out:
1161 	return err;
1162 }
1163 
1164 static void __exit afiucv_exit(void)
1165 {
1166 	sock_unregister(PF_IUCV);
1167 	proto_unregister(&iucv_proto);
1168 	iucv_unregister(&af_iucv_handler, 0);
1169 
1170 	printk(KERN_INFO "AF_IUCV lowlevel driver unloaded\n");
1171 }
1172 
1173 module_init(afiucv_init);
1174 module_exit(afiucv_exit);
1175 
1176 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
1177 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION);
1178 MODULE_VERSION(VERSION);
1179 MODULE_LICENSE("GPL");
1180 MODULE_ALIAS_NETPROTO(PF_IUCV);
1181