blob: fc094f87414bc730e8ff893f692f98ff4d2f1912 [file] [log] [blame]
Damien Millere4340be2000-09-16 13:29:08 +11001/*
2 * Copyright (c) 2000 Markus Friedl. All rights reserved.
Damien Miller6476cad2005-06-16 13:18:34 +10003 * Copyright (c) 2005 Damien Miller. All rights reserved.
Damien Millere4340be2000-09-16 13:29:08 +11004 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
Damien Miller61c51502000-08-18 14:01:04 +100026#include "includes.h"
Damien Miller6476cad2005-06-16 13:18:34 +100027RCSID("$OpenBSD: misc.c,v 1.31 2005/06/06 11:20:36 djm Exp $");
Damien Miller61c51502000-08-18 14:01:04 +100028
Kevin Stevesb6e773a2001-02-04 13:20:36 +000029#include "misc.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000030#include "log.h"
Ben Lindstrom06909012001-03-05 06:09:31 +000031#include "xmalloc.h"
Damien Miller61c51502000-08-18 14:01:04 +100032
Ben Lindstrom4cc240d2001-07-04 04:46:56 +000033/* remove newline at end of string */
Damien Miller61c51502000-08-18 14:01:04 +100034char *
35chop(char *s)
36{
37 char *t = s;
38 while (*t) {
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +000039 if (*t == '\n' || *t == '\r') {
Damien Miller61c51502000-08-18 14:01:04 +100040 *t = '\0';
41 return s;
42 }
43 t++;
44 }
45 return s;
46
47}
48
Ben Lindstrom4cc240d2001-07-04 04:46:56 +000049/* set/unset filedescriptor to non-blocking */
Damien Miller232711f2004-06-15 10:35:30 +100050int
Damien Miller61c51502000-08-18 14:01:04 +100051set_nonblock(int fd)
52{
53 int val;
Ben Lindstromc93e84c2001-05-12 00:08:37 +000054
Damien Miller61c51502000-08-18 14:01:04 +100055 val = fcntl(fd, F_GETFL, 0);
56 if (val < 0) {
57 error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
Damien Miller232711f2004-06-15 10:35:30 +100058 return (-1);
Damien Miller61c51502000-08-18 14:01:04 +100059 }
Damien Miller69b69aa2000-10-28 14:19:58 +110060 if (val & O_NONBLOCK) {
Damien Miller232711f2004-06-15 10:35:30 +100061 debug3("fd %d is O_NONBLOCK", fd);
62 return (0);
Damien Miller69b69aa2000-10-28 14:19:58 +110063 }
Damien Milleref095ce2003-05-14 13:41:39 +100064 debug2("fd %d setting O_NONBLOCK", fd);
Damien Miller61c51502000-08-18 14:01:04 +100065 val |= O_NONBLOCK;
Damien Miller232711f2004-06-15 10:35:30 +100066 if (fcntl(fd, F_SETFL, val) == -1) {
67 debug("fcntl(%d, F_SETFL, O_NONBLOCK): %s", fd,
68 strerror(errno));
69 return (-1);
70 }
71 return (0);
Damien Miller61c51502000-08-18 14:01:04 +100072}
73
Damien Miller232711f2004-06-15 10:35:30 +100074int
Ben Lindstromc93e84c2001-05-12 00:08:37 +000075unset_nonblock(int fd)
76{
77 int val;
78
79 val = fcntl(fd, F_GETFL, 0);
80 if (val < 0) {
81 error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
Damien Miller232711f2004-06-15 10:35:30 +100082 return (-1);
Ben Lindstromc93e84c2001-05-12 00:08:37 +000083 }
84 if (!(val & O_NONBLOCK)) {
Damien Miller232711f2004-06-15 10:35:30 +100085 debug3("fd %d is not O_NONBLOCK", fd);
86 return (0);
Ben Lindstromc93e84c2001-05-12 00:08:37 +000087 }
Ben Lindstrom352b1c22001-06-21 03:04:37 +000088 debug("fd %d clearing O_NONBLOCK", fd);
Ben Lindstromc93e84c2001-05-12 00:08:37 +000089 val &= ~O_NONBLOCK;
Damien Miller232711f2004-06-15 10:35:30 +100090 if (fcntl(fd, F_SETFL, val) == -1) {
91 debug("fcntl(%d, F_SETFL, ~O_NONBLOCK): %s",
Ben Lindstrom84fcb312002-03-05 01:48:09 +000092 fd, strerror(errno));
Damien Miller232711f2004-06-15 10:35:30 +100093 return (-1);
94 }
95 return (0);
Ben Lindstromc93e84c2001-05-12 00:08:37 +000096}
97
Damien Miller398e1cf2002-02-05 11:52:13 +110098/* disable nagle on socket */
99void
100set_nodelay(int fd)
101{
Ben Lindstrome86de512002-03-05 01:28:14 +0000102 int opt;
103 socklen_t optlen;
Damien Miller398e1cf2002-02-05 11:52:13 +1100104
Ben Lindstrom1ebd7a52002-02-26 18:12:51 +0000105 optlen = sizeof opt;
106 if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen) == -1) {
Darren Tucker6db8f932003-11-03 20:07:14 +1100107 debug("getsockopt TCP_NODELAY: %.100s", strerror(errno));
Ben Lindstrom1ebd7a52002-02-26 18:12:51 +0000108 return;
109 }
110 if (opt == 1) {
111 debug2("fd %d is TCP_NODELAY", fd);
112 return;
113 }
114 opt = 1;
Ben Lindstrom1d568f92002-12-23 02:44:36 +0000115 debug2("fd %d setting TCP_NODELAY", fd);
Ben Lindstrom1ebd7a52002-02-26 18:12:51 +0000116 if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof opt) == -1)
Damien Miller398e1cf2002-02-05 11:52:13 +1100117 error("setsockopt TCP_NODELAY: %.100s", strerror(errno));
118}
119
Damien Miller61c51502000-08-18 14:01:04 +1000120/* Characters considered whitespace in strsep calls. */
121#define WHITESPACE " \t\r\n"
122
Ben Lindstrom4cc240d2001-07-04 04:46:56 +0000123/* return next token in configuration line */
Damien Miller61c51502000-08-18 14:01:04 +1000124char *
125strdelim(char **s)
126{
127 char *old;
128 int wspace = 0;
129
130 if (*s == NULL)
131 return NULL;
132
133 old = *s;
134
135 *s = strpbrk(*s, WHITESPACE "=");
136 if (*s == NULL)
137 return (old);
138
139 /* Allow only one '=' to be skipped */
140 if (*s[0] == '=')
141 wspace = 1;
142 *s[0] = '\0';
143
144 *s += strspn(*s + 1, WHITESPACE) + 1;
145 if (*s[0] == '=' && !wspace)
146 *s += strspn(*s + 1, WHITESPACE) + 1;
147
148 return (old);
149}
Kevin Stevesb6e773a2001-02-04 13:20:36 +0000150
Ben Lindstrom086cf212001-03-05 05:56:40 +0000151struct passwd *
152pwcopy(struct passwd *pw)
153{
154 struct passwd *copy = xmalloc(sizeof(*copy));
Ben Lindstrom40304422001-03-05 06:22:01 +0000155
Ben Lindstrom086cf212001-03-05 05:56:40 +0000156 memset(copy, 0, sizeof(*copy));
157 copy->pw_name = xstrdup(pw->pw_name);
158 copy->pw_passwd = xstrdup(pw->pw_passwd);
Ben Lindstrom40304422001-03-05 06:22:01 +0000159 copy->pw_gecos = xstrdup(pw->pw_gecos);
Ben Lindstrom086cf212001-03-05 05:56:40 +0000160 copy->pw_uid = pw->pw_uid;
161 copy->pw_gid = pw->pw_gid;
Kevin Steves82456952001-06-22 21:14:18 +0000162#ifdef HAVE_PW_EXPIRE_IN_PASSWD
Ben Lindstrom3af4d462001-06-21 03:11:27 +0000163 copy->pw_expire = pw->pw_expire;
Kevin Steves82456952001-06-22 21:14:18 +0000164#endif
165#ifdef HAVE_PW_CHANGE_IN_PASSWD
Ben Lindstrom3af4d462001-06-21 03:11:27 +0000166 copy->pw_change = pw->pw_change;
Kevin Steves82456952001-06-22 21:14:18 +0000167#endif
Ben Lindstrom0f68db42001-03-05 07:57:09 +0000168#ifdef HAVE_PW_CLASS_IN_PASSWD
Ben Lindstrom086cf212001-03-05 05:56:40 +0000169 copy->pw_class = xstrdup(pw->pw_class);
Ben Lindstrom0f68db42001-03-05 07:57:09 +0000170#endif
Ben Lindstrom086cf212001-03-05 05:56:40 +0000171 copy->pw_dir = xstrdup(pw->pw_dir);
172 copy->pw_shell = xstrdup(pw->pw_shell);
173 return copy;
174}
175
Ben Lindstrom4cc240d2001-07-04 04:46:56 +0000176/*
177 * Convert ASCII string to TCP/IP port number.
178 * Port must be >0 and <=65535.
179 * Return 0 if invalid.
180 */
181int
182a2port(const char *s)
Ben Lindstrom19066a12001-04-12 23:39:26 +0000183{
184 long port;
185 char *endp;
186
187 errno = 0;
188 port = strtol(s, &endp, 0);
189 if (s == endp || *endp != '\0' ||
190 (errno == ERANGE && (port == LONG_MIN || port == LONG_MAX)) ||
191 port <= 0 || port > 65535)
192 return 0;
193
194 return port;
195}
196
Ben Lindstrom1bda4c82001-06-05 19:59:08 +0000197#define SECONDS 1
198#define MINUTES (SECONDS * 60)
199#define HOURS (MINUTES * 60)
200#define DAYS (HOURS * 24)
201#define WEEKS (DAYS * 7)
202
Ben Lindstrom4cc240d2001-07-04 04:46:56 +0000203/*
204 * Convert a time string into seconds; format is
205 * a sequence of:
206 * time[qualifier]
207 *
208 * Valid time qualifiers are:
209 * <none> seconds
210 * s|S seconds
211 * m|M minutes
212 * h|H hours
213 * d|D days
214 * w|W weeks
215 *
216 * Examples:
217 * 90m 90 minutes
218 * 1h30m 90 minutes
219 * 2d 2 days
220 * 1w 1 week
221 *
222 * Return -1 if time string is invalid.
223 */
224long
225convtime(const char *s)
Ben Lindstrom1bda4c82001-06-05 19:59:08 +0000226{
227 long total, secs;
228 const char *p;
229 char *endp;
230
231 errno = 0;
232 total = 0;
233 p = s;
234
235 if (p == NULL || *p == '\0')
236 return -1;
237
238 while (*p) {
239 secs = strtol(p, &endp, 10);
240 if (p == endp ||
241 (errno == ERANGE && (secs == LONG_MIN || secs == LONG_MAX)) ||
242 secs < 0)
243 return -1;
244
245 switch (*endp++) {
246 case '\0':
247 endp--;
248 case 's':
249 case 'S':
250 break;
251 case 'm':
252 case 'M':
253 secs *= MINUTES;
254 break;
255 case 'h':
256 case 'H':
257 secs *= HOURS;
258 break;
259 case 'd':
260 case 'D':
261 secs *= DAYS;
262 break;
263 case 'w':
264 case 'W':
265 secs *= WEEKS;
266 break;
267 default:
268 return -1;
269 }
270 total += secs;
271 if (total < 0)
272 return -1;
273 p = endp;
274 }
275
276 return total;
277}
278
Damien Millerf91ee4c2005-03-01 21:24:33 +1100279/*
280 * Search for next delimiter between hostnames/addresses and ports.
281 * Argument may be modified (for termination).
282 * Returns *cp if parsing succeeds.
283 * *cp is set to the start of the next delimiter, if one was found.
284 * If this is the last field, *cp is set to NULL.
285 */
286char *
287hpdelim(char **cp)
288{
289 char *s, *old;
290
291 if (cp == NULL || *cp == NULL)
292 return NULL;
293
294 old = s = *cp;
295 if (*s == '[') {
296 if ((s = strchr(s, ']')) == NULL)
297 return NULL;
298 else
299 s++;
300 } else if ((s = strpbrk(s, ":/")) == NULL)
301 s = *cp + strlen(*cp); /* skip to end (see first case below) */
302
303 switch (*s) {
304 case '\0':
305 *cp = NULL; /* no more fields*/
306 break;
Darren Tucker47eede72005-03-14 23:08:12 +1100307
Damien Millerf91ee4c2005-03-01 21:24:33 +1100308 case ':':
309 case '/':
310 *s = '\0'; /* terminate */
311 *cp = s + 1;
312 break;
Darren Tucker47eede72005-03-14 23:08:12 +1100313
Damien Millerf91ee4c2005-03-01 21:24:33 +1100314 default:
315 return NULL;
316 }
317
318 return old;
319}
320
Ben Lindstrom4529b702001-05-03 23:39:53 +0000321char *
322cleanhostname(char *host)
323{
324 if (*host == '[' && host[strlen(host) - 1] == ']') {
325 host[strlen(host) - 1] = '\0';
326 return (host + 1);
327 } else
328 return host;
329}
330
331char *
332colon(char *cp)
333{
334 int flag = 0;
335
336 if (*cp == ':') /* Leading colon is part of file name. */
337 return (0);
338 if (*cp == '[')
339 flag = 1;
340
341 for (; *cp; ++cp) {
342 if (*cp == '@' && *(cp+1) == '[')
343 flag = 1;
344 if (*cp == ']' && *(cp+1) == ':' && flag)
345 return (cp+1);
346 if (*cp == ':' && !flag)
347 return (cp);
348 if (*cp == '/')
349 return (0);
350 }
351 return (0);
352}
353
Ben Lindstrom4cc240d2001-07-04 04:46:56 +0000354/* function to assist building execv() arguments */
Ben Lindstrom387c4722001-05-08 20:27:25 +0000355void
356addargs(arglist *args, char *fmt, ...)
357{
358 va_list ap;
359 char buf[1024];
Darren Tuckerc7a6fc42004-08-13 21:18:00 +1000360 u_int nalloc;
Ben Lindstrom387c4722001-05-08 20:27:25 +0000361
362 va_start(ap, fmt);
363 vsnprintf(buf, sizeof(buf), fmt, ap);
364 va_end(ap);
365
Darren Tuckerfb16b242003-09-22 21:04:23 +1000366 nalloc = args->nalloc;
Ben Lindstrom387c4722001-05-08 20:27:25 +0000367 if (args->list == NULL) {
Darren Tuckerfb16b242003-09-22 21:04:23 +1000368 nalloc = 32;
Ben Lindstrom387c4722001-05-08 20:27:25 +0000369 args->num = 0;
Darren Tuckerfb16b242003-09-22 21:04:23 +1000370 } else if (args->num+2 >= nalloc)
371 nalloc *= 2;
Ben Lindstrom387c4722001-05-08 20:27:25 +0000372
Darren Tuckerfb16b242003-09-22 21:04:23 +1000373 args->list = xrealloc(args->list, nalloc * sizeof(char *));
374 args->nalloc = nalloc;
Ben Lindstrom387c4722001-05-08 20:27:25 +0000375 args->list[args->num++] = xstrdup(buf);
376 args->list[args->num] = NULL;
377}
Darren Tucker22cc7412004-12-06 22:47:41 +1100378
379/*
Damien Miller5fd38c02005-05-26 12:02:14 +1000380 * Expands tildes in the file name. Returns data allocated by xmalloc.
381 * Warning: this calls getpw*.
382 */
383char *
384tilde_expand_filename(const char *filename, uid_t uid)
385{
386 const char *path;
387 char user[128], ret[MAXPATHLEN];
388 struct passwd *pw;
389 int len;
390
391 if (*filename != '~')
392 return (xstrdup(filename));
393 filename++;
394
395 path = strchr(filename, '/');
396 if (path != NULL && path > filename) { /* ~user/path */
397 if (path - filename > sizeof(user) - 1)
398 fatal("tilde_expand_filename: ~username too long");
399 memcpy(user, filename, path - filename);
400 user[path - filename] = '\0';
401 if ((pw = getpwnam(user)) == NULL)
402 fatal("tilde_expand_filename: No such user %s", user);
403 } else if ((pw = getpwuid(uid)) == NULL) /* ~/path */
404 fatal("tilde_expand_filename: No such uid %d", uid);
405
406 if (strlcpy(ret, pw->pw_dir, sizeof(ret)) >= sizeof(ret))
407 fatal("tilde_expand_filename: Path too long");
408
409 /* Make sure directory has a trailing '/' */
410 len = strlen(pw->pw_dir);
411 if ((len == 0 || pw->pw_dir[len - 1] != '/') &&
412 strlcat(ret, "/", sizeof(ret)) >= sizeof(ret))
413 fatal("tilde_expand_filename: Path too long");
414
415 /* Skip leading '/' from specified path */
416 if (path != NULL)
417 filename = path + 1;
418 if (strlcat(ret, filename, sizeof(ret)) >= sizeof(ret))
419 fatal("tilde_expand_filename: Path too long");
420
421 return (xstrdup(ret));
422}
423
424/*
Damien Miller6476cad2005-06-16 13:18:34 +1000425 * Expand a string with a set of %[char] escapes. A number of escapes may be
426 * specified as (char *escape_chars, char *replacement) pairs. The list must
427 * be terminated by an escape_char of -1. Returns replaced string in memory
428 * allocated by xmalloc.
429 */
430char *
431percent_expand(const char *string, ...)
432{
433#define EXPAND_MAX_KEYS 16
434 struct {
435 const char *key;
436 const char *repl;
437 } keys[EXPAND_MAX_KEYS];
438 int num_keys, i, j;
439 char buf[4096];
440 va_list ap;
441
442 /* Gather keys */
443 va_start(ap, string);
444 for (num_keys = 0; num_keys < EXPAND_MAX_KEYS; num_keys++) {
445 keys[num_keys].key = va_arg(ap, char *);
446 if (keys[num_keys].key == NULL)
447 break;
448 keys[num_keys].repl = va_arg(ap, char *);
449 if (keys[num_keys].repl == NULL)
450 fatal("percent_expand: NULL replacement");
451 }
452 va_end(ap);
453
454 if (num_keys >= EXPAND_MAX_KEYS)
455 fatal("percent_expand: too many keys");
456
457 /* Expand string */
458 *buf = '\0';
459 for (i = 0; *string != '\0'; string++) {
460 if (*string != '%') {
461 append:
462 buf[i++] = *string;
463 if (i >= sizeof(buf))
464 fatal("percent_expand: string too long");
465 buf[i] = '\0';
466 continue;
467 }
468 string++;
469 if (*string == '%')
470 goto append;
471 for (j = 0; j < num_keys; j++) {
472 if (strchr(keys[j].key, *string) != NULL) {
473 i = strlcat(buf, keys[j].repl, sizeof(buf));
474 if (i >= sizeof(buf))
475 fatal("percent_expand: string too long");
476 break;
477 }
478 }
479 if (j >= num_keys)
480 fatal("percent_expand: unknown key %%%c", *string);
481 }
482 return (xstrdup(buf));
483#undef EXPAND_MAX_KEYS
484}
485
486/*
Darren Tucker22cc7412004-12-06 22:47:41 +1100487 * Read an entire line from a public key file into a static buffer, discarding
488 * lines that exceed the buffer size. Returns 0 on success, -1 on failure.
489 */
490int
491read_keyfile_line(FILE *f, const char *filename, char *buf, size_t bufsz,
Darren Tuckerf0f90982004-12-11 13:39:50 +1100492 u_long *lineno)
Darren Tucker22cc7412004-12-06 22:47:41 +1100493{
494 while (fgets(buf, bufsz, f) != NULL) {
495 (*lineno)++;
496 if (buf[strlen(buf) - 1] == '\n' || feof(f)) {
497 return 0;
498 } else {
Darren Tuckerf0f90982004-12-11 13:39:50 +1100499 debug("%s: %s line %lu exceeds size limit", __func__,
500 filename, *lineno);
Darren Tucker22cc7412004-12-06 22:47:41 +1100501 /* discard remainder of line */
Darren Tucker47eede72005-03-14 23:08:12 +1100502 while (fgetc(f) != '\n' && !feof(f))
Darren Tucker22cc7412004-12-06 22:47:41 +1100503 ; /* nothing */
504 }
505 }
506 return -1;
507}