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