/*
* dhcpcd - DHCP client daemon
* Copyright 2006-2008 Roy Marples <roy@marples.name>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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 <sys/time.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "common.h"
#include "logger.h"
/* Handy routine to read very long lines in text files.
* This means we read the whole line and avoid any nasty buffer overflows. */
char *get_line (FILE *fp)
{
char *line = NULL;
char *p;
size_t len = 0;
size_t last = 0;
if (feof (fp))
return (NULL);
do
{
len += BUFSIZ;
line = xrealloc (line, sizeof (char) * len);
p = line + last;
memset (p, 0, BUFSIZ);
fgets (p, BUFSIZ, fp);
last += strlen (p);
}
while (! feof (fp) && line[last - 1] != '\n');
/* Trim the trailing newline */
if (*line && line[--last] == '\n')
line[last] = '\0';
return (line);
}
/* OK, this should be in dhcpcd.c
* It's here to make dhcpcd more readable */
#ifndef HAVE_SRANDOMDEV
void srandomdev (void)
{
int fd;
unsigned long seed;
fd = open ("/dev/urandom", 0);
if (fd == -1 || read (fd, &seed, sizeof (seed)) == -1)
{
logger (LOG_WARNING, "Could not read from /dev/urandom: %s",
strerror (errno));
seed = time (0);
}
if (fd >= 0)
close(fd);
srandom (seed);
}
#endif
/* strlcpy is nice, shame glibc does not define it */
#ifndef HAVE_STRLCPY
size_t strlcpy (char *dst, const char *src, size_t size)
{
const char *s = src;
size_t n = size;
if (n && --n)
do
{
if (! (*dst++ = *src++))
break;
}
while (--n);
if (! n)
{
if (size)
*dst = '\0';
while (*src++);
}
return (src - s - 1);
}
#endif
/* Close our fd's */
int close_fds (void)
{
int fd;
if ((fd = open ("/dev/null", O_RDWR)) == -1)
{
logger (LOG_ERR, "open `/dev/null': %s", strerror (errno));
return (-1);
}
dup2 (fd, fileno (stdin));
dup2 (fd, fileno (stdout));
dup2 (fd, fileno (stderr));
if (fd > 2)
close (fd);
return (0);
}
int close_on_exec (int fd)
{
int flags;
if ((flags = fcntl (fd, F_GETFD, 0)) == -1
|| fcntl (fd, F_SETFD, flags | FD_CLOEXEC) == -1)
{
logger (LOG_ERR, "fcntl: %s", strerror (errno));
return (-1);
}
return (0);
}
/* Handy function to get the time.
* We only care about time advancements, not the actual time itself
* Which is why we use CLOCK_MONOTONIC, but it is not available on all
* platforms.
*/
int get_time (struct timeval *tp)
{
#if defined(_POSIX_MONOTONIC_CLOCK) && defined(CLOCK_MONOTONIC)
struct timespec ts;
static clockid_t posix_clock;
static int posix_clock_set = 0;
if (! posix_clock_set)
{
if (sysconf (_SC_MONOTONIC_CLOCK) >= 0)
posix_clock = CLOCK_MONOTONIC;
else
posix_clock = CLOCK_REALTIME;
posix_clock_set = 1;
}
if (clock_gettime (posix_clock, &ts) == -1)
{
logger (LOG_ERR, "clock_gettime: %s", strerror (errno));
return (-1);
}
tp->tv_sec = ts.tv_sec;
tp->tv_usec = ts.tv_nsec / 1000;
return (0);
#else
if (gettimeofday (tp, NULL) == -1)
{
logger (LOG_ERR, "gettimeofday: %s", strerror (errno));
return (-1);
}
return (0);
#endif
}
time_t uptime (void)
{
struct timeval tp;
if (get_time (&tp) == -1)
return (-1);
return (tp.tv_sec);
}
void writepid (int fd, pid_t pid)
{
char spid[16];
if (ftruncate (fd, (off_t) 0) == -1)
{
logger (LOG_ERR, "ftruncate: %s", strerror (errno));
}
else
{
ssize_t len;
snprintf (spid, sizeof (spid), "%u", pid);
len = pwrite (fd, spid, strlen (spid), (off_t) 0);
if (len != (ssize_t) strlen (spid))
logger (LOG_ERR, "pwrite: %s", strerror (errno));
}
}
void *xmalloc (size_t s)
{
void *value = malloc (s);
if (value)
return (value);
logger (LOG_ERR, "memory exhausted");
exit (EXIT_FAILURE);
/* NOTREACHED */
}
void *xzalloc (size_t s)
{
void *value = xmalloc (s);
memset (value, 0, s);
return (value);
}
void *xrealloc (void *ptr, size_t s)
{
void *value = realloc (ptr, s);
if (value)
return (value);
logger (LOG_ERR, "memory exhausted");
exit (EXIT_FAILURE);
/* NOTREACHED */
}
char *xstrdup (const char *str)
{
char *value;
if (! str)
return (NULL);
if ((value = strdup (str)))
return (value);
logger (LOG_ERR, "memory exhausted");
exit (EXIT_FAILURE);
/* NOTREACHED */
}
