misc.c revision 204917 
1/* $OpenBSD: misc.c,v 1.75 2010/01/09 23:04:13 dtucker Exp $ */
2/*
3 * Copyright (c) 2000 Markus Friedl.  All rights reserved.
4 * Copyright (c) 2005,2006 Damien Miller.  All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include "includes.h"
28
29#include <sys/types.h>
30#include <sys/ioctl.h>
31#include <sys/socket.h>
32#include <sys/param.h>
33
34#include <stdarg.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <unistd.h>
39
40#include <netinet/in.h>
41#include <netinet/tcp.h>
42
43#include <errno.h>
44#include <fcntl.h>
45#include <netdb.h>
46#ifdef HAVE_PATHS_H
47# include <paths.h>
48#include <pwd.h>
49#endif
50#ifdef SSH_TUN_OPENBSD
51#include <net/if.h>
52#endif
53
54#include "xmalloc.h"
55#include "misc.h"
56#include "log.h"
57#include "ssh.h"
58
59/* remove newline at end of string */
60char *
61chop(char *s)
62{
63	char *t = s;
64	while (*t) {
65		if (*t == '\n' || *t == '\r') {
66			*t = '\0';
67			return s;
68		}
69		t++;
70	}
71	return s;
72
73}
74
75/* set/unset filedescriptor to non-blocking */
76int
77set_nonblock(int fd)
78{
79	int val;
80
81	val = fcntl(fd, F_GETFL, 0);
82	if (val < 0) {
83		error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
84		return (-1);
85	}
86	if (val & O_NONBLOCK) {
87		debug3("fd %d is O_NONBLOCK", fd);
88		return (0);
89	}
90	debug2("fd %d setting O_NONBLOCK", fd);
91	val |= O_NONBLOCK;
92	if (fcntl(fd, F_SETFL, val) == -1) {
93		debug("fcntl(%d, F_SETFL, O_NONBLOCK): %s", fd,
94		    strerror(errno));
95		return (-1);
96	}
97	return (0);
98}
99
100int
101unset_nonblock(int fd)
102{
103	int val;
104
105	val = fcntl(fd, F_GETFL, 0);
106	if (val < 0) {
107		error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
108		return (-1);
109	}
110	if (!(val & O_NONBLOCK)) {
111		debug3("fd %d is not O_NONBLOCK", fd);
112		return (0);
113	}
114	debug("fd %d clearing O_NONBLOCK", fd);
115	val &= ~O_NONBLOCK;
116	if (fcntl(fd, F_SETFL, val) == -1) {
117		debug("fcntl(%d, F_SETFL, ~O_NONBLOCK): %s",
118		    fd, strerror(errno));
119		return (-1);
120	}
121	return (0);
122}
123
124const char *
125ssh_gai_strerror(int gaierr)
126{
127	if (gaierr == EAI_SYSTEM)
128		return strerror(errno);
129	return gai_strerror(gaierr);
130}
131
132/* disable nagle on socket */
133void
134set_nodelay(int fd)
135{
136	int opt;
137	socklen_t optlen;
138
139	optlen = sizeof opt;
140	if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen) == -1) {
141		debug("getsockopt TCP_NODELAY: %.100s", strerror(errno));
142		return;
143	}
144	if (opt == 1) {
145		debug2("fd %d is TCP_NODELAY", fd);
146		return;
147	}
148	opt = 1;
149	debug2("fd %d setting TCP_NODELAY", fd);
150	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof opt) == -1)
151		error("setsockopt TCP_NODELAY: %.100s", strerror(errno));
152}
153
154/* Characters considered whitespace in strsep calls. */
155#define WHITESPACE " \t\r\n"
156#define QUOTE	"\""
157
158/* return next token in configuration line */
159char *
160strdelim(char **s)
161{
162	char *old;
163	int wspace = 0;
164
165	if (*s == NULL)
166		return NULL;
167
168	old = *s;
169
170	*s = strpbrk(*s, WHITESPACE QUOTE "=");
171	if (*s == NULL)
172		return (old);
173
174	if (*s[0] == '\"') {
175		memmove(*s, *s + 1, strlen(*s)); /* move nul too */
176		/* Find matching quote */
177		if ((*s = strpbrk(*s, QUOTE)) == NULL) {
178			return (NULL);		/* no matching quote */
179		} else {
180			*s[0] = '\0';
181			return (old);
182		}
183	}
184
185	/* Allow only one '=' to be skipped */
186	if (*s[0] == '=')
187		wspace = 1;
188	*s[0] = '\0';
189
190	/* Skip any extra whitespace after first token */
191	*s += strspn(*s + 1, WHITESPACE) + 1;
192	if (*s[0] == '=' && !wspace)
193		*s += strspn(*s + 1, WHITESPACE) + 1;
194
195	return (old);
196}
197
198struct passwd *
199pwcopy(struct passwd *pw)
200{
201	struct passwd *copy = xcalloc(1, sizeof(*copy));
202
203	copy->pw_name = xstrdup(pw->pw_name);
204	copy->pw_passwd = xstrdup(pw->pw_passwd);
205	copy->pw_gecos = xstrdup(pw->pw_gecos);
206	copy->pw_uid = pw->pw_uid;
207	copy->pw_gid = pw->pw_gid;
208#ifdef HAVE_PW_EXPIRE_IN_PASSWD
209	copy->pw_expire = pw->pw_expire;
210#endif
211#ifdef HAVE_PW_CHANGE_IN_PASSWD
212	copy->pw_change = pw->pw_change;
213#endif
214#ifdef HAVE_PW_CLASS_IN_PASSWD
215	copy->pw_class = xstrdup(pw->pw_class);
216#endif
217	copy->pw_dir = xstrdup(pw->pw_dir);
218	copy->pw_shell = xstrdup(pw->pw_shell);
219	return copy;
220}
221
222/*
223 * Convert ASCII string to TCP/IP port number.
224 * Port must be >=0 and <=65535.
225 * Return -1 if invalid.
226 */
227int
228a2port(const char *s)
229{
230	long long port;
231	const char *errstr;
232
233	port = strtonum(s, 0, 65535, &errstr);
234	if (errstr != NULL)
235		return -1;
236	return (int)port;
237}
238
239int
240a2tun(const char *s, int *remote)
241{
242	const char *errstr = NULL;
243	char *sp, *ep;
244	int tun;
245
246	if (remote != NULL) {
247		*remote = SSH_TUNID_ANY;
248		sp = xstrdup(s);
249		if ((ep = strchr(sp, ':')) == NULL) {
250			xfree(sp);
251			return (a2tun(s, NULL));
252		}
253		ep[0] = '\0'; ep++;
254		*remote = a2tun(ep, NULL);
255		tun = a2tun(sp, NULL);
256		xfree(sp);
257		return (*remote == SSH_TUNID_ERR ? *remote : tun);
258	}
259
260	if (strcasecmp(s, "any") == 0)
261		return (SSH_TUNID_ANY);
262
263	tun = strtonum(s, 0, SSH_TUNID_MAX, &errstr);
264	if (errstr != NULL)
265		return (SSH_TUNID_ERR);
266
267	return (tun);
268}
269
270#define SECONDS		1
271#define MINUTES		(SECONDS * 60)
272#define HOURS		(MINUTES * 60)
273#define DAYS		(HOURS * 24)
274#define WEEKS		(DAYS * 7)
275
276/*
277 * Convert a time string into seconds; format is
278 * a sequence of:
279 *      time[qualifier]
280 *
281 * Valid time qualifiers are:
282 *      <none>  seconds
283 *      s|S     seconds
284 *      m|M     minutes
285 *      h|H     hours
286 *      d|D     days
287 *      w|W     weeks
288 *
289 * Examples:
290 *      90m     90 minutes
291 *      1h30m   90 minutes
292 *      2d      2 days
293 *      1w      1 week
294 *
295 * Return -1 if time string is invalid.
296 */
297long
298convtime(const char *s)
299{
300	long total, secs;
301	const char *p;
302	char *endp;
303
304	errno = 0;
305	total = 0;
306	p = s;
307
308	if (p == NULL || *p == '\0')
309		return -1;
310
311	while (*p) {
312		secs = strtol(p, &endp, 10);
313		if (p == endp ||
314		    (errno == ERANGE && (secs == LONG_MIN || secs == LONG_MAX)) ||
315		    secs < 0)
316			return -1;
317
318		switch (*endp++) {
319		case '\0':
320			endp--;
321			break;
322		case 's':
323		case 'S':
324			break;
325		case 'm':
326		case 'M':
327			secs *= MINUTES;
328			break;
329		case 'h':
330		case 'H':
331			secs *= HOURS;
332			break;
333		case 'd':
334		case 'D':
335			secs *= DAYS;
336			break;
337		case 'w':
338		case 'W':
339			secs *= WEEKS;
340			break;
341		default:
342			return -1;
343		}
344		total += secs;
345		if (total < 0)
346			return -1;
347		p = endp;
348	}
349
350	return total;
351}
352
353/*
354 * Returns a standardized host+port identifier string.
355 * Caller must free returned string.
356 */
357char *
358put_host_port(const char *host, u_short port)
359{
360	char *hoststr;
361
362	if (port == 0 || port == SSH_DEFAULT_PORT)
363		return(xstrdup(host));
364	if (asprintf(&hoststr, "[%s]:%d", host, (int)port) < 0)
365		fatal("put_host_port: asprintf: %s", strerror(errno));
366	debug3("put_host_port: %s", hoststr);
367	return hoststr;
368}
369
370/*
371 * Search for next delimiter between hostnames/addresses and ports.
372 * Argument may be modified (for termination).
373 * Returns *cp if parsing succeeds.
374 * *cp is set to the start of the next delimiter, if one was found.
375 * If this is the last field, *cp is set to NULL.
376 */
377char *
378hpdelim(char **cp)
379{
380	char *s, *old;
381
382	if (cp == NULL || *cp == NULL)
383		return NULL;
384
385	old = s = *cp;
386	if (*s == '[') {
387		if ((s = strchr(s, ']')) == NULL)
388			return NULL;
389		else
390			s++;
391	} else if ((s = strpbrk(s, ":/")) == NULL)
392		s = *cp + strlen(*cp); /* skip to end (see first case below) */
393
394	switch (*s) {
395	case '\0':
396		*cp = NULL;	/* no more fields*/
397		break;
398
399	case ':':
400	case '/':
401		*s = '\0';	/* terminate */
402		*cp = s + 1;
403		break;
404
405	default:
406		return NULL;
407	}
408
409	return old;
410}
411
412char *
413cleanhostname(char *host)
414{
415	if (*host == '[' && host[strlen(host) - 1] == ']') {
416		host[strlen(host) - 1] = '\0';
417		return (host + 1);
418	} else
419		return host;
420}
421
422char *
423colon(char *cp)
424{
425	int flag = 0;
426
427	if (*cp == ':')		/* Leading colon is part of file name. */
428		return (0);
429	if (*cp == '[')
430		flag = 1;
431
432	for (; *cp; ++cp) {
433		if (*cp == '@' && *(cp+1) == '[')
434			flag = 1;
435		if (*cp == ']' && *(cp+1) == ':' && flag)
436			return (cp+1);
437		if (*cp == ':' && !flag)
438			return (cp);
439		if (*cp == '/')
440			return (0);
441	}
442	return (0);
443}
444
445/* function to assist building execv() arguments */
446void
447addargs(arglist *args, char *fmt, ...)
448{
449	va_list ap;
450	char *cp;
451	u_int nalloc;
452	int r;
453
454	va_start(ap, fmt);
455	r = vasprintf(&cp, fmt, ap);
456	va_end(ap);
457	if (r == -1)
458		fatal("addargs: argument too long");
459
460	nalloc = args->nalloc;
461	if (args->list == NULL) {
462		nalloc = 32;
463		args->num = 0;
464	} else if (args->num+2 >= nalloc)
465		nalloc *= 2;
466
467	args->list = xrealloc(args->list, nalloc, sizeof(char *));
468	args->nalloc = nalloc;
469	args->list[args->num++] = cp;
470	args->list[args->num] = NULL;
471}
472
473void
474replacearg(arglist *args, u_int which, char *fmt, ...)
475{
476	va_list ap;
477	char *cp;
478	int r;
479
480	va_start(ap, fmt);
481	r = vasprintf(&cp, fmt, ap);
482	va_end(ap);
483	if (r == -1)
484		fatal("replacearg: argument too long");
485
486	if (which >= args->num)
487		fatal("replacearg: tried to replace invalid arg %d >= %d",
488		    which, args->num);
489	xfree(args->list[which]);
490	args->list[which] = cp;
491}
492
493void
494freeargs(arglist *args)
495{
496	u_int i;
497
498	if (args->list != NULL) {
499		for (i = 0; i < args->num; i++)
500			xfree(args->list[i]);
501		xfree(args->list);
502		args->nalloc = args->num = 0;
503		args->list = NULL;
504	}
505}
506
507/*
508 * Expands tildes in the file name.  Returns data allocated by xmalloc.
509 * Warning: this calls getpw*.
510 */
511char *
512tilde_expand_filename(const char *filename, uid_t uid)
513{
514	const char *path;
515	char user[128], ret[MAXPATHLEN];
516	struct passwd *pw;
517	u_int len, slash;
518
519	if (*filename != '~')
520		return (xstrdup(filename));
521	filename++;
522
523	path = strchr(filename, '/');
524	if (path != NULL && path > filename) {		/* ~user/path */
525		slash = path - filename;
526		if (slash > sizeof(user) - 1)
527			fatal("tilde_expand_filename: ~username too long");
528		memcpy(user, filename, slash);
529		user[slash] = '\0';
530		if ((pw = getpwnam(user)) == NULL)
531			fatal("tilde_expand_filename: No such user %s", user);
532	} else if ((pw = getpwuid(uid)) == NULL)	/* ~/path */
533		fatal("tilde_expand_filename: No such uid %ld", (long)uid);
534
535	if (strlcpy(ret, pw->pw_dir, sizeof(ret)) >= sizeof(ret))
536		fatal("tilde_expand_filename: Path too long");
537
538	/* Make sure directory has a trailing '/' */
539	len = strlen(pw->pw_dir);
540	if ((len == 0 || pw->pw_dir[len - 1] != '/') &&
541	    strlcat(ret, "/", sizeof(ret)) >= sizeof(ret))
542		fatal("tilde_expand_filename: Path too long");
543
544	/* Skip leading '/' from specified path */
545	if (path != NULL)
546		filename = path + 1;
547	if (strlcat(ret, filename, sizeof(ret)) >= sizeof(ret))
548		fatal("tilde_expand_filename: Path too long");
549
550	return (xstrdup(ret));
551}
552
553/*
554 * Expand a string with a set of %[char] escapes. A number of escapes may be
555 * specified as (char *escape_chars, char *replacement) pairs. The list must
556 * be terminated by a NULL escape_char. Returns replaced string in memory
557 * allocated by xmalloc.
558 */
559char *
560percent_expand(const char *string, ...)
561{
562#define EXPAND_MAX_KEYS	16
563	u_int num_keys, i, j;
564	struct {
565		const char *key;
566		const char *repl;
567	} keys[EXPAND_MAX_KEYS];
568	char buf[4096];
569	va_list ap;
570
571	/* Gather keys */
572	va_start(ap, string);
573	for (num_keys = 0; num_keys < EXPAND_MAX_KEYS; num_keys++) {
574		keys[num_keys].key = va_arg(ap, char *);
575		if (keys[num_keys].key == NULL)
576			break;
577		keys[num_keys].repl = va_arg(ap, char *);
578		if (keys[num_keys].repl == NULL)
579			fatal("%s: NULL replacement", __func__);
580	}
581	if (num_keys == EXPAND_MAX_KEYS && va_arg(ap, char *) != NULL)
582		fatal("%s: too many keys", __func__);
583	va_end(ap);
584
585	/* Expand string */
586	*buf = '\0';
587	for (i = 0; *string != '\0'; string++) {
588		if (*string != '%') {
589 append:
590			buf[i++] = *string;
591			if (i >= sizeof(buf))
592				fatal("%s: string too long", __func__);
593			buf[i] = '\0';
594			continue;
595		}
596		string++;
597		/* %% case */
598		if (*string == '%')
599			goto append;
600		for (j = 0; j < num_keys; j++) {
601			if (strchr(keys[j].key, *string) != NULL) {
602				i = strlcat(buf, keys[j].repl, sizeof(buf));
603				if (i >= sizeof(buf))
604					fatal("%s: string too long", __func__);
605				break;
606			}
607		}
608		if (j >= num_keys)
609			fatal("%s: unknown key %%%c", __func__, *string);
610	}
611	return (xstrdup(buf));
612#undef EXPAND_MAX_KEYS
613}
614
615/*
616 * Read an entire line from a public key file into a static buffer, discarding
617 * lines that exceed the buffer size.  Returns 0 on success, -1 on failure.
618 */
619int
620read_keyfile_line(FILE *f, const char *filename, char *buf, size_t bufsz,
621   u_long *lineno)
622{
623	while (fgets(buf, bufsz, f) != NULL) {
624		if (buf[0] == '\0')
625			continue;
626		(*lineno)++;
627		if (buf[strlen(buf) - 1] == '\n' || feof(f)) {
628			return 0;
629		} else {
630			debug("%s: %s line %lu exceeds size limit", __func__,
631			    filename, *lineno);
632			/* discard remainder of line */
633			while (fgetc(f) != '\n' && !feof(f))
634				;	/* nothing */
635		}
636	}
637	return -1;
638}
639
640int
641tun_open(int tun, int mode)
642{
643#if defined(CUSTOM_SYS_TUN_OPEN)
644	return (sys_tun_open(tun, mode));
645#elif defined(SSH_TUN_OPENBSD)
646	struct ifreq ifr;
647	char name[100];
648	int fd = -1, sock;
649
650	/* Open the tunnel device */
651	if (tun <= SSH_TUNID_MAX) {
652		snprintf(name, sizeof(name), "/dev/tun%d", tun);
653		fd = open(name, O_RDWR);
654	} else if (tun == SSH_TUNID_ANY) {
655		for (tun = 100; tun >= 0; tun--) {
656			snprintf(name, sizeof(name), "/dev/tun%d", tun);
657			if ((fd = open(name, O_RDWR)) >= 0)
658				break;
659		}
660	} else {
661		debug("%s: invalid tunnel %u", __func__, tun);
662		return (-1);
663	}
664
665	if (fd < 0) {
666		debug("%s: %s open failed: %s", __func__, name, strerror(errno));
667		return (-1);
668	}
669
670	debug("%s: %s mode %d fd %d", __func__, name, mode, fd);
671
672	/* Set the tunnel device operation mode */
673	snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "tun%d", tun);
674	if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
675		goto failed;
676
677	if (ioctl(sock, SIOCGIFFLAGS, &ifr) == -1)
678		goto failed;
679
680	/* Set interface mode */
681	ifr.ifr_flags &= ~IFF_UP;
682	if (mode == SSH_TUNMODE_ETHERNET)
683		ifr.ifr_flags |= IFF_LINK0;
684	else
685		ifr.ifr_flags &= ~IFF_LINK0;
686	if (ioctl(sock, SIOCSIFFLAGS, &ifr) == -1)
687		goto failed;
688
689	/* Bring interface up */
690	ifr.ifr_flags |= IFF_UP;
691	if (ioctl(sock, SIOCSIFFLAGS, &ifr) == -1)
692		goto failed;
693
694	close(sock);
695	return (fd);
696
697 failed:
698	if (fd >= 0)
699		close(fd);
700	if (sock >= 0)
701		close(sock);
702	debug("%s: failed to set %s mode %d: %s", __func__, name,
703	    mode, strerror(errno));
704	return (-1);
705#else
706	error("Tunnel interfaces are not supported on this platform");
707	return (-1);
708#endif
709}
710
711void
712sanitise_stdfd(void)
713{
714	int nullfd, dupfd;
715
716	if ((nullfd = dupfd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
717		fprintf(stderr, "Couldn't open /dev/null: %s\n",
718		    strerror(errno));
719		exit(1);
720	}
721	while (++dupfd <= 2) {
722		/* Only clobber closed fds */
723		if (fcntl(dupfd, F_GETFL, 0) >= 0)
724			continue;
725		if (dup2(nullfd, dupfd) == -1) {
726			fprintf(stderr, "dup2: %s\n", strerror(errno));
727			exit(1);
728		}
729	}
730	if (nullfd > 2)
731		close(nullfd);
732}
733
734char *
735tohex(const void *vp, size_t l)
736{
737	const u_char *p = (const u_char *)vp;
738	char b[3], *r;
739	size_t i, hl;
740
741	if (l > 65536)
742		return xstrdup("tohex: length > 65536");
743
744	hl = l * 2 + 1;
745	r = xcalloc(1, hl);
746	for (i = 0; i < l; i++) {
747		snprintf(b, sizeof(b), "%02x", p[i]);
748		strlcat(r, b, hl);
749	}
750	return (r);
751}
752
753u_int64_t
754get_u64(const void *vp)
755{
756	const u_char *p = (const u_char *)vp;
757	u_int64_t v;
758
759	v  = (u_int64_t)p[0] << 56;
760	v |= (u_int64_t)p[1] << 48;
761	v |= (u_int64_t)p[2] << 40;
762	v |= (u_int64_t)p[3] << 32;
763	v |= (u_int64_t)p[4] << 24;
764	v |= (u_int64_t)p[5] << 16;
765	v |= (u_int64_t)p[6] << 8;
766	v |= (u_int64_t)p[7];
767
768	return (v);
769}
770
771u_int32_t
772get_u32(const void *vp)
773{
774	const u_char *p = (const u_char *)vp;
775	u_int32_t v;
776
777	v  = (u_int32_t)p[0] << 24;
778	v |= (u_int32_t)p[1] << 16;
779	v |= (u_int32_t)p[2] << 8;
780	v |= (u_int32_t)p[3];
781
782	return (v);
783}
784
785u_int16_t
786get_u16(const void *vp)
787{
788	const u_char *p = (const u_char *)vp;
789	u_int16_t v;
790
791	v  = (u_int16_t)p[0] << 8;
792	v |= (u_int16_t)p[1];
793
794	return (v);
795}
796
797void
798put_u64(void *vp, u_int64_t v)
799{
800	u_char *p = (u_char *)vp;
801
802	p[0] = (u_char)(v >> 56) & 0xff;
803	p[1] = (u_char)(v >> 48) & 0xff;
804	p[2] = (u_char)(v >> 40) & 0xff;
805	p[3] = (u_char)(v >> 32) & 0xff;
806	p[4] = (u_char)(v >> 24) & 0xff;
807	p[5] = (u_char)(v >> 16) & 0xff;
808	p[6] = (u_char)(v >> 8) & 0xff;
809	p[7] = (u_char)v & 0xff;
810}
811
812void
813put_u32(void *vp, u_int32_t v)
814{
815	u_char *p = (u_char *)vp;
816
817	p[0] = (u_char)(v >> 24) & 0xff;
818	p[1] = (u_char)(v >> 16) & 0xff;
819	p[2] = (u_char)(v >> 8) & 0xff;
820	p[3] = (u_char)v & 0xff;
821}
822
823
824void
825put_u16(void *vp, u_int16_t v)
826{
827	u_char *p = (u_char *)vp;
828
829	p[0] = (u_char)(v >> 8) & 0xff;
830	p[1] = (u_char)v & 0xff;
831}
832
833void
834ms_subtract_diff(struct timeval *start, int *ms)
835{
836	struct timeval diff, finish;
837
838	gettimeofday(&finish, NULL);
839	timersub(&finish, start, &diff);
840	*ms -= (diff.tv_sec * 1000) + (diff.tv_usec / 1000);
841}
842
843void
844ms_to_timeval(struct timeval *tv, int ms)
845{
846	if (ms < 0)
847		ms = 0;
848	tv->tv_sec = ms / 1000;
849	tv->tv_usec = (ms % 1000) * 1000;
850}
851
852void
853sock_set_v6only(int s)
854{
855#ifdef IPV6_V6ONLY
856	int on = 1;
857
858	debug3("%s: set socket %d IPV6_V6ONLY", __func__, s);
859	if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) == -1)
860		error("setsockopt IPV6_V6ONLY: %s", strerror(errno));
861#endif
862}
863