1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * IUCV protocol stack for Linux on zSeries
4 *
5 * Copyright IBM Corp. 2006, 2009
6 *
7 * Author(s): Jennifer Hunt <jenhunt@us.ibm.com>
8 * Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
9 * PM functions:
10 * Ursula Braun <ursula.braun@de.ibm.com>
11 */
12
13 #define pr_fmt(fmt) "af_iucv: " fmt
14
15 #include <linux/filter.h>
16 #include <linux/module.h>
17 #include <linux/netdevice.h>
18 #include <linux/types.h>
19 #include <linux/limits.h>
20 #include <linux/list.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/sched/signal.h>
24 #include <linux/slab.h>
25 #include <linux/skbuff.h>
26 #include <linux/init.h>
27 #include <linux/poll.h>
28 #include <linux/security.h>
29 #include <linux/uio.h>
30 #include <net/sock.h>
31 #include <asm/machine.h>
32 #include <asm/ebcdic.h>
33 #include <asm/cpcmd.h>
34 #include <linux/kmod.h>
35
36 #include <net/iucv/af_iucv.h>
37
38 #define VERSION "1.2"
39
40 static char iucv_userid[80];
41
42 static struct proto iucv_proto = {
43 .name = "AF_IUCV",
44 .owner = THIS_MODULE,
45 .obj_size = sizeof(struct iucv_sock),
46 };
47
48 static struct iucv_interface *pr_iucv;
49 static struct iucv_handler af_iucv_handler;
50
51 /* special AF_IUCV IPRM messages */
52 static const u8 iprm_shutdown[8] =
53 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
54
55 #define TRGCLS_SIZE sizeof_field(struct iucv_message, class)
56
57 #define __iucv_sock_wait(sk, condition, timeo, ret) \
58 do { \
59 DEFINE_WAIT(__wait); \
60 long __timeo = timeo; \
61 ret = 0; \
62 prepare_to_wait(sk_sleep(sk), &__wait, TASK_INTERRUPTIBLE); \
63 while (!(condition)) { \
64 if (!__timeo) { \
65 ret = -EAGAIN; \
66 break; \
67 } \
68 if (signal_pending(current)) { \
69 ret = sock_intr_errno(__timeo); \
70 break; \
71 } \
72 release_sock(sk); \
73 __timeo = schedule_timeout(__timeo); \
74 lock_sock(sk); \
75 ret = sock_error(sk); \
76 if (ret) \
77 break; \
78 } \
79 finish_wait(sk_sleep(sk), &__wait); \
80 } while (0)
81
82 #define iucv_sock_wait(sk, condition, timeo) \
83 ({ \
84 int __ret = 0; \
85 if (!(condition)) \
86 __iucv_sock_wait(sk, condition, timeo, __ret); \
87 __ret; \
88 })
89
90 static struct sock *iucv_accept_dequeue(struct sock *parent,
91 struct socket *newsock);
92 static void iucv_sock_kill(struct sock *sk);
93 static void iucv_sock_close(struct sock *sk);
94
95 static void afiucv_hs_callback_txnotify(struct sock *sk, enum iucv_tx_notify);
96
97 static struct iucv_sock_list iucv_sk_list = {
98 .lock = __RW_LOCK_UNLOCKED(iucv_sk_list.lock),
99 .autobind_name = ATOMIC_INIT(0)
100 };
101
high_nmcpy(unsigned char * dst,char * src)102 static inline void high_nmcpy(unsigned char *dst, char *src)
103 {
104 memcpy(dst, src, 8);
105 }
106
low_nmcpy(unsigned char * dst,char * src)107 static inline void low_nmcpy(unsigned char *dst, char *src)
108 {
109 memcpy(&dst[8], src, 8);
110 }
111
112 /**
113 * iucv_msg_length() - Returns the length of an iucv message.
114 * @msg: Pointer to struct iucv_message, MUST NOT be NULL
115 *
116 * The function returns the length of the specified iucv message @msg of data
117 * stored in a buffer and of data stored in the parameter list (PRMDATA).
118 *
119 * For IUCV_IPRMDATA, AF_IUCV uses the following convention to transport socket
120 * data:
121 * PRMDATA[0..6] socket data (max 7 bytes);
122 * PRMDATA[7] socket data length value (len is 0xff - PRMDATA[7])
123 *
124 * The socket data length is computed by subtracting the socket data length
125 * value from 0xFF.
126 * If the socket data len is greater 7, then PRMDATA can be used for special
127 * notifications (see iucv_sock_shutdown); and further,
128 * if the socket data len is > 7, the function returns 8.
129 *
130 * Use this function to allocate socket buffers to store iucv message data.
131 *
132 * Returns: Length of the IUCV message.
133 */
iucv_msg_length(struct iucv_message * msg)134 static inline size_t iucv_msg_length(struct iucv_message *msg)
135 {
136 size_t datalen;
137
138 if (msg->flags & IUCV_IPRMDATA) {
139 datalen = 0xff - msg->rmmsg[7];
140 return (datalen < 8) ? datalen : 8;
141 }
142 return msg->length;
143 }
144
145 /**
146 * iucv_sock_in_state() - check for specific states
147 * @sk: sock structure
148 * @state: first iucv sk state
149 * @state2: second iucv sk state
150 *
151 * Returns: true if the socket is either in the first or second state.
152 */
iucv_sock_in_state(struct sock * sk,int state,int state2)153 static int iucv_sock_in_state(struct sock *sk, int state, int state2)
154 {
155 return (sk->sk_state == state || sk->sk_state == state2);
156 }
157
158 /**
159 * iucv_below_msglim() - function to check if messages can be sent
160 * @sk: sock structure
161 *
162 * Returns: true, if either the socket is not connected (no iucv path for
163 * checking the message limit) or if the send queue length is lower
164 * than the message limit.
165 */
iucv_below_msglim(struct sock * sk)166 static inline int iucv_below_msglim(struct sock *sk)
167 {
168 struct iucv_sock *iucv = iucv_sk(sk);
169
170 if (sk->sk_state != IUCV_CONNECTED)
171 return 1;
172 if (iucv->transport == AF_IUCV_TRANS_IUCV)
173 return (atomic_read(&iucv->skbs_in_xmit) < iucv->path->msglim);
174 else
175 return ((atomic_read(&iucv->msg_sent) < iucv->msglimit_peer) &&
176 (atomic_read(&iucv->pendings) <= 0));
177 }
178
179 /*
180 * iucv_sock_wake_msglim() - Wake up thread waiting on msg limit
181 */
iucv_sock_wake_msglim(struct sock * sk)182 static void iucv_sock_wake_msglim(struct sock *sk)
183 {
184 struct socket_wq *wq;
185
186 rcu_read_lock();
187 wq = rcu_dereference(sk->sk_wq);
188 if (skwq_has_sleeper(wq))
189 wake_up_interruptible_all(&wq->wait);
190 sk_wake_async_rcu(sk, SOCK_WAKE_SPACE, POLL_OUT);
191 rcu_read_unlock();
192 }
193
194 /*
195 * afiucv_hs_send() - send a message through HiperSockets transport
196 */
afiucv_hs_send(struct iucv_message * imsg,struct sock * sock,struct sk_buff * skb,u8 flags)197 static int afiucv_hs_send(struct iucv_message *imsg, struct sock *sock,
198 struct sk_buff *skb, u8 flags)
199 {
200 struct iucv_sock *iucv = iucv_sk(sock);
201 struct af_iucv_trans_hdr *phs_hdr;
202 int err, confirm_recv = 0;
203
204 phs_hdr = skb_push(skb, sizeof(*phs_hdr));
205 memset(phs_hdr, 0, sizeof(*phs_hdr));
206 skb_reset_network_header(skb);
207
208 phs_hdr->magic = ETH_P_AF_IUCV;
209 phs_hdr->version = 1;
210 phs_hdr->flags = flags;
211 if (flags == AF_IUCV_FLAG_SYN)
212 phs_hdr->window = iucv->msglimit;
213 memcpy(phs_hdr->destUserID, iucv->dst_user_id, 8);
214 memcpy(phs_hdr->destAppName, iucv->dst_name, 8);
215 memcpy(phs_hdr->srcUserID, iucv->src_user_id, 8);
216 memcpy(phs_hdr->srcAppName, iucv->src_name, 8);
217 ASCEBC(phs_hdr->destUserID, sizeof(phs_hdr->destUserID));
218 ASCEBC(phs_hdr->destAppName, sizeof(phs_hdr->destAppName));
219 ASCEBC(phs_hdr->srcUserID, sizeof(phs_hdr->srcUserID));
220 ASCEBC(phs_hdr->srcAppName, sizeof(phs_hdr->srcAppName));
221 if (imsg)
222 memcpy(&phs_hdr->iucv_hdr, imsg, sizeof(struct iucv_message));
223
224 skb->dev = iucv->hs_dev;
225 if (!skb->dev) {
226 err = -ENODEV;
227 goto err_free;
228 }
229
230 dev_hard_header(skb, skb->dev, ETH_P_AF_IUCV, NULL, NULL, skb->len);
231
232 if (!(skb->dev->flags & IFF_UP) || !netif_carrier_ok(skb->dev)) {
233 err = -ENETDOWN;
234 goto err_free;
235 }
236 if (skb->len > skb->dev->mtu) {
237 if (sock->sk_type == SOCK_SEQPACKET) {
238 err = -EMSGSIZE;
239 goto err_free;
240 }
241 err = pskb_trim(skb, skb->dev->mtu);
242 if (err)
243 goto err_free;
244 }
245 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
246
247 /* Claim the receive credit here, not while building the header: every
248 * way this frame can be dropped has now been ruled out, so the window
249 * is zeroed only for as long as the transmit itself takes.
250 */
251 if (flags == AF_IUCV_FLAG_WIN || !flags) {
252 confirm_recv = atomic_xchg(&iucv->msg_recv, 0);
253 phs_hdr->window = confirm_recv;
254 if (confirm_recv)
255 phs_hdr->flags = phs_hdr->flags | AF_IUCV_FLAG_WIN;
256 }
257
258 atomic_inc(&iucv->skbs_in_xmit);
259 err = dev_queue_xmit(skb);
260 if (net_xmit_eval(err)) {
261 atomic_dec(&iucv->skbs_in_xmit);
262 atomic_add(confirm_recv, &iucv->msg_recv);
263 }
264 return net_xmit_eval(err);
265
266 err_free:
267 kfree_skb(skb);
268 return err;
269 }
270
__iucv_get_sock_by_name(char * nm)271 static struct sock *__iucv_get_sock_by_name(char *nm)
272 {
273 struct sock *sk;
274
275 sk_for_each(sk, &iucv_sk_list.head)
276 if (!memcmp(&iucv_sk(sk)->src_name, nm, 8))
277 return sk;
278
279 return NULL;
280 }
281
iucv_sock_destruct(struct sock * sk)282 static void iucv_sock_destruct(struct sock *sk)
283 {
284 skb_queue_purge(&sk->sk_receive_queue);
285 skb_queue_purge(&sk->sk_error_queue);
286
287 if (!sock_flag(sk, SOCK_DEAD)) {
288 pr_err("Attempt to release alive iucv socket %p\n", sk);
289 return;
290 }
291
292 WARN_ON(atomic_read(&sk->sk_rmem_alloc));
293 WARN_ON(refcount_read(&sk->sk_wmem_alloc));
294 WARN_ON(sk->sk_wmem_queued);
295 WARN_ON(sk->sk_forward_alloc);
296 }
297
298 /* Cleanup Listen */
iucv_sock_cleanup_listen(struct sock * parent)299 static void iucv_sock_cleanup_listen(struct sock *parent)
300 {
301 struct sock *sk;
302
303 /* Close non-accepted connections */
304 while ((sk = iucv_accept_dequeue(parent, NULL))) {
305 iucv_sock_close(sk);
306 iucv_sock_kill(sk);
307 }
308
309 parent->sk_state = IUCV_CLOSED;
310 }
311
iucv_sock_link(struct iucv_sock_list * l,struct sock * sk)312 static void iucv_sock_link(struct iucv_sock_list *l, struct sock *sk)
313 {
314 write_lock_bh(&l->lock);
315 sk_add_node(sk, &l->head);
316 write_unlock_bh(&l->lock);
317 }
318
iucv_sock_unlink(struct iucv_sock_list * l,struct sock * sk)319 static void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *sk)
320 {
321 write_lock_bh(&l->lock);
322 sk_del_node_init(sk);
323 write_unlock_bh(&l->lock);
324 }
325
326 /* Kill socket (only if zapped and orphaned) */
iucv_sock_kill(struct sock * sk)327 static void iucv_sock_kill(struct sock *sk)
328 {
329 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
330 return;
331
332 iucv_sock_unlink(&iucv_sk_list, sk);
333 sock_set_flag(sk, SOCK_DEAD);
334 sock_put(sk);
335 }
336
337 /* Terminate an IUCV path */
iucv_sever_path(struct sock * sk,int with_user_data)338 static void iucv_sever_path(struct sock *sk, int with_user_data)
339 {
340 unsigned char user_data[16];
341 struct iucv_sock *iucv = iucv_sk(sk);
342 struct iucv_path *path = iucv->path;
343 struct sock_msg_q *p, *n;
344
345 /* Whoever resets the path pointer, must sever and free it. */
346 if (xchg(&iucv->path, NULL)) {
347 if (with_user_data) {
348 low_nmcpy(user_data, iucv->src_name);
349 high_nmcpy(user_data, iucv->dst_name);
350 ASCEBC(user_data, sizeof(user_data));
351 pr_iucv->path_sever(path, user_data);
352 } else
353 pr_iucv->path_sever(path, NULL);
354 iucv_path_free(path);
355
356 /*
357 * Message notifications queued on message_q still reference
358 * the now freed path; drop them, otherwise a later recvmsg()
359 * would pass the freed iucv_path to message_receive() via
360 * iucv_process_message_q().
361 */
362 spin_lock_bh(&iucv->message_q.lock);
363 list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
364 list_del(&p->list);
365 kfree(p);
366 }
367 spin_unlock_bh(&iucv->message_q.lock);
368 }
369 }
370
371 /* Send controlling flags through an IUCV socket for HIPER transport */
iucv_send_ctrl(struct sock * sk,u8 flags)372 static int iucv_send_ctrl(struct sock *sk, u8 flags)
373 {
374 struct iucv_sock *iucv = iucv_sk(sk);
375 int err = 0;
376 int blen;
377 struct sk_buff *skb;
378 u8 shutdown = 0;
379
380 blen = sizeof(struct af_iucv_trans_hdr) +
381 LL_RESERVED_SPACE(iucv->hs_dev);
382 if (sk->sk_shutdown & SEND_SHUTDOWN) {
383 /* controlling flags should be sent anyway */
384 shutdown = sk->sk_shutdown;
385 sk->sk_shutdown &= RCV_SHUTDOWN;
386 }
387 skb = sock_alloc_send_skb(sk, blen, 1, &err);
388 if (skb) {
389 skb_reserve(skb, blen);
390 err = afiucv_hs_send(NULL, sk, skb, flags);
391 }
392 if (shutdown)
393 sk->sk_shutdown = shutdown;
394 return err;
395 }
396
397 /* Close an IUCV socket */
iucv_sock_close(struct sock * sk)398 static void iucv_sock_close(struct sock *sk)
399 {
400 struct iucv_sock *iucv = iucv_sk(sk);
401 unsigned long timeo;
402 int err = 0;
403
404 lock_sock(sk);
405
406 switch (sk->sk_state) {
407 case IUCV_LISTEN:
408 iucv_sock_cleanup_listen(sk);
409 break;
410
411 case IUCV_CONNECTED:
412 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
413 err = iucv_send_ctrl(sk, AF_IUCV_FLAG_FIN);
414 sk->sk_state = IUCV_DISCONN;
415 sk->sk_state_change(sk);
416 }
417 fallthrough;
418
419 case IUCV_DISCONN:
420 sk->sk_state = IUCV_CLOSING;
421 sk->sk_state_change(sk);
422
423 if (!err && atomic_read(&iucv->skbs_in_xmit) > 0) {
424 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
425 timeo = sk->sk_lingertime;
426 else
427 timeo = IUCV_DISCONN_TIMEOUT;
428 iucv_sock_wait(sk,
429 iucv_sock_in_state(sk, IUCV_CLOSED, 0),
430 timeo);
431 }
432 fallthrough;
433
434 case IUCV_CLOSING:
435 sk->sk_state = IUCV_CLOSED;
436 sk->sk_state_change(sk);
437
438 sk->sk_err = ECONNRESET;
439 sk->sk_state_change(sk);
440
441 skb_queue_purge(&iucv->send_skb_q);
442 skb_queue_purge(&iucv->backlog_skb_q);
443 fallthrough;
444
445 default:
446 iucv_sever_path(sk, 1);
447 }
448
449 if (iucv->hs_dev) {
450 dev_put(iucv->hs_dev);
451 iucv->hs_dev = NULL;
452 sk->sk_bound_dev_if = 0;
453 }
454
455 /* mark socket for deletion by iucv_sock_kill() */
456 sock_set_flag(sk, SOCK_ZAPPED);
457
458 release_sock(sk);
459 }
460
iucv_sock_init(struct sock * sk,struct sock * parent)461 static void iucv_sock_init(struct sock *sk, struct sock *parent)
462 {
463 if (parent) {
464 sk->sk_type = parent->sk_type;
465 security_sk_clone(parent, sk);
466 }
467 }
468
iucv_sock_alloc(struct socket * sock,int proto,gfp_t prio,int kern)469 static struct sock *iucv_sock_alloc(struct socket *sock, int proto, gfp_t prio, int kern)
470 {
471 struct sock *sk;
472 struct iucv_sock *iucv;
473
474 sk = sk_alloc(&init_net, PF_IUCV, prio, &iucv_proto, kern);
475 if (!sk)
476 return NULL;
477 iucv = iucv_sk(sk);
478
479 sock_init_data(sock, sk);
480 INIT_LIST_HEAD(&iucv->accept_q);
481 spin_lock_init(&iucv->accept_q_lock);
482 skb_queue_head_init(&iucv->send_skb_q);
483 INIT_LIST_HEAD(&iucv->message_q.list);
484 spin_lock_init(&iucv->message_q.lock);
485 skb_queue_head_init(&iucv->backlog_skb_q);
486 iucv->send_tag = 0;
487 atomic_set(&iucv->pendings, 0);
488 iucv->flags = 0;
489 iucv->msglimit = 0;
490 atomic_set(&iucv->skbs_in_xmit, 0);
491 atomic_set(&iucv->msg_sent, 0);
492 atomic_set(&iucv->msg_recv, 0);
493 iucv->path = NULL;
494 iucv->sk_txnotify = afiucv_hs_callback_txnotify;
495 memset(&iucv->init, 0, sizeof(iucv->init));
496 if (pr_iucv)
497 iucv->transport = AF_IUCV_TRANS_IUCV;
498 else
499 iucv->transport = AF_IUCV_TRANS_HIPER;
500
501 sk->sk_destruct = iucv_sock_destruct;
502 sk->sk_sndtimeo = IUCV_CONN_TIMEOUT;
503
504 sock_reset_flag(sk, SOCK_ZAPPED);
505
506 sk->sk_protocol = proto;
507 sk->sk_state = IUCV_OPEN;
508
509 iucv_sock_link(&iucv_sk_list, sk);
510 return sk;
511 }
512
iucv_accept_enqueue(struct sock * parent,struct sock * sk)513 static void iucv_accept_enqueue(struct sock *parent, struct sock *sk)
514 {
515 unsigned long flags;
516 struct iucv_sock *par = iucv_sk(parent);
517
518 sock_hold(sk);
519 spin_lock_irqsave(&par->accept_q_lock, flags);
520 list_add_tail(&iucv_sk(sk)->accept_q, &par->accept_q);
521 spin_unlock_irqrestore(&par->accept_q_lock, flags);
522 iucv_sk(sk)->parent = parent;
523 sk_acceptq_added(parent);
524 }
525
iucv_accept_unlink(struct sock * sk)526 static void iucv_accept_unlink(struct sock *sk)
527 {
528 unsigned long flags;
529 struct iucv_sock *par = iucv_sk(iucv_sk(sk)->parent);
530
531 spin_lock_irqsave(&par->accept_q_lock, flags);
532 list_del_init(&iucv_sk(sk)->accept_q);
533 spin_unlock_irqrestore(&par->accept_q_lock, flags);
534 sk_acceptq_removed(iucv_sk(sk)->parent);
535 iucv_sk(sk)->parent = NULL;
536 sock_put(sk);
537 }
538
iucv_accept_dequeue(struct sock * parent,struct socket * newsock)539 static struct sock *iucv_accept_dequeue(struct sock *parent,
540 struct socket *newsock)
541 {
542 struct iucv_sock *isk, *n;
543 struct sock *sk;
544
545 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
546 sk = (struct sock *) isk;
547 lock_sock(sk);
548
549 if (sk->sk_state == IUCV_CLOSED) {
550 iucv_accept_unlink(sk);
551 release_sock(sk);
552 continue;
553 }
554
555 if (sk->sk_state == IUCV_CONNECTED ||
556 sk->sk_state == IUCV_DISCONN ||
557 !newsock) {
558 iucv_accept_unlink(sk);
559 if (newsock)
560 sock_graft(sk, newsock);
561
562 release_sock(sk);
563 return sk;
564 }
565
566 release_sock(sk);
567 }
568 return NULL;
569 }
570
__iucv_auto_name(struct iucv_sock * iucv)571 static void __iucv_auto_name(struct iucv_sock *iucv)
572 {
573 char name[12];
574
575 scnprintf(name, sizeof(name),
576 "%08x", atomic_inc_return(&iucv_sk_list.autobind_name));
577 while (__iucv_get_sock_by_name(name)) {
578 scnprintf(name, sizeof(name), "%08x",
579 atomic_inc_return(&iucv_sk_list.autobind_name));
580 }
581 memcpy(iucv->src_name, name, 8);
582 }
583
584 /* Bind an unbound socket */
iucv_sock_bind(struct socket * sock,struct sockaddr_unsized * addr,int addr_len)585 static int iucv_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
586 int addr_len)
587 {
588 DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
589 char uid[sizeof(sa->siucv_user_id)];
590 struct sock *sk = sock->sk;
591 struct iucv_sock *iucv;
592 int err = 0;
593 struct net_device *dev;
594
595 /* Verify the input sockaddr */
596 if (addr_len < sizeof(struct sockaddr_iucv) ||
597 addr->sa_family != AF_IUCV)
598 return -EINVAL;
599
600 lock_sock(sk);
601 if (sk->sk_state != IUCV_OPEN) {
602 err = -EBADFD;
603 goto done;
604 }
605
606 write_lock_bh(&iucv_sk_list.lock);
607
608 iucv = iucv_sk(sk);
609 if (__iucv_get_sock_by_name(sa->siucv_name)) {
610 err = -EADDRINUSE;
611 goto done_unlock;
612 }
613 if (iucv->path)
614 goto done_unlock;
615
616 /* Bind the socket */
617 if (pr_iucv)
618 if (!memcmp(sa->siucv_user_id, iucv_userid, 8))
619 goto vm_bind; /* VM IUCV transport */
620
621 /* try hiper transport */
622 memcpy(uid, sa->siucv_user_id, sizeof(uid));
623 ASCEBC(uid, 8);
624 rcu_read_lock();
625 for_each_netdev_rcu(&init_net, dev) {
626 if (!memcmp(dev->perm_addr, uid, 8)) {
627 memcpy(iucv->src_user_id, sa->siucv_user_id, 8);
628 /* Check for uninitialized siucv_name */
629 if (strncmp(sa->siucv_name, " ", 8) == 0)
630 __iucv_auto_name(iucv);
631 else
632 memcpy(iucv->src_name, sa->siucv_name, 8);
633 sk->sk_bound_dev_if = dev->ifindex;
634 iucv->hs_dev = dev;
635 dev_hold(dev);
636 sk->sk_state = IUCV_BOUND;
637 iucv->transport = AF_IUCV_TRANS_HIPER;
638 if (!iucv->msglimit)
639 iucv->msglimit = IUCV_HIPER_MSGLIM_DEFAULT;
640 rcu_read_unlock();
641 goto done_unlock;
642 }
643 }
644 rcu_read_unlock();
645 vm_bind:
646 if (pr_iucv) {
647 /* use local userid for backward compat */
648 memcpy(iucv->src_name, sa->siucv_name, 8);
649 memcpy(iucv->src_user_id, iucv_userid, 8);
650 sk->sk_state = IUCV_BOUND;
651 iucv->transport = AF_IUCV_TRANS_IUCV;
652 sk->sk_allocation |= GFP_DMA;
653 if (!iucv->msglimit)
654 iucv->msglimit = IUCV_QUEUELEN_DEFAULT;
655 goto done_unlock;
656 }
657 /* found no dev to bind */
658 err = -ENODEV;
659 done_unlock:
660 /* Release the socket list lock */
661 write_unlock_bh(&iucv_sk_list.lock);
662 done:
663 release_sock(sk);
664 return err;
665 }
666
667 /* Automatically bind an unbound socket */
iucv_sock_autobind(struct sock * sk)668 static int iucv_sock_autobind(struct sock *sk)
669 {
670 struct iucv_sock *iucv = iucv_sk(sk);
671 int err = 0;
672
673 if (unlikely(!pr_iucv))
674 return -EPROTO;
675
676 memcpy(iucv->src_user_id, iucv_userid, 8);
677 iucv->transport = AF_IUCV_TRANS_IUCV;
678 sk->sk_allocation |= GFP_DMA;
679
680 write_lock_bh(&iucv_sk_list.lock);
681 __iucv_auto_name(iucv);
682 write_unlock_bh(&iucv_sk_list.lock);
683
684 if (!iucv->msglimit)
685 iucv->msglimit = IUCV_QUEUELEN_DEFAULT;
686
687 return err;
688 }
689
afiucv_path_connect(struct socket * sock,struct sockaddr_unsized * addr)690 static int afiucv_path_connect(struct socket *sock, struct sockaddr_unsized *addr)
691 {
692 DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
693 struct sock *sk = sock->sk;
694 struct iucv_sock *iucv = iucv_sk(sk);
695 unsigned char user_data[16];
696 int err;
697
698 high_nmcpy(user_data, sa->siucv_name);
699 low_nmcpy(user_data, iucv->src_name);
700 ASCEBC(user_data, sizeof(user_data));
701
702 /* Create path. */
703 iucv->path = iucv_path_alloc(iucv->msglimit,
704 IUCV_IPRMDATA, GFP_KERNEL);
705 if (!iucv->path) {
706 err = -ENOMEM;
707 goto done;
708 }
709 err = pr_iucv->path_connect(iucv->path, &af_iucv_handler,
710 sa->siucv_user_id, NULL, user_data,
711 sk);
712 if (err) {
713 iucv_path_free(iucv->path);
714 iucv->path = NULL;
715 switch (err) {
716 case 0x0b: /* Target communicator is not logged on */
717 err = -ENETUNREACH;
718 break;
719 case 0x0d: /* Max connections for this guest exceeded */
720 case 0x0e: /* Max connections for target guest exceeded */
721 err = -EAGAIN;
722 break;
723 case 0x0f: /* Missing IUCV authorization */
724 err = -EACCES;
725 break;
726 default:
727 err = -ECONNREFUSED;
728 break;
729 }
730 }
731 done:
732 return err;
733 }
734
735 /* Connect an unconnected socket */
iucv_sock_connect(struct socket * sock,struct sockaddr_unsized * addr,int alen,int flags)736 static int iucv_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
737 int alen, int flags)
738 {
739 DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
740 struct sock *sk = sock->sk;
741 struct iucv_sock *iucv = iucv_sk(sk);
742 int err;
743
744 if (alen < sizeof(struct sockaddr_iucv) || addr->sa_family != AF_IUCV)
745 return -EINVAL;
746
747 if (sk->sk_state != IUCV_OPEN && sk->sk_state != IUCV_BOUND)
748 return -EBADFD;
749
750 if (sk->sk_state == IUCV_OPEN &&
751 iucv->transport == AF_IUCV_TRANS_HIPER)
752 return -EBADFD; /* explicit bind required */
753
754 if (sk->sk_type != SOCK_STREAM && sk->sk_type != SOCK_SEQPACKET)
755 return -EINVAL;
756
757 if (sk->sk_state == IUCV_OPEN) {
758 err = iucv_sock_autobind(sk);
759 if (unlikely(err))
760 return err;
761 }
762
763 lock_sock(sk);
764
765 /* Set the destination information */
766 memcpy(iucv->dst_user_id, sa->siucv_user_id, 8);
767 memcpy(iucv->dst_name, sa->siucv_name, 8);
768
769 if (iucv->transport == AF_IUCV_TRANS_HIPER)
770 err = iucv_send_ctrl(sock->sk, AF_IUCV_FLAG_SYN);
771 else
772 err = afiucv_path_connect(sock, addr);
773 if (err)
774 goto done;
775
776 if (sk->sk_state != IUCV_CONNECTED)
777 err = iucv_sock_wait(sk, iucv_sock_in_state(sk, IUCV_CONNECTED,
778 IUCV_DISCONN),
779 sock_sndtimeo(sk, flags & O_NONBLOCK));
780
781 if (sk->sk_state == IUCV_DISCONN || sk->sk_state == IUCV_CLOSED)
782 err = -ECONNREFUSED;
783
784 if (err && iucv->transport == AF_IUCV_TRANS_IUCV)
785 iucv_sever_path(sk, 0);
786
787 done:
788 release_sock(sk);
789 return err;
790 }
791
792 /* Move a socket into listening state. */
iucv_sock_listen(struct socket * sock,int backlog)793 static int iucv_sock_listen(struct socket *sock, int backlog)
794 {
795 struct sock *sk = sock->sk;
796 int err;
797
798 lock_sock(sk);
799
800 err = -EINVAL;
801 if (sk->sk_state != IUCV_BOUND)
802 goto done;
803
804 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
805 goto done;
806
807 sk->sk_max_ack_backlog = backlog;
808 sk->sk_ack_backlog = 0;
809 sk->sk_state = IUCV_LISTEN;
810 err = 0;
811
812 done:
813 release_sock(sk);
814 return err;
815 }
816
817 /* Accept a pending connection */
iucv_sock_accept(struct socket * sock,struct socket * newsock,struct proto_accept_arg * arg)818 static int iucv_sock_accept(struct socket *sock, struct socket *newsock,
819 struct proto_accept_arg *arg)
820 {
821 DECLARE_WAITQUEUE(wait, current);
822 struct sock *sk = sock->sk, *nsk;
823 long timeo;
824 int err = 0;
825
826 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
827
828 if (sk->sk_state != IUCV_LISTEN) {
829 err = -EBADFD;
830 goto done;
831 }
832
833 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
834
835 /* Wait for an incoming connection */
836 add_wait_queue_exclusive(sk_sleep(sk), &wait);
837 while (!(nsk = iucv_accept_dequeue(sk, newsock))) {
838 set_current_state(TASK_INTERRUPTIBLE);
839 if (!timeo) {
840 err = -EAGAIN;
841 break;
842 }
843
844 release_sock(sk);
845 timeo = schedule_timeout(timeo);
846 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
847
848 if (sk->sk_state != IUCV_LISTEN) {
849 err = -EBADFD;
850 break;
851 }
852
853 if (signal_pending(current)) {
854 err = sock_intr_errno(timeo);
855 break;
856 }
857 }
858
859 set_current_state(TASK_RUNNING);
860 remove_wait_queue(sk_sleep(sk), &wait);
861
862 if (err)
863 goto done;
864
865 newsock->state = SS_CONNECTED;
866
867 done:
868 release_sock(sk);
869 return err;
870 }
871
iucv_sock_getname(struct socket * sock,struct sockaddr * addr,int peer)872 static int iucv_sock_getname(struct socket *sock, struct sockaddr *addr,
873 int peer)
874 {
875 DECLARE_SOCKADDR(struct sockaddr_iucv *, siucv, addr);
876 struct sock *sk = sock->sk;
877 struct iucv_sock *iucv = iucv_sk(sk);
878
879 addr->sa_family = AF_IUCV;
880
881 if (peer) {
882 memcpy(siucv->siucv_user_id, iucv->dst_user_id, 8);
883 memcpy(siucv->siucv_name, iucv->dst_name, 8);
884 } else {
885 memcpy(siucv->siucv_user_id, iucv->src_user_id, 8);
886 memcpy(siucv->siucv_name, iucv->src_name, 8);
887 }
888 memset(&siucv->siucv_port, 0, sizeof(siucv->siucv_port));
889 memset(&siucv->siucv_addr, 0, sizeof(siucv->siucv_addr));
890 memset(&siucv->siucv_nodeid, 0, sizeof(siucv->siucv_nodeid));
891
892 return sizeof(struct sockaddr_iucv);
893 }
894
895 /**
896 * iucv_send_iprm() - Send socket data in parameter list of an iucv message.
897 * @path: IUCV path
898 * @msg: Pointer to a struct iucv_message
899 * @skb: The socket data to send, skb->len MUST BE <= 7
900 *
901 * Send the socket data in the parameter list in the iucv message
902 * (IUCV_IPRMDATA). The socket data is stored at index 0 to 6 in the parameter
903 * list and the socket data len at index 7 (last byte).
904 * See also iucv_msg_length().
905 *
906 * Returns: the return code from the iucv_message_send() call.
907 */
iucv_send_iprm(struct iucv_path * path,struct iucv_message * msg,struct sk_buff * skb)908 static int iucv_send_iprm(struct iucv_path *path, struct iucv_message *msg,
909 struct sk_buff *skb)
910 {
911 u8 prmdata[8];
912
913 memcpy(prmdata, (void *) skb->data, skb->len);
914 prmdata[7] = 0xff - (u8) skb->len;
915 return pr_iucv->message_send(path, msg, IUCV_IPRMDATA, 0,
916 (void *) prmdata, 8);
917 }
918
iucv_sock_sendmsg(struct socket * sock,struct msghdr * msg,size_t len)919 static int iucv_sock_sendmsg(struct socket *sock, struct msghdr *msg,
920 size_t len)
921 {
922 struct sock *sk = sock->sk;
923 struct iucv_sock *iucv = iucv_sk(sk);
924 size_t headroom = 0;
925 size_t linear;
926 struct sk_buff *skb;
927 struct iucv_message txmsg = {0};
928 struct cmsghdr *cmsg;
929 int cmsg_done;
930 long timeo;
931 char user_id[9];
932 char appl_id[9];
933 int err;
934 int noblock = msg->msg_flags & MSG_DONTWAIT;
935
936 err = sock_error(sk);
937 if (err)
938 return err;
939
940 if (msg->msg_flags & MSG_OOB)
941 return -EOPNOTSUPP;
942
943 /* SOCK_SEQPACKET: we do not support segmented records */
944 if (sk->sk_type == SOCK_SEQPACKET && !(msg->msg_flags & MSG_EOR))
945 return -EOPNOTSUPP;
946
947 lock_sock(sk);
948
949 if (sk->sk_shutdown & SEND_SHUTDOWN) {
950 err = -EPIPE;
951 goto out;
952 }
953
954 /* Return if the socket is not in connected state */
955 if (sk->sk_state != IUCV_CONNECTED) {
956 err = -ENOTCONN;
957 goto out;
958 }
959
960 /* initialize defaults */
961 cmsg_done = 0; /* check for duplicate headers */
962
963 /* iterate over control messages */
964 for_each_cmsghdr(cmsg, msg) {
965 if (!CMSG_OK(msg, cmsg)) {
966 err = -EINVAL;
967 goto out;
968 }
969
970 if (cmsg->cmsg_level != SOL_IUCV)
971 continue;
972
973 if (cmsg->cmsg_type & cmsg_done) {
974 err = -EINVAL;
975 goto out;
976 }
977 cmsg_done |= cmsg->cmsg_type;
978
979 switch (cmsg->cmsg_type) {
980 case SCM_IUCV_TRGCLS:
981 if (cmsg->cmsg_len != CMSG_LEN(TRGCLS_SIZE)) {
982 err = -EINVAL;
983 goto out;
984 }
985
986 /* set iucv message target class */
987 memcpy(&txmsg.class,
988 (void *) CMSG_DATA(cmsg), TRGCLS_SIZE);
989
990 break;
991
992 default:
993 err = -EINVAL;
994 goto out;
995 }
996 }
997
998 /* allocate one skb for each iucv message:
999 * this is fine for SOCK_SEQPACKET (unless we want to support
1000 * segmented records using the MSG_EOR flag), but
1001 * for SOCK_STREAM we might want to improve it in future */
1002 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1003 headroom = sizeof(struct af_iucv_trans_hdr) +
1004 LL_RESERVED_SPACE(iucv->hs_dev);
1005 linear = min(len, PAGE_SIZE - headroom);
1006 } else {
1007 if (len < PAGE_SIZE) {
1008 linear = len;
1009 } else {
1010 /* In nonlinear "classic" iucv skb,
1011 * reserve space for iucv_array
1012 */
1013 headroom = sizeof(struct iucv_array) *
1014 (MAX_SKB_FRAGS + 1);
1015 linear = PAGE_SIZE - headroom;
1016 }
1017 }
1018 skb = sock_alloc_send_pskb(sk, headroom + linear, len - linear,
1019 noblock, &err, 0);
1020 if (!skb)
1021 goto out;
1022 if (headroom)
1023 skb_reserve(skb, headroom);
1024 skb_put(skb, linear);
1025 skb->len = len;
1026 skb->data_len = len - linear;
1027 err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1028 if (err)
1029 goto fail;
1030
1031 /* wait if outstanding messages for iucv path has reached */
1032 timeo = sock_sndtimeo(sk, noblock);
1033 err = iucv_sock_wait(sk, iucv_below_msglim(sk), timeo);
1034 if (err)
1035 goto fail;
1036
1037 /* return -ECONNRESET if the socket is no longer connected */
1038 if (sk->sk_state != IUCV_CONNECTED) {
1039 err = -ECONNRESET;
1040 goto fail;
1041 }
1042
1043 /* increment and save iucv message tag for msg_completion cbk */
1044 txmsg.tag = iucv->send_tag++;
1045 IUCV_SKB_CB(skb)->tag = txmsg.tag;
1046
1047 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1048 atomic_inc(&iucv->msg_sent);
1049 err = afiucv_hs_send(&txmsg, sk, skb, 0);
1050 if (err) {
1051 atomic_dec(&iucv->msg_sent);
1052 goto out;
1053 }
1054 } else { /* Classic VM IUCV transport */
1055 skb_queue_tail(&iucv->send_skb_q, skb);
1056 atomic_inc(&iucv->skbs_in_xmit);
1057
1058 if (((iucv->path->flags & IUCV_IPRMDATA) & iucv->flags) &&
1059 skb->len <= 7) {
1060 err = iucv_send_iprm(iucv->path, &txmsg, skb);
1061
1062 /* on success: there is no message_complete callback */
1063 /* for an IPRMDATA msg; remove skb from send queue */
1064 if (err == 0) {
1065 atomic_dec(&iucv->skbs_in_xmit);
1066 skb_unlink(skb, &iucv->send_skb_q);
1067 consume_skb(skb);
1068 }
1069
1070 /* this error should never happen since the */
1071 /* IUCV_IPRMDATA path flag is set... sever path */
1072 if (err == 0x15) {
1073 pr_iucv->path_sever(iucv->path, NULL);
1074 atomic_dec(&iucv->skbs_in_xmit);
1075 skb_unlink(skb, &iucv->send_skb_q);
1076 err = -EPIPE;
1077 goto fail;
1078 }
1079 } else if (skb_is_nonlinear(skb)) {
1080 struct iucv_array *iba = (struct iucv_array *)skb->head;
1081 int i;
1082
1083 /* skip iucv_array lying in the headroom */
1084 iba[0].address = virt_to_dma32(skb->data);
1085 iba[0].length = (u32)skb_headlen(skb);
1086 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1087 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1088
1089 iba[i + 1].address = virt_to_dma32(skb_frag_address(frag));
1090 iba[i + 1].length = (u32)skb_frag_size(frag);
1091 }
1092 err = pr_iucv->message_send(iucv->path, &txmsg,
1093 IUCV_IPBUFLST, 0,
1094 (void *)iba, skb->len);
1095 } else { /* non-IPRM Linear skb */
1096 err = pr_iucv->message_send(iucv->path, &txmsg,
1097 0, 0, (void *)skb->data, skb->len);
1098 }
1099 if (err) {
1100 if (err == 3) {
1101 user_id[8] = 0;
1102 memcpy(user_id, iucv->dst_user_id, 8);
1103 appl_id[8] = 0;
1104 memcpy(appl_id, iucv->dst_name, 8);
1105 pr_err(
1106 "Application %s on z/VM guest %s exceeds message limit\n",
1107 appl_id, user_id);
1108 err = -EAGAIN;
1109 } else {
1110 err = -EPIPE;
1111 }
1112
1113 atomic_dec(&iucv->skbs_in_xmit);
1114 skb_unlink(skb, &iucv->send_skb_q);
1115 goto fail;
1116 }
1117 }
1118
1119 release_sock(sk);
1120 return len;
1121
1122 fail:
1123 kfree_skb(skb);
1124 out:
1125 release_sock(sk);
1126 return err;
1127 }
1128
alloc_iucv_recv_skb(unsigned long len)1129 static struct sk_buff *alloc_iucv_recv_skb(unsigned long len)
1130 {
1131 size_t headroom, linear;
1132 struct sk_buff *skb;
1133 int err;
1134
1135 if (len < PAGE_SIZE) {
1136 headroom = 0;
1137 linear = len;
1138 } else {
1139 headroom = sizeof(struct iucv_array) * (MAX_SKB_FRAGS + 1);
1140 linear = PAGE_SIZE - headroom;
1141 }
1142 skb = alloc_skb_with_frags(headroom + linear, len - linear,
1143 0, &err, GFP_ATOMIC | GFP_DMA);
1144 WARN_ONCE(!skb,
1145 "alloc of recv iucv skb len=%lu failed with errcode=%d\n",
1146 len, err);
1147 if (skb) {
1148 if (headroom)
1149 skb_reserve(skb, headroom);
1150 skb_put(skb, linear);
1151 skb->len = len;
1152 skb->data_len = len - linear;
1153 }
1154 return skb;
1155 }
1156
1157 /* iucv_process_message() - Receive a single outstanding IUCV message
1158 *
1159 * Locking: must be called with message_q.lock held
1160 */
iucv_process_message(struct sock * sk,struct sk_buff * skb,struct iucv_path * path,struct iucv_message * msg)1161 static void iucv_process_message(struct sock *sk, struct sk_buff *skb,
1162 struct iucv_path *path,
1163 struct iucv_message *msg)
1164 {
1165 int rc;
1166 unsigned int len;
1167
1168 len = iucv_msg_length(msg);
1169
1170 /* store msg target class in the second 4 bytes of skb ctrl buffer */
1171 /* Note: the first 4 bytes are reserved for msg tag */
1172 IUCV_SKB_CB(skb)->class = msg->class;
1173
1174 /* check for special IPRM messages (e.g. iucv_sock_shutdown) */
1175 if ((msg->flags & IUCV_IPRMDATA) && len > 7) {
1176 if (memcmp(msg->rmmsg, iprm_shutdown, 8) == 0) {
1177 skb->data = NULL;
1178 skb->len = 0;
1179 }
1180 } else {
1181 if (skb_is_nonlinear(skb)) {
1182 struct iucv_array *iba = (struct iucv_array *)skb->head;
1183 int i;
1184
1185 iba[0].address = virt_to_dma32(skb->data);
1186 iba[0].length = (u32)skb_headlen(skb);
1187 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1188 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1189
1190 iba[i + 1].address = virt_to_dma32(skb_frag_address(frag));
1191 iba[i + 1].length = (u32)skb_frag_size(frag);
1192 }
1193 rc = pr_iucv->message_receive(path, msg,
1194 IUCV_IPBUFLST,
1195 (void *)iba, len, NULL);
1196 } else {
1197 rc = pr_iucv->message_receive(path, msg,
1198 msg->flags & IUCV_IPRMDATA,
1199 skb->data, len, NULL);
1200 }
1201 if (rc) {
1202 kfree_skb(skb);
1203 return;
1204 }
1205 WARN_ON_ONCE(skb->len != len);
1206 }
1207
1208 IUCV_SKB_CB(skb)->offset = 0;
1209 if (sk_filter(sk, skb)) {
1210 sk_drops_inc(sk); /* skb rejected by filter */
1211 kfree_skb(skb);
1212 return;
1213 }
1214 if (__sock_queue_rcv_skb(sk, skb)) /* handle rcv queue full */
1215 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
1216 }
1217
1218 /* iucv_process_message_q() - Process outstanding IUCV messages
1219 *
1220 * Locking: must be called with message_q.lock held
1221 */
iucv_process_message_q(struct sock * sk)1222 static void iucv_process_message_q(struct sock *sk)
1223 {
1224 struct iucv_sock *iucv = iucv_sk(sk);
1225 struct sk_buff *skb;
1226 struct sock_msg_q *p, *n;
1227
1228 list_for_each_entry_safe(p, n, &iucv->message_q.list, list) {
1229 skb = alloc_iucv_recv_skb(iucv_msg_length(&p->msg));
1230 if (!skb)
1231 break;
1232 iucv_process_message(sk, skb, p->path, &p->msg);
1233 list_del(&p->list);
1234 kfree(p);
1235 if (!skb_queue_empty(&iucv->backlog_skb_q))
1236 break;
1237 }
1238 }
1239
iucv_sock_recvmsg(struct socket * sock,struct msghdr * msg,size_t len,int flags)1240 static int iucv_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1241 size_t len, int flags)
1242 {
1243 struct sock *sk = sock->sk;
1244 struct iucv_sock *iucv = iucv_sk(sk);
1245 unsigned int copied, rlen;
1246 struct sk_buff *skb, *rskb, *cskb;
1247 bool send_win = false;
1248 int err = 0;
1249 u32 offset;
1250
1251 if ((sk->sk_state == IUCV_DISCONN) &&
1252 skb_queue_empty(&iucv->backlog_skb_q) &&
1253 skb_queue_empty(&sk->sk_receive_queue) &&
1254 list_empty(&iucv->message_q.list))
1255 return 0;
1256
1257 if (flags & (MSG_OOB))
1258 return -EOPNOTSUPP;
1259
1260 /* receive/dequeue next skb:
1261 * the function understands MSG_PEEK and, thus, does not dequeue skb
1262 * only refcount is increased.
1263 */
1264 skb = skb_recv_datagram(sk, flags, &err);
1265 if (!skb) {
1266 if (sk->sk_shutdown & RCV_SHUTDOWN)
1267 return 0;
1268 return err;
1269 }
1270
1271 offset = IUCV_SKB_CB(skb)->offset;
1272 rlen = skb->len - offset; /* real length of skb */
1273 copied = min_t(unsigned int, rlen, len);
1274 if (!rlen)
1275 sk->sk_shutdown = sk->sk_shutdown | RCV_SHUTDOWN;
1276
1277 cskb = skb;
1278 if (skb_copy_datagram_msg(cskb, offset, msg, copied)) {
1279 err = -EFAULT;
1280 goto err_out;
1281 }
1282
1283 /* SOCK_SEQPACKET: set MSG_TRUNC if recv buf size is too small */
1284 if (sk->sk_type == SOCK_SEQPACKET) {
1285 if (copied < rlen)
1286 msg->msg_flags |= MSG_TRUNC;
1287 /* each iucv message contains a complete record */
1288 msg->msg_flags |= MSG_EOR;
1289 }
1290
1291 /* create control message to store iucv msg target class:
1292 * get the trgcls from the control buffer of the skb due to
1293 * fragmentation of original iucv message. */
1294 err = put_cmsg(msg, SOL_IUCV, SCM_IUCV_TRGCLS,
1295 sizeof(IUCV_SKB_CB(skb)->class),
1296 (void *)&IUCV_SKB_CB(skb)->class);
1297 if (err)
1298 goto err_out;
1299
1300 /* Mark read part of skb as used */
1301 if (!(flags & MSG_PEEK)) {
1302
1303 /* SOCK_STREAM: re-queue skb if it contains unreceived data */
1304 if (sk->sk_type == SOCK_STREAM) {
1305 if (copied < rlen) {
1306 IUCV_SKB_CB(skb)->offset = offset + copied;
1307 skb_queue_head(&sk->sk_receive_queue, skb);
1308 goto done;
1309 }
1310 }
1311
1312 consume_skb(skb);
1313 if (iucv->transport == AF_IUCV_TRANS_HIPER) {
1314 atomic_inc(&iucv->msg_recv);
1315 if (atomic_read(&iucv->msg_recv) > iucv->msglimit) {
1316 WARN_ON(1);
1317 iucv_sock_close(sk);
1318 return -EFAULT;
1319 }
1320 }
1321
1322 /* Queue backlog skbs */
1323 spin_lock_bh(&iucv->message_q.lock);
1324 rskb = skb_dequeue(&iucv->backlog_skb_q);
1325 while (rskb) {
1326 IUCV_SKB_CB(rskb)->offset = 0;
1327 if (__sock_queue_rcv_skb(sk, rskb)) {
1328 /* handle rcv queue full */
1329 skb_queue_head(&iucv->backlog_skb_q,
1330 rskb);
1331 break;
1332 }
1333 rskb = skb_dequeue(&iucv->backlog_skb_q);
1334 }
1335 if (skb_queue_empty(&iucv->backlog_skb_q)) {
1336 if (!list_empty(&iucv->message_q.list))
1337 iucv_process_message_q(sk);
1338 if (iucv->transport == AF_IUCV_TRANS_HIPER &&
1339 atomic_read(&iucv->msg_recv) >=
1340 iucv->msglimit / 2)
1341 send_win = true;
1342 }
1343 spin_unlock_bh(&iucv->message_q.lock);
1344
1345 if (send_win) {
1346 err = iucv_send_ctrl(sk, AF_IUCV_FLAG_WIN);
1347 if (err) {
1348 sk->sk_state = IUCV_DISCONN;
1349 sk->sk_state_change(sk);
1350 }
1351 }
1352 }
1353
1354 done:
1355 /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
1356 if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
1357 copied = rlen;
1358 if (flags & MSG_PEEK)
1359 skb_unref(skb);
1360
1361 return copied;
1362
1363 err_out:
1364 if (!(flags & MSG_PEEK))
1365 skb_queue_head(&sk->sk_receive_queue, skb);
1366 else
1367 skb_unref(skb);
1368
1369 return err;
1370 }
1371
iucv_accept_poll(struct sock * parent)1372 static inline __poll_t iucv_accept_poll(struct sock *parent)
1373 {
1374 struct iucv_sock *isk, *n;
1375 struct sock *sk;
1376
1377 list_for_each_entry_safe(isk, n, &iucv_sk(parent)->accept_q, accept_q) {
1378 sk = (struct sock *) isk;
1379
1380 if (sk->sk_state == IUCV_CONNECTED)
1381 return EPOLLIN | EPOLLRDNORM;
1382 }
1383
1384 return 0;
1385 }
1386
iucv_sock_poll(struct file * file,struct socket * sock,poll_table * wait)1387 static __poll_t iucv_sock_poll(struct file *file, struct socket *sock,
1388 poll_table *wait)
1389 {
1390 struct sock *sk = sock->sk;
1391 __poll_t mask = 0;
1392
1393 sock_poll_wait(file, sock, wait);
1394
1395 if (sk->sk_state == IUCV_LISTEN)
1396 return iucv_accept_poll(sk);
1397
1398 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
1399 mask |= EPOLLERR |
1400 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
1401
1402 if (sk->sk_shutdown & RCV_SHUTDOWN)
1403 mask |= EPOLLRDHUP;
1404
1405 if (sk->sk_shutdown == SHUTDOWN_MASK)
1406 mask |= EPOLLHUP;
1407
1408 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1409 (sk->sk_shutdown & RCV_SHUTDOWN))
1410 mask |= EPOLLIN | EPOLLRDNORM;
1411
1412 if (sk->sk_state == IUCV_CLOSED)
1413 mask |= EPOLLHUP;
1414
1415 if (sk->sk_state == IUCV_DISCONN)
1416 mask |= EPOLLIN;
1417
1418 if (sock_writeable(sk) && iucv_below_msglim(sk))
1419 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
1420 else
1421 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1422
1423 return mask;
1424 }
1425
iucv_sock_shutdown(struct socket * sock,int how)1426 static int iucv_sock_shutdown(struct socket *sock, int how)
1427 {
1428 struct sock *sk = sock->sk;
1429 struct iucv_sock *iucv = iucv_sk(sk);
1430 struct iucv_message txmsg;
1431 int err = 0;
1432
1433 how++;
1434
1435 if ((how & ~SHUTDOWN_MASK) || !how)
1436 return -EINVAL;
1437
1438 lock_sock(sk);
1439 switch (sk->sk_state) {
1440 case IUCV_LISTEN:
1441 case IUCV_DISCONN:
1442 case IUCV_CLOSING:
1443 case IUCV_CLOSED:
1444 err = -ENOTCONN;
1445 goto fail;
1446 default:
1447 break;
1448 }
1449
1450 if ((how == SEND_SHUTDOWN || how == SHUTDOWN_MASK) &&
1451 sk->sk_state == IUCV_CONNECTED) {
1452 if (iucv->transport == AF_IUCV_TRANS_IUCV) {
1453 txmsg.class = 0;
1454 txmsg.tag = 0;
1455 err = pr_iucv->message_send(iucv->path, &txmsg,
1456 IUCV_IPRMDATA, 0, (void *) iprm_shutdown, 8);
1457 if (err) {
1458 switch (err) {
1459 case 1:
1460 err = -ENOTCONN;
1461 break;
1462 case 2:
1463 err = -ECONNRESET;
1464 break;
1465 default:
1466 err = -ENOTCONN;
1467 break;
1468 }
1469 }
1470 } else
1471 iucv_send_ctrl(sk, AF_IUCV_FLAG_SHT);
1472 }
1473
1474 sk->sk_shutdown |= how;
1475 if (how == RCV_SHUTDOWN || how == SHUTDOWN_MASK) {
1476 if ((iucv->transport == AF_IUCV_TRANS_IUCV) &&
1477 iucv->path) {
1478 err = pr_iucv->path_quiesce(iucv->path, NULL);
1479 if (err)
1480 err = -ENOTCONN;
1481 /* skb_queue_purge(&sk->sk_receive_queue); */
1482 }
1483 skb_queue_purge(&sk->sk_receive_queue);
1484 }
1485
1486 /* Wake up anyone sleeping in poll */
1487 sk->sk_state_change(sk);
1488
1489 fail:
1490 release_sock(sk);
1491 return err;
1492 }
1493
iucv_sock_release(struct socket * sock)1494 static int iucv_sock_release(struct socket *sock)
1495 {
1496 struct sock *sk = sock->sk;
1497 int err = 0;
1498
1499 if (!sk)
1500 return 0;
1501
1502 iucv_sock_close(sk);
1503
1504 sock_orphan(sk);
1505 iucv_sock_kill(sk);
1506 return err;
1507 }
1508
1509 /* getsockopt and setsockopt */
iucv_sock_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int optlen)1510 static int iucv_sock_setsockopt(struct socket *sock, int level, int optname,
1511 sockptr_t optval, unsigned int optlen)
1512 {
1513 struct sock *sk = sock->sk;
1514 struct iucv_sock *iucv = iucv_sk(sk);
1515 int val;
1516 int rc;
1517
1518 if (level != SOL_IUCV)
1519 return -ENOPROTOOPT;
1520
1521 if (optlen < sizeof(int))
1522 return -EINVAL;
1523
1524 if (copy_from_sockptr(&val, optval, sizeof(int)))
1525 return -EFAULT;
1526
1527 rc = 0;
1528
1529 lock_sock(sk);
1530 switch (optname) {
1531 case SO_IPRMDATA_MSG:
1532 if (val)
1533 iucv->flags |= IUCV_IPRMDATA;
1534 else
1535 iucv->flags &= ~IUCV_IPRMDATA;
1536 break;
1537 case SO_MSGLIMIT:
1538 switch (sk->sk_state) {
1539 case IUCV_OPEN:
1540 case IUCV_BOUND:
1541 if (val < 1 || val > U16_MAX)
1542 rc = -EINVAL;
1543 else
1544 iucv->msglimit = val;
1545 break;
1546 default:
1547 rc = -EINVAL;
1548 break;
1549 }
1550 break;
1551 default:
1552 rc = -ENOPROTOOPT;
1553 break;
1554 }
1555 release_sock(sk);
1556
1557 return rc;
1558 }
1559
iucv_sock_getsockopt(struct socket * sock,int level,int optname,sockopt_t * opt)1560 static int iucv_sock_getsockopt(struct socket *sock, int level, int optname,
1561 sockopt_t *opt)
1562 {
1563 struct sock *sk = sock->sk;
1564 struct iucv_sock *iucv = iucv_sk(sk);
1565 unsigned int val;
1566 int len, rc;
1567
1568 if (level != SOL_IUCV)
1569 return -ENOPROTOOPT;
1570
1571 len = opt->optlen;
1572 if (len < 0)
1573 return -EINVAL;
1574
1575 len = min_t(unsigned int, len, sizeof(int));
1576
1577 rc = 0;
1578
1579 lock_sock(sk);
1580 switch (optname) {
1581 case SO_IPRMDATA_MSG:
1582 val = (iucv->flags & IUCV_IPRMDATA) ? 1 : 0;
1583 break;
1584 case SO_MSGLIMIT:
1585 val = (iucv->path != NULL) ? iucv->path->msglim /* connected */
1586 : iucv->msglimit; /* default */
1587 break;
1588 case SO_MSGSIZE:
1589 if (sk->sk_state == IUCV_OPEN) {
1590 rc = -EBADFD;
1591 break;
1592 }
1593 val = (iucv->hs_dev) ? iucv->hs_dev->mtu -
1594 sizeof(struct af_iucv_trans_hdr) - ETH_HLEN :
1595 0x7fffffff;
1596 break;
1597 default:
1598 rc = -ENOPROTOOPT;
1599 break;
1600 }
1601 release_sock(sk);
1602
1603 if (rc)
1604 return rc;
1605
1606 opt->optlen = len;
1607 if (copy_to_iter(&val, len, &opt->iter_out) != len)
1608 return -EFAULT;
1609
1610 return 0;
1611 }
1612
1613
1614 /* Callback wrappers - called from iucv base support */
iucv_callback_connreq(struct iucv_path * path,u8 ipvmid[8],u8 ipuser[16])1615 static int iucv_callback_connreq(struct iucv_path *path,
1616 u8 ipvmid[8], u8 ipuser[16])
1617 {
1618 unsigned char user_data[16];
1619 unsigned char nuser_data[16];
1620 unsigned char src_name[8];
1621 struct sock *sk, *nsk;
1622 struct iucv_sock *iucv, *niucv;
1623 int err;
1624
1625 memcpy(src_name, ipuser, 8);
1626 EBCASC(src_name, 8);
1627 /* Find out if this path belongs to af_iucv. */
1628 read_lock(&iucv_sk_list.lock);
1629 iucv = NULL;
1630 sk = NULL;
1631 sk_for_each(sk, &iucv_sk_list.head)
1632 if (sk->sk_state == IUCV_LISTEN &&
1633 !memcmp(&iucv_sk(sk)->src_name, src_name, 8)) {
1634 /*
1635 * Found a listening socket with
1636 * src_name == ipuser[0-7].
1637 */
1638 iucv = iucv_sk(sk);
1639 break;
1640 }
1641 read_unlock(&iucv_sk_list.lock);
1642 if (!iucv)
1643 /* No socket found, not one of our paths. */
1644 return -EINVAL;
1645
1646 bh_lock_sock(sk);
1647
1648 /* Check if parent socket is listening */
1649 low_nmcpy(user_data, iucv->src_name);
1650 high_nmcpy(user_data, iucv->dst_name);
1651 ASCEBC(user_data, sizeof(user_data));
1652 if (sk->sk_state != IUCV_LISTEN) {
1653 err = pr_iucv->path_sever(path, user_data);
1654 iucv_path_free(path);
1655 goto fail;
1656 }
1657
1658 /* Check for backlog size */
1659 if (sk_acceptq_is_full(sk)) {
1660 err = pr_iucv->path_sever(path, user_data);
1661 iucv_path_free(path);
1662 goto fail;
1663 }
1664
1665 /* Create the new socket */
1666 nsk = iucv_sock_alloc(NULL, sk->sk_protocol, GFP_ATOMIC, 0);
1667 if (!nsk) {
1668 err = pr_iucv->path_sever(path, user_data);
1669 iucv_path_free(path);
1670 goto fail;
1671 }
1672
1673 niucv = iucv_sk(nsk);
1674 iucv_sock_init(nsk, sk);
1675 niucv->transport = AF_IUCV_TRANS_IUCV;
1676 nsk->sk_allocation |= GFP_DMA;
1677
1678 /* Set the new iucv_sock */
1679 memcpy(niucv->dst_name, ipuser + 8, 8);
1680 EBCASC(niucv->dst_name, 8);
1681 memcpy(niucv->dst_user_id, ipvmid, 8);
1682 memcpy(niucv->src_name, iucv->src_name, 8);
1683 memcpy(niucv->src_user_id, iucv->src_user_id, 8);
1684 niucv->path = path;
1685
1686 /* Call iucv_accept */
1687 high_nmcpy(nuser_data, ipuser + 8);
1688 memcpy(nuser_data + 8, niucv->src_name, 8);
1689 ASCEBC(nuser_data + 8, 8);
1690
1691 /* set message limit for path based on msglimit of accepting socket */
1692 niucv->msglimit = iucv->msglimit;
1693 path->msglim = iucv->msglimit;
1694 err = pr_iucv->path_accept(path, &af_iucv_handler, nuser_data, nsk);
1695 if (err) {
1696 iucv_sever_path(nsk, 1);
1697 iucv_sock_kill(nsk);
1698 goto fail;
1699 }
1700
1701 iucv_accept_enqueue(sk, nsk);
1702
1703 /* Wake up accept */
1704 nsk->sk_state = IUCV_CONNECTED;
1705 sk->sk_data_ready(sk);
1706 err = 0;
1707 fail:
1708 bh_unlock_sock(sk);
1709 return 0;
1710 }
1711
iucv_callback_connack(struct iucv_path * path,u8 ipuser[16])1712 static void iucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
1713 {
1714 struct sock *sk = path->private;
1715
1716 sk->sk_state = IUCV_CONNECTED;
1717 sk->sk_state_change(sk);
1718 }
1719
iucv_callback_rx(struct iucv_path * path,struct iucv_message * msg)1720 static void iucv_callback_rx(struct iucv_path *path, struct iucv_message *msg)
1721 {
1722 struct sock *sk = path->private;
1723 struct iucv_sock *iucv = iucv_sk(sk);
1724 struct sk_buff *skb;
1725 struct sock_msg_q *save_msg;
1726 int len;
1727
1728 if (sk->sk_shutdown & RCV_SHUTDOWN) {
1729 pr_iucv->message_reject(path, msg);
1730 return;
1731 }
1732
1733 spin_lock(&iucv->message_q.lock);
1734
1735 if (!list_empty(&iucv->message_q.list) ||
1736 !skb_queue_empty(&iucv->backlog_skb_q))
1737 goto save_message;
1738
1739 len = atomic_read(&sk->sk_rmem_alloc);
1740 len += SKB_TRUESIZE(iucv_msg_length(msg));
1741 if (len > sk->sk_rcvbuf)
1742 goto save_message;
1743
1744 skb = alloc_iucv_recv_skb(iucv_msg_length(msg));
1745 if (!skb)
1746 goto save_message;
1747
1748 iucv_process_message(sk, skb, path, msg);
1749 goto out_unlock;
1750
1751 save_message:
1752 save_msg = kzalloc_obj(struct sock_msg_q, GFP_ATOMIC | GFP_DMA);
1753 if (!save_msg)
1754 goto out_unlock;
1755 save_msg->path = path;
1756 save_msg->msg = *msg;
1757
1758 list_add_tail(&save_msg->list, &iucv->message_q.list);
1759
1760 out_unlock:
1761 spin_unlock(&iucv->message_q.lock);
1762 }
1763
iucv_callback_txdone(struct iucv_path * path,struct iucv_message * msg)1764 static void iucv_callback_txdone(struct iucv_path *path,
1765 struct iucv_message *msg)
1766 {
1767 struct sock *sk = path->private;
1768 struct sk_buff *this = NULL;
1769 struct sk_buff_head *list;
1770 struct sk_buff *list_skb;
1771 struct iucv_sock *iucv;
1772 unsigned long flags;
1773
1774 iucv = iucv_sk(sk);
1775 list = &iucv->send_skb_q;
1776
1777 bh_lock_sock(sk);
1778
1779 spin_lock_irqsave(&list->lock, flags);
1780 skb_queue_walk(list, list_skb) {
1781 if (msg->tag == IUCV_SKB_CB(list_skb)->tag) {
1782 this = list_skb;
1783 break;
1784 }
1785 }
1786 if (this) {
1787 atomic_dec(&iucv->skbs_in_xmit);
1788 __skb_unlink(this, list);
1789 }
1790
1791 spin_unlock_irqrestore(&list->lock, flags);
1792
1793 if (this) {
1794 consume_skb(this);
1795 /* wake up any process waiting for sending */
1796 iucv_sock_wake_msglim(sk);
1797 }
1798
1799 if (sk->sk_state == IUCV_CLOSING) {
1800 if (atomic_read(&iucv->skbs_in_xmit) == 0) {
1801 sk->sk_state = IUCV_CLOSED;
1802 sk->sk_state_change(sk);
1803 }
1804 }
1805 bh_unlock_sock(sk);
1806
1807 }
1808
iucv_callback_connrej(struct iucv_path * path,u8 ipuser[16])1809 static void iucv_callback_connrej(struct iucv_path *path, u8 ipuser[16])
1810 {
1811 struct sock *sk = path->private;
1812
1813 if (sk->sk_state == IUCV_CLOSED)
1814 return;
1815
1816 bh_lock_sock(sk);
1817 iucv_sever_path(sk, 1);
1818 sk->sk_state = IUCV_DISCONN;
1819
1820 sk->sk_state_change(sk);
1821 bh_unlock_sock(sk);
1822 }
1823
1824 /* called if the other communication side shuts down its RECV direction;
1825 * in turn, the callback sets SEND_SHUTDOWN to disable sending of data.
1826 */
iucv_callback_shutdown(struct iucv_path * path,u8 ipuser[16])1827 static void iucv_callback_shutdown(struct iucv_path *path, u8 ipuser[16])
1828 {
1829 struct sock *sk = path->private;
1830
1831 bh_lock_sock(sk);
1832 if (sk->sk_state != IUCV_CLOSED) {
1833 sk->sk_shutdown |= SEND_SHUTDOWN;
1834 sk->sk_state_change(sk);
1835 }
1836 bh_unlock_sock(sk);
1837 }
1838
1839 static struct iucv_handler af_iucv_handler = {
1840 .path_pending = iucv_callback_connreq,
1841 .path_complete = iucv_callback_connack,
1842 .path_severed = iucv_callback_connrej,
1843 .message_pending = iucv_callback_rx,
1844 .message_complete = iucv_callback_txdone,
1845 .path_quiesced = iucv_callback_shutdown,
1846 };
1847
1848 /***************** HiperSockets transport callbacks ********************/
afiucv_swap_src_dest(struct sk_buff * skb)1849 static void afiucv_swap_src_dest(struct sk_buff *skb)
1850 {
1851 struct af_iucv_trans_hdr *trans_hdr = iucv_trans_hdr(skb);
1852 char tmpID[8];
1853 char tmpName[8];
1854
1855 ASCEBC(trans_hdr->destUserID, sizeof(trans_hdr->destUserID));
1856 ASCEBC(trans_hdr->destAppName, sizeof(trans_hdr->destAppName));
1857 ASCEBC(trans_hdr->srcUserID, sizeof(trans_hdr->srcUserID));
1858 ASCEBC(trans_hdr->srcAppName, sizeof(trans_hdr->srcAppName));
1859 memcpy(tmpID, trans_hdr->srcUserID, 8);
1860 memcpy(tmpName, trans_hdr->srcAppName, 8);
1861 memcpy(trans_hdr->srcUserID, trans_hdr->destUserID, 8);
1862 memcpy(trans_hdr->srcAppName, trans_hdr->destAppName, 8);
1863 memcpy(trans_hdr->destUserID, tmpID, 8);
1864 memcpy(trans_hdr->destAppName, tmpName, 8);
1865 skb_push(skb, ETH_HLEN);
1866 memset(skb->data, 0, ETH_HLEN);
1867 }
1868
1869 /*
1870 * afiucv_hs_callback_syn - react on received SYN
1871 */
afiucv_hs_callback_syn(struct sock * sk,struct sk_buff * skb)1872 static int afiucv_hs_callback_syn(struct sock *sk, struct sk_buff *skb)
1873 {
1874 struct af_iucv_trans_hdr *trans_hdr = iucv_trans_hdr(skb);
1875 struct sock *nsk;
1876 struct iucv_sock *iucv, *niucv;
1877 int err;
1878
1879 iucv = iucv_sk(sk);
1880 if (!iucv) {
1881 /* no sock - connection refused */
1882 afiucv_swap_src_dest(skb);
1883 trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN;
1884 err = dev_queue_xmit(skb);
1885 goto out;
1886 }
1887
1888 nsk = iucv_sock_alloc(NULL, sk->sk_protocol, GFP_ATOMIC, 0);
1889 bh_lock_sock(sk);
1890 if ((sk->sk_state != IUCV_LISTEN) ||
1891 sk_acceptq_is_full(sk) ||
1892 !nsk) {
1893 /* error on server socket - connection refused */
1894 afiucv_swap_src_dest(skb);
1895 trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN;
1896 err = dev_queue_xmit(skb);
1897 if (nsk)
1898 iucv_sock_kill(nsk);
1899 bh_unlock_sock(sk);
1900 goto out;
1901 }
1902
1903 niucv = iucv_sk(nsk);
1904 iucv_sock_init(nsk, sk);
1905 niucv->transport = AF_IUCV_TRANS_HIPER;
1906 niucv->msglimit = iucv->msglimit;
1907 if (!trans_hdr->window)
1908 niucv->msglimit_peer = IUCV_HIPER_MSGLIM_DEFAULT;
1909 else
1910 niucv->msglimit_peer = trans_hdr->window;
1911 memcpy(niucv->dst_name, trans_hdr->srcAppName, 8);
1912 memcpy(niucv->dst_user_id, trans_hdr->srcUserID, 8);
1913 memcpy(niucv->src_name, iucv->src_name, 8);
1914 memcpy(niucv->src_user_id, iucv->src_user_id, 8);
1915 nsk->sk_bound_dev_if = sk->sk_bound_dev_if;
1916 niucv->hs_dev = iucv->hs_dev;
1917 dev_hold(niucv->hs_dev);
1918 afiucv_swap_src_dest(skb);
1919 trans_hdr->flags = AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_ACK;
1920 trans_hdr->window = niucv->msglimit;
1921 /* if receiver acks the xmit connection is established */
1922 err = dev_queue_xmit(skb);
1923 if (!err) {
1924 iucv_accept_enqueue(sk, nsk);
1925 nsk->sk_state = IUCV_CONNECTED;
1926 sk->sk_data_ready(sk);
1927 } else
1928 iucv_sock_kill(nsk);
1929 bh_unlock_sock(sk);
1930
1931 out:
1932 return NET_RX_SUCCESS;
1933 }
1934
1935 /*
1936 * afiucv_hs_callback_synack() - react on received SYN-ACK
1937 */
afiucv_hs_callback_synack(struct sock * sk,struct sk_buff * skb)1938 static int afiucv_hs_callback_synack(struct sock *sk, struct sk_buff *skb)
1939 {
1940 struct iucv_sock *iucv = iucv_sk(sk);
1941
1942 if (!iucv || sk->sk_state != IUCV_BOUND) {
1943 kfree_skb(skb);
1944 return NET_RX_SUCCESS;
1945 }
1946
1947 bh_lock_sock(sk);
1948 iucv->msglimit_peer = iucv_trans_hdr(skb)->window;
1949 sk->sk_state = IUCV_CONNECTED;
1950 sk->sk_state_change(sk);
1951 bh_unlock_sock(sk);
1952 consume_skb(skb);
1953 return NET_RX_SUCCESS;
1954 }
1955
1956 /*
1957 * afiucv_hs_callback_synfin() - react on received SYN_FIN
1958 */
afiucv_hs_callback_synfin(struct sock * sk,struct sk_buff * skb)1959 static int afiucv_hs_callback_synfin(struct sock *sk, struct sk_buff *skb)
1960 {
1961 struct iucv_sock *iucv = iucv_sk(sk);
1962
1963 if (!iucv || sk->sk_state != IUCV_BOUND) {
1964 kfree_skb(skb);
1965 return NET_RX_SUCCESS;
1966 }
1967
1968 bh_lock_sock(sk);
1969 sk->sk_state = IUCV_DISCONN;
1970 sk->sk_state_change(sk);
1971 bh_unlock_sock(sk);
1972 consume_skb(skb);
1973 return NET_RX_SUCCESS;
1974 }
1975
1976 /*
1977 * afiucv_hs_callback_fin() - react on received FIN
1978 */
afiucv_hs_callback_fin(struct sock * sk,struct sk_buff * skb)1979 static int afiucv_hs_callback_fin(struct sock *sk, struct sk_buff *skb)
1980 {
1981 struct iucv_sock *iucv = iucv_sk(sk);
1982
1983 /* other end of connection closed */
1984 if (!iucv) {
1985 kfree_skb(skb);
1986 return NET_RX_SUCCESS;
1987 }
1988
1989 bh_lock_sock(sk);
1990 if (sk->sk_state == IUCV_CONNECTED) {
1991 sk->sk_state = IUCV_DISCONN;
1992 sk->sk_state_change(sk);
1993 }
1994 bh_unlock_sock(sk);
1995 consume_skb(skb);
1996 return NET_RX_SUCCESS;
1997 }
1998
1999 /*
2000 * afiucv_hs_callback_win() - react on received WIN
2001 */
afiucv_hs_callback_win(struct sock * sk,struct sk_buff * skb)2002 static int afiucv_hs_callback_win(struct sock *sk, struct sk_buff *skb)
2003 {
2004 struct iucv_sock *iucv = iucv_sk(sk);
2005
2006 if (!iucv)
2007 return NET_RX_SUCCESS;
2008
2009 if (sk->sk_state != IUCV_CONNECTED)
2010 return NET_RX_SUCCESS;
2011
2012 atomic_sub(iucv_trans_hdr(skb)->window, &iucv->msg_sent);
2013 iucv_sock_wake_msglim(sk);
2014 return NET_RX_SUCCESS;
2015 }
2016
2017 /*
2018 * afiucv_hs_callback_rx() - react on received data
2019 */
afiucv_hs_callback_rx(struct sock * sk,struct sk_buff * skb)2020 static int afiucv_hs_callback_rx(struct sock *sk, struct sk_buff *skb)
2021 {
2022 struct iucv_sock *iucv = iucv_sk(sk);
2023
2024 if (!iucv) {
2025 kfree_skb(skb);
2026 return NET_RX_SUCCESS;
2027 }
2028
2029 if (sk->sk_state != IUCV_CONNECTED) {
2030 kfree_skb(skb);
2031 return NET_RX_SUCCESS;
2032 }
2033
2034 if (sk->sk_shutdown & RCV_SHUTDOWN) {
2035 kfree_skb(skb);
2036 return NET_RX_SUCCESS;
2037 }
2038
2039 /* write stuff from iucv_msg to skb cb */
2040 skb_pull(skb, sizeof(struct af_iucv_trans_hdr));
2041 skb_reset_transport_header(skb);
2042 skb_reset_network_header(skb);
2043 IUCV_SKB_CB(skb)->offset = 0;
2044 if (sk_filter(sk, skb)) {
2045 sk_drops_inc(sk); /* skb rejected by filter */
2046 kfree_skb(skb);
2047 return NET_RX_SUCCESS;
2048 }
2049
2050 spin_lock(&iucv->message_q.lock);
2051 if (skb_queue_empty(&iucv->backlog_skb_q)) {
2052 if (__sock_queue_rcv_skb(sk, skb))
2053 /* handle rcv queue full */
2054 skb_queue_tail(&iucv->backlog_skb_q, skb);
2055 } else
2056 skb_queue_tail(&iucv_sk(sk)->backlog_skb_q, skb);
2057 spin_unlock(&iucv->message_q.lock);
2058 return NET_RX_SUCCESS;
2059 }
2060
2061 /*
2062 * afiucv_hs_rcv() - base function for arriving data through HiperSockets
2063 * transport
2064 * called from netif RX softirq
2065 */
afiucv_hs_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)2066 static int afiucv_hs_rcv(struct sk_buff *skb, struct net_device *dev,
2067 struct packet_type *pt, struct net_device *orig_dev)
2068 {
2069 struct sock *sk;
2070 struct iucv_sock *iucv;
2071 struct af_iucv_trans_hdr *trans_hdr;
2072 int err = NET_RX_SUCCESS;
2073 char nullstring[8];
2074
2075 if (!pskb_may_pull(skb, sizeof(*trans_hdr))) {
2076 kfree_skb(skb);
2077 return NET_RX_SUCCESS;
2078 }
2079
2080 trans_hdr = iucv_trans_hdr(skb);
2081 EBCASC(trans_hdr->destAppName, sizeof(trans_hdr->destAppName));
2082 EBCASC(trans_hdr->destUserID, sizeof(trans_hdr->destUserID));
2083 EBCASC(trans_hdr->srcAppName, sizeof(trans_hdr->srcAppName));
2084 EBCASC(trans_hdr->srcUserID, sizeof(trans_hdr->srcUserID));
2085 memset(nullstring, 0, sizeof(nullstring));
2086 iucv = NULL;
2087 sk = NULL;
2088 read_lock(&iucv_sk_list.lock);
2089 sk_for_each(sk, &iucv_sk_list.head) {
2090 if (iucv_sk(sk)->hs_dev != dev)
2091 continue;
2092 if (trans_hdr->flags == AF_IUCV_FLAG_SYN) {
2093 if ((!memcmp(&iucv_sk(sk)->src_name,
2094 trans_hdr->destAppName, 8)) &&
2095 (!memcmp(&iucv_sk(sk)->src_user_id,
2096 trans_hdr->destUserID, 8)) &&
2097 (!memcmp(&iucv_sk(sk)->dst_name, nullstring, 8)) &&
2098 (!memcmp(&iucv_sk(sk)->dst_user_id,
2099 nullstring, 8))) {
2100 iucv = iucv_sk(sk);
2101 break;
2102 }
2103 } else {
2104 if ((!memcmp(&iucv_sk(sk)->src_name,
2105 trans_hdr->destAppName, 8)) &&
2106 (!memcmp(&iucv_sk(sk)->src_user_id,
2107 trans_hdr->destUserID, 8)) &&
2108 (!memcmp(&iucv_sk(sk)->dst_name,
2109 trans_hdr->srcAppName, 8)) &&
2110 (!memcmp(&iucv_sk(sk)->dst_user_id,
2111 trans_hdr->srcUserID, 8))) {
2112 iucv = iucv_sk(sk);
2113 break;
2114 }
2115 }
2116 }
2117 if (sk)
2118 sock_hold(sk);
2119 read_unlock(&iucv_sk_list.lock);
2120 if (!iucv)
2121 sk = NULL;
2122
2123 /* no sock
2124 how should we send with no sock
2125 1) send without sock no send rc checking?
2126 2) introduce default sock to handle this cases
2127
2128 SYN -> send SYN|ACK in good case, send SYN|FIN in bad case
2129 data -> send FIN
2130 SYN|ACK, SYN|FIN, FIN -> no action? */
2131
2132 switch (trans_hdr->flags) {
2133 case AF_IUCV_FLAG_SYN:
2134 /* connect request */
2135 err = afiucv_hs_callback_syn(sk, skb);
2136 break;
2137 case (AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_ACK):
2138 /* connect request confirmed */
2139 err = afiucv_hs_callback_synack(sk, skb);
2140 break;
2141 case (AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN):
2142 /* connect request refused */
2143 err = afiucv_hs_callback_synfin(sk, skb);
2144 break;
2145 case (AF_IUCV_FLAG_FIN):
2146 /* close request */
2147 err = afiucv_hs_callback_fin(sk, skb);
2148 break;
2149 case (AF_IUCV_FLAG_WIN):
2150 err = afiucv_hs_callback_win(sk, skb);
2151 if (skb->len == sizeof(struct af_iucv_trans_hdr)) {
2152 consume_skb(skb);
2153 break;
2154 }
2155 fallthrough; /* and receive non-zero length data */
2156 case (AF_IUCV_FLAG_SHT):
2157 /* shutdown request */
2158 fallthrough; /* and receive zero length data */
2159 case 0:
2160 /* plain data frame */
2161 IUCV_SKB_CB(skb)->class = trans_hdr->iucv_hdr.class;
2162 err = afiucv_hs_callback_rx(sk, skb);
2163 break;
2164 default:
2165 kfree_skb(skb);
2166 }
2167
2168 if (sk)
2169 sock_put(sk);
2170 return err;
2171 }
2172
2173 /*
2174 * afiucv_hs_callback_txnotify() - handle send notifications from HiperSockets
2175 * transport
2176 */
afiucv_hs_callback_txnotify(struct sock * sk,enum iucv_tx_notify n)2177 static void afiucv_hs_callback_txnotify(struct sock *sk, enum iucv_tx_notify n)
2178 {
2179 struct iucv_sock *iucv = iucv_sk(sk);
2180
2181 if (sock_flag(sk, SOCK_ZAPPED))
2182 return;
2183
2184 switch (n) {
2185 case TX_NOTIFY_OK:
2186 atomic_dec(&iucv->skbs_in_xmit);
2187 iucv_sock_wake_msglim(sk);
2188 break;
2189 case TX_NOTIFY_PENDING:
2190 atomic_inc(&iucv->pendings);
2191 break;
2192 case TX_NOTIFY_DELAYED_OK:
2193 atomic_dec(&iucv->skbs_in_xmit);
2194 if (atomic_dec_return(&iucv->pendings) <= 0)
2195 iucv_sock_wake_msglim(sk);
2196 break;
2197 default:
2198 atomic_dec(&iucv->skbs_in_xmit);
2199 if (sk->sk_state == IUCV_CONNECTED) {
2200 sk->sk_state = IUCV_DISCONN;
2201 sk->sk_state_change(sk);
2202 }
2203 }
2204
2205 if (sk->sk_state == IUCV_CLOSING) {
2206 if (atomic_read(&iucv->skbs_in_xmit) == 0) {
2207 sk->sk_state = IUCV_CLOSED;
2208 sk->sk_state_change(sk);
2209 }
2210 }
2211 }
2212
2213 /*
2214 * afiucv_netdev_event: handle netdev notifier chain events
2215 */
afiucv_netdev_event(struct notifier_block * this,unsigned long event,void * ptr)2216 static int afiucv_netdev_event(struct notifier_block *this,
2217 unsigned long event, void *ptr)
2218 {
2219 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
2220 struct sock *sk;
2221 struct iucv_sock *iucv;
2222
2223 switch (event) {
2224 case NETDEV_REBOOT:
2225 case NETDEV_GOING_DOWN:
2226 sk_for_each(sk, &iucv_sk_list.head) {
2227 iucv = iucv_sk(sk);
2228 if ((iucv->hs_dev == event_dev) &&
2229 (sk->sk_state == IUCV_CONNECTED)) {
2230 if (event == NETDEV_GOING_DOWN)
2231 iucv_send_ctrl(sk, AF_IUCV_FLAG_FIN);
2232 sk->sk_state = IUCV_DISCONN;
2233 sk->sk_state_change(sk);
2234 }
2235 }
2236 break;
2237 case NETDEV_DOWN:
2238 case NETDEV_UNREGISTER:
2239 default:
2240 break;
2241 }
2242 return NOTIFY_DONE;
2243 }
2244
2245 static struct notifier_block afiucv_netdev_notifier = {
2246 .notifier_call = afiucv_netdev_event,
2247 };
2248
2249 static const struct proto_ops iucv_sock_ops = {
2250 .family = PF_IUCV,
2251 .owner = THIS_MODULE,
2252 .release = iucv_sock_release,
2253 .bind = iucv_sock_bind,
2254 .connect = iucv_sock_connect,
2255 .listen = iucv_sock_listen,
2256 .accept = iucv_sock_accept,
2257 .getname = iucv_sock_getname,
2258 .sendmsg = iucv_sock_sendmsg,
2259 .recvmsg = iucv_sock_recvmsg,
2260 .poll = iucv_sock_poll,
2261 .ioctl = sock_no_ioctl,
2262 .mmap = sock_no_mmap,
2263 .socketpair = sock_no_socketpair,
2264 .shutdown = iucv_sock_shutdown,
2265 .setsockopt = iucv_sock_setsockopt,
2266 .getsockopt_iter = iucv_sock_getsockopt,
2267 };
2268
iucv_sock_create(struct net * net,struct socket * sock,int protocol,int kern)2269 static int iucv_sock_create(struct net *net, struct socket *sock, int protocol,
2270 int kern)
2271 {
2272 struct sock *sk;
2273
2274 if (protocol && protocol != PF_IUCV)
2275 return -EPROTONOSUPPORT;
2276
2277 sock->state = SS_UNCONNECTED;
2278
2279 switch (sock->type) {
2280 case SOCK_STREAM:
2281 case SOCK_SEQPACKET:
2282 /* currently, proto ops can handle both sk types */
2283 sock->ops = &iucv_sock_ops;
2284 break;
2285 default:
2286 return -ESOCKTNOSUPPORT;
2287 }
2288
2289 sk = iucv_sock_alloc(sock, protocol, GFP_KERNEL, kern);
2290 if (!sk)
2291 return -ENOMEM;
2292
2293 iucv_sock_init(sk, NULL);
2294
2295 return 0;
2296 }
2297
2298 static const struct net_proto_family iucv_sock_family_ops = {
2299 .family = AF_IUCV,
2300 .owner = THIS_MODULE,
2301 .create = iucv_sock_create,
2302 };
2303
2304 static struct packet_type iucv_packet_type = {
2305 .type = cpu_to_be16(ETH_P_AF_IUCV),
2306 .func = afiucv_hs_rcv,
2307 };
2308
afiucv_init(void)2309 static int __init afiucv_init(void)
2310 {
2311 int err;
2312
2313 if (machine_is_vm() && IS_ENABLED(CONFIG_IUCV)) {
2314 cpcmd("QUERY USERID", iucv_userid, sizeof(iucv_userid), &err);
2315 if (unlikely(err)) {
2316 WARN_ON(err);
2317 err = -EPROTONOSUPPORT;
2318 goto out;
2319 }
2320
2321 pr_iucv = &iucv_if;
2322 } else {
2323 memset(&iucv_userid, 0, sizeof(iucv_userid));
2324 pr_iucv = NULL;
2325 }
2326
2327 err = proto_register(&iucv_proto, 0);
2328 if (err)
2329 goto out;
2330 err = sock_register(&iucv_sock_family_ops);
2331 if (err)
2332 goto out_proto;
2333
2334 if (pr_iucv) {
2335 err = pr_iucv->iucv_register(&af_iucv_handler, 0);
2336 if (err)
2337 goto out_sock;
2338 }
2339
2340 err = register_netdevice_notifier(&afiucv_netdev_notifier);
2341 if (err)
2342 goto out_notifier;
2343
2344 dev_add_pack(&iucv_packet_type);
2345 return 0;
2346
2347 out_notifier:
2348 if (pr_iucv)
2349 pr_iucv->iucv_unregister(&af_iucv_handler, 0);
2350 out_sock:
2351 sock_unregister(PF_IUCV);
2352 out_proto:
2353 proto_unregister(&iucv_proto);
2354 out:
2355 return err;
2356 }
2357
afiucv_exit(void)2358 static void __exit afiucv_exit(void)
2359 {
2360 if (pr_iucv)
2361 pr_iucv->iucv_unregister(&af_iucv_handler, 0);
2362
2363 unregister_netdevice_notifier(&afiucv_netdev_notifier);
2364 dev_remove_pack(&iucv_packet_type);
2365 sock_unregister(PF_IUCV);
2366 proto_unregister(&iucv_proto);
2367 }
2368
2369 module_init(afiucv_init);
2370 module_exit(afiucv_exit);
2371
2372 MODULE_AUTHOR("Jennifer Hunt <jenhunt@us.ibm.com>");
2373 MODULE_DESCRIPTION("IUCV Sockets ver " VERSION);
2374 MODULE_VERSION(VERSION);
2375 MODULE_LICENSE("GPL");
2376 MODULE_ALIAS_NETPROTO(PF_IUCV);
2377