Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/isakmpd/transport.c	Lines:	0	105	0.0 %
Date:	2016-12-06	Branches:	0	92	0.0 %


/* $OpenBSD: transport.c,v 1.37 2016/03/10 07:32:16 yasuoka Exp $	 */
/* $EOM: transport.c,v 1.43 2000/10/10 12:36:39 provos Exp $	 */

/*
 * Copyright (c) 1998, 1999 Niklas Hallqvist.  All rights reserved.
 * Copyright (c) 2001, 2004 H�kan Olsson.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This code was written under funding by Ericsson Radio Systems.
 */

#include <sys/queue.h>
#include <netdb.h>
#include <string.h>

#include "conf.h"
#include "exchange.h"
#include "log.h"
#include "message.h"
#include "sa.h"
#include "timer.h"
#include "transport.h"
#include "virtual.h"

/* If no retransmit limit is given, use this as a default.  */
#define RETRANSMIT_DEFAULT 10

LIST_HEAD(transport_method_list, transport_vtbl) transport_method_list;

/* Call the reinit function of the various transports.  */
void
transport_reinit(void)
{
	struct transport_vtbl *method;

	for (method = LIST_FIRST(&transport_method_list); method;
	    method = LIST_NEXT(method, link))
		if (method->reinit)
			method->reinit();
}

/* Initialize the transport maintenance module.  */
void
transport_init(void)
{
	LIST_INIT(&transport_list);
	LIST_INIT(&transport_method_list);
}

/* Register another transport T.  */
void
transport_setup(struct transport *t, int toplevel)
{
	if (toplevel) {
		/* Only the toplevel (virtual) transport has sendqueues.  */
		LOG_DBG((LOG_TRANSPORT, 70,
		    "transport_setup: virtual transport %p", t));
		TAILQ_INIT(&t->sendq);
		TAILQ_INIT(&t->prio_sendq);
		t->refcnt = 0;
	} else {
		/* udp and udp_encap trp goes into the transport list.  */
		LOG_DBG((LOG_TRANSPORT, 70,
		    "transport_setup: added %p to transport list", t));
		LIST_INSERT_HEAD(&transport_list, t, link);
		t->refcnt = 1;
	}
	t->flags = 0;
}

/* Add a referer to transport T.  */
void
transport_reference(struct transport *t)
{
	t->refcnt++;
	LOG_DBG((LOG_TRANSPORT, 95,
	    "transport_reference: transport %p now has %d references", t,
	    t->refcnt));
}

/*
 * Remove a referer from transport T, removing all of T when no referers left.
 */
void
transport_release(struct transport *t)
{
	LOG_DBG((LOG_TRANSPORT, 95,
	    "transport_release: transport %p had %d references", t,
	    t->refcnt));
	if (--t->refcnt)
		return;

	LOG_DBG((LOG_TRANSPORT, 70, "transport_release: freeing %p", t));
	t->vtbl->remove(t);
}

void
transport_report(void)
{
	struct virtual_transport *v;
	struct transport *t;
	struct message *msg;

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
		LOG_DBG((LOG_REPORT, 0,
		    "transport_report: transport %p flags %x refcnt %d", t,
		    t->flags, t->refcnt));

		/* XXX Report sth on the virtual transport?  */
		t->vtbl->report(t);

		/*
		 * This is the reason message_dump_raw lives outside
		 * message.c.
		 */
		v = (struct virtual_transport *)t->virtual;
		if ((v->encap_is_active && v->encap == t) ||
		    (!v->encap_is_active && v->main == t)) {
			for (msg = TAILQ_FIRST(&t->virtual->prio_sendq); msg;
			    msg = TAILQ_NEXT(msg, link))
				message_dump_raw("udp_report(prio)", msg,
				    LOG_REPORT);

			for (msg = TAILQ_FIRST(&t->virtual->sendq); msg;
			    msg = TAILQ_NEXT(msg, link))
				message_dump_raw("udp_report", msg,
				    LOG_REPORT);
		}
	}
}

int
transport_prio_sendqs_empty(void)
{
	struct transport *t;

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
		if (TAILQ_FIRST(&t->virtual->prio_sendq))
			return 0;
	return 1;
}

/* Register another transport method T.  */
void
transport_method_add(struct transport_vtbl *t)
{
	LIST_INSERT_HEAD(&transport_method_list, t, link);
}

/*
 * Build up a file descriptor set FDS with all transport descriptors we want
 * to read from.  Return the number of file descriptors select(2) needs to
 * check in order to cover the ones we setup in here.
 */
int
transport_fd_set(fd_set * fds)
{
	struct transport *t;
	int	n;
	int	max = -1;

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
		if (t->virtual->flags & TRANSPORT_LISTEN) {
			n = t->vtbl->fd_set(t, fds, 1);
			if (n > max)
				max = n;

			LOG_DBG((LOG_TRANSPORT, 95, "transport_fd_set: "
			    "transport %p (virtual %p) fd %d", t,
			    t->virtual, n));
		}
	return max + 1;
}

/*
 * Build up a file descriptor set FDS with all the descriptors belonging to
 * transport where messages are queued for transmittal.  Return the number
 * of file descriptors select(2) needs to check in order to cover the ones
 * we setup in here.
 */
int
transport_pending_wfd_set(fd_set * fds)
{
	struct transport *t;
	int	n;
	int	max = -1;

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
		if (TAILQ_FIRST(&t->virtual->sendq) ||
		    TAILQ_FIRST(&t->virtual->prio_sendq)) {
			n = t->vtbl->fd_set(t, fds, 1);
			LOG_DBG((LOG_TRANSPORT, 95,
			    "transport_pending_wfd_set: "
			    "transport %p (virtual %p) fd %d pending", t,
			    t->virtual, n));
			if (n > max)
				max = n;
		}
	}
	return max + 1;
}

/*
 * For each transport with a file descriptor in FDS, try to get an
 * incoming message and start processing it.
 */
void
transport_handle_messages(fd_set *fds)
{
	struct transport *t;

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
		if ((t->flags & TRANSPORT_LISTEN) &&
		    (*t->vtbl->fd_isset)(t, fds)) {
			(*t->virtual->vtbl->handle_message)(t);
			(*t->vtbl->fd_set)(t, fds, 0);
		}
	}
}

/*
 * Send the first queued message on the transports found whose file
 * descriptor is in FDS and has messages queued.  Remove the fd bit from
 * FDS as soon as one message has been sent on it so other transports
 * sharing the socket won't get service without an intervening select
 * call.  Perhaps a fairness strategy should be implemented between
 * such transports.  Now early transports in the list will potentially
 * be favoured to later ones sharing the file descriptor.
 */
void
transport_send_messages(fd_set * fds)
{
	struct transport *t, *next;
	struct message *msg;
	struct exchange *exchange;
	struct sockaddr *dst;
	struct timeval  expiration;
	int             expiry, ok_to_drop_message;
	char peer[NI_MAXHOST], peersv[NI_MAXSERV];

	/*
	 * Reference all transports first so noone will disappear while in
	 * use.
	 */
	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
		transport_reference(t->virtual);

	for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
		if ((TAILQ_FIRST(&t->virtual->sendq) ||
		    TAILQ_FIRST(&t->virtual->prio_sendq)) &&
		    t->vtbl->fd_isset(t, fds)) {
			/* Remove fd bit.  */
			t->vtbl->fd_set(t, fds, 0);

			/* Prefer a message from the prioritized sendq.  */
			if (TAILQ_FIRST(&t->virtual->prio_sendq)) {
				msg = TAILQ_FIRST(&t->virtual->prio_sendq);
				TAILQ_REMOVE(&t->virtual->prio_sendq, msg,
				    link);
			} else {
				msg = TAILQ_FIRST(&t->virtual->sendq);
				TAILQ_REMOVE(&t->virtual->sendq, msg, link);
			}

			msg->flags &= ~MSG_IN_TRANSIT;
			exchange = msg->exchange;
			exchange->in_transit = 0;

			/*
			 * We disregard the potential error message here,
			 * hoping that the retransmit will go better.
			 * XXX Consider a retry/fatal error discriminator.
			 */
			t->virtual->vtbl->send_message(msg, 0);
			msg->xmits++;

			/*
			 * This piece of code has been proven to be quite
			 * delicate. Think twice for before altering.
			 * Here's an outline:
			 *
			 * If this message is not the one which finishes an
			 * exchange, check if we have reached the number of
			 * retransmit before queuing it up for another.
			 *
			 * If it is a finishing message we still may have to
			 * keep it around for an on-demand retransmit when
			 * seeing a duplicate of our peer's previous message.
			 */
			if ((msg->flags & MSG_LAST) == 0) {
				if (msg->flags & MSG_DONTRETRANSMIT)
					exchange->last_sent = 0;
				else if (msg->xmits > conf_get_num("General",
				    "retransmits", RETRANSMIT_DEFAULT)) {
					t->virtual->vtbl->get_dst(t->virtual, &dst);
					if (getnameinfo(dst, SA_LEN(dst), peer,
					    sizeof peer, peersv, sizeof peersv,
					    NI_NUMERICHOST | NI_NUMERICSERV)) {
						strlcpy(peer, "<unknown>", sizeof peer);
						strlcpy(peersv, "<?>", sizeof peersv);
					}
					log_print("transport_send_messages: "
					    "giving up on exchange %s, no "
					    "response from peer %s:%s",
					    exchange->name ? exchange->name :
					    "<unnamed>", peer, peersv);

					exchange->last_sent = 0;
#ifdef notyet
					exchange_free(exchange);
					exchange = 0;
#endif
				} else {
					gettimeofday(&expiration, 0);

					/*
					 * XXX Calculate from round trip
					 * timings and a backoff func.
					 */
					expiry = msg->xmits * 2 + 5;
					expiration.tv_sec += expiry;
					LOG_DBG((LOG_TRANSPORT, 30,
					    "transport_send_messages: "
					    "message %p scheduled for "
					    "retransmission %d in %d secs",
					    msg, msg->xmits, expiry));
					if (msg->retrans)
						timer_remove_event(msg->retrans);
					msg->retrans
					    = timer_add_event("message_send_expire",
						(void (*) (void *)) message_send_expire,
						msg, &expiration);
					/*
					 * If we cannot retransmit, we
					 * cannot...
					 */
					exchange->last_sent =
					    msg->retrans ? msg : 0;
				}
			} else
				exchange->last_sent =
				    exchange->last_received ? msg : 0;

			/*
			 * If this message is not referred to for later
			 * retransmission it will be ok for us to drop it
			 * after the post-send function. But as the post-send
			 * function may remove the exchange, we need to
			 * remember this fact here.
			 */
			ok_to_drop_message = exchange->last_sent == 0;

			/*
			 * If this is not a retransmit call post-send
			 * functions that allows parallel work to be done
			 * while the network and peer does their share of
			 * the job.  Note that a post-send function may take
			 * away the exchange we belong to, but only if no
			 * retransmits are possible.
			 */
			if (msg->xmits == 1)
				message_post_send(msg);

			if (ok_to_drop_message)
				message_free(msg);
		}
	}

	for (t = LIST_FIRST(&transport_list); t; t = next) {
		next = LIST_NEXT(t, link);
		transport_release(t->virtual);
	}
}

/*
 * Textual search after the transport method denoted by NAME, then create
 * a transport connected to the peer with address ADDR, given in a transport-
 * specific string format.
 */
struct transport *
transport_create(char *name, char *addr)
{
	struct transport_vtbl *method;

	for (method = LIST_FIRST(&transport_method_list); method;
	    method = LIST_NEXT(method, link))
		if (strcmp(method->name, name) == 0)
			return (*method->create) (addr);
	return 0;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: transport.c,v 1.37 2016/03/10 07:32:16 yasuoka Exp $ */
2			/* $EOM: transport.c,v 1.43 2000/10/10 12:36:39 provos Exp $ */
3
4			/*
5			* Copyright (c) 1998, 1999 Niklas Hallqvist. All rights reserved.
6			* Copyright (c) 2001, 2004 H�kan Olsson. All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20			* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26			* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27			*/
28
29			/*
30			* This code was written under funding by Ericsson Radio Systems.
31			*/
32
33			#include <sys/queue.h>
34			#include <netdb.h>
35			#include <string.h>
36
37			#include "conf.h"
38			#include "exchange.h"
39			#include "log.h"
40			#include "message.h"
41			#include "sa.h"
42			#include "timer.h"
43			#include "transport.h"
44			#include "virtual.h"
45
46			/* If no retransmit limit is given, use this as a default. */
47			#define RETRANSMIT_DEFAULT 10
48
49			LIST_HEAD(transport_method_list, transport_vtbl) transport_method_list;
50
51			/* Call the reinit function of the various transports. */
52			void
53			transport_reinit(void)
54			{
55			struct transport_vtbl *method;
56
57			for (method = LIST_FIRST(&transport_method_list); method;
58			method = LIST_NEXT(method, link))
59			if (method->reinit)
60			method->reinit();
61			}
62
63			/* Initialize the transport maintenance module. */
64			void
65			transport_init(void)
66			{
67			LIST_INIT(&transport_list);
68			LIST_INIT(&transport_method_list);
69			}
70
71			/* Register another transport T. */
72			void
73			transport_setup(struct transport *t, int toplevel)
74			{
75			if (toplevel) {
76			/* Only the toplevel (virtual) transport has sendqueues. */
77			LOG_DBG((LOG_TRANSPORT, 70,
78			"transport_setup: virtual transport %p", t));
79			TAILQ_INIT(&t->sendq);
80			TAILQ_INIT(&t->prio_sendq);
81			t->refcnt = 0;
82			} else {
83			/* udp and udp_encap trp goes into the transport list. */
84			LOG_DBG((LOG_TRANSPORT, 70,
85			"transport_setup: added %p to transport list", t));
86			LIST_INSERT_HEAD(&transport_list, t, link);
87			t->refcnt = 1;
88			}
89			t->flags = 0;
90			}
91
92			/* Add a referer to transport T. */
93			void
94			transport_reference(struct transport *t)
95			{
96			t->refcnt++;
97			LOG_DBG((LOG_TRANSPORT, 95,
98			"transport_reference: transport %p now has %d references", t,
99			t->refcnt));
100			}
101
102			/*
103			* Remove a referer from transport T, removing all of T when no referers left.
104			*/
105			void
106			transport_release(struct transport *t)
107			{
108			LOG_DBG((LOG_TRANSPORT, 95,
109			"transport_release: transport %p had %d references", t,
110			t->refcnt));
111			if (--t->refcnt)
112			return;
113
114			LOG_DBG((LOG_TRANSPORT, 70, "transport_release: freeing %p", t));
115			t->vtbl->remove(t);
116			}
117
118			void
119			transport_report(void)
120			{
121			struct virtual_transport *v;
122			struct transport *t;
123			struct message *msg;
124
125			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
126			LOG_DBG((LOG_REPORT, 0,
127			"transport_report: transport %p flags %x refcnt %d", t,
128			t->flags, t->refcnt));
129
130			/* XXX Report sth on the virtual transport? */
131			t->vtbl->report(t);
132
133			/*
134			* This is the reason message_dump_raw lives outside
135			* message.c.
136			*/
137			v = (struct virtual_transport *)t->virtual;
138			if ((v->encap_is_active && v->encap == t) \|\|
139			(!v->encap_is_active && v->main == t)) {
140			for (msg = TAILQ_FIRST(&t->virtual->prio_sendq); msg;
141			msg = TAILQ_NEXT(msg, link))
142			message_dump_raw("udp_report(prio)", msg,
143			LOG_REPORT);
144
145			for (msg = TAILQ_FIRST(&t->virtual->sendq); msg;
146			msg = TAILQ_NEXT(msg, link))
147			message_dump_raw("udp_report", msg,
148			LOG_REPORT);
149			}
150			}
151			}
152
153			int
154			transport_prio_sendqs_empty(void)
155			{
156			struct transport *t;
157
158			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
159			if (TAILQ_FIRST(&t->virtual->prio_sendq))
160			return 0;
161			return 1;
162			}
163
164			/* Register another transport method T. */
165			void
166			transport_method_add(struct transport_vtbl *t)
167			{
168			LIST_INSERT_HEAD(&transport_method_list, t, link);
169			}
170
171			/*
172			* Build up a file descriptor set FDS with all transport descriptors we want
173			* to read from. Return the number of file descriptors select(2) needs to
174			* check in order to cover the ones we setup in here.
175			*/
176			int
177			transport_fd_set(fd_set * fds)
178			{
179			struct transport *t;
180			int n;
181			int max = -1;
182
183			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
184			if (t->virtual->flags & TRANSPORT_LISTEN) {
185			n = t->vtbl->fd_set(t, fds, 1);
186			if (n > max)
187			max = n;
188
189			LOG_DBG((LOG_TRANSPORT, 95, "transport_fd_set: "
190			"transport %p (virtual %p) fd %d", t,
191			t->virtual, n));
192			}
193			return max + 1;
194			}
195
196			/*
197			* Build up a file descriptor set FDS with all the descriptors belonging to
198			* transport where messages are queued for transmittal. Return the number
199			* of file descriptors select(2) needs to check in order to cover the ones
200			* we setup in here.
201			*/
202			int
203			transport_pending_wfd_set(fd_set * fds)
204			{
205			struct transport *t;
206			int n;
207			int max = -1;
208
209			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
210			if (TAILQ_FIRST(&t->virtual->sendq) \|\|
211			TAILQ_FIRST(&t->virtual->prio_sendq)) {
212			n = t->vtbl->fd_set(t, fds, 1);
213			LOG_DBG((LOG_TRANSPORT, 95,
214			"transport_pending_wfd_set: "
215			"transport %p (virtual %p) fd %d pending", t,
216			t->virtual, n));
217			if (n > max)
218			max = n;
219			}
220			}
221			return max + 1;
222			}
223
224			/*
225			* For each transport with a file descriptor in FDS, try to get an
226			* incoming message and start processing it.
227			*/
228			void
229			transport_handle_messages(fd_set *fds)
230			{
231			struct transport *t;
232
233			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
234			if ((t->flags & TRANSPORT_LISTEN) &&
235			(*t->vtbl->fd_isset)(t, fds)) {
236			(*t->virtual->vtbl->handle_message)(t);
237			(*t->vtbl->fd_set)(t, fds, 0);
238			}
239			}
240			}
241
242			/*
243			* Send the first queued message on the transports found whose file
244			* descriptor is in FDS and has messages queued. Remove the fd bit from
245			* FDS as soon as one message has been sent on it so other transports
246			* sharing the socket won't get service without an intervening select
247			* call. Perhaps a fairness strategy should be implemented between
248			* such transports. Now early transports in the list will potentially
249			* be favoured to later ones sharing the file descriptor.
250			*/
251			void
252			transport_send_messages(fd_set * fds)
253			{
254			struct transport t, next;
255			struct message *msg;
256			struct exchange *exchange;
257			struct sockaddr *dst;
258			struct timeval expiration;
259			int expiry, ok_to_drop_message;
260			char peer[NI_MAXHOST], peersv[NI_MAXSERV];
261
262			/*
263			* Reference all transports first so noone will disappear while in
264			* use.
265			*/
266			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link))
267			transport_reference(t->virtual);
268
269			for (t = LIST_FIRST(&transport_list); t; t = LIST_NEXT(t, link)) {
270			if ((TAILQ_FIRST(&t->virtual->sendq) \|\|
271			TAILQ_FIRST(&t->virtual->prio_sendq)) &&
272			t->vtbl->fd_isset(t, fds)) {
273			/* Remove fd bit. */
274			t->vtbl->fd_set(t, fds, 0);
275
276			/* Prefer a message from the prioritized sendq. */
277			if (TAILQ_FIRST(&t->virtual->prio_sendq)) {
278			msg = TAILQ_FIRST(&t->virtual->prio_sendq);
279			TAILQ_REMOVE(&t->virtual->prio_sendq, msg,
280			link);
281			} else {
282			msg = TAILQ_FIRST(&t->virtual->sendq);
283			TAILQ_REMOVE(&t->virtual->sendq, msg, link);
284			}
285
286			msg->flags &= ~MSG_IN_TRANSIT;
287			exchange = msg->exchange;
288			exchange->in_transit = 0;
289
290			/*
291			* We disregard the potential error message here,
292			* hoping that the retransmit will go better.
293			* XXX Consider a retry/fatal error discriminator.
294			*/
295			t->virtual->vtbl->send_message(msg, 0);
296			msg->xmits++;
297
298			/*
299			* This piece of code has been proven to be quite
300			* delicate. Think twice for before altering.
301			* Here's an outline:
302			*
303			* If this message is not the one which finishes an
304			* exchange, check if we have reached the number of
305			* retransmit before queuing it up for another.
306			*
307			* If it is a finishing message we still may have to
308			* keep it around for an on-demand retransmit when
309			* seeing a duplicate of our peer's previous message.
310			*/
311			if ((msg->flags & MSG_LAST) == 0) {
312			if (msg->flags & MSG_DONTRETRANSMIT)
313			exchange->last_sent = 0;
314			else if (msg->xmits > conf_get_num("General",
315			"retransmits", RETRANSMIT_DEFAULT)) {
316			t->virtual->vtbl->get_dst(t->virtual, &dst);
317			if (getnameinfo(dst, SA_LEN(dst), peer,
318			sizeof peer, peersv, sizeof peersv,
319			NI_NUMERICHOST \| NI_NUMERICSERV)) {
320			strlcpy(peer, "<unknown>", sizeof peer);
321			strlcpy(peersv, "<?>", sizeof peersv);
322			}
323			log_print("transport_send_messages: "
324			"giving up on exchange %s, no "
325			"response from peer %s:%s",
326			exchange->name ? exchange->name :
327			"<unnamed>", peer, peersv);
328
329			exchange->last_sent = 0;
330			#ifdef notyet
331			exchange_free(exchange);
332			exchange = 0;
333			#endif
334			} else {
335			gettimeofday(&expiration, 0);
336
337			/*
338			* XXX Calculate from round trip
339			* timings and a backoff func.
340			*/
341			expiry = msg->xmits * 2 + 5;
342			expiration.tv_sec += expiry;
343			LOG_DBG((LOG_TRANSPORT, 30,
344			"transport_send_messages: "
345			"message %p scheduled for "
346			"retransmission %d in %d secs",
347			msg, msg->xmits, expiry));
348			if (msg->retrans)
349			timer_remove_event(msg->retrans);
350			msg->retrans
351			= timer_add_event("message_send_expire",
352			(void () (void )) message_send_expire,
353			msg, &expiration);
354			/*
355			* If we cannot retransmit, we
356			* cannot...
357			*/
358			exchange->last_sent =
359			msg->retrans ? msg : 0;
360			}
361			} else
362			exchange->last_sent =
363			exchange->last_received ? msg : 0;
364
365			/*
366			* If this message is not referred to for later
367			* retransmission it will be ok for us to drop it
368			* after the post-send function. But as the post-send
369			* function may remove the exchange, we need to
370			* remember this fact here.
371			*/
372			ok_to_drop_message = exchange->last_sent == 0;
373
374			/*
375			* If this is not a retransmit call post-send
376			* functions that allows parallel work to be done
377			* while the network and peer does their share of
378			* the job. Note that a post-send function may take
379			* away the exchange we belong to, but only if no
380			* retransmits are possible.
381			*/
382			if (msg->xmits == 1)
383			message_post_send(msg);
384
385			if (ok_to_drop_message)
386			message_free(msg);
387			}
388			}
389
390			for (t = LIST_FIRST(&transport_list); t; t = next) {
391			next = LIST_NEXT(t, link);
392			transport_release(t->virtual);
393			}
394			}
395
396			/*
397			* Textual search after the transport method denoted by NAME, then create
398			* a transport connected to the peer with address ADDR, given in a transport-
399			* specific string format.
400			*/
401			struct transport *
402			transport_create(char name, char addr)
403			{
404			struct transport_vtbl *method;
405
406			for (method = LIST_FIRST(&transport_method_list); method;
407			method = LIST_NEXT(method, link))
408			if (strcmp(method->name, name) == 0)
409			return (*method->create) (addr);
410			return 0;
411			}