misc.c - net/sftp-server - Rivoreo Source Code Repositories

 /* $OpenBSD: misc.c,v 1.105 2016/07/15 00:24:30 djm Exp $ */
 /*
  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  * Copyright (c) 2005,2006 Damien Miller.  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.
  */

 #include "includes.h"

 #include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/un.h>

 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>

 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
 #include <netinet/tcp.h>

 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #ifdef HAVE_PATHS_H
 # include <paths.h>
 #include <pwd.h>
 #endif

 #include "xmalloc.h"
 #include "misc.h"
 #include "log.h"
 #include "ssh.h"

 /* remove newline at end of string */
 char *
 chop(char *s)
 {
 	char *t = s;
 	while (*t) {
 		if (*t == '\n' || *t == '\r') {
 			*t = '\0';
 			return s;
 		}
 		t++;
 	}
 	return s;

 }

 const char *
 ssh_gai_strerror(int gaierr)
 {
 	if (gaierr == EAI_SYSTEM && errno != 0)
 		return strerror(errno);
 	return gai_strerror(gaierr);
 }

 /* Characters considered whitespace in strsep calls. */
 #define WHITESPACE " \t\r\n"
 #define QUOTE	"\""

 /* return next token in configuration line */
 char *
 strdelim(char **s)
 {
 	char *old;
 	int wspace = 0;

 	if (*s == NULL)
 		return NULL;

 	old = *s;

 	*s = strpbrk(*s, WHITESPACE QUOTE "=");
 	if (*s == NULL)
 		return (old);

 	if (*s[0] == '\"') {
 		memmove(*s, *s + 1, strlen(*s)); /* move nul too */
 		/* Find matching quote */
 		if ((*s = strpbrk(*s, QUOTE)) == NULL) {
 			return (NULL);		/* no matching quote */
 		} else {
 			*s[0] = '\0';
 			*s += strspn(*s + 1, WHITESPACE) + 1;
 			return (old);
 		}
 	}

 	/* Allow only one '=' to be skipped */
 	if (*s[0] == '=')
 		wspace = 1;
 	*s[0] = '\0';

 	/* Skip any extra whitespace after first token */
 	*s += strspn(*s + 1, WHITESPACE) + 1;
 	if (*s[0] == '=' && !wspace)
 		*s += strspn(*s + 1, WHITESPACE) + 1;

 	return (old);
 }

 struct passwd *
 pwcopy(struct passwd *pw)
 {
 	struct passwd *copy = xcalloc(1, sizeof(*copy));

 	copy->pw_name = xstrdup(pw->pw_name);
 	copy->pw_passwd = xstrdup(pw->pw_passwd);
 #ifdef HAVE_STRUCT_PASSWD_PW_GECOS
 	copy->pw_gecos = xstrdup(pw->pw_gecos);
 #endif
 	copy->pw_uid = pw->pw_uid;
 	copy->pw_gid = pw->pw_gid;
 #ifdef HAVE_STRUCT_PASSWD_PW_EXPIRE
 	copy->pw_expire = pw->pw_expire;
 #endif
 #ifdef HAVE_STRUCT_PASSWD_PW_CHANGE
 	copy->pw_change = pw->pw_change;
 #endif
 #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
 	copy->pw_class = xstrdup(pw->pw_class);
 #endif
 	copy->pw_dir = xstrdup(pw->pw_dir);
 	copy->pw_shell = xstrdup(pw->pw_shell);
 	return copy;
 }

 #define SECONDS		1
 #define MINUTES		(SECONDS * 60)
 #define HOURS		(MINUTES * 60)
 #define DAYS		(HOURS * 24)
 #define WEEKS		(DAYS * 7)

 /*
  * Convert a time string into seconds; format is
  * a sequence of:
  *      time[qualifier]
  *
  * Valid time qualifiers are:
  *      <none>  seconds
  *      s|S     seconds
  *      m|M     minutes
  *      h|H     hours
  *      d|D     days
  *      w|W     weeks
  *
  * Examples:
  *      90m     90 minutes
  *      1h30m   90 minutes
  *      2d      2 days
  *      1w      1 week
  *
  * Return -1 if time string is invalid.
  */
 long
 convtime(const char *s)
 {
 	long total, secs;
 	const char *p;
 	char *endp;

 	errno = 0;
 	total = 0;
 	p = s;

 	if (p == NULL || *p == '\0')
 		return -1;

 	while (*p) {
 		secs = strtol(p, &endp, 10);
 		if (p == endp ||
 		    (errno == ERANGE && (secs == LONG_MIN || secs == LONG_MAX)) ||
 		    secs < 0)
 			return -1;

 		switch (*endp++) {
 		case '\0':
 			endp--;
 			break;
 		case 's':
 		case 'S':
 			break;
 		case 'm':
 		case 'M':
 			secs *= MINUTES;
 			break;
 		case 'h':
 		case 'H':
 			secs *= HOURS;
 			break;
 		case 'd':
 		case 'D':
 			secs *= DAYS;
 			break;
 		case 'w':
 		case 'W':
 			secs *= WEEKS;
 			break;
 		default:
 			return -1;
 		}
 		total += secs;
 		if (total < 0)
 			return -1;
 		p = endp;
 	}

 	return total;
 }

 /*
  * Expands tildes in the file name.  Returns data allocated by xmalloc.
  * Warning: this calls getpw*.
  */
 char *
 tilde_expand_filename(const char *filename, uid_t uid)
 {
 	const char *path, *sep;
 	char user[128], *ret;
 	struct passwd *pw;
 	u_int len, slash;

 	if (*filename != '~')
 		return (xstrdup(filename));
 	filename++;

 	path = strchr(filename, '/');
 	if (path != NULL && path > filename) {		/* ~user/path */
 		slash = path - filename;
 		if (slash > sizeof(user) - 1)
 			fatal("tilde_expand_filename: ~username too long");
 		memcpy(user, filename, slash);
 		user[slash] = '\0';
 		if ((pw = getpwnam(user)) == NULL)
 			fatal("tilde_expand_filename: No such user %s", user);
 	} else if ((pw = getpwuid(uid)) == NULL)	/* ~/path */
 		fatal("tilde_expand_filename: No such uid %ld", (long)uid);

 	/* Make sure directory has a trailing '/' */
 	len = strlen(pw->pw_dir);
 	if (len == 0 || pw->pw_dir[len - 1] != '/')
 		sep = "/";
 	else
 		sep = "";

 	/* Skip leading '/' from specified path */
 	if (path != NULL)
 		filename = path + 1;

 	if (xasprintf(&ret, "%s%s%s", pw->pw_dir, sep, filename) >= PATH_MAX)
 		fatal("tilde_expand_filename: Path too long");

 	return (ret);
 }

 /*
  * Expand a string with a set of %[char] escapes. A number of escapes may be
  * specified as (char *escape_chars, char *replacement) pairs. The list must
  * be terminated by a NULL escape_char. Returns replaced string in memory
  * allocated by xmalloc.
  */
 char *
 percent_expand(const char *string, ...)
 {
 #define EXPAND_MAX_KEYS	16
 	u_int num_keys, i, j;
 	struct {
 		const char *key;
 		const char *repl;
 	} keys[EXPAND_MAX_KEYS];
 	char buf[4096];
 	va_list ap;

 	/* Gather keys */
 	va_start(ap, string);
 	for (num_keys = 0; num_keys < EXPAND_MAX_KEYS; num_keys++) {
 		keys[num_keys].key = va_arg(ap, char *);
 		if (keys[num_keys].key == NULL)
 			break;
 		keys[num_keys].repl = va_arg(ap, char *);
 		if (keys[num_keys].repl == NULL)
 			fatal("%s: NULL replacement", __func__);
 	}
 	if (num_keys == EXPAND_MAX_KEYS && va_arg(ap, char *) != NULL)
 		fatal("%s: too many keys", __func__);
 	va_end(ap);

 	/* Expand string */
 	*buf = '\0';
 	for (i = 0; *string != '\0'; string++) {
 		if (*string != '%') {
  append:
 			buf[i++] = *string;
 			if (i >= sizeof(buf))
 				fatal("%s: string too long", __func__);
 			buf[i] = '\0';
 			continue;
 		}
 		string++;
 		/* %% case */
 		if (*string == '%')
 			goto append;
 		if (*string == '\0')
 			fatal("%s: invalid format", __func__);
 		for (j = 0; j < num_keys; j++) {
 			if (strchr(keys[j].key, *string) != NULL) {
 				i = strlcat(buf, keys[j].repl, sizeof(buf));
 				if (i >= sizeof(buf))
 					fatal("%s: string too long", __func__);
 				break;
 			}
 		}
 		if (j >= num_keys)
 			fatal("%s: unknown key %%%c", __func__, *string);
 	}
 	return (xstrdup(buf));
 #undef EXPAND_MAX_KEYS
 }

 void
 sanitise_stdfd(void)
 {
 	int nullfd, dupfd;

 	if ((nullfd = dupfd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
 		fprintf(stderr, "Couldn't open /dev/null: %s\n",
 		    strerror(errno));
 		exit(1);
 	}
 	while (++dupfd <= STDERR_FILENO) {
 		/* Only populate closed fds. */
 		if (fcntl(dupfd, F_GETFL) == -1 && errno == EBADF) {
 			if (dup2(nullfd, dupfd) == -1) {
 				fprintf(stderr, "dup2: %s\n", strerror(errno));
 				exit(1);
 			}
 		}
 	}
 	if (nullfd > STDERR_FILENO)
 		close(nullfd);
 }

 u_int32_t
 get_u32(const void *vp)
 {
 	const u_char *p = (const u_char *)vp;
 	u_int32_t v;

 	v  = (u_int32_t)p[0] << 24;
 	v |= (u_int32_t)p[1] << 16;
 	v |= (u_int32_t)p[2] << 8;
 	v |= (u_int32_t)p[3];

 	return (v);
 }

 void
 put_u32(void *vp, u_int32_t v)
 {
 	u_char *p = (u_char *)vp;

 	p[0] = (u_char)(v >> 24) & 0xff;
 	p[1] = (u_char)(v >> 16) & 0xff;
 	p[2] = (u_char)(v >> 8) & 0xff;
 	p[3] = (u_char)v & 0xff;
 }
	/* $OpenBSD: misc.c,v 1.105 2016/07/15 00:24:30 djm Exp $ */
	/*
	* Copyright (c) 2000 Markus Friedl. All rights reserved.
	* Copyright (c) 2005,2006 Damien Miller. 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.
	*/

	#include "includes.h"

	#include <sys/types.h>
	#include <sys/ioctl.h>
	#include <sys/socket.h>
	#include <sys/time.h>
	#include <sys/un.h>

	#include <limits.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <unistd.h>

	#include <netinet/in.h>
	#include <netinet/in_systm.h>
	#include <netinet/ip.h>
	#include <netinet/tcp.h>

	#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <netdb.h>
	#ifdef HAVE_PATHS_H
	# include <paths.h>
	#include <pwd.h>
	#endif

	#include "xmalloc.h"
	#include "misc.h"
	#include "log.h"
	#include "ssh.h"

	/* remove newline at end of string */
	char *
	chop(char *s)
	{
	char *t = s;
	while (*t) {
	if (t == '\n' \|\| t == '\r') {
	*t = '\0';
	return s;
	}
	t++;
	}
	return s;

	}

	const char *
	ssh_gai_strerror(int gaierr)
	{
	if (gaierr == EAI_SYSTEM && errno != 0)
	return strerror(errno);
	return gai_strerror(gaierr);
	}

	/* Characters considered whitespace in strsep calls. */
	#define WHITESPACE " \t\r\n"
	#define QUOTE "\""

	/* return next token in configuration line */
	char *
	strdelim(char **s)
	{
	char *old;
	int wspace = 0;

	if (*s == NULL)
	return NULL;

	old = *s;

	s = strpbrk(s, WHITESPACE QUOTE "=");
	if (*s == NULL)
	return (old);

	if (*s[0] == '\"') {
	memmove(s, s + 1, strlen(s)); / move nul too */
	/* Find matching quote */
	if ((s = strpbrk(s, QUOTE)) == NULL) {
	return (NULL); /* no matching quote */
	} else {
	*s[0] = '\0';
	s += strspn(s + 1, WHITESPACE) + 1;
	return (old);
	}
	}

	/* Allow only one '=' to be skipped */
	if (*s[0] == '=')
	wspace = 1;
	*s[0] = '\0';

	/* Skip any extra whitespace after first token */
	s += strspn(s + 1, WHITESPACE) + 1;
	if (*s[0] == '=' && !wspace)
	s += strspn(s + 1, WHITESPACE) + 1;

	return (old);
	}

	struct passwd *
	pwcopy(struct passwd *pw)
	{
	struct passwd copy = xcalloc(1, sizeof(copy));

	copy->pw_name = xstrdup(pw->pw_name);
	copy->pw_passwd = xstrdup(pw->pw_passwd);
	#ifdef HAVE_STRUCT_PASSWD_PW_GECOS
	copy->pw_gecos = xstrdup(pw->pw_gecos);
	#endif
	copy->pw_uid = pw->pw_uid;
	copy->pw_gid = pw->pw_gid;
	#ifdef HAVE_STRUCT_PASSWD_PW_EXPIRE
	copy->pw_expire = pw->pw_expire;
	#endif
	#ifdef HAVE_STRUCT_PASSWD_PW_CHANGE
	copy->pw_change = pw->pw_change;
	#endif
	#ifdef HAVE_STRUCT_PASSWD_PW_CLASS
	copy->pw_class = xstrdup(pw->pw_class);
	#endif
	copy->pw_dir = xstrdup(pw->pw_dir);
	copy->pw_shell = xstrdup(pw->pw_shell);
	return copy;
	}

	#define SECONDS 1
	#define MINUTES (SECONDS * 60)
	#define HOURS (MINUTES * 60)
	#define DAYS (HOURS * 24)
	#define WEEKS (DAYS * 7)

	/*
	* Convert a time string into seconds; format is
	* a sequence of:
	* time[qualifier]
	*
	* Valid time qualifiers are:
	* <none> seconds
	* s\|S seconds
	* m\|M minutes
	* h\|H hours
	* d\|D days
	* w\|W weeks
	*
	* Examples:
	* 90m 90 minutes
	* 1h30m 90 minutes
	* 2d 2 days
	* 1w 1 week
	*
	* Return -1 if time string is invalid.
	*/
	long
	convtime(const char *s)
	{
	long total, secs;
	const char *p;
	char *endp;

	errno = 0;
	total = 0;
	p = s;

	if (p == NULL \|\| *p == '\0')
	return -1;

	while (*p) {
	secs = strtol(p, &endp, 10);
	if (p == endp \|\|
	(errno == ERANGE && (secs == LONG_MIN \|\| secs == LONG_MAX)) \|\|
	secs < 0)
	return -1;

	switch (*endp++) {
	case '\0':
	endp--;
	break;
	case 's':
	case 'S':
	break;
	case 'm':
	case 'M':
	secs *= MINUTES;
	break;
	case 'h':
	case 'H':
	secs *= HOURS;
	break;
	case 'd':
	case 'D':
	secs *= DAYS;
	break;
	case 'w':
	case 'W':
	secs *= WEEKS;
	break;
	default:
	return -1;
	}
	total += secs;
	if (total < 0)
	return -1;
	p = endp;
	}

	return total;
	}

	/*
	* Expands tildes in the file name. Returns data allocated by xmalloc.
	* Warning: this calls getpw*.
	*/
	char *
	tilde_expand_filename(const char *filename, uid_t uid)
	{
	const char path, sep;
	char user[128], *ret;
	struct passwd *pw;
	u_int len, slash;

	if (*filename != '~')
	return (xstrdup(filename));
	filename++;

	path = strchr(filename, '/');
	if (path != NULL && path > filename) { /* ~user/path */
	slash = path - filename;
	if (slash > sizeof(user) - 1)
	fatal("tilde_expand_filename: ~username too long");
	memcpy(user, filename, slash);
	user[slash] = '\0';
	if ((pw = getpwnam(user)) == NULL)
	fatal("tilde_expand_filename: No such user %s", user);
	} else if ((pw = getpwuid(uid)) == NULL) /* ~/path */
	fatal("tilde_expand_filename: No such uid %ld", (long)uid);

	/* Make sure directory has a trailing '/' */
	len = strlen(pw->pw_dir);
	if (len == 0 \|\| pw->pw_dir[len - 1] != '/')
	sep = "/";
	else
	sep = "";

	/* Skip leading '/' from specified path */
	if (path != NULL)
	filename = path + 1;

	if (xasprintf(&ret, "%s%s%s", pw->pw_dir, sep, filename) >= PATH_MAX)
	fatal("tilde_expand_filename: Path too long");

	return (ret);
	}

	/*
	* Expand a string with a set of %[char] escapes. A number of escapes may be
	* specified as (char escape_chars, char replacement) pairs. The list must
	* be terminated by a NULL escape_char. Returns replaced string in memory
	* allocated by xmalloc.
	*/
	char *
	percent_expand(const char *string, ...)
	{
	#define EXPAND_MAX_KEYS 16
	u_int num_keys, i, j;
	struct {
	const char *key;
	const char *repl;
	} keys[EXPAND_MAX_KEYS];
	char buf[4096];
	va_list ap;

	/* Gather keys */
	va_start(ap, string);
	for (num_keys = 0; num_keys < EXPAND_MAX_KEYS; num_keys++) {
	keys[num_keys].key = va_arg(ap, char *);
	if (keys[num_keys].key == NULL)
	break;
	keys[num_keys].repl = va_arg(ap, char *);
	if (keys[num_keys].repl == NULL)
	fatal("%s: NULL replacement", __func__);
	}
	if (num_keys == EXPAND_MAX_KEYS && va_arg(ap, char *) != NULL)
	fatal("%s: too many keys", __func__);
	va_end(ap);

	/* Expand string */
	*buf = '\0';
	for (i = 0; *string != '\0'; string++) {
	if (*string != '%') {
	append:
	buf[i++] = *string;
	if (i >= sizeof(buf))
	fatal("%s: string too long", __func__);
	buf[i] = '\0';
	continue;
	}
	string++;
	/* %% case */
	if (*string == '%')
	goto append;
	if (*string == '\0')
	fatal("%s: invalid format", __func__);
	for (j = 0; j < num_keys; j++) {
	if (strchr(keys[j].key, *string) != NULL) {
	i = strlcat(buf, keys[j].repl, sizeof(buf));
	if (i >= sizeof(buf))
	fatal("%s: string too long", __func__);
	break;
	}
	}
	if (j >= num_keys)
	fatal("%s: unknown key %%%c", __func__, *string);
	}
	return (xstrdup(buf));
	#undef EXPAND_MAX_KEYS
	}

	void
	sanitise_stdfd(void)
	{
	int nullfd, dupfd;

	if ((nullfd = dupfd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
	fprintf(stderr, "Couldn't open /dev/null: %s\n",
	strerror(errno));
	exit(1);
	}
	while (++dupfd <= STDERR_FILENO) {
	/* Only populate closed fds. */
	if (fcntl(dupfd, F_GETFL) == -1 && errno == EBADF) {
	if (dup2(nullfd, dupfd) == -1) {
	fprintf(stderr, "dup2: %s\n", strerror(errno));
	exit(1);
	}
	}
	}
	if (nullfd > STDERR_FILENO)
	close(nullfd);
	}

	u_int32_t
	get_u32(const void *vp)
	{
	const u_char p = (const u_char )vp;
	u_int32_t v;

	v = (u_int32_t)p[0] << 24;
	v \|= (u_int32_t)p[1] << 16;
	v \|= (u_int32_t)p[2] << 8;
	v \|= (u_int32_t)p[3];

	return (v);
	}

	void
	put_u32(void *vp, u_int32_t v)
	{
	u_char p = (u_char )vp;

	p[0] = (u_char)(v >> 24) & 0xff;
	p[1] = (u_char)(v >> 16) & 0xff;
	p[2] = (u_char)(v >> 8) & 0xff;
	p[3] = (u_char)v & 0xff;
	}