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