?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
local_t: i386 extension
[linux-2.6/openmoko-kernel.git] / net / iucv / af_iucv.c
blobd9e9ddb8eac5e68a22365e7e1cc1519a8649df04
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);
Openmoko development kernel tree