[PATCH] scx200_acb: Fix the state machine
[linux-3.10.git] / net / rxrpc / transport.c
1 /* transport.c: Rx Transport routines
2  *
3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/sched.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <rxrpc/transport.h>
16 #include <rxrpc/peer.h>
17 #include <rxrpc/connection.h>
18 #include <rxrpc/call.h>
19 #include <rxrpc/message.h>
20 #include <rxrpc/krxiod.h>
21 #include <rxrpc/krxsecd.h>
22 #include <linux/udp.h>
23 #include <linux/in.h>
24 #include <linux/in6.h>
25 #include <linux/icmp.h>
26 #include <linux/skbuff.h>
27 #include <net/sock.h>
28 #include <net/ip.h>
29 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
30 #include <linux/ipv6.h> /* this should _really_ be in errqueue.h.. */
31 #endif
32 #include <linux/errqueue.h>
33 #include <asm/uaccess.h>
34 #include <asm/checksum.h>
35 #include "internal.h"
36
37 struct errormsg {
38         struct cmsghdr                  cmsg;           /* control message header */
39         struct sock_extended_err        ee;             /* extended error information */
40         struct sockaddr_in              icmp_src;       /* ICMP packet source address */
41 };
42
43 static DEFINE_SPINLOCK(rxrpc_transports_lock);
44 static struct list_head rxrpc_transports = LIST_HEAD_INIT(rxrpc_transports);
45
46 __RXACCT_DECL(atomic_t rxrpc_transport_count);
47 LIST_HEAD(rxrpc_proc_transports);
48 DECLARE_RWSEM(rxrpc_proc_transports_sem);
49
50 static void rxrpc_data_ready(struct sock *sk, int count);
51 static void rxrpc_error_report(struct sock *sk);
52 static int rxrpc_trans_receive_new_call(struct rxrpc_transport *trans,
53                                         struct list_head *msgq);
54 static void rxrpc_trans_receive_error_report(struct rxrpc_transport *trans);
55
56 /*****************************************************************************/
57 /*
58  * create a new transport endpoint using the specified UDP port
59  */
60 int rxrpc_create_transport(unsigned short port,
61                            struct rxrpc_transport **_trans)
62 {
63         struct rxrpc_transport *trans;
64         struct sockaddr_in sin;
65         mm_segment_t oldfs;
66         struct sock *sock;
67         int ret, opt;
68
69         _enter("%hu", port);
70
71         trans = kmalloc(sizeof(struct rxrpc_transport), GFP_KERNEL);
72         if (!trans)
73                 return -ENOMEM;
74
75         memset(trans, 0, sizeof(struct rxrpc_transport));
76         atomic_set(&trans->usage, 1);
77         INIT_LIST_HEAD(&trans->services);
78         INIT_LIST_HEAD(&trans->link);
79         INIT_LIST_HEAD(&trans->krxiodq_link);
80         spin_lock_init(&trans->lock);
81         INIT_LIST_HEAD(&trans->peer_active);
82         INIT_LIST_HEAD(&trans->peer_graveyard);
83         spin_lock_init(&trans->peer_gylock);
84         init_waitqueue_head(&trans->peer_gy_waitq);
85         rwlock_init(&trans->peer_lock);
86         atomic_set(&trans->peer_count, 0);
87         trans->port = port;
88
89         /* create a UDP socket to be my actual transport endpoint */
90         ret = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &trans->socket);
91         if (ret < 0)
92                 goto error;
93
94         /* use the specified port */
95         if (port) {
96                 memset(&sin, 0, sizeof(sin));
97                 sin.sin_family = AF_INET;
98                 sin.sin_port = htons(port);
99                 ret = trans->socket->ops->bind(trans->socket,
100                                                (struct sockaddr *) &sin,
101                                                sizeof(sin));
102                 if (ret < 0)
103                         goto error;
104         }
105
106         opt = 1;
107         oldfs = get_fs();
108         set_fs(KERNEL_DS);
109         ret = trans->socket->ops->setsockopt(trans->socket, SOL_IP, IP_RECVERR,
110                                              (char *) &opt, sizeof(opt));
111         set_fs(oldfs);
112
113         spin_lock(&rxrpc_transports_lock);
114         list_add(&trans->link, &rxrpc_transports);
115         spin_unlock(&rxrpc_transports_lock);
116
117         /* set the socket up */
118         sock = trans->socket->sk;
119         sock->sk_user_data      = trans;
120         sock->sk_data_ready     = rxrpc_data_ready;
121         sock->sk_error_report   = rxrpc_error_report;
122
123         down_write(&rxrpc_proc_transports_sem);
124         list_add_tail(&trans->proc_link, &rxrpc_proc_transports);
125         up_write(&rxrpc_proc_transports_sem);
126
127         __RXACCT(atomic_inc(&rxrpc_transport_count));
128
129         *_trans = trans;
130         _leave(" = 0 (%p)", trans);
131         return 0;
132
133  error:
134         /* finish cleaning up the transport (not really needed here, but...) */
135         if (trans->socket)
136                 trans->socket->ops->shutdown(trans->socket, 2);
137
138         /* close the socket */
139         if (trans->socket) {
140                 trans->socket->sk->sk_user_data = NULL;
141                 sock_release(trans->socket);
142                 trans->socket = NULL;
143         }
144
145         kfree(trans);
146
147
148         _leave(" = %d", ret);
149         return ret;
150 } /* end rxrpc_create_transport() */
151
152 /*****************************************************************************/
153 /*
154  * destroy a transport endpoint
155  */
156 void rxrpc_put_transport(struct rxrpc_transport *trans)
157 {
158         _enter("%p{u=%d p=%hu}",
159                trans, atomic_read(&trans->usage), trans->port);
160
161         BUG_ON(atomic_read(&trans->usage) <= 0);
162
163         /* to prevent a race, the decrement and the dequeue must be
164          * effectively atomic */
165         spin_lock(&rxrpc_transports_lock);
166         if (likely(!atomic_dec_and_test(&trans->usage))) {
167                 spin_unlock(&rxrpc_transports_lock);
168                 _leave("");
169                 return;
170         }
171
172         list_del(&trans->link);
173         spin_unlock(&rxrpc_transports_lock);
174
175         /* finish cleaning up the transport */
176         if (trans->socket)
177                 trans->socket->ops->shutdown(trans->socket, 2);
178
179         rxrpc_krxsecd_clear_transport(trans);
180         rxrpc_krxiod_dequeue_transport(trans);
181
182         /* discard all peer information */
183         rxrpc_peer_clearall(trans);
184
185         down_write(&rxrpc_proc_transports_sem);
186         list_del(&trans->proc_link);
187         up_write(&rxrpc_proc_transports_sem);
188         __RXACCT(atomic_dec(&rxrpc_transport_count));
189
190         /* close the socket */
191         if (trans->socket) {
192                 trans->socket->sk->sk_user_data = NULL;
193                 sock_release(trans->socket);
194                 trans->socket = NULL;
195         }
196
197         kfree(trans);
198
199         _leave("");
200 } /* end rxrpc_put_transport() */
201
202 /*****************************************************************************/
203 /*
204  * add a service to a transport to be listened upon
205  */
206 int rxrpc_add_service(struct rxrpc_transport *trans,
207                       struct rxrpc_service *newsrv)
208 {
209         struct rxrpc_service *srv;
210         struct list_head *_p;
211         int ret = -EEXIST;
212
213         _enter("%p{%hu},%p{%hu}",
214                trans, trans->port, newsrv, newsrv->service_id);
215
216         /* verify that the service ID is not already present */
217         spin_lock(&trans->lock);
218
219         list_for_each(_p, &trans->services) {
220                 srv = list_entry(_p, struct rxrpc_service, link);
221                 if (srv->service_id == newsrv->service_id)
222                         goto out;
223         }
224
225         /* okay - add the transport to the list */
226         list_add_tail(&newsrv->link, &trans->services);
227         rxrpc_get_transport(trans);
228         ret = 0;
229
230  out:
231         spin_unlock(&trans->lock);
232
233         _leave("= %d", ret);
234         return ret;
235 } /* end rxrpc_add_service() */
236
237 /*****************************************************************************/
238 /*
239  * remove a service from a transport
240  */
241 void rxrpc_del_service(struct rxrpc_transport *trans, struct rxrpc_service *srv)
242 {
243         _enter("%p{%hu},%p{%hu}", trans, trans->port, srv, srv->service_id);
244
245         spin_lock(&trans->lock);
246         list_del(&srv->link);
247         spin_unlock(&trans->lock);
248
249         rxrpc_put_transport(trans);
250
251         _leave("");
252 } /* end rxrpc_del_service() */
253
254 /*****************************************************************************/
255 /*
256  * INET callback when data has been received on the socket.
257  */
258 static void rxrpc_data_ready(struct sock *sk, int count)
259 {
260         struct rxrpc_transport *trans;
261
262         _enter("%p{t=%p},%d", sk, sk->sk_user_data, count);
263
264         /* queue the transport for attention by krxiod */
265         trans = (struct rxrpc_transport *) sk->sk_user_data;
266         if (trans)
267                 rxrpc_krxiod_queue_transport(trans);
268
269         /* wake up anyone waiting on the socket */
270         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
271                 wake_up_interruptible(sk->sk_sleep);
272
273         _leave("");
274 } /* end rxrpc_data_ready() */
275
276 /*****************************************************************************/
277 /*
278  * INET callback when an ICMP error packet is received
279  * - sk->err is error (EHOSTUNREACH, EPROTO or EMSGSIZE)
280  */
281 static void rxrpc_error_report(struct sock *sk)
282 {
283         struct rxrpc_transport *trans;
284
285         _enter("%p{t=%p}", sk, sk->sk_user_data);
286
287         /* queue the transport for attention by krxiod */
288         trans = (struct rxrpc_transport *) sk->sk_user_data;
289         if (trans) {
290                 trans->error_rcvd = 1;
291                 rxrpc_krxiod_queue_transport(trans);
292         }
293
294         /* wake up anyone waiting on the socket */
295         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
296                 wake_up_interruptible(sk->sk_sleep);
297
298         _leave("");
299 } /* end rxrpc_error_report() */
300
301 /*****************************************************************************/
302 /*
303  * split a message up, allocating message records and filling them in
304  * from the contents of a socket buffer
305  */
306 static int rxrpc_incoming_msg(struct rxrpc_transport *trans,
307                               struct sk_buff *pkt,
308                               struct list_head *msgq)
309 {
310         struct rxrpc_message *msg;
311         int ret;
312
313         _enter("");
314
315         msg = kmalloc(sizeof(struct rxrpc_message), GFP_KERNEL);
316         if (!msg) {
317                 _leave(" = -ENOMEM");
318                 return -ENOMEM;
319         }
320
321         memset(msg, 0, sizeof(*msg));
322         atomic_set(&msg->usage, 1);
323         list_add_tail(&msg->link,msgq);
324
325         /* dig out the Rx routing parameters */
326         if (skb_copy_bits(pkt, sizeof(struct udphdr),
327                           &msg->hdr, sizeof(msg->hdr)) < 0) {
328                 ret = -EBADMSG;
329                 goto error;
330         }
331
332         msg->trans = trans;
333         msg->state = RXRPC_MSG_RECEIVED;
334         skb_get_timestamp(pkt, &msg->stamp);
335         if (msg->stamp.tv_sec == 0) {
336                 do_gettimeofday(&msg->stamp); 
337                 if (pkt->sk) 
338                         sock_enable_timestamp(pkt->sk);
339         } 
340         msg->seq = ntohl(msg->hdr.seq);
341
342         /* attach the packet */
343         skb_get(pkt);
344         msg->pkt = pkt;
345
346         msg->offset = sizeof(struct udphdr) + sizeof(struct rxrpc_header);
347         msg->dsize = msg->pkt->len - msg->offset;
348
349         _net("Rx Received packet from %s (%08x;%08x,%1x,%d,%s,%02x,%d,%d)",
350              msg->hdr.flags & RXRPC_CLIENT_INITIATED ? "client" : "server",
351              ntohl(msg->hdr.epoch),
352              (ntohl(msg->hdr.cid) & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT,
353              ntohl(msg->hdr.cid) & RXRPC_CHANNELMASK,
354              ntohl(msg->hdr.callNumber),
355              rxrpc_pkts[msg->hdr.type],
356              msg->hdr.flags,
357              ntohs(msg->hdr.serviceId),
358              msg->hdr.securityIndex);
359
360         __RXACCT(atomic_inc(&rxrpc_message_count));
361
362         /* split off jumbo packets */
363         while (msg->hdr.type == RXRPC_PACKET_TYPE_DATA &&
364                msg->hdr.flags & RXRPC_JUMBO_PACKET
365                ) {
366                 struct rxrpc_jumbo_header jumbo;
367                 struct rxrpc_message *jumbomsg = msg;
368
369                 _debug("split jumbo packet");
370
371                 /* quick sanity check */
372                 ret = -EBADMSG;
373                 if (msg->dsize <
374                     RXRPC_JUMBO_DATALEN + sizeof(struct rxrpc_jumbo_header))
375                         goto error;
376                 if (msg->hdr.flags & RXRPC_LAST_PACKET)
377                         goto error;
378
379                 /* dig out the secondary header */
380                 if (skb_copy_bits(pkt, msg->offset + RXRPC_JUMBO_DATALEN,
381                                   &jumbo, sizeof(jumbo)) < 0)
382                         goto error;
383
384                 /* allocate a new message record */
385                 ret = -ENOMEM;
386                 msg = kmalloc(sizeof(struct rxrpc_message), GFP_KERNEL);
387                 if (!msg)
388                         goto error;
389
390                 memcpy(msg, jumbomsg, sizeof(*msg));
391                 list_add_tail(&msg->link, msgq);
392
393                 /* adjust the jumbo packet */
394                 jumbomsg->dsize = RXRPC_JUMBO_DATALEN;
395
396                 /* attach the packet here too */
397                 skb_get(pkt);
398
399                 /* adjust the parameters */
400                 msg->seq++;
401                 msg->hdr.seq = htonl(msg->seq);
402                 msg->hdr.serial = htonl(ntohl(msg->hdr.serial) + 1);
403                 msg->offset += RXRPC_JUMBO_DATALEN +
404                         sizeof(struct rxrpc_jumbo_header);
405                 msg->dsize -= RXRPC_JUMBO_DATALEN +
406                         sizeof(struct rxrpc_jumbo_header);
407                 msg->hdr.flags = jumbo.flags;
408                 msg->hdr._rsvd = jumbo._rsvd;
409
410                 _net("Rx Split jumbo packet from %s"
411                      " (%08x;%08x,%1x,%d,%s,%02x,%d,%d)",
412                      msg->hdr.flags & RXRPC_CLIENT_INITIATED ? "client" : "server",
413                      ntohl(msg->hdr.epoch),
414                      (ntohl(msg->hdr.cid) & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT,
415                      ntohl(msg->hdr.cid) & RXRPC_CHANNELMASK,
416                      ntohl(msg->hdr.callNumber),
417                      rxrpc_pkts[msg->hdr.type],
418                      msg->hdr.flags,
419                      ntohs(msg->hdr.serviceId),
420                      msg->hdr.securityIndex);
421
422                 __RXACCT(atomic_inc(&rxrpc_message_count));
423         }
424
425         _leave(" = 0 #%d", atomic_read(&rxrpc_message_count));
426         return 0;
427
428  error:
429         while (!list_empty(msgq)) {
430                 msg = list_entry(msgq->next, struct rxrpc_message, link);
431                 list_del_init(&msg->link);
432
433                 rxrpc_put_message(msg);
434         }
435
436         _leave(" = %d", ret);
437         return ret;
438 } /* end rxrpc_incoming_msg() */
439
440 /*****************************************************************************/
441 /*
442  * accept a new call
443  * - called from krxiod in process context
444  */
445 void rxrpc_trans_receive_packet(struct rxrpc_transport *trans)
446 {
447         struct rxrpc_message *msg;
448         struct rxrpc_peer *peer;
449         struct sk_buff *pkt;
450         int ret;
451         __be32 addr;
452         __be16 port;
453
454         LIST_HEAD(msgq);
455
456         _enter("%p{%d}", trans, trans->port);
457
458         for (;;) {
459                 /* deal with outstanting errors first */
460                 if (trans->error_rcvd)
461                         rxrpc_trans_receive_error_report(trans);
462
463                 /* attempt to receive a packet */
464                 pkt = skb_recv_datagram(trans->socket->sk, 0, 1, &ret);
465                 if (!pkt) {
466                         if (ret == -EAGAIN) {
467                                 _leave(" EAGAIN");
468                                 return;
469                         }
470
471                         /* an icmp error may have occurred */
472                         rxrpc_krxiod_queue_transport(trans);
473                         _leave(" error %d\n", ret);
474                         return;
475                 }
476
477                 /* we'll probably need to checksum it (didn't call
478                  * sock_recvmsg) */
479                 if (skb_checksum_complete(pkt)) {
480                         kfree_skb(pkt);
481                         rxrpc_krxiod_queue_transport(trans);
482                         _leave(" CSUM failed");
483                         return;
484                 }
485
486                 addr = pkt->nh.iph->saddr;
487                 port = pkt->h.uh->source;
488
489                 _net("Rx Received UDP packet from %08x:%04hu",
490                      ntohl(addr), ntohs(port));
491
492                 /* unmarshall the Rx parameters and split jumbo packets */
493                 ret = rxrpc_incoming_msg(trans, pkt, &msgq);
494                 if (ret < 0) {
495                         kfree_skb(pkt);
496                         rxrpc_krxiod_queue_transport(trans);
497                         _leave(" bad packet");
498                         return;
499                 }
500
501                 BUG_ON(list_empty(&msgq));
502
503                 msg = list_entry(msgq.next, struct rxrpc_message, link);
504
505                 /* locate the record for the peer from which it
506                  * originated */
507                 ret = rxrpc_peer_lookup(trans, addr, &peer);
508                 if (ret < 0) {
509                         kdebug("Rx No connections from that peer");
510                         rxrpc_trans_immediate_abort(trans, msg, -EINVAL);
511                         goto finished_msg;
512                 }
513
514                 /* try and find a matching connection */
515                 ret = rxrpc_connection_lookup(peer, msg, &msg->conn);
516                 if (ret < 0) {
517                         kdebug("Rx Unknown Connection");
518                         rxrpc_trans_immediate_abort(trans, msg, -EINVAL);
519                         rxrpc_put_peer(peer);
520                         goto finished_msg;
521                 }
522                 rxrpc_put_peer(peer);
523
524                 /* deal with the first packet of a new call */
525                 if (msg->hdr.flags & RXRPC_CLIENT_INITIATED &&
526                     msg->hdr.type == RXRPC_PACKET_TYPE_DATA &&
527                     ntohl(msg->hdr.seq) == 1
528                     ) {
529                         _debug("Rx New server call");
530                         rxrpc_trans_receive_new_call(trans, &msgq);
531                         goto finished_msg;
532                 }
533
534                 /* deal with subsequent packet(s) of call */
535                 _debug("Rx Call packet");
536                 while (!list_empty(&msgq)) {
537                         msg = list_entry(msgq.next, struct rxrpc_message, link);
538                         list_del_init(&msg->link);
539
540                         ret = rxrpc_conn_receive_call_packet(msg->conn, NULL, msg);
541                         if (ret < 0) {
542                                 rxrpc_trans_immediate_abort(trans, msg, ret);
543                                 rxrpc_put_message(msg);
544                                 goto finished_msg;
545                         }
546
547                         rxrpc_put_message(msg);
548                 }
549
550                 goto finished_msg;
551
552                 /* dispose of the packets */
553         finished_msg:
554                 while (!list_empty(&msgq)) {
555                         msg = list_entry(msgq.next, struct rxrpc_message, link);
556                         list_del_init(&msg->link);
557
558                         rxrpc_put_message(msg);
559                 }
560                 kfree_skb(pkt);
561         }
562
563         _leave("");
564
565 } /* end rxrpc_trans_receive_packet() */
566
567 /*****************************************************************************/
568 /*
569  * accept a new call from a client trying to connect to one of my services
570  * - called in process context
571  */
572 static int rxrpc_trans_receive_new_call(struct rxrpc_transport *trans,
573                                         struct list_head *msgq)
574 {
575         struct rxrpc_message *msg;
576
577         _enter("");
578
579         /* only bother with the first packet */
580         msg = list_entry(msgq->next, struct rxrpc_message, link);
581         list_del_init(&msg->link);
582         rxrpc_krxsecd_queue_incoming_call(msg);
583         rxrpc_put_message(msg);
584
585         _leave(" = 0");
586
587         return 0;
588 } /* end rxrpc_trans_receive_new_call() */
589
590 /*****************************************************************************/
591 /*
592  * perform an immediate abort without connection or call structures
593  */
594 int rxrpc_trans_immediate_abort(struct rxrpc_transport *trans,
595                                 struct rxrpc_message *msg,
596                                 int error)
597 {
598         struct rxrpc_header ahdr;
599         struct sockaddr_in sin;
600         struct msghdr msghdr;
601         struct kvec iov[2];
602         __be32 _error;
603         int len, ret;
604
605         _enter("%p,%p,%d", trans, msg, error);
606
607         /* don't abort an abort packet */
608         if (msg->hdr.type == RXRPC_PACKET_TYPE_ABORT) {
609                 _leave(" = 0");
610                 return 0;
611         }
612
613         _error = htonl(-error);
614
615         /* set up the message to be transmitted */
616         memcpy(&ahdr, &msg->hdr, sizeof(ahdr));
617         ahdr.epoch      = msg->hdr.epoch;
618         ahdr.serial     = htonl(1);
619         ahdr.seq        = 0;
620         ahdr.type       = RXRPC_PACKET_TYPE_ABORT;
621         ahdr.flags      = RXRPC_LAST_PACKET;
622         ahdr.flags      |= ~msg->hdr.flags & RXRPC_CLIENT_INITIATED;
623
624         iov[0].iov_len  = sizeof(ahdr);
625         iov[0].iov_base = &ahdr;
626         iov[1].iov_len  = sizeof(_error);
627         iov[1].iov_base = &_error;
628
629         len = sizeof(ahdr) + sizeof(_error);
630
631         memset(&sin,0,sizeof(sin));
632         sin.sin_family          = AF_INET;
633         sin.sin_port            = msg->pkt->h.uh->source;
634         sin.sin_addr.s_addr     = msg->pkt->nh.iph->saddr;
635
636         msghdr.msg_name         = &sin;
637         msghdr.msg_namelen      = sizeof(sin);
638         msghdr.msg_control      = NULL;
639         msghdr.msg_controllen   = 0;
640         msghdr.msg_flags        = MSG_DONTWAIT;
641
642         _net("Sending message type %d of %d bytes to %08x:%d",
643              ahdr.type,
644              len,
645              ntohl(sin.sin_addr.s_addr),
646              ntohs(sin.sin_port));
647
648         /* send the message */
649         ret = kernel_sendmsg(trans->socket, &msghdr, iov, 2, len);
650
651         _leave(" = %d", ret);
652         return ret;
653 } /* end rxrpc_trans_immediate_abort() */
654
655 /*****************************************************************************/
656 /*
657  * receive an ICMP error report and percolate it to all connections
658  * heading to the affected host or port
659  */
660 static void rxrpc_trans_receive_error_report(struct rxrpc_transport *trans)
661 {
662         struct rxrpc_connection *conn;
663         struct sockaddr_in sin;
664         struct rxrpc_peer *peer;
665         struct list_head connq, *_p;
666         struct errormsg emsg;
667         struct msghdr msg;
668         __be16 port;
669         int local, err;
670
671         _enter("%p", trans);
672
673         for (;;) {
674                 trans->error_rcvd = 0;
675
676                 /* try and receive an error message */
677                 msg.msg_name    = &sin;
678                 msg.msg_namelen = sizeof(sin);
679                 msg.msg_control = &emsg;
680                 msg.msg_controllen = sizeof(emsg);
681                 msg.msg_flags   = 0;
682
683                 err = kernel_recvmsg(trans->socket, &msg, NULL, 0, 0,
684                                    MSG_ERRQUEUE | MSG_DONTWAIT | MSG_TRUNC);
685
686                 if (err == -EAGAIN) {
687                         _leave("");
688                         return;
689                 }
690
691                 if (err < 0) {
692                         printk("%s: unable to recv an error report: %d\n",
693                                __FUNCTION__, err);
694                         _leave("");
695                         return;
696                 }
697
698                 msg.msg_controllen = (char *) msg.msg_control - (char *) &emsg;
699
700                 if (msg.msg_controllen < sizeof(emsg.cmsg) ||
701                     msg.msg_namelen < sizeof(sin)) {
702                         printk("%s: short control message"
703                                " (nlen=%u clen=%Zu fl=%x)\n",
704                                __FUNCTION__,
705                                msg.msg_namelen,
706                                msg.msg_controllen,
707                                msg.msg_flags);
708                         continue;
709                 }
710
711                 _net("Rx Received control message"
712                      " { len=%Zu level=%u type=%u }",
713                      emsg.cmsg.cmsg_len,
714                      emsg.cmsg.cmsg_level,
715                      emsg.cmsg.cmsg_type);
716
717                 if (sin.sin_family != AF_INET) {
718                         printk("Rx Ignoring error report with non-INET address"
719                                " (fam=%u)",
720                                sin.sin_family);
721                         continue;
722                 }
723
724                 _net("Rx Received message pertaining to host addr=%x port=%hu",
725                      ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port));
726
727                 if (emsg.cmsg.cmsg_level != SOL_IP ||
728                     emsg.cmsg.cmsg_type != IP_RECVERR) {
729                         printk("Rx Ignoring unknown error report"
730                                " { level=%u type=%u }",
731                                emsg.cmsg.cmsg_level,
732                                emsg.cmsg.cmsg_type);
733                         continue;
734                 }
735
736                 if (msg.msg_controllen < sizeof(emsg.cmsg) + sizeof(emsg.ee)) {
737                         printk("%s: short error message (%Zu)\n",
738                                __FUNCTION__, msg.msg_controllen);
739                         _leave("");
740                         return;
741                 }
742
743                 port = sin.sin_port;
744
745                 switch (emsg.ee.ee_origin) {
746                 case SO_EE_ORIGIN_ICMP:
747                         local = 0;
748                         switch (emsg.ee.ee_type) {
749                         case ICMP_DEST_UNREACH:
750                                 switch (emsg.ee.ee_code) {
751                                 case ICMP_NET_UNREACH:
752                                         _net("Rx Received ICMP Network Unreachable");
753                                         port = 0;
754                                         err = -ENETUNREACH;
755                                         break;
756                                 case ICMP_HOST_UNREACH:
757                                         _net("Rx Received ICMP Host Unreachable");
758                                         port = 0;
759                                         err = -EHOSTUNREACH;
760                                         break;
761                                 case ICMP_PORT_UNREACH:
762                                         _net("Rx Received ICMP Port Unreachable");
763                                         err = -ECONNREFUSED;
764                                         break;
765                                 case ICMP_NET_UNKNOWN:
766                                         _net("Rx Received ICMP Unknown Network");
767                                         port = 0;
768                                         err = -ENETUNREACH;
769                                         break;
770                                 case ICMP_HOST_UNKNOWN:
771                                         _net("Rx Received ICMP Unknown Host");
772                                         port = 0;
773                                         err = -EHOSTUNREACH;
774                                         break;
775                                 default:
776                                         _net("Rx Received ICMP DestUnreach { code=%u }",
777                                              emsg.ee.ee_code);
778                                         err = emsg.ee.ee_errno;
779                                         break;
780                                 }
781                                 break;
782
783                         case ICMP_TIME_EXCEEDED:
784                                 _net("Rx Received ICMP TTL Exceeded");
785                                 err = emsg.ee.ee_errno;
786                                 break;
787
788                         default:
789                                 _proto("Rx Received ICMP error { type=%u code=%u }",
790                                        emsg.ee.ee_type, emsg.ee.ee_code);
791                                 err = emsg.ee.ee_errno;
792                                 break;
793                         }
794                         break;
795
796                 case SO_EE_ORIGIN_LOCAL:
797                         _proto("Rx Received local error { error=%d }",
798                                emsg.ee.ee_errno);
799                         local = 1;
800                         err = emsg.ee.ee_errno;
801                         break;
802
803                 case SO_EE_ORIGIN_NONE:
804                 case SO_EE_ORIGIN_ICMP6:
805                 default:
806                         _proto("Rx Received error report { orig=%u }",
807                                emsg.ee.ee_origin);
808                         local = 0;
809                         err = emsg.ee.ee_errno;
810                         break;
811                 }
812
813                 /* find all the connections between this transport and the
814                  * affected destination */
815                 INIT_LIST_HEAD(&connq);
816
817                 if (rxrpc_peer_lookup(trans, sin.sin_addr.s_addr,
818                                       &peer) == 0) {
819                         read_lock(&peer->conn_lock);
820                         list_for_each(_p, &peer->conn_active) {
821                                 conn = list_entry(_p, struct rxrpc_connection,
822                                                   link);
823                                 if (port && conn->addr.sin_port != port)
824                                         continue;
825                                 if (!list_empty(&conn->err_link))
826                                         continue;
827
828                                 rxrpc_get_connection(conn);
829                                 list_add_tail(&conn->err_link, &connq);
830                         }
831                         read_unlock(&peer->conn_lock);
832
833                         /* service all those connections */
834                         while (!list_empty(&connq)) {
835                                 conn = list_entry(connq.next,
836                                                   struct rxrpc_connection,
837                                                   err_link);
838                                 list_del(&conn->err_link);
839
840                                 rxrpc_conn_handle_error(conn, local, err);
841
842                                 rxrpc_put_connection(conn);
843                         }
844
845                         rxrpc_put_peer(peer);
846                 }
847         }
848
849         _leave("");
850         return;
851 } /* end rxrpc_trans_receive_error_report() */