Remove the --logfile option.
Support LOG_PTRIM and LOG_NLOG if available.
This reduces the binary size by almost 5k.
If you don't like how the diagnostics look on your screen, speak
with your libc vendor about implementing the above NetBSD extensions.
#include <signal.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#define ELOOP_QUEUE 5
}
if (ifn) {
#ifdef ARP_DEBUG
- logger(ifp->ctx, LOG_DEBUG,
- "%s: ignoring ARP from self", ifp->name);
+ syslog(LOG_DEBUG, "%s: ignoring ARP from self", ifp->name);
#endif
return;
}
while (!(flags & BPF_EOF)) {
bytes = bpf_read(ifp, state->fd, buf, sizeof(buf), &flags);
if (bytes == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: arp bpf_read: %m", ifp->name);
+ syslog(LOG_ERR, "%s: arp bpf_read: %m", ifp->name);
arp_close(ifp);
return;
}
if (state->fd == -1) {
state->fd = bpf_open(ifp, bpf_arp);
if (state->fd == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m",
- __func__, ifp->name);
+ syslog(LOG_ERR, "%s: %s: %m", __func__, ifp->name);
return -1;
}
eloop_event_add(ifp->ctx->eloop, state->fd, arp_read, ifp);
tv.tv_nsec = 0;
eloop_timeout_add_tv(ifp->ctx->eloop, &tv, arp_probed, astate);
}
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: ARP probing %s (%d of %d), next in %0.1f seconds",
ifp->name, inet_ntoa(astate->addr),
astate->probes ? astate->probes : PROBE_NUM, PROBE_NUM,
timespec_to_double(&tv));
if (arp_request(ifp, 0, astate->addr.s_addr) == -1)
- logger(ifp->ctx, LOG_ERR, "send_arp: %m");
+ syslog(LOG_ERR, "send_arp: %m");
}
void
{
if (arp_open(astate->iface) == -1) {
- logger(astate->iface->ctx, LOG_ERR,
- "%s: %s: %m", __func__, astate->iface->name);
+ syslog(LOG_ERR, "%s: %s: %m", __func__, astate->iface->name);
return;
} else {
const struct iarp_state *state = ARP_CSTATE(astate->iface);
bpf_arp(astate->iface, state->fd);
}
astate->probes = 0;
- logger(astate->iface->ctx, LOG_DEBUG, "%s: probing for %s",
+ syslog(LOG_DEBUG, "%s: probing for %s",
astate->iface->name, inet_ntoa(astate->addr));
arp_probe1(astate);
}
astate->claims++;
#else
if (++astate->claims < ANNOUNCE_NUM)
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: ARP announcing %s (%d of %d), "
"next in %d.0 seconds",
ifp->name, inet_ntoa(astate->addr),
astate->claims, ANNOUNCE_NUM, ANNOUNCE_WAIT);
else
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: ARP announcing %s (%d of %d)",
ifp->name, inet_ntoa(astate->addr),
astate->claims, ANNOUNCE_NUM);
if (arp_request(ifp, astate->addr.s_addr, astate->addr.s_addr) == -1)
- logger(ifp->ctx, LOG_ERR, "send_arp: %m");
+ syslog(LOG_ERR, "arp_request: %m");
#endif
eloop_timeout_add_sec(ifp->ctx->eloop, ANNOUNCE_WAIT,
astate->claims < ANNOUNCE_NUM ? arp_announce1 : arp_announced,
#ifndef KERNEL_RFC5227
if (arp_open(astate->iface) == -1) {
- logger(astate->iface->ctx, LOG_ERR,
- "%s: %s: %m", __func__, astate->iface->name);
+ syslog(LOG_ERR, "%s: %s: %m", __func__, astate->iface->name);
return;
}
#endif
if (amsg != NULL) {
char buf[HWADDR_LEN * 3];
- logger(astate->iface->ctx, LOG_ERR,
- "%s: hardware address %s claims %s",
+ syslog(LOG_ERR, "%s: hardware address %s claims %s",
astate->iface->name,
hwaddr_ntoa(amsg->sha, astate->iface->hwlen,
buf, sizeof(buf)),
inet_ntoa(astate->failed));
} else
- logger(astate->iface->ctx, LOG_ERR,
- "%s: DAD detected %s",
+ syslog(LOG_ERR, "%s: DAD detected %s",
astate->iface->name, inet_ntoa(astate->failed));
}
ifp->if_data[IF_DATA_ARP] = malloc(sizeof(*state));
state = ARP_STATE(ifp);
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
state->fd = -1;
}
if ((astate = calloc(1, sizeof(*astate))) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m", ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: %m", ifp->name, __func__);
return NULL;
}
astate->iface = ifp;
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include "common.h"
#include "arp.h"
goto eexit;
if (pv.bv_major != BPF_MAJOR_VERSION ||
pv.bv_minor < BPF_MINOR_VERSION) {
- logger(ifp->ctx, LOG_ERR, "BPF version mismatch - recompile");
+ syslog(LOG_ERR, "BPF version mismatch - recompile");
goto eexit;
}
TAILQ_FOREACH(astate, &state->arp_states, next) {
if (++naddrs > ARP_ADDRS_MAX) {
errno = ENOBUFS;
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
break;
}
BPF_SET_JUMP(bp, BPF_JMP + BPF_JEQ + BPF_K,
#include "dhcpcd.h"
#include "if-options.h"
-#ifndef _PATH_DEVNULL
-# define _PATH_DEVNULL "/dev/null"
-#endif
-
/* Most route(4) messages are less than 256 bytes. */
#define IOVEC_BUFSIZ 256
-#if USE_LOGFILE
-void
-logger_open(struct dhcpcd_ctx *ctx)
-{
-
- if (ctx->logfile) {
- int f = O_CREAT | O_APPEND | O_TRUNC;
-
-#ifdef O_CLOEXEC
- f |= O_CLOEXEC;
-#endif
- ctx->log_fd = open(ctx->logfile, O_WRONLY | f, 0644);
- if (ctx->log_fd == -1)
- warn("open: %s", ctx->logfile);
-#ifndef O_CLOEXEC
- else {
- if ((f = fcntl(ctx->log_fd, F_GETFD)) == -1 ||
- fcntl(ctx->log_fd, F_SETFD, f | FD_CLOEXEC) == -1)
- warn("fcntl: %s", ctx->logfile);
- }
-#endif
- } else
- openlog(PACKAGE, LOG_PID, LOG_DAEMON);
-}
-
-void
-logger_close(struct dhcpcd_ctx *ctx)
-{
-
- if (ctx->log_fd != -1) {
- close(ctx->log_fd);
- ctx->log_fd = -1;
- }
- closelog();
-}
-
-/*
- * NetBSD's gcc has been modified to check for the non standard %m in printf
- * like functions and warn noisily about it that they should be marked as
- * syslog like instead.
- * This is all well and good, but our logger also goes via vfprintf and
- * when marked as a sysloglike funcion, gcc will then warn us that the
- * function should be printflike instead!
- * This creates an infinte loop of gcc warnings.
- * Until NetBSD solves this issue, we have to disable a gcc diagnostic
- * for our fully standards compliant code in the logger function.
- */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5))
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-format-attribute"
-#endif
-void
-logger(struct dhcpcd_ctx *ctx, int pri, const char *fmt, ...)
-{
- va_list va;
- int serrno;
-#ifndef HAVE_PRINTF_M
- char fmt_cpy[1024];
-#endif
-
- /* If we're printing the pidfile, don't do anything. */
- if (ctx != NULL && ctx->options & DHCPCD_PRINT_PIDFILE)
- return;
-
- serrno = errno;
- va_start(va, fmt);
-
-#ifndef HAVE_PRINTF_M
- /* Print strerrno(errno) in place of %m */
- if (ctx == NULL || !(ctx->options & DHCPCD_QUIET) || ctx->log_fd != -1)
- {
- const char *p;
- char *fp = fmt_cpy, *serr = NULL;
- size_t fmt_left = sizeof(fmt_cpy) - 1, fmt_wrote;
-
- for (p = fmt; *p != '\0'; p++) {
- if (p[0] == '%' && p[1] == '%') {
- if (fmt_left < 2)
- break;
- *fp++ = '%';
- *fp++ = '%';
- fmt_left -= 2;
- p++;
- } else if (p[0] == '%' && p[1] == 'm') {
- if (serr == NULL) {
- /* strerror_r isn't portable.
- * strerror_l isn't widely found
- * and also problematic to use.
- * Also, if strerror_l exists then
- * strerror could easily be made
- * treadsafe in the same libc.
- * dhcpcd is only threaded in RTEMS
- * where strerror is threadsafe,
- * so this should be fine. */
- serr = strerror(serrno);
- }
- fmt_wrote = strlcpy(fp, serr, fmt_left);
- if (fmt_wrote > fmt_left)
- break;
- fp += fmt_wrote;
- fmt_left -= fmt_wrote;
- p++;
- } else {
- *fp++ = *p;
- --fmt_left;
- }
- if (fmt_left == 0)
- break;
- }
- *fp++ = '\0';
- fmt = fmt_cpy;
- }
-#endif
-
- if ((ctx == NULL || !(ctx->options & DHCPCD_QUIET)) &&
- (pri < LOG_DEBUG || (ctx && ctx->options & DHCPCD_DEBUG)))
- {
- va_list vac;
-
- va_copy(vac, va);
-#ifdef HAVE_PRINTF_M
- errno = serrno;
-#endif
- vfprintf(stderr, fmt, vac);
- fputc('\n', stderr);
- va_end(vac);
- }
-
- /* Don't send to syslog if dumping leases or testing */
- if (ctx && ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))
- goto out;
-
- if (ctx && ctx->log_fd != -1) {
- if (pri < LOG_DEBUG || (ctx->options & DHCPCD_DEBUG)) {
- struct timeval tv;
- char buf[32];
-
- /* Write the time, syslog style. month day time - */
- if (gettimeofday(&tv, NULL) != -1) {
- time_t now;
- struct tm tmnow;
-
- tzset();
- now = tv.tv_sec;
- localtime_r(&now, &tmnow);
- strftime(buf, sizeof(buf), "%b %d %T ", &tmnow);
- dprintf(ctx->log_fd, "%s", buf);
- }
-
-#ifdef HAVE_PRINTF_M
- errno = serrno;
-#endif
- vdprintf(ctx->log_fd, fmt, va);
- dprintf(ctx->log_fd, "\n");
- }
- } else {
-#ifdef HAVE_PRINTF_M
- errno = serrno;
-#endif
- vsyslog(pri, fmt, va);
- }
-out:
- va_end(va);
-}
-#endif
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5))
-#pragma GCC diagnostic pop
-#endif
-
ssize_t
-setvar(struct dhcpcd_ctx *ctx,
- char **e, const char *prefix, const char *var, const char *value)
+setvar(char **e, const char *prefix, const char *var, const char *value)
{
size_t len = strlen(var) + strlen(value) + 3;
len += strlen(prefix) + 1;
*e = malloc(len);
if (*e == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
if (prefix)
}
ssize_t
-setvard(struct dhcpcd_ctx *ctx,
- char **e, const char *prefix, const char *var, size_t value)
+setvard(char **e, const char *prefix, const char *var, size_t value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%zu", value);
- return setvar(ctx, e, prefix, var, buffer);
+ return setvar(e, prefix, var, buffer);
}
ssize_t
-addvar(struct dhcpcd_ctx *ctx,
- char ***e, const char *prefix, const char *var, const char *value)
+addvar(char ***e, const char *prefix, const char *var, const char *value)
{
ssize_t len;
- len = setvar(ctx, *e, prefix, var, value);
+ len = setvar(*e, prefix, var, value);
if (len != -1)
(*e)++;
return (ssize_t)len;
}
ssize_t
-addvard(struct dhcpcd_ctx *ctx,
- char ***e, const char *prefix, const char *var, size_t value)
+addvard(char ***e, const char *prefix, const char *var, size_t value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%zu", value);
- return addvar(ctx, e, prefix, var, buffer);
+ return addvar(e, prefix, var, buffer);
}
const char *
#include <sys/param.h>
#include <sys/time.h>
#include <stdio.h>
-#include <syslog.h>
#include "config.h"
#include "defs.h"
extern int clock_monotonic;
int get_monotonic(struct timespec *);
-/* We could shave a few k off the binary size by just using the
- * syslog(3) interface.
- * However, this results in a ugly output on the command line
- * and relies on syslogd(8) starting before dhcpcd which is not
- * always the case. */
-#ifdef SMALL
-# undef USE_LOGFILE
-# define USE_LOGFILE 0
-#endif
-#ifndef USE_LOGFILE
-# define USE_LOGFILE 1
-#endif
-#if USE_LOGFILE
-void logger_open(struct dhcpcd_ctx *);
-#define logger_mask(ctx, lvl) setlogmask((lvl))
-void logger(struct dhcpcd_ctx *, int, const char *, ...) __sysloglike(3, 4);
-void logger_close(struct dhcpcd_ctx *);
-#else
-#define logger_open(ctx) openlog(PACKAGE, LOG_PERROR | LOG_PID, LOG_DAEMON)
-#define logger_mask(ctx, lvl) setlogmask((lvl))
-#define logger(ctx, pri, fmt, ...) \
- do { \
- UNUSED((ctx)); \
- syslog((pri), (fmt), ##__VA_ARGS__); \
- } while (0 /*CONSTCOND */)
-#define logger_close(ctx) closelog()
-#endif
-
-ssize_t setvar(struct dhcpcd_ctx *,
- char **, const char *, const char *, const char *);
-ssize_t setvard(struct dhcpcd_ctx *,
- char **, const char *, const char *, size_t);
-ssize_t addvar(struct dhcpcd_ctx *,
- char ***, const char *, const char *, const char *);
-ssize_t addvard(struct dhcpcd_ctx *,
- char ***, const char *, const char *, size_t);
+ssize_t setvar(char **, const char *, const char *, const char *);
+ssize_t setvard(char **, const char *, const char *, size_t);
+ssize_t addvar(char ***, const char *, const char *, const char *);
+ssize_t addvard(char ***, const char *, const char *, size_t);
const char *hwaddr_ntoa(const void *, size_t, char *, size_t);
size_t hwaddr_aton(uint8_t *, const char *);
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <time.h>
#include <unistd.h>
}
*ap = NULL;
if (dhcpcd_handleargs(fd->ctx, fd, argc, argvp) == -1) {
- logger(fd->ctx, LOG_ERR,
- "%s: dhcpcd_handleargs: %m", __func__);
+ syslog(LOG_ERR, "%s: dhcpcd_handleargs: %m", __func__);
if (errno != EINTR && errno != EAGAIN) {
control_delete(fd);
return;
iov[1].iov_base = data->data;
iov[1].iov_len = data->data_len;
if (writev(fd->fd, iov, 2) == -1) {
- logger(fd->ctx, LOG_ERR,
- "%s: writev fd %d: %m", __func__, fd->fd);
+ syslog(LOG_ERR, "%s: writev fd %d: %m", __func__, fd->fd);
if (errno != EINTR && errno != EAGAIN)
control_delete(fd);
return;
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include <arpa/nameser.h> /* after normal includes for sunos */
prefix, opt, 1, od, ol, ifname))
return 1;
else
- logger(ctx, LOG_ERR, "%s: %s %d: %m",
+ syslog(LOG_ERR, "%s: %s %d: %m",
ifname, __func__, opt->option);
}
return 0;
if (opt->type & OT_INDEX) {
if (opt->index > 999) {
errno = ENOBUFS;
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return 0;
}
}
(opt->type & OT_INDEX ? 3 : 0);
pfx = malloc(e);
if (pfx == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return 0;
}
if (opt->type & OT_INDEX)
eo = dhcp_optlen(eopt, ol);
if (eo == -1) {
if (env == NULL)
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: %s %d.%d/%zu: "
"malformed embedded option",
ifname, __func__, opt->option,
* option which is optional. */
if (env == NULL &&
(ol != 0 || !(eopt->type & OT_OPTIONAL)))
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: %s %d.%d/%zu: missing embedded option",
ifname, __func__, opt->option,
eopt->option, i);
pfx, eopt, ov, od, (size_t)eo, ifname))
n++;
else if (env == NULL)
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: %s %d.%d/%zu: %m",
ifname, __func__,
opt->option, eopt->option, i);
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#define ELOOP_QUEUE 2
if (!(ifo->options & DHCPCD_CSR_WARNED) &&
!(state->added & STATE_FAKE))
{
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: using %sClassless Static Routes",
ifp->name, csr);
ifo->options |= DHCPCD_CSR_WARNED;
#endif
if ((mtu = if_getmtu(ifp)) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: if_getmtu: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_getmtu: %m", ifp->name);
else if (mtu < MTU_MIN) {
if (if_setmtu(ifp, MTU_MIN) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: if_setmtu: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_setmtu: %m", ifp->name);
mtu = MTU_MIN;
}
{
AREA_FIT(vivco->len);
if (vivco->len + 2 + *lp > 255) {
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: VIVCO option too big",
ifp->name);
free(bootp);
alen = -1;
}
if (alen == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_auth_encode: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_auth_encode: %m", ifp->name);
else if (alen != 0) {
auth_len = (uint8_t)alen;
AREA_CHECK(auth_len);
return (ssize_t)len;
toobig:
- logger(ifp->ctx, LOG_ERR, "%s: DHCP message too big", ifp->name);
+ syslog(LOG_ERR, "%s: DHCP message too big", ifp->name);
free(bootp);
return -1;
}
ssize_t bytes;
const struct dhcp_state *state = D_CSTATE(ifp);
- logger(ifp->ctx, LOG_DEBUG, "%s: writing lease `%s'",
+ syslog(LOG_DEBUG, "%s: writing lease `%s'",
ifp->name, state->leasefile);
fd = open(state->leasefile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
}
if (fd == -1) {
if (errno != ENOENT)
- logger(ifp->ctx, LOG_ERR, "%s: open `%s': %m",
+ syslog(LOG_ERR, "%s: open `%s': %m",
ifp->name, state->leasefile);
return 0;
}
if (state->leasefile[0] == '\0')
- logger(ifp->ctx, LOG_DEBUG, "reading standard input");
+ syslog(LOG_DEBUG, "reading standard input");
else
- logger(ifp->ctx, LOG_DEBUG, "%s: reading lease `%s'",
+ syslog(LOG_DEBUG, "%s: reading lease `%s'",
ifp->name, state->leasefile);
bytes = dhcp_read_lease_fd(fd, (void **)&lease);
close(fd);
if (bytes == 0) {
free(lease);
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_read_lease_fd: %m", __func__);
+ syslog(LOG_ERR, "%s: dhcp_read_lease_fd: %m", __func__);
return 0;
}
* scribble whatever in the stored lease file. */
if (bytes < offsetof(struct bootp, vend) + 4) {
free(lease);
- logger(ifp->ctx, LOG_ERR, "%s: truncated lease", __func__);
+ syslog(LOG_ERR, "%s: truncated lease", __func__);
return 0;
}
if (dhcp_auth_validate(&state->auth, &ifp->options->auth,
lease, bytes, 4, type, auth, auth_len) == NULL)
{
- logger(ifp->ctx, LOG_DEBUG,
- "%s: dhcp_auth_validate: %m", ifp->name);
+ syslog(LOG_DEBUG, "%s: dhcp_auth_validate: %m",
+ ifp->name);
free(lease);
return 0;
}
if (state->auth.token)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: validated using 0x%08" PRIu32,
+ syslog(LOG_DEBUG, "%s: validated using 0x%08" PRIu32,
ifp->name, state->auth.token->secretid);
else
- logger(ifp->ctx, LOG_DEBUG,
- "%s: accepted reconfigure key", ifp->name);
+ syslog(LOG_DEBUG, "%s: accepted reconfigure key",
+ ifp->name);
} else if ((ifp->options->auth.options & DHCPCD_AUTH_SENDREQUIRE) ==
DHCPCD_AUTH_SENDREQUIRE)
{
- logger(ifp->ctx, LOG_ERR,
- "%s: authentication now required", ifp->name);
+ syslog(LOG_ERR, "%s: authentication now required", ifp->name);
free(lease);
return 0;
}
/* Set some useful variables that we derive from the DHCP
* message but are not necessarily in the options */
addr.s_addr = bootp->yiaddr ? bootp->yiaddr : bootp->ciaddr;
- addvar(ifp->ctx, &ep, prefix, "ip_address", inet_ntoa(addr));
+ addvar(&ep, prefix, "ip_address", inet_ntoa(addr));
if (get_option_addr(ifp->ctx, &net,
bootp, bootp_len, DHO_SUBNETMASK) == -1)
{
net.s_addr = ipv4_getnetmask(addr.s_addr);
- addvar(ifp->ctx, &ep, prefix,
+ addvar(&ep, prefix,
"subnet_mask", inet_ntoa(net));
}
snprintf(cidr, sizeof(cidr), "%d", inet_ntocidr(net));
- addvar(ifp->ctx, &ep, prefix, "subnet_cidr", cidr);
+ addvar(&ep, prefix, "subnet_cidr", cidr);
if (get_option_addr(ifp->ctx, &brd,
bootp, bootp_len, DHO_BROADCAST) == -1)
{
brd.s_addr = addr.s_addr | ~net.s_addr;
- addvar(ifp->ctx, &ep, prefix,
+ addvar(&ep, prefix,
"broadcast_address", inet_ntoa(brd));
}
addr.s_addr = bootp->yiaddr & net.s_addr;
- addvar(ifp->ctx, &ep, prefix,
+ addvar(&ep, prefix,
"network_number", inet_ntoa(addr));
}
if (*bootp->file && !(overl & 1)) {
print_string(safe, sizeof(safe), OT_STRING,
bootp->file, sizeof(bootp->file));
- addvar(ifp->ctx, &ep, prefix, "filename", safe);
+ addvar(&ep, prefix, "filename", safe);
}
if (*bootp->sname && !(overl & 2)) {
print_string(safe, sizeof(safe), OT_STRING | OT_DOMAIN,
bootp->sname, sizeof(bootp->sname));
- addvar(ifp->ctx, &ep, prefix, "server_name", safe);
+ addvar(&ep, prefix, "server_name", safe);
}
/* Zero our indexes */
/* No carrier? Don't bother sending the packet. */
if (ifp->carrier == LINK_DOWN)
return;
- logger(ifp->ctx, LOG_DEBUG, "%s: sending %s with xid 0x%x",
+ syslog(LOG_DEBUG, "%s: sending %s with xid 0x%x",
ifp->name,
ifo->options & DHCPCD_BOOTP ? "BOOTP" : get_dhcp_op(type),
state->xid);
* However, we do need to advance the timeout. */
if (ifp->carrier == LINK_DOWN)
goto fail;
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: sending %s (xid 0x%x), next in %0.1f seconds",
ifp->name,
ifo->options & DHCPCD_BOOTP ? "BOOTP" : get_dhcp_op(type),
s = dhcp_openudp(ifp);
if (s == -1) {
if (errno != EADDRINUSE)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_openudp: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_openudp: %m",
+ ifp->name);
/* We cannot renew */
state->addr = NULL;
}
r = sendto(s, (uint8_t *)bootp, len, 0,
(struct sockaddr *)&sin, sizeof(sin));
if (r == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_sendpacket: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_sendpacket: %m", ifp->name);
} else {
size_t ulen;
udp = dhcp_makeudppacket(&ulen, (uint8_t *)bootp, len, from,to);
if (udp == NULL) {
- logger(ifp->ctx, LOG_ERR, "dhcp_makeudppacket: %m");
+ syslog(LOG_ERR, "dhcp_makeudppacket: %m");
r = 0;
} else {
r = bpf_send(ifp, state->bpf_fd,
* As such we remove it from consideration without actually
* stopping the interface. */
if (r == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: if_sendraw: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_sendraw: %m", ifp->name);
switch(errno) {
case ENETDOWN:
case ENETRESET:
ifo->reboot, ipv4ll_start, ifp);
#endif
if (ifo->options & DHCPCD_REQUEST)
- logger(ifp->ctx, LOG_INFO,
- "%s: soliciting a DHCP lease (requesting %s)",
+ syslog(LOG_INFO, "%s: soliciting a DHCP lease (requesting %s)",
ifp->name, inet_ntoa(ifo->req_addr));
else
- logger(ifp->ctx, LOG_INFO,
- "%s: soliciting a %s lease",
+ syslog(LOG_INFO, "%s: soliciting a %s lease",
ifp->name, ifo->options & DHCPCD_BOOTP ? "BOOTP" : "DHCP");
send_discover(ifp);
}
return -1;
#endif
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: extending lease until DaD failure or DHCP", ifp->name);
return 0;
}
#endif
- logger(ifp->ctx, LOG_WARNING, "%s: extending lease", ifp->name);
+ syslog(LOG_WARNING, "%s: extending lease", ifp->name);
return 0;
}
{
struct interface *ifp = arg;
- logger(ifp->ctx, LOG_ERR, "%s: DHCP lease expired", ifp->name);
+ syslog(LOG_ERR, "%s: DHCP lease expired", ifp->name);
if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) {
if (dhcp_leaseextend(ifp) == 0)
return;
- logger(ifp->ctx, LOG_ERR, "%s: dhcp_leaseextend: %m",
- ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_leaseextend: %m", ifp->name);
}
dhcp_expire1(ifp);
}
eloop_timeout_delete(ifp->ctx->eloop, dhcp_startrenew, ifp);
lease = &state->lease;
- logger(ifp->ctx, LOG_DEBUG, "%s: renewing lease of %s",
- ifp->name, inet_ntoa(lease->addr));
+ syslog(LOG_DEBUG, "%s: renewing lease of %s", ifp->name,
+ inet_ntoa(lease->addr));
state->state = DHS_RENEW;
dhcp_new_xid(ifp);
state->interval = 0;
struct dhcp_state *state = D_STATE(ifp);
struct dhcp_lease *lease = &state->lease;
- logger(ifp->ctx, LOG_WARNING,
- "%s: failed to renew DHCP, rebinding", ifp->name);
- logger(ifp->ctx, LOG_DEBUG, "%s: expire in %"PRIu32" seconds",
+ syslog(LOG_WARNING, "%s: failed to renew DHCP, rebinding", ifp->name);
+ syslog(LOG_DEBUG, "%s: expire in %"PRIu32" seconds",
ifp->name, lease->leasetime - lease->rebindtime);
state->state = DHS_REBIND;
eloop_timeout_delete(ifp->ctx->eloop, send_renew, ifp);
if (state->state == DHS_BOUND)
return;
- logger(ifp->ctx, LOG_DEBUG, "%s: DAD completed for %s",
+ syslog(LOG_DEBUG, "%s: DAD completed for %s",
ifp->name, inet_ntoa(astate->addr));
if (state->state != DHS_INFORM)
dhcp_bind(ifp);
}
get_lease(ifp, lease, state->new, state->new_len);
if (ifo->options & DHCPCD_STATIC) {
- logger(ifp->ctx, LOG_INFO, "%s: using static address %s/%d",
+ syslog(LOG_INFO, "%s: using static address %s/%d",
ifp->name, inet_ntoa(lease->addr),
inet_ntocidr(lease->mask));
lease->leasetime = ~0U;
state->reason = "STATIC";
} else if (ifo->options & DHCPCD_INFORM) {
- logger(ifp->ctx, LOG_INFO, "%s: received approval for %s",
+ syslog(LOG_INFO, "%s: received approval for %s",
ifp->name, inet_ntoa(lease->addr));
lease->leasetime = ~0U;
state->reason = "INFORM";
lease->renewaltime =
lease->rebindtime =
lease->leasetime;
- logger(ifp->ctx, LOG_INFO, "%s: leased %s for infinity",
+ syslog(LOG_INFO, "%s: leased %s for infinity",
ifp->name, inet_ntoa(lease->addr));
} else {
if (lease->leasetime < DHCP_MIN_LEASE) {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: minimum lease is %d seconds",
ifp->name, DHCP_MIN_LEASE);
lease->leasetime = DHCP_MIN_LEASE;
else if (lease->rebindtime >= lease->leasetime) {
lease->rebindtime =
(uint32_t)(lease->leasetime * T2);
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: rebind time greater than lease "
"time, forcing to %"PRIu32" seconds",
ifp->name, lease->rebindtime);
else if (lease->renewaltime > lease->rebindtime) {
lease->renewaltime =
(uint32_t)(lease->leasetime * T1);
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: renewal time greater than rebind "
"time, forcing to %"PRIu32" seconds",
ifp->name, lease->renewaltime);
}
- logger(ifp->ctx,
- state->addr &&
+ syslog(state->addr &&
lease->addr.s_addr == state->addr->addr.s_addr &&
!(state->added & STATE_FAKE) ?
LOG_DEBUG : LOG_INFO,
(time_t)lease->rebindtime, dhcp_rebind, ifp);
eloop_timeout_add_sec(ifp->ctx->eloop,
(time_t)lease->leasetime, dhcp_expire, ifp);
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: renew in %"PRIu32" seconds, rebind in %"PRIu32
" seconds",
ifp->name, lease->renewaltime, lease->rebindtime);
if (!state->lease.frominfo &&
!(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)))
if (write_lease(ifp, state->new, state->new_len) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: write_lease: %m", __func__);
+ syslog(LOG_ERR, "%s: write_lease: %m", __func__);
ipv4_applyaddr(ifp);
}
struct interface *ifp = arg;
struct dhcp_state *state = D_STATE(ifp);
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: timed out contacting a DHCP server, using last lease",
ifp->name);
dhcp_bind(ifp);
if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND &&
dhcp_leaseextend(ifp) == -1)
{
- logger(ifp->ctx, LOG_ERR, "%s: dhcp_leaseextend: %m",
- ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_leaseextend: %m", ifp->name);
dhcp_expire(ifp);
}
dhcp_discover(ifp);
/* Add the address now, let the kernel handle DAD. */
ipv4_addaddr(ifp, &l.addr, &l.mask, &l.brd);
} else
- logger(ifp->ctx, LOG_INFO, "%s: waiting for DAD on %s",
+ syslog(LOG_INFO, "%s: waiting for DAD on %s",
ifp->name, inet_ntoa(addr));
return 0;
}
struct dhcp_lease l;
get_lease(ifp, &l, state->offer, state->offer_len);
- logger(ifp->ctx, LOG_INFO, "%s: probing address %s/%d",
+ syslog(LOG_INFO, "%s: probing address %s/%d",
ifp->name, inet_ntoa(l.addr), inet_ntocidr(l.mask));
/* We need to handle DAD. */
arp_probe(astate);
if (ifo->req_addr.s_addr == INADDR_ANY &&
(ia = ipv4_iffindaddr(ifp, NULL, NULL)) == NULL)
{
- logger(ifp->ctx, LOG_INFO,
- "%s: waiting for 3rd party to "
- "configure IP address",
- ifp->name);
+ syslog(LOG_INFO, "%s: waiting for 3rd party to "
+ "configure IP address", ifp->name);
state->reason = "3RDPARTY";
script_runreason(ifp, state->reason);
return;
if (ifo->req_addr.s_addr == INADDR_ANY) {
ia = ipv4_iffindaddr(ifp, NULL, NULL);
if (ia == NULL) {
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: waiting for 3rd party to configure IP address",
ifp->name);
if (!(ifp->ctx->options & DHCPCD_TEST)) {
ia = ipv4_iffindaddr(ifp, &ifo->req_addr, &ifo->req_mask);
if (ia == NULL) {
if (ifp->ctx->options & DHCPCD_TEST) {
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: cannot add IP address in test mode",
ifp->name);
return;
state->interval = 0;
if (ifo->options & DHCPCD_LINK && ifp->carrier == LINK_DOWN) {
- logger(ifp->ctx, LOG_INFO,
- "%s: waiting for carrier", ifp->name);
+ syslog(LOG_INFO, "%s: waiting for carrier", ifp->name);
return;
}
if (ifo->options & DHCPCD_STATIC) {
return;
}
if (ifo->options & DHCPCD_INFORM) {
- logger(ifp->ctx, LOG_INFO, "%s: informing address of %s",
+ syslog(LOG_INFO, "%s: informing address of %s",
ifp->name, inet_ntoa(state->lease.addr));
dhcp_inform(ifp);
return;
if (!IS_DHCP(state->offer))
return;
- logger(ifp->ctx, LOG_INFO, "%s: rebinding lease of %s",
+ syslog(LOG_INFO, "%s: rebinding lease of %s",
ifp->name, inet_ntoa(state->lease.addr));
dhcp_new_xid(ifp);
state->lease.server.s_addr = 0;
state->new != NULL &&
state->lease.server.s_addr != INADDR_ANY)
{
- logger(ifp->ctx, LOG_INFO, "%s: releasing lease of %s",
+ syslog(LOG_INFO, "%s: releasing lease of %s",
ifp->name, inet_ntoa(state->lease.addr));
dhcp_new_xid(ifp);
send_message(ifp, DHCP_RELEASE, NULL);
tmpl = (al * 4) + 1;
tmp = malloc(tmpl);
if (tmp == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(a);
return;
}
addr.s_addr = bootp->yiaddr;
a = strdup(inet_ntoa(addr));
if (a == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
} else
print_string(sname, sizeof(sname), OT_STRING | OT_DOMAIN,
bootp->sname, sizeof(bootp->sname));
if (a == NULL)
- logger(ifp->ctx, lvl, "%s: %s %s %s `%s'",
+ syslog(lvl, "%s: %s %s %s `%s'",
ifp->name, msg, tfrom, inet_ntoa(addr), sname);
else
- logger(ifp->ctx, lvl, "%s: %s %s %s %s `%s'",
+ syslog(lvl, "%s: %s %s %s %s `%s'",
ifp->name, msg, a, tfrom, inet_ntoa(addr), sname);
} else {
if (r != 0) {
addr = *from;
}
if (a == NULL)
- logger(ifp->ctx, lvl, "%s: %s %s %s",
+ syslog(lvl, "%s: %s %s %s",
ifp->name, msg, tfrom, inet_ntoa(addr));
else
- logger(ifp->ctx, lvl, "%s: %s %s %s %s",
+ syslog(lvl, "%s: %s %s %s %s",
ifp->name, msg, a, tfrom, inet_ntoa(addr));
}
free(a);
/* Handled in our BPF filter. */
#if 0
if (bootp->op != BOOTREPLY) {
- logger(ifp->ctx, LOG_DEBUG, "%s: op (%d) is not BOOTREPLY",
+ syslog(LOG_DEBUG, "%s: op (%d) is not BOOTREPLY",
ifp->name, bootp->op);
return;
}
{
char buf[sizeof(bootp->chaddr) * 3];
- logger(ifp->ctx, LOG_DEBUG, "%s: xid 0x%x is for hwaddr %s",
+ syslog(LOG_DEBUG, "%s: xid 0x%x is for hwaddr %s",
ifp->name, ntohl(bootp->xid),
hwaddr_ntoa(bootp->chaddr, sizeof(bootp->chaddr),
buf, sizeof(buf)));
bootp, bootp_len, DHO_MESSAGETYPE) == -1)
type = 0;
else if (ifo->options & DHCPCD_BOOTP) {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: ignoring DHCP reply (expecting BOOTP)",
+ syslog(LOG_DEBUG, "%s: ignoring DHCP reply (expecting BOOTP)",
ifp->name);
return;
}
(uint8_t *)bootp, bootp_len, 4, type,
auth, auth_len) == NULL)
{
- logger(ifp->ctx, LOG_DEBUG,
- "%s: dhcp_auth_validate: %m", ifp->name);
+ syslog(LOG_DEBUG, "%s: dhcp_auth_validate: %m",
+ ifp->name);
LOGDHCP0(LOG_ERR, "authentication failed");
return;
}
if (state->auth.token)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: validated using 0x%08" PRIu32,
+ syslog(LOG_DEBUG, "%s: validated using 0x%08" PRIu32,
ifp->name, state->auth.token->secretid);
else
- logger(ifp->ctx, LOG_DEBUG,
- "%s: accepted reconfigure key", ifp->name);
+ syslog(LOG_INFO, "%s: accepted reconfigure key",
+ ifp->name);
} else if (ifo->auth.options & DHCPCD_AUTH_SEND) {
if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) {
LOGDHCP0(LOG_ERR, "no authentication");
#if 0
/* Ensure it's the right transaction */
if (state->xid != ntohl(bootp->xid)) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: wrong xid 0x%x (expecting 0x%x) from %s",
ifp->name, ntohl(bootp->xid), state->xid,
inet_ntoa(*from));
if ((msg = get_option_string(ifp->ctx,
bootp, bootp_len, DHO_MESSAGE)))
{
- logger(ifp->ctx, LOG_WARNING, "%s: message: %s",
- ifp->name, msg);
+ syslog(LOG_WARNING, "%s: message: %s", ifp->name, msg);
free(msg);
}
if (state->state == DHS_INFORM) /* INFORM should not be NAKed */
if ((msg = get_option_string(ifp->ctx,
bootp, bootp_len, DHO_MESSAGE)))
{
- logger(ifp->ctx, LOG_WARNING,
- "%s: message: %s", ifp->name, msg);
+ syslog(LOG_WARNING, "%s: message: %s", ifp->name, msg);
free(msg);
}
#ifdef IPV4LL
ipv4ll_start(ifp);
break;
default:
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: unknown auto configuration option %d",
ifp->name, tmp);
break;
if (state->offer_len < bootp_len) {
free(state->offer);
if ((state->offer = malloc(bootp_len)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: malloc: %m",
- __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
state->offer_len = 0;
return;
}
if (state->offer_len < bootp_len) {
free(state->offer);
if ((state->offer = malloc(bootp_len)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: malloc: %m",
- __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
state->offer_len = 0;
return;
}
if (valid_udp_packet(data, len, &from, flags & RAW_PARTIALCSUM) == -1)
{
- logger(ifp->ctx, LOG_ERR, "%s: invalid UDP packet from %s",
+ syslog(LOG_ERR, "%s: invalid UDP packet from %s",
ifp->name, inet_ntoa(from));
return;
}
i = whitelisted_ip(ifp->options, from.s_addr);
if (i == 0) {
- logger(ifp->ctx, LOG_WARNING,
- "%s: non whitelisted DHCP packet from %s",
+ syslog(LOG_WARNING, "%s: non whitelisted DHCP packet from %s",
ifp->name, inet_ntoa(from));
return;
} else if (i != 1 && blacklisted_ip(ifp->options, from.s_addr) == 1) {
- logger(ifp->ctx, LOG_WARNING,
- "%s: blacklisted DHCP packet from %s",
+ syslog(LOG_WARNING, "%s: blacklisted DHCP packet from %s",
ifp->name, inet_ntoa(from));
return;
}
if (ifp->flags & IFF_POINTOPOINT &&
(state->addr == NULL || state->addr->brd.s_addr != from.s_addr))
{
- logger(ifp->ctx, LOG_WARNING,
- "%s: server %s is not destination",
+ syslog(LOG_WARNING, "%s: server %s is not destination",
ifp->name, inet_ntoa(from));
}
/* udp_len must be correct because the values are checked in
* valid_udp_packet(). */
if (udp_len < offsetof(struct bootp, vend)) {
- logger(ifp->ctx, LOG_ERR,
- "%s: truncated packet (%zu) from %s",
+ syslog(LOG_ERR, "%s: truncated packet (%zu) from %s",
ifp->name, udp_len, inet_ntoa(from));
return;
}
while (!(flags & BPF_EOF)) {
bytes = bpf_read(ifp, state->bpf_fd, buf,sizeof(buf), &flags);
if (bytes == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp if_readrawpacket: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp if_readrawpacket: %m",
+ ifp->name);
dhcp_close(ifp);
return;
}
/* Just read what's in the UDP fd and discard it as we always read
* from the raw fd */
if (read(ctx->udp_fd, buffer, sizeof(buffer)) == -1) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
eloop_event_delete(ctx->eloop, ctx->udp_fd);
close(ctx->udp_fd);
ctx->udp_fd = -1;
state->bpf_fd = bpf_open(ifp, bpf_bootp);
if (state->bpf_fd == -1) {
if (errno == ENOENT) {
- logger(ifp->ctx, LOG_ERR,
- "%s not found", bpf_name);
+ syslog(LOG_ERR, "%s not found", bpf_name);
/* May as well disable IPv4 entirely at
* this point as we really need it. */
ifp->options->options &= ~DHCPCD_IPV4;
} else
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m",
+ syslog(LOG_ERR, "%s: %s: %m",
__func__, ifp->name);
return -1;
}
AF_INET, ifp);
state->new_len = read_lease(ifp, &state->new);
if (state->new == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m",
+ syslog(LOG_ERR, "%s: %s: %m",
*ifp->name ? ifp->name : state->leasefile, __func__);
return -1;
}
return script_runreason(ifp, state->reason);
eexit:
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
return 0;
if (ifo->options & DHCPCD_CLIENTID)
- logger(ifp->ctx, LOG_DEBUG, "%s: using ClientID %s", ifp->name,
+ syslog(LOG_DEBUG, "%s: using ClientID %s", ifp->name,
hwaddr_ntoa(state->clientid + 1, state->clientid[0],
buf, sizeof(buf)));
else if (ifp->hwlen)
- logger(ifp->ctx, LOG_DEBUG, "%s: using hwaddr %s", ifp->name,
+ syslog(LOG_DEBUG, "%s: using hwaddr %s", ifp->name,
hwaddr_ntoa(ifp->hwaddr, ifp->hwlen, buf, sizeof(buf)));
return 0;
eexit:
- logger(ifp->ctx, LOG_ERR, "%s: error making ClientID: %m", __func__);
+ syslog(LOG_ERR, "%s: error making ClientID: %m", __func__);
return -1;
}
/* Don't log an error if some other process
* is handling this. */
if (errno != EADDRINUSE)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_openudp: %m", __func__);
+ syslog(LOG_ERR, "%s: dhcp_openudp: %m",
+ __func__);
} else
eloop_event_add(ifp->ctx->eloop,
ifp->ctx->udp_fd, dhcp_handleudp, ifp->ctx);
}
if (dhcp_init(ifp) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: dhcp_init: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_init: %m", ifp->name);
return;
}
return;
}
if (ifp->hwlen == 0 && ifo->clientid[0] == '\0') {
- logger(ifp->ctx, LOG_WARNING,
- "%s: needs a clientid to configure", ifp->name);
+ syslog(LOG_WARNING, "%s: needs a clientid to configure",
+ ifp->name);
dhcp_drop(ifp, "FAIL");
eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp);
return;
state->added |= STATE_ADDED | STATE_FAKE;
rt_build(ifp->ctx, AF_INET);
} else
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
}
if (!IS_DHCP(state->offer)) {
free(state->offer);
if (now == -1 ||
(time_t)state->lease.leasetime < now - st.st_mtime)
{
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: discarding expired lease", ifp->name);
free(state->offer);
state->offer = NULL;
tv.tv_nsec = (suseconds_t)arc4random_uniform(
(DHCP_MAX_DELAY - DHCP_MIN_DELAY) * NSEC_PER_SEC);
timespecnorm(&tv);
- logger(ifp->ctx, LOG_DEBUG,
- "%s: delaying IPv4 for %0.1f seconds",
+ syslog(LOG_DEBUG, "%s: delaying IPv4 for %0.1f seconds",
ifp->name, timespec_to_double(&tv));
eloop_timeout_add_tv(ifp->ctx->eloop, &tv, dhcp_start1, ifp);
if (cmd == RTM_DELADDR) {
if (state->addr == ia) {
- logger(ifp->ctx, LOG_INFO,
- "%s: deleted IP address %s", ifp->name, ia->saddr);
+ syslog(LOG_INFO, "%s: deleted IP address %s",
+ ifp->name, ia->saddr);
state->addr = NULL;
/* Don't clear the added state as we need
* to drop the lease. */
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include <fcntl.h>
}
if (len > UINT16_MAX) {
- logger(ifp->ctx, LOG_ERR,
- "%s: DHCPv6 Vendor Class too big", ifp->name);
+ syslog(LOG_ERR, "%s: DHCPv6 Vendor Class too big", ifp->name);
return 0;
}
ifp->if_data[IF_DATA_DHCP6] = calloc(1, sizeof(*state));
state = D6_STATE(ifp);
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
{
sa = inet_ntop(AF_INET6, &prefix->prefix,
sabuf, sizeof(sabuf));
- logger(ifp->ctx, LOG_ERR,
- "%s: invalid prefix %s/%d + %d/%d: %m",
+ syslog(LOG_ERR, "%s: invalid prefix %s/%d + %d/%d: %m",
ifp->name, sa, prefix->prefix_len,
sla->sla, sla->prefix_len);
return -1;
{
sa = inet_ntop(AF_INET6, &prefix->prefix_exclude,
sabuf, sizeof(sabuf));
- logger(ifp->ctx, LOG_ERR,
- "%s: cannot delegate excluded prefix %s/%d",
+ syslog(LOG_ERR, "%s: cannot delegate excluded prefix %s/%d",
ifp->name, sa, prefix->prefix_exclude_len);
return -1;
}
alen = -1;
}
if (alen == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp_auth_encode: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp_auth_encode: %m", ifp->name);
else if (alen != 0) {
auth_len = (uint16_t)alen;
len += sizeof(o) + auth_len;
}
if (!callback)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: %s %s with xid 0x%02x%02x%02x",
+ syslog(LOG_DEBUG, "%s: %s %s with xid 0x%02x%02x%02x",
ifp->name,
broad_uni,
dhcp6_get_op(state->send->type),
logsend:
if (ifp->carrier != LINK_DOWN)
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: %s %s (xid 0x%02x%02x%02x),"
" next in %0.1f seconds",
ifp->name,
if (ifp->options->auth.options & DHCPCD_AUTH_SEND &&
dhcp6_update_auth(ifp, state->send, state->send_len) == -1)
{
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_updateauth: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_updateauth: %m", ifp->name);
if (errno != ESRCH)
return -1;
}
memcpy(CMSG_DATA(cm), &pi, sizeof(pi));
if (sendmsg(ctx->dhcp6_fd, &ctx->sndhdr, 0) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: %s: sendmsg: %m", ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: sendmsg: %m", ifp->name, __func__);
/* Allow DHCPv6 to continue .... the errors
* would be rate limited by the protocol.
* Generally the error is ENOBUFS when struggling to
eloop_timeout_add_tv(ifp->ctx->eloop,
&state->RT, state->MRCcallback, ifp);
else
- logger(ifp->ctx, LOG_WARNING,
- "%s: sent %d times with no reply",
+ syslog(LOG_WARNING, "%s: sent %d times with no reply",
ifp->name, state->RTC);
}
return 0;
state->MRC = 0;
if (dhcp6_makemessage(ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
else
dhcp6_sendrenew(ifp);
}
if (ap->flags & IPV6_AF_DUPLICATED)
/* XXX FIXME
* We should decline the address */
- logger(ap->iface->ctx, LOG_WARNING, "%s: DAD detected %s",
+ syslog(LOG_WARNING, "%s: DAD detected %s",
ap->iface->name, ap->saddr);
if (!wascompleted) {
}
}
if (!wascompleted) {
- logger(ap->iface->ctx, LOG_DEBUG,
- "%s: DHCPv6 DAD completed", ifp->name);
+ syslog(LOG_DEBUG, "%s: DHCPv6 DAD completed",
+ ifp->name);
script_runreason(ifp,
ap->delegating_prefix ?
"DELEGATED6" : state->reason);
continue;
a = calloc(1, sizeof(*a));
if (a == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
a->flags = IPV6_AF_REQUEST;
#ifndef SMALL
dhcp6_delete_delegates(ifp);
#endif
- logger(ifp->ctx, LOG_INFO, "%s: soliciting a DHCPv6 lease", ifp->name);
+ syslog(LOG_INFO, "%s: soliciting a DHCPv6 lease", ifp->name);
state = D6_STATE(ifp);
state->state = DH6S_DISCOVER;
state->RTC = 0;
dhcp6_addrequestedaddrs(ifp);
if (dhcp6_makemessage(ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
else
dhcp6_senddiscover(ifp);
}
struct interface *ifp;
ifp = arg;
- logger(ifp->ctx, LOG_ERR,
- "%s: failed to confirm prior address", ifp->name);
+ syslog(LOG_ERR, "%s: failed to confirm prior address", ifp->name);
/* Section 18.1.2 says that we SHOULD use the last known
* IP address(s) and lifetimes if we didn't get a reply.
* I disagree with this. */
struct interface *ifp;
ifp = arg;
- logger(ifp->ctx, LOG_ERR, "%s: failed to request address", ifp->name);
+ syslog(LOG_ERR, "%s: failed to request address", ifp->name);
/* Section 18.1.1 says that client local policy dictates
* what happens if a REQUEST fails.
* Of the possible scenarios listed, moving back to the
struct interface *ifp;
ifp = arg;
- logger(ifp->ctx, LOG_ERR,
- "%s: failed to rebind prior delegation", ifp->name);
+ syslog(LOG_ERR, "%s: failed to rebind prior delegation", ifp->name);
dhcp6_delete_delegates(ifp);
/* Section 18.1.2 says that we SHOULD use the last known
* IP address(s) and lifetimes if we didn't get a reply.
eloop_timeout_delete(ifp->ctx->eloop, dhcp6_sendrenew, ifp);
state = D6_STATE(ifp);
if (state->state == DH6S_RENEW)
- logger(ifp->ctx, LOG_WARNING,
- "%s: failed to renew DHCPv6, rebinding", ifp->name);
+ syslog(LOG_WARNING, "%s: failed to renew DHCPv6, rebinding",
+ ifp->name);
else
- logger(ifp->ctx, LOG_INFO,
- "%s: rebinding prior DHCPv6 lease", ifp->name);
+ syslog(LOG_INFO, "%s: rebinding prior DHCPv6 lease", ifp->name);
state->state = DH6S_REBIND;
state->RTC = 0;
state->MRC = 0;
}
if (dhcp6_makemessage(ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
else
dhcp6_sendrebind(ifp);
state->MRCcallback = dhcp6_failrequest;
if (dhcp6_makemessage(ifp) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
return;
}
state->MRT = CNF_MAX_RT;
state->MRC = 0;
- logger(ifp->ctx, LOG_INFO,
- "%s: confirming prior DHCPv6 lease", ifp->name);
+ syslog(LOG_INFO, "%s: confirming prior DHCPv6 lease", ifp->name);
if (dhcp6_makemessage(ifp) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
return;
}
dhcp6_sendconfirm(ifp);
ifp = arg;
state = D6_STATE(ifp);
if (state->new == NULL || ifp->options->options & DHCPCD_DEBUG)
- logger(ifp->ctx, LOG_INFO,
- "%s: requesting DHCPv6 information", ifp->name);
+ syslog(LOG_INFO, "%s: requesting DHCPv6 information",
+ ifp->name);
state->state = DH6S_INFORM;
state->RTC = 0;
state->IMD = INF_MAX_DELAY;
state->MRC = 0;
if (dhcp6_makemessage(ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
else
dhcp6_sendinform(ifp);
}
ifp = arg;
eloop_timeout_delete(ifp->ctx->eloop, dhcp6_sendrebind, ifp);
- logger(ifp->ctx, LOG_ERR, "%s: DHCPv6 lease expired", ifp->name);
+ syslog(LOG_ERR, "%s: DHCPv6 lease expired", ifp->name);
dhcp6_freedrop_addrs(ifp, 1, NULL);
#ifndef SMALL
dhcp6_delete_delegates(ifp);
if (ipv6nd_hasradhcp(ifp) || dhcp6_hasprefixdelegation(ifp))
dhcp6_startdiscover(ifp);
else
- logger(ifp->ctx, LOG_WARNING,
- "%s: no advertising IPv6 router wants DHCP", ifp->name);
+ syslog(LOG_WARNING, "%s: no advertising IPv6 router wants DHCP",
+ ifp->name);
}
static void
#endif
if (dhcp6_makemessage(ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_makemessage: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_makemessage: %m", ifp->name);
else {
dhcp6_sendrelease(ifp);
dhcp6_finishrelease(ifp);
else
farg = m;
if ((opt = f(farg, len, D6_OPTION_STATUS_CODE, &opt_len)) == NULL) {
- //logger(ifp->ctx, LOG_DEBUG, "%s: no status", ifp->name);
+ //syslog(LOG_DEBUG, "%s: no status", ifp->name);
return 0;
}
if (opt_len < sizeof(code)) {
- logger(ifp->ctx, LOG_ERR, "%s: status truncated", ifp->name);
+ syslog(LOG_ERR, "%s: status truncated", ifp->name);
return -1;
}
memcpy(&code, opt, sizeof(code));
}
} else {
if ((sbuf = malloc((size_t)opt_len + 1)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return false;
}
memcpy(sbuf, opt, opt_len);
status = sbuf;
}
- logger(ifp->ctx, LOG_ERR, "%s: DHCPv6 REPLY: %s", ifp->name, status);
+ syslog(LOG_ERR, "%s: DHCPv6 REPLY: %s", ifp->name, status);
free(sbuf);
return -1;
}
d = nd;
if (ol < 24) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
- "%s: IA Address option truncated", ifp->name);
+ syslog(LOG_ERR, "%s: IA Address option truncated",
+ ifp->name);
continue;
}
memcpy(&ia, o, ol);
/* RFC 3315 22.6 */
if (ia.pltime > ia.vltime) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: IA Address pltime %"PRIu32" > vltime %"PRIu32,
ifp->name, ia.pltime, ia.vltime);
continue;
if (a == NULL) {
a = calloc(1, sizeof(*a));
if (a == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
break;
}
a->iface = ifp;
d = nd;
if (ol < sizeof(pdp)) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
- "%s: IA Prefix option truncated", ifp->name);
+ syslog(LOG_ERR, "%s: IA Prefix option truncated",
+ ifp->name);
continue;
}
/* RFC 3315 22.6 */
if (pdp.pltime > pdp.vltime) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: IA Prefix pltime %"PRIu32" > vltime %"PRIu32,
ifp->name, pdp.pltime, pdp.vltime);
continue;
if (a == NULL) {
a = calloc(1, sizeof(*a));
if (a == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
break;
}
a->iface = ifp;
if (o == NULL)
continue;
if (ol < 2) {
- logger(ifp->ctx, LOG_ERR,
- "%s: truncated PD Exclude", ifp->name);
+ syslog(LOG_ERR, "%s: truncated PD Exclude", ifp->name);
continue;
}
a->prefix_exclude_len = *o++;
if (((a->prefix_exclude_len - a->prefix_len - 1) / NBBY) + 1
!= ol)
{
- logger(ifp->ctx, LOG_ERR,
- "%s: PD Exclude length mismatch", ifp->name);
+ syslog(LOG_ERR, "%s: PD Exclude length mismatch",
+ ifp->name);
a->prefix_exclude_len = 0;
continue;
}
o.len = ntohs(o.len);
if (o.len > l || sizeof(o) + o.len > l) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
- "%s: option overflow", ifp->name);
+ syslog(LOG_ERR, "%s: option overflow", ifp->name);
break;
}
p = d + sizeof(o);
}
if (o.len < nl) {
errno = EINVAL;
- logger(ifp->ctx, LOG_ERR,
- "%s: IA option truncated", ifp->name);
+ syslog(LOG_ERR, "%s: IA option truncated", ifp->name);
continue;
}
if (j == ifo->ia_len &&
!(ifo->ia_len == 0 && ifp->ctx->options & DHCPCD_DUMPLEASE))
{
- logger(ifp->ctx, LOG_DEBUG,
- "%s: ignoring unrequested IAID %s",
+ syslog(LOG_DEBUG, "%s: ignoring unrequested IAID %s",
ifp->name,
hwaddr_ntoa(ia.iaid, sizeof(ia.iaid),
buf, sizeof(buf)));
continue;
}
if ( j < ifo->ia_len && ifo->ia[j].ia_type != o.code) {
- logger(ifp->ctx, LOG_ERR,
- "%s: IAID %s: option type mismatch",
+ syslog(LOG_ERR, "%s: IAID %s: option type mismatch",
ifp->name,
hwaddr_ntoa(ia.iaid, sizeof(ia.iaid),
buf, sizeof(buf)));
ia.t2 = ntohl(ia.t2);
/* RFC 3315 22.4 */
if (ia.t2 > 0 && ia.t1 > ia.t2) {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: IAID %s T1 (%d) > T2 (%d) from %s",
ifp->name,
- hwaddr_ntoa(iaid, sizeof(iaid), buf, sizeof(buf)),
+ hwaddr_ntoa(iaid, sizeof(iaid), buf,
+ sizeof(buf)),
ia.t1, ia.t2, sfrom);
continue;
}
if (dhcp6_findpd(ifp, ia.iaid, p, o.len,
acquired) == 0)
{
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: %s: DHCPv6 REPLY missing Prefix",
ifp->name, sfrom);
continue;
if (dhcp6_findna(ifp, o.code, ia.iaid, p, o.len,
acquired) == 0)
{
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: %s: DHCPv6 REPLY missing IA Address",
ifp->name, sfrom);
continue;
struct timespec aq;
if (len <= sizeof(*m)) {
- logger(ifp->ctx, LOG_ERR,
- "%s: DHCPv6 lease truncated", ifp->name);
+ syslog(LOG_ERR, "%s: DHCPv6 lease truncated", ifp->name);
return -1;
}
nia = dhcp6_findia(ifp, m, len, sfrom, acquired);
if (nia == 0) {
if (state->state != DH6S_CONFIRM && ok != 1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: no useable IA found in lease", ifp->name);
+ syslog(LOG_ERR, "%s: no useable IA found in lease",
+ ifp->name);
return -1;
}
ssize_t bytes;
state = D6_CSTATE(ifp);
- logger(ifp->ctx, LOG_DEBUG,
- "%s: writing lease `%s'", ifp->name, state->leasefile);
+ syslog(LOG_DEBUG, "%s: writing lease `%s'",
+ ifp->name, state->leasefile);
fd = open(state->leasefile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: dhcp6_writelease: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_writelease: %m", ifp->name);
return -1;
}
bytes = write(fd, state->new, state->new_len);
state = D6_STATE(ifp);
if (state->leasefile[0] == '\0') {
- logger(ifp->ctx, LOG_DEBUG, "reading standard input");
+ syslog(LOG_DEBUG, "reading standard input");
fd = fileno(stdin);
fd_opened = false;
} else {
- logger(ifp->ctx, LOG_DEBUG, "%s: reading lease `%s'",
+ syslog(LOG_DEBUG, "%s: reading lease `%s'",
ifp->name, state->leasefile);
fd = open(state->leasefile, O_RDONLY);
if (fd != -1 && fstat(fd, &st) == -1) {
state->leasefile[0] != '\0')
{
if ((time_t)state->expire < now - st.st_mtime) {
- logger(ifp->ctx,
- LOG_DEBUG,"%s: discarding expired lease",
+ syslog(LOG_DEBUG,"%s: discarding expired lease",
ifp->name);
retval = 0;
goto ex;
(uint8_t *)state->new, state->new_len, 6, state->new->type,
o, ol) == NULL)
{
- logger(ifp->ctx, LOG_DEBUG,
- "%s: dhcp_auth_validate: %m", ifp->name);
- logger(ifp->ctx, LOG_ERR,
- "%s: authentication failed", ifp->name);
+ syslog(LOG_DEBUG, "%s: dhcp_auth_validate: %m",
+ ifp->name);
+ syslog(LOG_ERR, "%s: authentication failed", ifp->name);
goto ex;
}
if (state->auth.token)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: validated using 0x%08" PRIu32,
+ syslog(LOG_DEBUG, "%s: validated using 0x%08" PRIu32,
ifp->name, state->auth.token->secretid);
else
- logger(ifp->ctx, LOG_DEBUG,
- "%s: accepted reconfigure key", ifp->name);
+ syslog(LOG_INFO, "%s: accepted reconfigure key",
+ ifp->name);
} else if ((ifp->options->auth.options & DHCPCD_AUTH_SENDREQUIRE) ==
DHCPCD_AUTH_SENDREQUIRE)
{
- logger(ifp->ctx, LOG_ERR,
- "%s: authentication now required", ifp->name);
+ syslog(LOG_ERR, "%s: authentication now required", ifp->name);
goto ex;
}
#endif
r = dhcp6_readlease(ifp, 1);
if (r == -1) {
if (errno != ENOENT)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_readlease: %s: %m",
+ syslog(LOG_ERR, "%s: dhcp6_readlease: %s: %m",
ifp->name, state->leasefile);
} else if (r != 0) {
/* RFC 3633 section 12.1 */
if (prefix->prefix_exclude_len == 0) {
/* Don't spam the log automatically */
if (sla)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: DHCPv6 server does not support "
"OPTION_PD_EXCLUDE",
ifp->name);
return NULL;
if (fls64(sla->suffix) > 128 - pfxlen) {
- logger(ifp->ctx, LOG_ERR,
- "%s: suffix %" PRIu64 " + prefix_len %d > 128",
+ syslog(LOG_ERR, "%s: suffix %" PRIu64 " + prefix_len %d > 128",
ifp->name, sla->suffix, pfxlen);
return NULL;
}
} else {
dadcounter = ipv6_makeaddr(&daddr, ifp, &addr, pfxlen);
if (dadcounter == -1) {
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: error adding slaac to prefix_len %d",
ifp->name, pfxlen);
return NULL;
if (ia == NULL) {
ia = calloc(1, sizeof(*ia));
if (ia == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
ia->iface = ifp;
continue;
if (ap->flags & IPV6_AF_ONLINK) {
if (!(ap->flags & IPV6_AF_DADCOMPLETED) &&
- ipv6_iffindaddr(ap->iface, &ap->addr, IN6_IFF_TENTATIVE))
+ ipv6_iffindaddr(ap->iface, &ap->addr,
+ IN6_IFF_TENTATIVE))
ap->flags |= IPV6_AF_DADCOMPLETED;
if ((ap->flags & IPV6_AF_DADCOMPLETED) == 0 &&
((delegated && ap->delegating_prefix) ||
if (!delegated)
dhcpcd_daemonise(ifp->ctx);
} else
- logger(ifp->ctx, LOG_DEBUG,
- "%s: waiting for DHCPv6 DAD to complete", ifp->name);
+ syslog(LOG_DEBUG, "%s: waiting for DHCPv6 DAD to complete",
+ ifp->name);
}
#ifdef SMALL
/* We only want to log this the once as we loop
* through many interfaces first. */
ap->flags |= IPV6_AF_DELEGATEDLOG;
- logger(ifp->ctx,
- ap->flags & IPV6_AF_NEW ?LOG_INFO:LOG_DEBUG,
+ syslog(ap->flags & IPV6_AF_NEW ?
+ LOG_INFO : LOG_DEBUG,
"%s: delegated prefix %s",
ifp->name, ap->saddr);
ap->flags &= ~IPV6_AF_NEW;
/* no SLA configured, so lets
* automate it */
if (ifd->carrier != LINK_UP) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: has no carrier, cannot"
" delegate addresses",
ifd->name);
if (strcmp(ifd->name, sla->ifname))
continue;
if (ifd->carrier != LINK_UP) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: has no carrier, cannot"
" delegate addresses",
ifd->name);
if (strcmp(ifp->name, sla->ifname))
continue;
if (ipv6_linklocal(ifp) == NULL) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: delaying adding"
" delegated addresses for"
" LL address",
}
if (k) {
- logger(ifp->ctx, LOG_INFO,
- "%s: adding delegated prefixes", ifp->name);
+ syslog(LOG_INFO, "%s: adding delegated prefixes", ifp->name);
state = D6_STATE(ifp);
state->state = DH6S_DELEGATED;
ipv6_addaddrs(&state->addrs);
ctx->rcvhdr.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
bytes = recvmsg_realloc(ctx->dhcp6_fd, &ctx->rcvhdr, 0);
if (bytes == -1) {
- logger(ctx, LOG_ERR, "%s: recvmsg: %m", __func__);
+ syslog(LOG_ERR, "%s: recvmsg: %m", __func__);
close(ctx->dhcp6_fd);
eloop_event_delete(ctx->eloop, ctx->dhcp6_fd);
ctx->dhcp6_fd = -1;
ctx->sfrom = inet_ntop(AF_INET6, &ctx->from.sin6_addr,
ctx->ntopbuf, sizeof(ctx->ntopbuf));
if (len < sizeof(struct dhcp6_message)) {
- logger(ctx, LOG_ERR,
- "DHCPv6 packet too short from %s", ctx->sfrom);
+ syslog(LOG_ERR, "DHCPv6 packet too short from %s", ctx->sfrom);
return;
}
}
}
if (pkt.ipi6_ifindex == 0) {
- logger(ctx, LOG_ERR,
- "DHCPv6 reply did not contain index from %s", ctx->sfrom);
+ syslog(LOG_ERR, "DHCPv6 reply did not contain index from %s",
+ ctx->sfrom);
return;
}
break;
}
if (ifp == NULL) {
- logger(ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"DHCPv6 reply for unexpected interface from %s",
ctx->sfrom);
return;
state = D6_STATE(ifp);
if (state == NULL || state->send == NULL) {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: DHCPv6 reply received but not running", ifp->name);
+ syslog(LOG_DEBUG, "%s: DHCPv6 reply received but not running",
+ ifp->name);
return;
}
/* We're already bound and this message is for another machine */
/* XXX DELEGATED? */
if (r->type != DHCP6_RECONFIGURE &&
- (state->state == DH6S_BOUND || state->state == DH6S_INFORMED))
+ (state->state == DH6S_BOUND || state->state == DH6S_INFORMED))
{
- logger(ifp->ctx, LOG_DEBUG,
- "%s: DHCPv6 reply received but already bound", ifp->name);
+ syslog(LOG_DEBUG, "%s: DHCPv6 reply received but already bound",
+ ifp->name);
return;
}
r->xid[1] != state->send->xid[1] ||
r->xid[2] != state->send->xid[2]))
{
- logger(ctx, LOG_DEBUG,
- "%s: wrong xid 0x%02x%02x%02x"
+ syslog(LOG_DEBUG, "%s: wrong xid 0x%02x%02x%02x"
" (expecting 0x%02x%02x%02x) from %s",
ifp->name,
r->xid[0], r->xid[1], r->xid[2],
}
if (dhcp6_findmoption(r, len, D6_OPTION_SERVERID, NULL) == NULL) {
- logger(ifp->ctx, LOG_DEBUG, "%s: no DHCPv6 server ID from %s",
+ syslog(LOG_DEBUG, "%s: no DHCPv6 server ID from %s",
ifp->name, ctx->sfrom);
return;
}
if (o == NULL || ol != ctx->duid_len ||
memcmp(o, ctx->duid, ol) != 0)
{
- logger(ifp->ctx, LOG_DEBUG, "%s: incorrect client ID from %s",
+ syslog(LOG_DEBUG, "%s: incorrect client ID from %s",
ifp->name, ctx->sfrom);
return;
}
if (has_option_mask(ifo->requiremask6, opt->option) &&
!dhcp6_findmoption(r, len, (uint16_t)opt->option, NULL))
{
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: reject DHCPv6 (no option %s) from %s",
ifp->name, opt->var, ctx->sfrom);
return;
if (has_option_mask(ifo->rejectmask6, opt->option) &&
dhcp6_findmoption(r, len, (uint16_t)opt->option, NULL))
{
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: reject DHCPv6 (option %s) from %s",
ifp->name, opt->var, ctx->sfrom);
return;
if (dhcp_auth_validate(&state->auth, &ifo->auth,
(uint8_t *)r, len, 6, r->type, auth, auth_len) == NULL)
{
- logger(ifp->ctx, LOG_DEBUG, "dhcp_auth_validate: %m");
- logger(ifp->ctx, LOG_ERR,
- "%s: authentication failed from %s",
+ syslog(LOG_DEBUG, "dhcp_auth_validate: %m");
+ syslog(LOG_ERR, "%s: authentication failed from %s",
ifp->name, ctx->sfrom);
return;
}
if (state->auth.token)
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: validated using 0x%08" PRIu32,
ifp->name, state->auth.token->secretid);
else
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_INFO,
"%s: accepted reconfigure key", ifp->name);
} else if (ifo->auth.options & DHCPCD_AUTH_SEND) {
if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) {
- logger(ifp->ctx, LOG_ERR,
- "%s: no authentication from %s",
+ syslog(LOG_ERR, "%s: no authentication from %s",
ifp->name, ctx->sfrom);
return;
}
- logger(ifp->ctx, LOG_WARNING,
- "%s: no authentication from %s", ifp->name, ctx->sfrom);
+ syslog(LOG_WARNING, "%s: no authentication from %s",
+ ifp->name, ctx->sfrom);
}
#else
auth = NULL;
memcpy(&max_rt, o, sizeof(max_rt));
max_rt = ntohl(max_rt);
if (max_rt >= 60 && max_rt <= 86400) {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: SOL_MAX_RT %llu -> %u", ifp->name,
+ syslog(LOG_DEBUG, "%s: SOL_MAX_RT %llu -> %u",
+ ifp->name,
(unsigned long long)state->sol_max_rt,
max_rt);
state->sol_max_rt = (time_t)max_rt;
} else
- logger(ifp->ctx, LOG_ERR,
- "%s: invalid SOL_MAX_RT %u",
+ syslog(LOG_ERR, "%s: invalid SOL_MAX_RT %u",
ifp->name, max_rt);
}
o = dhcp6_findmoption(r, len, D6_OPTION_INF_MAX_RT, &ol);
memcpy(&max_rt, o, sizeof(max_rt));
max_rt = ntohl(max_rt);
if (max_rt >= 60 && max_rt <= 86400) {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: INF_MAX_RT %llu -> %u",
+ syslog(LOG_DEBUG, "%s: INF_MAX_RT %llu -> %u",
ifp->name,
(unsigned long long)state->inf_max_rt,
max_rt);
state->inf_max_rt = (time_t)max_rt;
} else
- logger(ifp->ctx, LOG_ERR,
- "%s: invalid INF_MAX_RT %u",
+ syslog(LOG_ERR, "%s: invalid INF_MAX_RT %u",
ifp->name, max_rt);
}
if (dhcp6_validatelease(ifp, r, len, ctx->sfrom, NULL) == -1)
break;
case DHCP6_RECONFIGURE:
if (auth == NULL) {
- logger(ifp->ctx, LOG_ERR,
- "%s: unauthenticated %s from %s",
+ syslog(LOG_ERR, "%s: unauthenticated %s from %s",
ifp->name, op, ctx->sfrom);
if (ifo->auth.options & DHCPCD_AUTH_REQUIRE)
return;
}
- logger(ifp->ctx, LOG_INFO, "%s: %s from %s",
+ syslog(LOG_INFO, "%s: %s from %s",
ifp->name, op, ctx->sfrom);
o = dhcp6_findmoption(r, len, D6_OPTION_RECONF_MSG, &ol);
if (o == NULL) {
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: missing Reconfigure Message option",
ifp->name);
return;
}
if (ol != 1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: missing Reconfigure Message type", ifp->name);
+ syslog(LOG_ERR, "%s: missing Reconfigure Message type",
+ ifp->name);
return;
}
switch(*o) {
case DHCP6_RENEW:
if (state->state != DH6S_BOUND) {
- logger(ifp->ctx, LOG_ERR,
- "%s: not bound, ignoring %s",
+ syslog(LOG_ERR, "%s: not bound, ignoring %s",
ifp->name, op);
return;
}
break;
case DHCP6_INFORMATION_REQ:
if (state->state != DH6S_INFORMED) {
- logger(ifp->ctx, LOG_ERR,
- "%s: not informed, ignoring %s",
+ syslog(LOG_ERR, "%s: not informed, ignoring %s",
ifp->name, op);
return;
}
dhcp6_startinform(ifp);
break;
default:
- logger(ifp->ctx, LOG_ERR,
- "%s: unsupported %s type %d",
+ syslog(LOG_ERR, "%s: unsupported %s type %d",
ifp->name, op, *o);
break;
}
return;
default:
- logger(ifp->ctx, LOG_ERR, "%s: invalid DHCP6 type %s (%d)",
+ syslog(LOG_ERR, "%s: invalid DHCP6 type %s (%d)",
ifp->name, op, r->type);
return;
}
if (!valid_op) {
- logger(ifp->ctx, LOG_WARNING,
- "%s: invalid state for DHCP6 type %s (%d)",
+ syslog(LOG_WARNING, "%s: invalid state for DHCP6 type %s (%d)",
ifp->name, op, r->type);
return;
}
free(state->recv);
state->recv = malloc(len);
if (state->recv == NULL) {
- logger(ifp->ctx, LOG_ERR,
- "%s: malloc recv: %m", ifp->name);
+ syslog(LOG_ERR, "%s: malloc recv: %m", ifp->name);
return;
}
}
}
if (ap == NULL)
ap = TAILQ_FIRST(&state->addrs);
- logger(ifp->ctx, LOG_INFO, "%s: ADV %s from %s",
+ syslog(LOG_INFO, "%s: ADV %s from %s",
ifp->name, ap->saddr, ctx->sfrom);
if (ifp->ctx->options & DHCPCD_TEST)
break;
break;
}
}
- logger(ifp->ctx, has_new ? LOG_INFO : LOG_DEBUG,
+ syslog(has_new ? LOG_INFO : LOG_DEBUG,
"%s: %s received from %s", ifp->name, op, ctx->sfrom);
state->reason = NULL;
if (ap->flags & IPV6_AF_STALE)
continue;
if (ap->prefix_vltime <= state->renew)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: %s will expire before renewal",
ifp->name, ap->saddr);
else
* and T2 fields for the T1 and T2 parameters,
* unless those values in those fields are 0.
*/
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: ignoring T1 %"PRIu32
" to due address expiry",
ifp->name, state->renew);
ipv6_addaddrs(&state->addrs);
if (state->state == DH6S_INFORMED)
- logger(ifp->ctx, has_new ? LOG_INFO : LOG_DEBUG,
+ syslog(has_new ? LOG_INFO : LOG_DEBUG,
"%s: refresh in %"PRIu32" seconds",
ifp->name, state->renew);
else if (state->renew || state->rebind)
- logger(ifp->ctx, has_new ? LOG_INFO : LOG_DEBUG,
+ syslog(has_new ? LOG_INFO : LOG_DEBUG,
"%s: renew in %"PRIu32", "
"rebind in %"PRIu32", "
"expire in %"PRIu32" seconds",
ifp->name,
state->renew, state->rebind, state->expire);
else if (state->expire == 0)
- logger(ifp->ctx, has_new ? LOG_INFO : LOG_DEBUG,
+ syslog(has_new ? LOG_INFO : LOG_DEBUG,
"%s: will expire", ifp->name);
if_initrt(ifp->ctx, AF_INET6);
rt_build(ifp->ctx, AF_INET6);
n = 1;
if (setsockopt(ctx->dhcp6_fd, SOL_SOCKET, SO_REUSEPORT,
&n, sizeof(n)) == -1)
- logger(ctx, LOG_WARNING, "setsockopt: SO_REUSEPORT: %m");
+ syslog(LOG_WARNING, "setsockopt: SO_REUSEPORT: %m");
#endif
if (!(ctx->options & DHCPCD_MASTER)) {
sla = &ia->sla[j];
ifd = if_find(ifp->ctx->ifaces, sla->ifname);
if (ifd == NULL) {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: cannot delegate to %s: %m",
ifp->name, sla->ifname);
continue;
}
if (!ifd->active) {
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: activating for delegation",
sla->ifname);
dhcpcd_activateinterface(ifd,
dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile),
AF_INET6, ifp);
if (ipv6_linklocal(ifp) == NULL) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: delaying DHCPv6 soliciation for LL address",
ifp->name);
ipv6_addlinklocalcallback(ifp, dhcp6_start1, ifp);
i = strlen(prefix) + strlen("_dhcp6") + 1;
pfx = malloc(i);
if (pfx == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
snprintf(pfx, i, "%s_dhcp6", prefix);
i += strlen(prefix) + strlen("_delegated_dhcp6_prefix=");
v = val = env[n] = malloc(i);
if (v == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
v += snprintf(val, i, "%s_delegated_dhcp6_prefix=", prefix);
ifp->if_data[IF_DATA_DHCP6] = state = calloc(1, sizeof(*state));
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
TAILQ_INIT(&state->addrs);
dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile),
AF_INET6, ifp);
if (dhcp6_readlease(ifp, 0) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m",
+ syslog(LOG_ERR, "%s: %s: %m",
*ifp->name ? ifp->name : state->leasefile, __func__);
return -1;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include <time.h>
struct dhcpcd_ctx *ctx;
ctx = arg;
- logger(ctx, LOG_ERR, "timed out");
+ syslog(LOG_ERR, "timed out");
if (!(ctx->options & DHCPCD_MASTER)) {
eloop_exit(ctx->eloop, EXIT_FAILURE);
return;
TAILQ_FOREACH(ifp, ctx->ifaces, next) {
if ((af = dhcpcd_ifafwaiting(ifp)) != AF_MAX) {
- logger(ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: waiting for an %s address",
ifp->name, dhcpcd_af(af));
return 0;
}
if ((af = dhcpcd_afwaiting(ctx)) != AF_MAX) {
- logger(ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"waiting for an %s address",
dhcpcd_af(af));
return 0;
}
if (ctx->options & DHCPCD_ONESHOT) {
- logger(ctx, LOG_INFO, "exiting due to oneshot");
+ syslog(LOG_INFO, "exiting due to oneshot");
eloop_exit(ctx->eloop, EXIT_SUCCESS);
return 0;
}
if (ctx->options & DHCPCD_DAEMONISED ||
!(ctx->options & DHCPCD_DAEMONISE))
return 0;
- logger(ctx, LOG_DEBUG, "forking to background");
+ syslog(LOG_DEBUG, "forking to background");
/* Setup a signal pipe so parent knows when to exit. */
if (pipe(sidpipe) == -1) {
- logger(ctx, LOG_ERR, "pipe: %m");
+ syslog(LOG_ERR, "pipe: %m");
return 0;
}
switch (pid = fork()) {
case -1:
- logger(ctx, LOG_ERR, "fork: %m");
+ syslog(LOG_ERR, "fork: %m");
return 0;
case 0:
if ((lpid = pidfile_lock(ctx->pidfile)) != 0)
- logger(ctx, LOG_ERR, "%s: pidfile_lock %d: %m",
+ syslog(LOG_ERR, "%s: pidfile_lock %d: %m",
__func__, lpid);
setsid();
/* Notify parent it's safe to exit as we've detached. */
close(sidpipe[0]);
if (write(sidpipe[1], &buf, 1) == -1)
- logger(ctx, LOG_ERR, "failed to notify parent: %m");
+ syslog(LOG_ERR, "failed to notify parent: %m");
close(sidpipe[1]);
/* Some polling methods don't survive after forking,
* so ensure we can requeue all our events. */
if (eloop_requeue(ctx->eloop) == -1) {
- logger(ctx, LOG_ERR, "eloop_requeue: %m");
+ syslog(LOG_ERR, "eloop_requeue: %m");
eloop_exit(ctx->eloop, EXIT_FAILURE);
}
if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
/* Wait for child to detach */
close(sidpipe[1]);
if (read(sidpipe[0], &buf, 1) == -1)
- logger(ctx, LOG_ERR, "failed to read child: %m");
+ syslog(LOG_ERR, "failed to read child: %m");
close(sidpipe[0]);
- logger(ctx, LOG_INFO, "forked to background, child pid %d", pid);
+ syslog(LOG_INFO, "forked to background, child pid %d", pid);
ctx->options |= DHCPCD_FORKED;
eloop_exit(ctx->eloop, EXIT_SUCCESS);
return pid;
struct dhcpcd_ctx *ctx;
ctx = ifp->ctx;
- logger(ctx, LOG_INFO, "%s: removing interface", ifp->name);
+ syslog(LOG_INFO, "%s: removing interface", ifp->name);
ifp->options->options |= DHCPCD_STOPPING;
dhcpcd_drop(ifp, 1);
{
ifo->ia = malloc(sizeof(*ifo->ia));
if (ifo->ia == NULL)
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
else {
ifo->ia_len = 1;
ifo->ia->ia_type = D6_OPTION_IA_NA;
r = print_string(pssid, sizeof(pssid), OT_ESCSTRING,
ifp->ssid, ifp->ssid_len);
if (r == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: %s: %m", ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: %m", ifp->name, __func__);
pssid[0] = '\0';
}
} else
pssid[0] = '\0';
ifo = read_config(ifp->ctx, ifp->name, pssid, profile);
if (ifo == NULL) {
- logger(ifp->ctx, LOG_DEBUG, "%s: no profile %s",
- ifp->name, profile);
+ syslog(LOG_DEBUG, "%s: no profile %s", ifp->name, profile);
return -1;
}
if (profile != NULL) {
strlcpy(ifp->profile, profile, sizeof(ifp->profile));
- logger(ifp->ctx, LOG_INFO, "%s: selected profile %s",
+ syslog(LOG_INFO, "%s: selected profile %s",
ifp->name, profile);
} else
*ifp->profile = '\0';
/* If the mtime has changed drop any old lease */
if (old != 0 && ifp->options->mtime != old) {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: confile file changed, expiring leases", ifp->name);
dhcpcd_drop(ifp, 0);
}
if (options) {
if ((ifo = default_config(ifp->ctx)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m",
- ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: %m", ifp->name, __func__);
return;
}
ifo->options |= options;
ifo = ifp->options;
if (ifo->options & DHCPCD_IPV6 && ipv6_init(ifp->ctx) == -1) {
- logger(ifp->ctx, LOG_ERR, "ipv6_init: %m");
+ syslog(LOG_ERR, "ipv6_init: %m");
ifo->options &= ~DHCPCD_IPV6;
}
}
if (carrier == LINK_UNKNOWN) {
if (errno != ENOTTY) /* For example a PPP link on BSD */
- logger(ctx, LOG_ERR, "%s: carrier_status: %m", ifname);
+ syslog(LOG_ERR, "%s: carrier_status: %m", ifname);
} else if (carrier == LINK_DOWN || (ifp->flags & IFF_UP) == 0) {
if (ifp->carrier != LINK_DOWN) {
if (ifp->carrier == LINK_UP)
- logger(ctx, LOG_INFO, "%s: carrier lost",
- ifp->name);
+ syslog(LOG_INFO, "%s: carrier lost", ifp->name);
ifp->carrier = LINK_DOWN;
script_runreason(ifp, "NOCARRIER");
#ifdef NOCARRIER_PRESERVE_IP
}
} else if (carrier == LINK_UP && ifp->flags & IFF_UP) {
if (ifp->carrier != LINK_UP) {
- logger(ctx, LOG_INFO, "%s: carrier acquired",
- ifp->name);
+ syslog(LOG_INFO, "%s: carrier acquired", ifp->name);
ifp->carrier = LINK_UP;
#if !defined(__linux__) && !defined(__NetBSD__)
/* BSD does not emit RTM_NEWADDR or RTM_CHGADDR when the
/* This is only a problem if the interfaces are on the same network. */
if (ifn)
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: IAID conflicts with one assigned to %s",
ifp->name, ifn->name);
}
case LINK_UP:
break;
case LINK_DOWN:
- logger(ifp->ctx, LOG_INFO, "%s: waiting for carrier",
- ifp->name);
+ syslog(LOG_INFO, "%s: waiting for carrier", ifp->name);
return;
case LINK_UNKNOWN:
/* No media state available.
if (ifp->ctx->duid == NULL) {
if (duid_init(ifp) == 0)
return;
- logger(ifp->ctx, LOG_INFO, "DUID %s",
+ syslog(LOG_INFO, "DUID %s",
hwaddr_ntoa(ifp->ctx->duid,
ifp->ctx->duid_len,
buf, sizeof(buf)));
if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) {
/* Report IAIDs */
- logger(ifp->ctx, LOG_INFO, "%s: IAID %s", ifp->name,
+ syslog(LOG_INFO, "%s: IAID %s", ifp->name,
hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid),
buf, sizeof(buf)));
warn_iaid_conflict(ifp, ifo->iaid);
if (memcmp(ifo->iaid, ifo->ia[i].iaid,
sizeof(ifo->iaid)))
{
- logger(ifp->ctx, LOG_INFO, "%s: IAID %s",
+ syslog(LOG_INFO, "%s: IAID %s",
ifp->name, hwaddr_ntoa(ifo->ia[i].iaid,
sizeof(ifo->ia[i].iaid),
buf, sizeof(buf)));
}
if (ifo->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: ipv6_start: %m", ifp->name);
+ syslog(LOG_ERR, "%s: ipv6_start: %m", ifp->name);
ifo->options &= ~DHCPCD_IPV6;
}
if (ifo->options & DHCPCD_IPV6) {
#endif
}
if (nolease == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: dhcp6_start: %m", ifp->name);
+ syslog(LOG_ERR, "%s: dhcp6_start: %m",
+ ifp->name);
}
}
if ((!(ifp->ctx->options & DHCPCD_MASTER) ||
ifp->options->options & DHCPCD_IF_UP) &&
if_up(ifp) == -1)
- logger(ifp->ctx, LOG_ERR, "%s: if_up: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_up: %m", ifp->name);
if (ifp->options->options & DHCPCD_LINK &&
ifp->carrier == LINK_UNKNOWN)
ifp->flags, ifp->name);
return;
}
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: unknown carrier, waiting for interface flags",
ifp->name);
}
ctx = arg;
if (if_handlelink(ctx) == -1) {
- logger(ctx, LOG_ERR, "if_handlelink: %m");
+ syslog(LOG_ERR, "if_handlelink: %m");
eloop_event_delete(ctx->eloop, ctx->link_fd);
close(ctx->link_fd);
ctx->link_fd = -1;
return -1;
}
if (ifp->active) {
- logger(ctx, LOG_DEBUG, "%s: interface departed",
+ syslog(LOG_DEBUG, "%s: interface departed",
ifp->name);
ifp->options->options |= DHCPCD_DEPARTED;
stop_interface(ifp);
i = -1;
ifs = if_discover(ctx, -1, UNCONST(argv));
if (ifs == NULL) {
- logger(ctx, LOG_ERR, "%s: if_discover: %m", __func__);
+ syslog(LOG_ERR, "%s: if_discover: %m", __func__);
return -1;
}
TAILQ_FOREACH_SAFE(ifp, ifs, next, ifn) {
iff = if_find(ctx->ifaces, ifp->name);
if (iff) {
if (iff->active)
- logger(ctx, LOG_DEBUG, "%s: interface updated",
+ syslog(LOG_DEBUG, "%s: interface updated",
iff->name);
/* The flags and hwaddr could have changed */
iff->flags = ifp->flags;
TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next);
if (!ifp->active)
continue;
- logger(ctx, LOG_DEBUG, "%s: interface added",
- ifp->name);
+ syslog(LOG_DEBUG, "%s: interface added", ifp->name);
dhcpcd_initstate(ifp, 0);
run_preinit(ifp);
iff = ifp;
if (hwlen > sizeof(ifp->hwaddr)) {
errno = ENOBUFS;
- logger(ctx, LOG_ERR, "%s: %s: %m", ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: %m", ifp->name, __func__);
return;
}
if (ifp->hwlen == hwlen && memcmp(ifp->hwaddr, hwaddr, hwlen) == 0)
return;
- logger(ctx, LOG_INFO, "%s: new hardware address: %s", ifp->name,
+ syslog(LOG_INFO, "%s: new hardware address: %s", ifp->name,
hwaddr_ntoa(hwaddr, hwlen, buf, sizeof(buf)));
ifp->hwlen = hwlen;
memcpy(ifp->hwaddr, hwaddr, hwlen);
exit_code = EXIT_FAILURE;
switch (sig) {
case SIGINT:
- logger(ctx, LOG_INFO, sigmsg, "SIGINT", "stopping");
+ syslog(LOG_INFO, sigmsg, "SIGINT", "stopping");
break;
case SIGTERM:
- logger(ctx, LOG_INFO, sigmsg, "SIGTERM", "stopping");
+ syslog(LOG_INFO, sigmsg, "SIGTERM", "stopping");
exit_code = EXIT_SUCCESS;
break;
case SIGALRM:
- logger(ctx, LOG_INFO, sigmsg, "SIGALRM", "releasing");
+ syslog(LOG_INFO, sigmsg, "SIGALRM", "releasing");
opts |= DHCPCD_RELEASE;
exit_code = EXIT_SUCCESS;
break;
case SIGHUP:
- logger(ctx, LOG_INFO, sigmsg, "SIGHUP", "rebinding");
+ syslog(LOG_INFO, sigmsg, "SIGHUP", "rebinding");
reload_config(ctx);
/* Preserve any options passed on the commandline
* when we were started. */
ctx->argc - ctx->ifc);
return;
case SIGUSR1:
- logger(ctx, LOG_INFO, sigmsg, "SIGUSR1", "renewing");
+ syslog(LOG_INFO, sigmsg, "SIGUSR1", "renewing");
dhcpcd_renew(ctx);
return;
case SIGUSR2:
- logger_close(ctx);
- logger_open(ctx);
- logger(ctx, LOG_INFO, sigmsg, "SIGUSR2", "reopened logfile");
+ closelog();
+ openlog(NULL, ctx->log_opts, LOG_DAEMON);
+ syslog(LOG_INFO, sigmsg, "SIGUSR2", "reopened syslog");
return;
case SIGPIPE:
- logger(ctx, LOG_WARNING, "received SIGPIPE");
+ syslog(LOG_WARNING, "received SIGPIPE");
return;
default:
- logger(ctx, LOG_ERR,
- "received signal %d, "
+ syslog(LOG_ERR, "received signal %d, "
"but don't know what to do with it",
sig);
return;
if (!ifp->active)
continue;
if (send_interface(fd, ifp) == -1)
- logger(ifp->ctx, LOG_ERR,
- "send_interface %d: %m", fd->fd);
+ syslog(LOG_ERR, "send_interface %d: %m", fd->fd);
}
}
*p++ = ' ';
}
*--p = '\0';
- logger(ctx, LOG_INFO, "control command: %s", tmp);
+ syslog(LOG_INFO, "control command: %s", tmp);
free(tmp);
optind = 0;
memset(&ctx, 0, sizeof(ctx));
- ctx.log_fd = -1;
- logger_open(&ctx);
- logger_mask(&ctx, LOG_UPTO(LOG_INFO));
-
ifo = NULL;
ctx.cffile = CONFIG;
ctx.control_fd = ctx.control_unpriv_fd = ctx.link_fd = -1;
#endif
#ifdef INET
ctx.udp_fd = -1;
+#endif
+ ctx.log_opts = LOG_PID;
+#ifdef LOG_PERROR
+ ctx.log_opts |= LOG_PERROR;
+#endif
+#ifdef LOG_PTRIM
+ ctx.log_opts |= LOG_PTRIM;
#endif
i = 0;
while ((opt = getopt_long(argc, argv,
case 'f':
ctx.cffile = optarg;
break;
- case 'j':
- ctx.logfile = strdup(optarg);
- logger_close(&ctx);
- logger_open(&ctx);
- break;
#ifdef USE_SIGNALS
case 'k':
sig = SIGALRM;
* out of user definable signals. */
i = 4;
break;
+ case 'q':
+#ifdef LOG_PERROR
+ ctx.log_opts &= ~LOG_PERROR;
+ break;
+#endif
case 'x':
sig = SIGTERM;
siga = "TERM";
break;
case 'T':
i = 1;
+#ifdef LOG_NLOG
+ ctx.log_opts |= LOG_NLOG;
+#endif
break;
case 'U':
i = 3;
}
}
+ openlog(NULL, ctx.log_opts, LOG_DAEMON);
+ setlogmask(LOG_UPTO(LOG_INFO));
+
ctx.argv = argv;
ctx.argc = argc;
ctx.ifc = argc - optind;
#endif
if (ctx.options & DHCPCD_DEBUG)
- logger_mask(&ctx, LOG_UPTO(LOG_DEBUG));
+ setlogmask(LOG_UPTO(LOG_DEBUG));
if (!(ctx.options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) {
printpidfile:
const char *per;
if (strlen(argv[optind]) > IF_NAMESIZE) {
- logger(&ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: interface name too long",
argv[optind]);
goto exit_failure;
}
if (chdir("/") == -1)
- logger(&ctx, LOG_ERR, "chdir `/': %m");
+ syslog(LOG_ERR, "chdir `/': %m");
/* Freeing allocated addresses from dumping leases can trigger
* eloop removals as well, so init here. */
if ((ctx.eloop = eloop_new()) == NULL) {
- logger(&ctx, LOG_ERR, "%s: eloop_init: %m", __func__);
+ syslog(LOG_ERR, "%s: eloop_init: %m", __func__);
goto exit_failure;
}
/* Open our persistent sockets.
* This is needed early for dumping leases on valid interfaces. */
if (if_opensockets(&ctx) == -1) {
- logger(&ctx, LOG_ERR, "if_opensockets: %m");
+ syslog(LOG_ERR, "if_opensockets: %m");
goto exit_failure;
}
TAILQ_INIT(ctx.ifaces);
}
if (ctx.ifaces == NULL) {
- logger(&ctx, LOG_ERR, "if_discover: %m");
+ syslog(LOG_ERR, "if_discover: %m");
goto exit_failure;
}
ifp = if_find(ctx.ifaces, argv[optind]);
if (ifp == NULL) {
ifp = calloc(1, sizeof(*ifp));
if (ifp == NULL) {
- logger(&ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
goto exit_failure;
}
if (optind != argc)
if (ctx.control_fd == -1)
ctx.control_fd = control_open(NULL);
if (ctx.control_fd != -1) {
- logger(&ctx, LOG_INFO,
+ syslog(LOG_INFO,
"sending commands to master dhcpcd process");
len = control_send(&ctx, argc, argv);
control_close(&ctx);
if (len > 0) {
- logger(&ctx, LOG_DEBUG, "send OK");
+ syslog(LOG_DEBUG, "send OK");
goto exit_success;
} else {
- logger(&ctx, LOG_ERR,
- "failed to send commands");
+ syslog(LOG_ERR, "failed to send commands");
goto exit_failure;
}
} else {
if (errno != ENOENT)
- logger(&ctx, LOG_ERR, "control_open: %m");
+ syslog(LOG_ERR, "control_open: %m");
}
#ifdef USE_SIGNALS
}
if (sig != 0) {
pid = pidfile_read(ctx.pidfile);
if (pid != 0 && pid != -1)
- logger(&ctx, LOG_INFO, "sending signal %s to pid %d",
+ syslog(LOG_INFO, "sending signal %s to pid %d",
siga, pid);
if (pid == 0 || pid == -1 || kill(pid, sig) != 0) {
if (sig != SIGHUP && sig != SIGUSR1 && errno != EPERM)
- logger(&ctx, LOG_ERR, ""PACKAGE" not running");
+ syslog(LOG_ERR, ""PACKAGE" not running");
if (pid != 0 && pid != -1 && errno != ESRCH) {
- logger(&ctx, LOG_ERR, "kill: %m");
+ syslog(LOG_ERR, "kill: %m");
goto exit_failure;
}
unlink(ctx.pidfile);
if (sig == SIGHUP || sig == SIGUSR1)
goto exit_success;
/* Spin until it exits */
- logger(&ctx, LOG_INFO,
- "waiting for pid %d to exit", pid);
+ syslog(LOG_INFO, "waiting for pid %d to exit", pid);
ts.tv_sec = 0;
ts.tv_nsec = 100000000; /* 10th of a second */
for(i = 0; i < 100; i++) {
if (pidfile_read(ctx.pidfile) == -1)
goto exit_success;
}
- logger(&ctx, LOG_ERR, "pid %d failed to exit", pid);
+ syslog(LOG_ERR, "pid %d failed to exit", pid);
goto exit_failure;
}
}
if (!(ctx.options & DHCPCD_TEST)) {
/* Ensure we have the needed directories */
if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST)
- logger(&ctx, LOG_ERR, "mkdir `%s': %m", RUNDIR);
+ syslog(LOG_ERR, "mkdir `%s': %m", RUNDIR);
if (mkdir(DBDIR, 0755) == -1 && errno != EEXIST)
- logger(&ctx, LOG_ERR, "mkdir `%s': %m", DBDIR);
+ syslog(LOG_ERR, "mkdir `%s': %m", DBDIR);
if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
if (pid == -1)
- logger(&ctx, LOG_ERR, "%s: pidfile_lock: %m",
+ syslog(LOG_ERR, "%s: pidfile_lock: %m",
__func__);
else
- logger(&ctx, LOG_ERR, ""PACKAGE
+ syslog(LOG_ERR, ""PACKAGE
" already running on pid %d (%s)",
pid, ctx.pidfile);
goto exit_failure;
if (ctx.options & DHCPCD_MASTER) {
if (control_start(&ctx, NULL) == -1)
- logger(&ctx, LOG_ERR, "control_start: %m");
+ syslog(LOG_ERR, "control_start: %m");
}
#else
if (control_start(&ctx,
ctx.options & DHCPCD_MASTER ? NULL : argv[optind]) == -1)
{
- logger(&ctx, LOG_ERR, "control_start: %m");
+ syslog(LOG_ERR, "control_start: %m");
goto exit_failure;
}
#endif
- logger(&ctx, LOG_DEBUG, PACKAGE "-" VERSION " starting");
+ syslog(LOG_DEBUG, PACKAGE "-" VERSION " starting");
ctx.options |= DHCPCD_STARTED;
#ifdef USE_SIGNALS
if (eloop_signal_set_cb(ctx.eloop,
dhcpcd_signals, dhcpcd_signals_len,
signal_cb, &ctx) == -1)
{
- logger(&ctx, LOG_ERR, "eloop_signal_set_cb: %m");
+ syslog(LOG_ERR, "eloop_signal_set_cb: %m");
goto exit_failure;
}
/* Save signal mask, block and redirect signals to our handler */
if (eloop_signal_mask(ctx.eloop, &ctx.sigset) == -1) {
- logger(&ctx, LOG_ERR, "eloop_signal_mask: %m");
+ syslog(LOG_ERR, "eloop_signal_mask: %m");
goto exit_failure;
}
#endif
ctx.ifaces = if_discover(&ctx, ctx.ifc, ctx.ifv);
if (ctx.ifaces == NULL) {
- logger(&ctx, LOG_ERR, "if_discover: %m");
+ syslog(LOG_ERR, "if_discover: %m");
goto exit_failure;
}
for (i = 0; i < ctx.ifc; i++) {
if ((ifp = if_find(ctx.ifaces, ctx.ifv[i])) == NULL ||
!ifp->active)
- logger(&ctx, LOG_ERR,
- "%s: interface not found or invalid",
+ syslog(LOG_ERR, "%s: interface not found or invalid",
ctx.ifv[i]);
}
TAILQ_FOREACH(ifp, ctx.ifaces, next) {
}
if (ifp == NULL) {
if (ctx.ifc == 0)
- logger(&ctx,
- ctx.options & DHCPCD_INACTIVE ? LOG_DEBUG : LOG_ERR,
+ syslog(ctx.options & DHCPCD_INACTIVE ?
+ LOG_DEBUG : LOG_ERR,
"no valid interfaces found");
else
goto exit_failure;
if (!(ctx.options & DHCPCD_LINK)) {
- logger(&ctx, LOG_ERR,
+ syslog(LOG_ERR,
"aborting as link detection is disabled");
goto exit_failure;
}
ctx.options & DHCPCD_LINK &&
!(ctx.options & DHCPCD_WAITIP))
{
- logger(&ctx,
- ctx.options & DHCPCD_INACTIVE ?
+ syslog(ctx.options & DHCPCD_INACTIVE ?
LOG_DEBUG : LOG_WARNING,
"no interfaces have a carrier");
if (dhcpcd_daemonise(&ctx))
exit1:
if (control_stop(&ctx) == -1)
- logger(&ctx, LOG_ERR, "control_stop: %m:");
+ syslog(LOG_ERR, "control_stop: %m:");
/* Free memory and close fd's */
if (ctx.ifaces) {
while ((ifp = TAILQ_FIRST(ctx.ifaces))) {
free(ctx.iov[0].iov_base);
if (ctx.options & DHCPCD_STARTED && !(ctx.options & DHCPCD_FORKED))
- logger(&ctx, LOG_INFO, PACKAGE " exited");
- logger_close(&ctx);
- free(ctx.logfile);
+ syslog(LOG_INFO, PACKAGE " exited");
+ closelog();
#ifdef USE_SIGNALS
if (ctx.options & DHCPCD_FORKED)
_exit(i); /* so atexit won't remove our pidfile */
char pidfile[sizeof(PIDFILE) + IF_NAMESIZE + 1];
const char *cffile;
unsigned long long options;
- char *logfile;
- int log_fd;
+ int log_opts;
int argc;
char **argv;
int ifac; /* allowed interfaces */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <time.h>
#include <unistd.h>
*d = data;
return len;
}
- logger(ifp->ctx, LOG_ERR,
- "DUID too big (max %u): %s", DUID_LEN, DUID);
+ syslog(LOG_ERR, "DUID too big (max %u): %s", DUID_LEN, DUID);
/* Keep the buffer, will assign below. */
} else {
if (errno != ENOENT)
- logger(ifp->ctx, LOG_ERR,
- "error reading DUID: %s: %m", DUID);
+ syslog(LOG_ERR, "error reading DUID: %s: %m", DUID);
if ((data = malloc(DUID_LEN)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: malloc: %m", __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
return 0;
}
}
/* No file? OK, lets make one based on our interface */
if (ifp->family == ARPHRD_NETROM) {
- logger(ifp->ctx, LOG_WARNING,
- "%s: is a NET/ROM pseudo interface", ifp->name);
+ syslog(LOG_WARNING, "%s: is a NET/ROM pseudo interface",
+ ifp->name);
TAILQ_FOREACH(ifp2, ifp->ctx->ifaces, next) {
if (ifp2->family != ARPHRD_NETROM)
break;
}
if (ifp2) {
ifp = ifp2;
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"picked interface %s to generate a DUID",
ifp->name);
} else {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"no interfaces have a fixed hardware address");
return duid_make(data, ifp, DUID_LL);
}
}
if (!(fp = fopen(DUID, "w"))) {
- logger(ifp->ctx, LOG_ERR, "error writing DUID: %s: %m", DUID);
+ syslog(LOG_ERR, "error writing DUID: %s: %m", DUID);
return duid_make(data, ifp, DUID_LL);
}
len = duid_make(data, ifp, DUID_LLT);
x = -1;
/* Failed to write the duid? scrub it, we cannot use it */
if (x < 1) {
- logger(ifp->ctx, LOG_ERR, "error writing DUID: %s: %m", DUID);
+ syslog(LOG_ERR, "error writing DUID: %s: %m", DUID);
unlink(DUID);
return duid_make(data, ifp, DUID_LL);
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#if defined(OpenBSD) && OpenBSD >= 201411
ifr_sin->sin_family = AF_INET;
ifr_sin->sin_addr = addr;
if (ioctl(ctx->pf_inet_fd, SIOCGIFADDR, &ifr) == 0) {
- logger(ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: ignored false RTM_DELADDR for %s",
ifp->name, inet_ntoa(addr));
break;
if (ifam->ifam_type == RTM_DELADDR)
addrflags = 0 ;
else if ((addrflags = if_addrflags(ifp, &addr, NULL)) == -1) {
- logger(ctx, LOG_ERR,
- "%s: if_addrflags: %s: %m",
+ syslog(LOG_ERR, "%s: if_addrflags: %s: %m",
ifp->name, inet_ntoa(addr));
break;
}
if (ifam->ifam_type == RTM_DELADDR)
addrflags = 0;
else if ((addrflags = if_addrflags6(ifp, &addr6, NULL)) == -1) {
- logger(ctx, LOG_ERR,
- "%s: if_addrflags6: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_addrflags6: %m", ifp->name);
break;
}
#endif
#ifdef ND6_IFF_AUTO_LINKLOCAL
if (own && flags & ND6_IFF_AUTO_LINKLOCAL) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: disabling Kernel IPv6 auto link-local support",
ifp->name);
flags &= ~ND6_IFF_AUTO_LINKLOCAL;
#ifdef ND6_IFF_ACCEPT_RTADV
if (own && flags & ND6_IFF_ACCEPT_RTADV) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: disabling Kernel IPv6 RA support",
ifp->name);
flags &= ~ND6_IFF_ACCEPT_RTADV;
if (nd.ndi.flags != (uint32_t)flags) {
nd.ndi.flags = (uint32_t)flags;
if (ioctl(s, SIOCSIFINFO_FLAGS, &nd) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: SIOCSIFINFO_FLAGS: %m",
+ syslog(LOG_ERR, "%s: SIOCSIFINFO_FLAGS: %m",
ifp->name);
return -1;
}
* LLADDR auto configuration are disabled where applicable. */
#ifdef SIOCIFAFATTACH
if (af_attach(s, ifp, AF_INET6) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: af_attach: %m", ifp->name);
+ syslog(LOG_ERR, "%s: af_attach: %m", ifp->name);
return -1;
}
#endif
#ifdef SIOCGIFXFLAGS
if (set_ifxflags(s, ifp, own) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: set_ifxflags: %m", ifp->name);
+ syslog(LOG_ERR, "%s: set_ifxflags: %m", ifp->name);
return -1;
}
#endif
if (ra == -1)
/* The sysctl probably doesn't exist, but this isn't an
* error as such so just log it and continue */
- logger(ctx, errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
+ syslog(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
"IPV6CTL_ACCEPT_RTADV: %m");
else if (ra != 0 && own) {
- logger(ctx, LOG_DEBUG, "disabling Kernel IPv6 RA support");
+ syslog(LOG_DEBUG, "disabling Kernel IPv6 RA support");
if (set_inet6_sysctl(IPV6CTL_ACCEPT_RTADV, 0) == -1) {
- logger(ctx, LOG_ERR, "IPV6CTL_ACCEPT_RTADV: %m");
+ syslog(LOG_ERR, "IPV6CTL_ACCEPT_RTADV: %m");
return ra;
}
ra = 0;
* and prefixes so the kernel does not expire prefixes
* and default routes we are trying to own. */
if (if_raflush(s) == -1)
- logger(ctx, LOG_WARNING, "if_raflush: %m");
+ syslog(LOG_WARNING, "if_raflush: %m");
}
ctx->ra_global = ra;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <time.h>
#include <unistd.h>
NLA_DATA(tb[NL80211_ATTR_BSS]),
NLA_LEN(tb[NL80211_ATTR_BSS]),
NL80211_BSS_STATUS) == -1)
- return 0;
-
+ return 0;
+
if (bss[NL80211_BSS_BSSID] == NULL || bss[NL80211_BSS_STATUS] == NULL)
return 0;
ifname = "all";
else if (own) {
if (if_disable_autolinklocal(ctx, ifp->index) == -1)
- logger(ctx, LOG_DEBUG,
- "%s: if_disable_autolinklocal: %m", ifp->name);
+ syslog(LOG_DEBUG, "%s: if_disable_autolinklocal: %m",
+ ifp->name);
}
if (ifp)
ifname = ifp->name;
ra = check_proc_int(path);
if (ra != 1) {
if (!own)
- logger(ctx, LOG_WARNING,
- "%s: IPv6 kernel autoconf disabled", ifname);
+ syslog(LOG_WARNING, "%s: IPv6 kernel autoconf disabled",
+ ifname);
} else if (ra != -1 && own) {
if (write_path(path, "0") == -1) {
- logger(ctx, LOG_ERR, "write_path: %s: %m", path);
+ syslog(LOG_ERR, "write_path: %s: %m", path);
return -1;
}
}
if (ra == -1)
/* The sysctl probably doesn't exist, but this isn't an
* error as such so just log it and continue */
- logger(ctx, errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
- "%s: %m", path);
+ syslog(errno == ENOENT ? LOG_DEBUG:LOG_WARNING, "%s: %m", path);
else if (ra != 0 && own) {
- logger(ctx, LOG_DEBUG, "%s: disabling kernel IPv6 RA support",
+ syslog(LOG_DEBUG, "%s: disabling kernel IPv6 RA support",
ifname);
if (write_path(path, "0") == -1) {
- logger(ctx, LOG_ERR, "write_path: %s: %m", path);
+ syslog(LOG_ERR, "write_path: %s: %m", path);
return ra;
}
return 0;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include <time.h>
{"reconfigure", no_argument, NULL, 'g'},
{"hostname", optional_argument, NULL, 'h'},
{"vendorclassid", optional_argument, NULL, 'i'},
- {"logfile", required_argument, NULL, 'j'},
{"release", no_argument, NULL, 'k'},
{"leasetime", required_argument, NULL, 'l'},
{"metric", required_argument, NULL, 'm'},
};
static char *
-add_environ(struct dhcpcd_ctx *ctx, struct if_options *ifo,
- const char *value, int uniq)
+add_environ(struct if_options *ifo, const char *value, int uniq)
{
char **newlist;
char **lst = ifo->environ;
match = strdup(value);
if (match == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
p = strchr(match, '=');
if (p == NULL) {
- logger(ctx, LOG_ERR, "%s: no assignment: %s", __func__, value);
+ syslog(LOG_ERR, "%s: no assignment: %s", __func__, value);
free(match);
return NULL;
}
if (uniq) {
n = strdup(value);
if (n == NULL) {
- logger(ctx, LOG_ERR,
- "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(match);
return NULL;
}
lv = strlen(p);
n = realloc(lst[i], l + lv + 2);
if (n == NULL) {
- logger(ctx, LOG_ERR,
- "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(match);
return NULL;
}
free(match);
n = strdup(value);
if (n == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
newlist = realloc(lst, sizeof(char *) * (i + 2));
if (newlist == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(n);
return NULL;
}
#endif
static char **
-splitv(struct dhcpcd_ctx *ctx, int *argc, char **argv, const char *arg)
+splitv(int *argc, char **argv, const char *arg)
{
char **n, **v = argv;
char *o = strdup(arg), *p, *t, *nt;
if (o == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return v;
}
p = o;
while ((t = strsep(&p, ", "))) {
nt = strdup(t);
if (nt == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(o);
return v;
}
n = realloc(v, sizeof(char *) * ((size_t)(*argc) + 1));
if (n == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(o);
free(nt);
return v;
#ifdef INET
static int
-parse_addr(struct dhcpcd_ctx *ctx,
- struct in_addr *addr, struct in_addr *net, const char *arg)
+parse_addr(struct in_addr *addr, struct in_addr *net, const char *arg)
{
char *p;
if (e != 0 ||
(net != NULL && inet_cidrtoaddr((int)i, net) != 0))
{
- logger(ctx, LOG_ERR, "`%s' is not a valid CIDR", p);
+ syslog(LOG_ERR, "`%s' is not a valid CIDR", p);
return -1;
}
}
if (addr != NULL && inet_aton(arg, addr) == 0) {
- logger(ctx, LOG_ERR, "`%s' is not a valid IP address", arg);
+ syslog(LOG_ERR, "`%s' is not a valid IP address", arg);
return -1;
}
if (p != NULL)
}
#else
static int
-parse_addr(struct dhcpcd_ctx *ctx,
- __unused struct in_addr *addr, __unused struct in_addr *net,
+parse_addr(__unused struct in_addr *addr, __unused struct in_addr *net,
__unused const char *arg)
{
- logger(ctx, LOG_ERR, "No IPv4 support");
+ syslog(LOG_ERR, "No IPv4 support");
return -1;
}
#endif
case 'f': /* FALLTHROUGH */
case 'g': /* FALLTHROUGH */
case 'n': /* FALLTHROUGH */
+ case 'q': /* FALLTHROUGH */
case 'x': /* FALLTHROUGH */
case 'N': /* FALLTHROUGH */
case 'P': /* FALLTHROUGH */
free(ifo->script);
ifo->script = strdup(arg);
if (ifo->script == NULL)
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
break;
case 'd':
ifo->options |= DHCPCD_DEBUG;
break;
case 'e':
ARG_REQUIRED;
- add_environ(ctx, ifo, arg, 1);
+ add_environ(ifo, arg, 1);
break;
case 'h':
if (!arg) {
}
s = parse_string(ifo->hostname, HOSTNAME_MAX_LEN, arg);
if (s == -1) {
- logger(ctx, LOG_ERR, "hostname: %m");
+ syslog(LOG_ERR, "hostname: %m");
return -1;
}
if (s != 0 && ifo->hostname[0] == '.') {
- logger(ctx, LOG_ERR, "hostname cannot begin with .");
+ syslog(LOG_ERR, "hostname cannot begin with .");
return -1;
}
ifo->hostname[s] = '\0';
else
s = 0;
if (s == -1) {
- logger(ctx, LOG_ERR, "vendorclassid: %m");
+ syslog(LOG_ERR, "vendorclassid: %m");
return -1;
}
*ifo->vendorclassid = (uint8_t)s;
break;
- case 'j':
- ARG_REQUIRED;
- /* per interface logging is not supported
- * don't want to overide the commandline */
- if (ifname == NULL && ctx->logfile == NULL) {
- logger_close(ctx);
- ctx->logfile = strdup(arg);
- logger_open(ctx);
- }
- break;
case 'k':
ifo->options |= DHCPCD_RELEASE;
break;
ifo->leasetime = (uint32_t)strtou(arg, NULL,
0, 0, UINT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "failed to convert leasetime %s", arg);
+ syslog(LOG_ERR, "failed to convert leasetime %s", arg);
return -1;
}
break;
ARG_REQUIRED;
ifo->metric = (int)strtoi(arg, NULL, 0, 0, INT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "failed to convert metric %s", arg);
+ syslog(LOG_ERR, "failed to convert metric %s", arg);
return -1;
}
break;
make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
{
- logger(ctx, LOG_ERR, "unknown option `%s'", arg);
+ syslog(LOG_ERR, "unknown option `%s'", arg);
return -1;
}
break;
make_option_mask(d, dl, od, odl, request, arg, -1) != 0 ||
make_option_mask(d, dl, od, odl, require, arg, -1) != 0)
{
- logger(ctx, LOG_ERR, "unknown option `%s'", arg);
+ syslog(LOG_ERR, "unknown option `%s'", arg);
return -1;
}
break;
case 'p':
ifo->options |= DHCPCD_PERSISTENT;
break;
- case 'q':
- ifo->options |= DHCPCD_QUIET;
- break;
case 'r':
- if (parse_addr(ctx, &ifo->req_addr, NULL, arg) != 0)
+ if (parse_addr(&ifo->req_addr, NULL, arg) != 0)
return -1;
ifo->options |= DHCPCD_REQUEST;
ifo->req_mask.s_addr = 0;
break;
case 's':
if (arg && *arg != '\0') {
- if (parse_addr(ctx,
- &ifo->req_addr, &ifo->req_mask, arg) != 0)
+ if (parse_addr(&ifo->req_addr, &ifo->req_mask, arg)
+ != 0)
return -1;
} else {
ifo->req_addr.s_addr = 0;
ARG_REQUIRED;
ifo->timeout = (time_t)strtoi(arg, NULL, 0, 0, INT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "failed to convert timeout");
+ syslog(LOG_ERR, "failed to convert timeout");
return -1;
}
break;
s = parse_string((char *)ifo->userclass +
ifo->userclass[0] + 2, (size_t)s, arg);
if (s == -1) {
- logger(ctx, LOG_ERR, "userclass: %m");
+ syslog(LOG_ERR, "userclass: %m");
return -1;
}
if (s != 0) {
ARG_REQUIRED;
p = strchr(arg, ',');
if (!p || !p[1]) {
- logger(ctx, LOG_ERR, "invalid vendor format: %s", arg);
+ syslog(LOG_ERR, "invalid vendor format: %s", arg);
return -1;
}
s = parse_string((char *)ifo->vendor + 1,
VENDOR_MAX_LEN, arg);
if (s == -1) {
- logger(ctx, LOG_ERR, "vendor: %m");
+ syslog(LOG_ERR, "vendor: %m");
return -1;
}
ifo->vendor[0] = (uint8_t)s;
i = (int)strtoi(arg, NULL, 0, 1, 254, &e);
*p = ',';
if (e) {
- logger(ctx, LOG_ERR, "vendor option should be between"
+ syslog(LOG_ERR, "vendor option should be between"
" 1 and 254 inclusive");
return -1;
}
ifo->vendor[0] + 3, (size_t)s, arg);
}
if (s == -1) {
- logger(ctx, LOG_ERR, "vendor: %m");
+ syslog(LOG_ERR, "vendor: %m");
return -1;
}
if (s != 0) {
ARG_REQUIRED;
ifo->reboot = (time_t)strtoi(arg, NULL, 0, 0, UINT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "failed to convert reboot %s", arg);
+ syslog(LOG_ERR, "failed to convert reboot %s", arg);
return -1;
}
break;
case 'z':
ARG_REQUIRED;
if (ifname == NULL)
- ctx->ifav = splitv(ctx, &ctx->ifac, ctx->ifav, arg);
+ ctx->ifav = splitv(&ctx->ifac, ctx->ifav, arg);
break;
case 'A':
ifo->options &= ~DHCPCD_ARP;
dl = strlen("skip_hooks=") + strlen(arg) + 1;
p = malloc(sizeof(char) * dl);
if (p == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
snprintf(p, dl, "skip_hooks=%s", arg);
- add_environ(ctx, ifo, p, 0);
+ add_environ(ifo, p, 0);
free(p);
break;
case 'D':
else if (strcmp(arg, "disable") == 0)
ifo->fqdn = FQDN_DISABLE;
else {
- logger(ctx, LOG_ERR, "invalid value `%s' for FQDN", arg);
+ syslog(LOG_ERR, "invalid value `%s' for FQDN", arg);
return -1;
}
break;
else
s = 0;
if (s == -1) {
- logger(ctx, LOG_ERR, "clientid: %m");
+ syslog(LOG_ERR, "clientid: %m");
return -1;
}
ifo->options |= DHCPCD_CLIENTID;
make_option_mask(d, dl, od, odl, require, arg, -1) != 0 ||
make_option_mask(d, dl, od, odl, no, arg, 1) != 0)
{
- logger(ctx, LOG_ERR, "unknown option `%s'", arg);
+ syslog(LOG_ERR, "unknown option `%s'", arg);
return -1;
}
break;
make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
{
- logger(ctx, LOG_ERR, "unknown option `%s'", arg);
+ syslog(LOG_ERR, "unknown option `%s'", arg);
return -1;
}
break;
ARG_REQUIRED;
p = strchr(arg, '=');
if (p == NULL) {
- logger(ctx, LOG_ERR, "static assignment required");
+ syslog(LOG_ERR, "static assignment required");
return -1;
}
p++;
if (strncmp(arg, "ip_address=", strlen("ip_address=")) == 0) {
- if (parse_addr(ctx, &ifo->req_addr,
+ if (parse_addr(&ifo->req_addr,
ifo->req_mask.s_addr == 0 ? &ifo->req_mask : NULL,
p) != 0)
return -1;
} else if (strncmp(arg, "subnet_mask=",
strlen("subnet_mask=")) == 0)
{
- if (parse_addr(ctx, &ifo->req_mask, NULL, p) != 0)
+ if (parse_addr(&ifo->req_mask, NULL, p) != 0)
return -1;
} else if (strncmp(arg, "routes=", strlen("routes=")) == 0 ||
strncmp(arg, "static_routes=",
fp = np = strwhite(p);
if (np == NULL) {
- logger(ctx, LOG_ERR,
- "all routes need a gateway");
+ syslog(LOG_ERR, "all routes need a gateway");
return -1;
}
*np++ = '\0';
np = strskipwhite(np);
- if (parse_addr(ctx, &addr, &addr2, p) == -1 ||
- parse_addr(ctx, &addr3, NULL, np) == -1)
+ if (parse_addr(&addr, &addr2, p) == -1 ||
+ parse_addr(&addr3, NULL, np) == -1)
{
*fp = ' ';
return -1;
TAILQ_INSERT_TAIL(&ifo->routes, rt, rt_next);
*fp = ' ';
} else if (strncmp(arg, "routers=", strlen("routers=")) == 0) {
- if (parse_addr(ctx, &addr, NULL, p) == -1)
+ if (parse_addr(&addr, NULL, p) == -1)
return -1;
if ((rt = rt_new(if_find(ctx->ifaces, ifname))) == NULL)
return -1;
ifo->mtu = (unsigned int)strtou(p, NULL, 0,
MTU_MIN, MTU_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "invalid MTU %s", p);
+ syslog(LOG_ERR, "invalid MTU %s", p);
return -1;
}
} else if (strncmp(arg, "ip6_address=", strlen("ip6_address=")) == 0) {
ifo->req_prefix_len = (uint8_t)strtou(np,
NULL, 0, 0, 128, &e);
if (e) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: failed to "
"convert prefix len",
ifname);
{
p = strdup(arg);
if (p == NULL) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: %m", __func__);
return -1;
}
}
p = strdup(arg);
if (p == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
nconf = realloc(ifo->config, sizeof(char *) * (dl + 2));
if (nconf == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(p);
return -1;
}
}
break;
case 'W':
- if (parse_addr(ctx, &addr, &addr2, arg) != 0)
+ if (parse_addr(&addr, &addr2, arg) != 0)
return -1;
if (strchr(arg, '/') == NULL)
addr2.s_addr = INADDR_BROADCAST;
naddr = realloc(ifo->whitelist,
sizeof(in_addr_t) * (ifo->whitelist_len + 2));
if (naddr == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ifo->whitelist = naddr;
ifo->whitelist[ifo->whitelist_len++] = addr2.s_addr;
break;
case 'X':
- if (parse_addr(ctx, &addr, &addr2, arg) != 0)
+ if (parse_addr(&addr, &addr2, arg) != 0)
return -1;
if (strchr(arg, '/') == NULL)
addr2.s_addr = INADDR_BROADCAST;
naddr = realloc(ifo->blacklist,
sizeof(in_addr_t) * (ifo->blacklist_len + 2));
if (naddr == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ifo->blacklist = naddr;
case 'Z':
ARG_REQUIRED;
if (ifname == NULL)
- ctx->ifdv = splitv(ctx, &ctx->ifdc, ctx->ifdv, arg);
+ ctx->ifdv = splitv(&ctx->ifdc, ctx->ifdv, arg);
break;
case '1':
ifo->options |= DHCPCD_ONESHOT;
fp = strwhite(arg);
if (fp)
*fp++ = '\0';
- if (parse_addr(ctx, &addr, NULL, arg) != 0)
+ if (parse_addr(&addr, NULL, arg) != 0)
return -1;
naddr = realloc(ifo->arping,
sizeof(in_addr_t) * ((size_t)ifo->arping_len + 1));
if (naddr == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ifo->arping = naddr;
ifo->dstmask, arg, 2) != 0)
{
if (errno == EINVAL)
- logger(ctx, LOG_ERR, "option `%s' does not take"
+ syslog(LOG_ERR, "option `%s' does not take"
" an IPv4 address", arg);
else
- logger(ctx, LOG_ERR, "unknown option `%s'", arg);
+ syslog(LOG_ERR, "unknown option `%s'", arg);
return -1;
}
break;
free(ifo->fallback);
ifo->fallback = strdup(arg);
if (ifo->fallback == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
break;
case O_IAID:
ARG_REQUIRED;
if (ifname == NULL) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"IAID must belong in an interface block");
return -1;
}
if (parse_iaid(ifo->iaid, arg, sizeof(ifo->iaid)) == -1) {
- logger(ctx, LOG_ERR, "invalid IAID %s", arg);
+ syslog(LOG_ERR, "invalid IAID %s", arg);
return -1;
}
ifo->options |= DHCPCD_IAID;
case O_IA_PD:
if (i == 0) {
if (ifname == NULL) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"IA PD must belong in an interface block");
return -1;
}
i = D6_OPTION_IA_PD;
}
if (ifname == NULL && arg) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"IA with IAID must belong in an interface block");
return -1;
}
if (p)
*p++ = '\0';
if (parse_iaid(iaid, arg, sizeof(iaid)) == -1) {
- logger(ctx, LOG_ERR, "invalid IAID: %s", arg);
+ syslog(LOG_ERR, "invalid IAID: %s", arg);
return -1;
}
}
}
}
if (ia && ia->ia_type != (uint16_t)i) {
- logger(ctx, LOG_ERR, "Cannot mix IA for the same IAID");
+ syslog(LOG_ERR, "Cannot mix IA for the same IAID");
break;
}
if (ia == NULL) {
ia = realloc(ifo->ia,
sizeof(*ifo->ia) * (ifo->ia_len + 1));
if (ia == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ifo->ia = ia;
if (p)
*p++ = '\0';
if (inet_pton(AF_INET6, arg, &ia->addr) == -1) {
- logger(ctx, LOG_ERR, "%s: %m", arg);
+ syslog(LOG_ERR, "%s: %m", arg);
memset(&ia->addr, 0, sizeof(ia->addr));
}
if (p && ia->ia_type == D6_OPTION_IA_PD) {
ia->prefix_len = (uint8_t)strtou(p,
NULL, 0, 8, 120, &e);
if (e) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: failed to convert"
" prefix len",
p);
sla = realloc(ia->sla,
sizeof(*ia->sla) * (ia->sla_len + 1));
if (sla == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ia->sla = sla;
if (strlcpy(sla->ifname, p,
sizeof(sla->ifname)) >= sizeof(sla->ifname))
{
- logger(ctx, LOG_ERR,
- "%s: interface name too long", arg);
+ syslog(LOG_ERR,
+ "%s: interface name too long", arg);
goto err_sla;
}
sla->sla_set = 0;
0, 0, UINT32_MAX, &e);
sla->sla_set = 1;
if (e) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: failed to convert sla",
ifname);
goto err_sla;
sla->prefix_len = (uint8_t)strtou(p,
NULL, 0, 0, 120, &e);
if (e) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: failed to "
"convert prefix len",
ifname);
sla->suffix = (uint64_t)strtou(p, NULL,
0, 0, UINT64_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: failed to "
"convert suffix",
ifname);
for (sl = 0; sl < ia->sla_len - 1; sl++) {
slap = &ia->sla[sl];
if (slap->sla_set != sla->sla_set) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: cannot mix automatic "
"and fixed SLA",
sla->ifname);
(sla->prefix_len == ia->prefix_len ||
slap->prefix_len == ia->prefix_len))
{
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: cannot delegte the same"
"prefix length more than once",
sla->ifname);
if (sla->sla_set == 0 &&
strcmp(slap->ifname, sla->ifname) == 0)
{
- logger(ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: cannot specify the "
"same interface twice with "
"an automatic SLA",
if (slap->sla_set && sla->sla_set &&
slap->sla == sla->sla)
{
- logger(ctx, LOG_ERR, "%s: cannot"
+ syslog(LOG_ERR, "%s: cannot"
" assign the same SLA %u"
" more than once",
sla->ifname, sla->sla);
dop = &(*ldop)->embopts;
dop_len = &(*ldop)->embopts_len;
} else {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"embed must be after a define or encap");
return -1;
}
ARG_REQUIRED;
if (dop == NULL) {
if (*ldop == NULL) {
- logger(ctx, LOG_ERR, "encap must be after a define");
+ syslog(LOG_ERR, "encap must be after a define");
return -1;
}
dop = &(*ldop)->encopts;
else {
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "invalid syntax: %s", arg);
+ syslog(LOG_ERR, "invalid syntax: %s", arg);
return -1;
}
*fp++ = '\0';
u = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "invalid code: %s", arg);
+ syslog(LOG_ERR, "invalid code: %s", arg);
return -1;
}
arg = strskipwhite(fp);
if (arg == NULL) {
- logger(ctx, LOG_ERR, "invalid syntax");
+ syslog(LOG_ERR, "invalid syntax");
return -1;
}
}
bp = NULL; /* No bitflag */
l = (long)strtou(np, NULL, 0, 0, LONG_MAX, &e);
if (e) {
- logger(ctx,LOG_ERR, "failed to convert length");
+ syslog(LOG_ERR, "failed to convert length");
return -1;
}
} else {
arg = strskipwhite(fp);
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "incomplete request type");
+ syslog(LOG_ERR, "incomplete request type");
return -1;
}
*fp++ = '\0';
arg = strskipwhite(fp);
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "incomplete request type");
+ syslog(LOG_ERR, "incomplete request type");
return -1;
}
*fp++ = '\0';
arg = strskipwhite(fp);
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR,
- "incomplete optional type");
+ syslog(LOG_ERR, "incomplete optional type");
return -1;
}
*fp++ = '\0';
arg = strskipwhite(fp);
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "incomplete index type");
+ syslog(LOG_ERR, "incomplete index type");
return -1;
}
*fp++ = '\0';
arg = strskipwhite(fp);
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "incomplete array type");
+ syslog(LOG_ERR, "incomplete array type");
return -1;
}
*fp++ = '\0';
else if (strcasecmp(arg, "option") == 0)
t |= OT_OPTION;
else {
- logger(ctx, LOG_ERR, "unknown type: %s", arg);
+ syslog(LOG_ERR, "unknown type: %s", arg);
return -1;
}
if (l && !(t & (OT_STRING | OT_BINHEX))) {
- logger(ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"ignoring length for type `%s'", arg);
l = 0;
}
if (t & OT_ARRAY && t & (OT_STRING | OT_BINHEX) &&
!(t & (OT_RFC1035 | OT_DOMAIN)))
{
- logger(ctx, LOG_WARNING, "ignoring array for strings");
+ syslog(LOG_WARNING, "ignoring array for strings");
t &= ~OT_ARRAY;
}
if (t & OT_BITFLAG) {
if (bp == NULL)
- logger(ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"missing bitflag assignment");
}
/* variable */
if (!fp) {
if (!(t & OT_OPTION)) {
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"type %s requires a variable name", arg);
return -1;
}
if (strcasecmp(arg, "reserved")) {
np = strdup(arg);
if (np == NULL) {
- logger(ctx, LOG_ERR,
- "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
} else {
if ((ndop = realloc(*dop,
sizeof(**dop) * ((*dop_len) + 1))) == NULL)
{
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(np);
return -1;
}
*fp++ = '\0';
u = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
if (e) {
- logger(ctx, LOG_ERR, "invalid code: %s", arg);
+ syslog(LOG_ERR, "invalid code: %s", arg);
return -1;
}
if (fp) {
s = parse_string(NULL, 0, fp);
if (s == -1) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
dl = (size_t)s;
if (dl + (sizeof(uint16_t) * 2) > UINT16_MAX) {
- logger(ctx, LOG_ERR, "vendor class is too big");
+ syslog(LOG_ERR, "vendor class is too big");
return -1;
}
np = malloc(dl);
if (np == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
parse_string(np, dl, fp);
vivco = realloc(ifo->vivco, sizeof(*ifo->vivco) *
(ifo->vivco_len + 1));
if (vivco == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
ifo->vivco = vivco;
else if (strcasecmp(arg, "delayedrealm") == 0)
ifo->auth.protocol = AUTH_PROTO_DELAYEDREALM;
else {
- logger(ctx, LOG_ERR, "%s: unsupported protocol", arg);
+ syslog(LOG_ERR, "%s: unsupported protocol", arg);
return -1;
}
arg = strskipwhite(fp);
strcasecmp(arg, "hmac-md5") == 0)
ifo->auth.algorithm = AUTH_ALG_HMAC_MD5;
else {
- logger(ctx, LOG_ERR, "%s: unsupported algorithm", arg);
+ syslog(LOG_ERR, "%s: unsupported algorithm", arg);
return 1;
}
arg = fp;
strcasecmp(arg, "monotime") == 0)
ifo->auth.rdm = AUTH_RDM_MONOTONIC;
else {
- logger(ctx, LOG_ERR, "%s: unsupported RDM", arg);
+ syslog(LOG_ERR, "%s: unsupported RDM", arg);
return -1;
}
ifo->auth.options |= DHCPCD_AUTH_SEND;
break;
#else
- logger(ctx, LOG_ERR, "no authentication support");
+ syslog(LOG_ERR, "no authentication support");
return -1;
#endif
case O_AUTHTOKEN:
#ifdef AUTH
fp = strwhite(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "authtoken requires a realm");
+ syslog(LOG_ERR, "authtoken requires a realm");
return -1;
}
*fp++ = '\0';
token = malloc(sizeof(*token));
if (token == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(token);
return -1;
}
if (parse_uint32(&token->secretid, arg) == -1) {
- logger(ctx, LOG_ERR, "%s: not a number", arg);
+ syslog(LOG_ERR, "%s: not a number", arg);
free(token);
return -1;
}
arg = fp;
fp = strend(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "authtoken requies an a key");
+ syslog(LOG_ERR, "authtoken requies an a key");
free(token);
return -1;
}
*fp++ = '\0';
s = parse_string(NULL, 0, arg);
if (s == -1) {
- logger(ctx, LOG_ERR, "realm_len: %m");
+ syslog(LOG_ERR, "realm_len: %m");
free(token);
return -1;
}
token->realm = malloc(token->realm_len);
if (token->realm == NULL) {
free(token);
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
parse_string((char *)token->realm, token->realm_len,
arg = fp;
fp = strend(arg);
if (fp == NULL) {
- logger(ctx, LOG_ERR, "authtoken requies an an expiry date");
+ syslog(LOG_ERR, "authtoken requies an an expiry date");
free(token->realm);
free(token);
return -1;
memset(&tm, 0, sizeof(tm));
if (strptime(arg, "%Y-%m-%d %H:%M", &tm) == NULL) {
- logger(ctx, LOG_ERR, "%s: invalid date time", arg);
+ syslog(LOG_ERR, "%s: invalid date time", arg);
free(token->realm);
free(token);
return -1;
}
if ((token->expire = mktime(&tm)) == (time_t)-1) {
- logger(ctx, LOG_ERR, "%s: mktime: %m", __func__);
+ syslog(LOG_ERR, "%s: mktime: %m", __func__);
free(token->realm);
free(token);
return -1;
arg = fp;
s = parse_string(NULL, 0, arg);
if (s == -1 || s == 0) {
- logger(ctx, LOG_ERR, s == -1 ? "token_len: %m" :
+ syslog(LOG_ERR, s == -1 ? "token_len: %m" :
"authtoken needs a key");
free(token->realm);
free(token);
parse_string((char *)token->key, token->key_len, arg);
TAILQ_INSERT_TAIL(&ifo->auth.tokens, token, next);
#else
- logger(ctx, LOG_ERR, "no authentication support");
+ syslog(LOG_ERR, "no authentication support");
return -1;
#endif
break;
dl = (size_t)l;
p = malloc(dl);
if (p == NULL) {
- logger(ctx, LOG_ERR, "%s: malloc: %m", __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
return -1;
}
while ((i = getgrnam_r(arg, &grpbuf, p, (size_t)l, &grp)) ==
{
size_t nl = dl * 2;
if (nl < dl) {
- logger(ctx, LOG_ERR, "control_group: out of buffer");
+ syslog(LOG_ERR, "control_group: out of buffer");
free(p);
return -1;
}
dl = nl;
np = realloc(p, dl);
if (np == NULL) {
- logger(ctx, LOG_ERR, "control_group: realloc: %m");
+ syslog(LOG_ERR, "control_group: realloc: %m");
free(p);
return -1;
}
}
if (i != 0) {
errno = i;
- logger(ctx, LOG_ERR, "getgrnam_r: %m");
+ syslog(LOG_ERR, "getgrnam_r: %m");
free(p);
return -1;
}
if (grp == NULL) {
- logger(ctx, LOG_ERR, "controlgroup: %s: not found", arg);
+ syslog(LOG_ERR, "controlgroup: %s: not found", arg);
free(p);
return -1;
}
#else
grp = getgrnam(arg);
if (grp == NULL) {
- logger(ctx, LOG_ERR, "controlgroup: %s: not found", arg);
+ syslog(LOG_ERR, "controlgroup: %s: not found", arg);
return -1;
}
ctx->control_group = grp->gr_gid;
ifo->options |= DHCPCD_INACTIVE;
break;
case O_MUDURL:
- ARG_REQUIRED;
+ ARG_REQUIRED;
s = parse_string((char *)ifo->mudurl + 1, MUDURL_MAX_LEN, arg);
if (s == -1) {
- logger(ctx, LOG_ERR, "mudurl: %m");
+ syslog(LOG_ERR, "mudurl: %m");
return -1;
}
*ifo->mudurl = (uint8_t)s;
#ifdef ARG_REQUIRED
arg_required:
- logger(ctx, LOG_ERR, "option %d requires an argument", opt);
+ syslog(LOG_ERR, "option %d requires an argument", opt);
return -1;
#undef ARG_REQUIRED
#endif
ldop, edop);
}
- logger(ctx, LOG_ERR, "unknown option: %s", opt);
+ syslog(LOG_ERR, "unknown option: %s", opt);
return -1;
}
/* Seed our default options */
if ((ifo = calloc(1, sizeof(*ifo))) == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
ifo->options |= DHCPCD_IF_UP | DHCPCD_LINK | DHCPCD_INITIAL_DELAY;
ifo->dhcp_override =
calloc(INITDEFINES, sizeof(*ifo->dhcp_override));
if (ifo->dhcp_override == NULL)
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
else
ifo->dhcp_override_len = INITDEFINES;
#endif
ifo->nd_override =
calloc(INITDEFINENDS, sizeof(*ifo->nd_override));
if (ifo->nd_override == NULL)
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
else
ifo->nd_override_len = INITDEFINENDS;
#endif
ifo->dhcp6_override =
calloc(INITDEFINE6S, sizeof(*ifo->dhcp6_override));
if (ifo->dhcp6_override == NULL)
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
else
ifo->dhcp6_override_len = INITDEFINE6S;
#endif
#ifdef EMBEDDED_CONFIG
fp = fopen(EMBEDDED_CONFIG, "r");
if (fp == NULL)
- logger(ctx, LOG_ERR, "fopen `%s': %m", EMBEDDED_CONFIG);
+ syslog(LOG_ERR, "fopen `%s': %m", EMBEDDED_CONFIG);
while (fp && (line = get_line(&buf, &buflen, fp))) {
#else
buflen = 80;
buf = malloc(buflen);
if (buf == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free_options(ifo);
return NULL;
}
buflen = ol;
nbuf = realloc(buf, buflen);
if (nbuf == NULL) {
- logger(ctx, LOG_ERR,
- "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(buf);
free_options(ifo);
return NULL;
if (fp == NULL) {
/* dhcpcd can continue without it, but no DNS options
* would be requested ... */
- logger(ctx, LOG_WARNING, "fopen `%s': %m", ctx->cffile);
+ syslog(LOG_WARNING, "fopen `%s': %m", ctx->cffile);
free(buf);
return ifo;
}
n = reallocarray(ctx->ifcv,
(size_t)ctx->ifcc + 1, sizeof(char *));
if (n == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
continue;
}
ctx->ifcv = n;
ctx->ifcv[ctx->ifcc] = strdup(line);
if (ctx->ifcv[ctx->ifcc] == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
continue;
}
ctx->ifcc++;
/* Don't set any optional arguments here so we retain POSIX
* compatibility with getopt */
-#define IF_OPTS "146bc:de:f:gh:i:j:kl:m:no:pqr:s:t:u:v:wxy:z:" \
+#define IF_OPTS "146bc:de:f:gh:i:kl:m:no:pqr:s:t:u:v:wxy:z:" \
"ABC:DEF:GHI:JKLMNO:PQ:S:TUVW:X:Z:"
#define NOERR_IF_OPTS ":" IF_OPTS
#define DHCPCD_HOSTNAME (1ULL << 18)
#define DHCPCD_CLIENTID (1ULL << 19)
#define DHCPCD_LINK (1ULL << 20)
-#define DHCPCD_QUIET (1ULL << 21)
+// unused (1ULL << 21)
#define DHCPCD_BACKGROUND (1ULL << 22)
#define DHCPCD_VENDORRAW (1ULL << 23)
#define DHCPCD_NOWAITIP (1ULL << 24) /* To force daemonise */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include <fcntl.h>
ifa->ifa_name);
if (addrflags == -1) {
if (errno != EEXIST)
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: if_addrflags: %s: %m",
__func__,
inet_ntoa(addr->sin_addr));
ifa->ifa_name);
if (addrflags == -1) {
if (errno != EEXIST)
- logger(ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: if_addrflags6: %m", __func__);
continue;
}
}
if (if_vimaster(ctx, spec.devname) == 1) {
- logger(ctx, argc ? LOG_ERR : LOG_DEBUG,
+ syslog(argc ? LOG_ERR : LOG_DEBUG,
"%s: is a Virtual Interface Master, skipping",
spec.devname);
continue;
ifp = calloc(1, sizeof(*ifp));
if (ifp == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
break;
}
ifp->ctx = ctx;
ctx->ifac == 0 && active &&
!if_hasconf(ctx, ifp->name))
{
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: ignoring due to"
" interface type and"
" no config",
!if_hasconf(ctx, ifp->name))
active = IF_INACTIVE;
if (active)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: unsupported"
" interface type %.2x",
ifp->name, sdl->sdl_type);
#ifndef AF_LINK
default:
if (active)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: unsupported"
" interface family %.2x",
ifp->name, ifp->family);
if (!(ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))) {
/* Handle any platform init for the interface */
if (active != IF_INACTIVE && if_init(ifp) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: if_init: %m",
- ifp->name);
+ syslog(LOG_ERR, "%s: if_init: %m", ifp->name);
if_free(ifp);
continue;
}
if (if_getmtu(ifp) < MTU_MIN && active &&
if_setmtu(ifp, MTU_MIN) == -1)
{
- logger(ifp->ctx, LOG_ERR,
- "%s: if_setmtu: %m", ifp->name);
+ syslog(LOG_ERR, "%s: if_setmtu: %m", ifp->name);
if_free(ifp);
continue;
}
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include "config.h"
char buf[INET_MAX_ADDRSTRLEN];
ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: forcing router %s through interface",
ifp->name,
sa_addrtop(&rt->rt_gateway,
char buf[INET_MAX_ADDRSTRLEN];
ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: router %s requires a host route",
ifp->name,
sa_addrtop(&rt->rt_gateway, buf, sizeof(buf)));
UNUSED(keeparp);
#endif
- logger(addr->iface->ctx, LOG_DEBUG,
- "%s: deleting IP address %s", addr->iface->name, addr->saddr);
+ syslog(LOG_DEBUG, "%s: deleting IP address %s",
+ addr->iface->name, addr->saddr);
r = if_address(RTM_DELADDR, addr);
if (r == -1 &&
errno != EADDRNOTAVAIL && errno != ESRCH &&
errno != ENXIO && errno != ENODEV)
- logger(addr->iface->ctx, LOG_ERR, "%s: %s: %m",
- addr->iface->name, __func__);
+ syslog(LOG_ERR, "%s: %s: %m", addr->iface->name, __func__);
#ifdef ARP
if (!keeparp && (astate = arp_find(addr->iface, &addr->addr)) != NULL)
ifp->if_data[IF_DATA_IPV4] = malloc(sizeof(*state));
state = IPV4_STATE(ifp);
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
TAILQ_INIT(&state->addrs);
#endif
if ((state = ipv4_getstate(ifp)) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: ipv4_getstate: %m", __func__);
+ syslog(LOG_ERR, "%s: ipv4_getstate: %m", __func__);
return NULL;
}
if (ifp->options->options & DHCPCD_NOALIAS) {
}
if ((ia = malloc(sizeof(*ia))) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
#ifdef ALIAS_ADDR
blank = (ia->alias[0] == '\0');
if ((replaced = ipv4_aliasaddr(ia, &replaced_ia)) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: ipv4_aliasaddr: %m", ifp->name);
+ syslog(LOG_ERR, "%s: ipv4_aliasaddr: %m", ifp->name);
free(ia);
return NULL;
}
if (blank)
- logger(ia->iface->ctx, LOG_DEBUG, "%s: aliased %s",
- ia->alias, ia->saddr);
+ syslog(LOG_DEBUG, "%s: aliased %s", ia->alias, ia->saddr);
#endif
- logger(ifp->ctx, LOG_DEBUG, "%s: adding IP address %s broadcast %s",
+ syslog(LOG_DEBUG, "%s: adding IP address %s broadcast %s",
ifp->name, ia->saddr, inet_ntoa(*bcast));
if (if_address(RTM_NEWADDR, ia) == -1) {
if (errno != EEXIST)
- logger(ifp->ctx, LOG_ERR, "%s: if_addaddress: %m",
+ syslog(LOG_ERR, "%s: if_addaddress: %m",
__func__);
free(ia);
return NULL;
nstate->addr->addr.s_addr == lease->addr.s_addr)
{
if (r == 0) {
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: preferring %s on %s",
ifp->name,
inet_ntoa(lease->addr),
ifn->name);
return;
}
- logger(ifp->ctx, LOG_INFO, "%s: preferring %s on %s",
+ syslog(LOG_INFO, "%s: preferring %s on %s",
ifn->name,
inet_ntoa(lease->addr),
ifp->name);
if (ia &&
ia->mask.s_addr == lease->mask.s_addr &&
ia->brd.s_addr == lease->brd.s_addr)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: IP address %s already exists",
+ syslog(LOG_DEBUG, "%s: IP address %s already exists",
ifp->name, ia->saddr);
else {
#if __linux__
ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
if (ia == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: added address vanished",
+ syslog(LOG_ERR, "%s: added address vanished",
ifp->name);
return;
}
case RTM_NEWADDR:
if (ia == NULL) {
if ((ia = malloc(sizeof(*ia))) == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
ia->iface = ifp;
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#define ELOOP_QUEUE 6
#ifdef IN_IFF_NOTREADY
if (ia == NULL || ia->addr_flags & IN_IFF_NOTREADY)
#endif
- logger(ifp->ctx, LOG_INFO, "%s: using IPv4LL address %s",
+ syslog(LOG_INFO, "%s: using IPv4LL address %s",
ifp->name, inet_ntoa(astate->addr));
if (ia == NULL) {
if (ifp->ctx->options & DHCPCD_TEST)
#ifdef IN_IFF_NOTREADY
if (ia->addr_flags & IN_IFF_NOTREADY)
return;
- logger(ifp->ctx, LOG_DEBUG, "%s: DAD completed for %s",
+ syslog(LOG_DEBUG, "%s: DAD completed for %s",
ifp->name, inet_ntoa(astate->addr));
#endif
test:
astate->failed.s_addr == state->addr->addr.s_addr)
{
#ifdef KERNEL_RFC5227
- logger(ifp->ctx, LOG_WARNING,
- "%s: IPv4LL defence failed for %s",
+ syslog(LOG_WARNING, "%s: IPv4LL defence failed for %s",
ifp->name, state->addr->saddr);
#else
struct timespec now, defend;
defend.tv_nsec = state->defend.tv_nsec;
clock_gettime(CLOCK_MONOTONIC, &now);
if (timespeccmp(&defend, &now, >))
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: IPv4LL %d second defence failed for %s",
ifp->name, DEFEND_INTERVAL, state->addr->saddr);
else if (arp_request(ifp,
state->addr->addr.s_addr, state->addr->addr.s_addr) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: arp_request: %m", __func__);
+ syslog(LOG_ERR, "%s: arp_request: %m", __func__);
else {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: defended IPv4LL address %s",
+ syslog(LOG_DEBUG, "%s: defended IPv4LL address %s",
ifp->name, state->addr->saddr);
state->defend = now;
return;
arp_cancel(astate);
if (++state->conflicts == MAX_CONFLICTS)
- logger(ifp->ctx, LOG_ERR,
- "%s: failed to acquire an IPv4LL address",
+ syslog(LOG_ERR, "%s: failed to acquire an IPv4LL address",
ifp->name);
astate->addr.s_addr = ipv4ll_pickaddr(astate);
eloop_timeout_add_sec(ifp->ctx->eloop,
astate->addr = ia->addr;
#ifdef IN_IFF_TENTATIVE
if (ia->addr_flags & (IN_IFF_TENTATIVE | IN_IFF_DETACHED)) {
- logger(ifp->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: waiting for DAD to complete on %s",
ifp->name, inet_ntoa(ia->addr));
return;
}
- logger(ifp->ctx, LOG_INFO, "%s: using IPv4LL address %s",
- ifp->name, ia->saddr);
+ syslog(LOG_INFO, "%s: using IPv4LL address %s",
+ ifp->name, ia->saddr);
#endif
ipv4ll_probed(astate);
return;
}
- logger(ifp->ctx, LOG_INFO, "%s: probing for an IPv4LL address",
- ifp->name);
+ syslog(LOG_INFO, "%s: probing for an IPv4LL address", ifp->name);
astate->addr.s_addr = ipv4ll_pickaddr(astate);
#ifdef IN_IFF_TENTATIVE
ipv4ll_probed(astate);
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#define ELOOP_QUEUE 7
return (ssize_t)ctx->secret_len;
if (errno != ENOENT)
- logger(ctx, LOG_ERR, "error reading secret: %s: %m", SECRET);
+ syslog(LOG_ERR, "error reading secret: %s: %m", SECRET);
/* Chaining arc4random should be good enough.
* RFC7217 section 5.1 states the key SHOULD be at least 128 bits.
* 512 bits (64 bytes). */
if (ctx->secret_len < 64) {
if ((ctx->secret = malloc(64)) == NULL) {
- logger(ctx, LOG_ERR, "%s: malloc: %m", __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
return -1;
}
ctx->secret_len = 64;
return (ssize_t)ctx->secret_len;
eexit:
- logger(ctx, LOG_ERR, "error writing secret: %s: %m", SECRET);
+ syslog(LOG_ERR, "error writing secret: %s: %m", SECRET);
if (fp != NULL)
fclose(fp);
unlink(SECRET);
alias = NULL;
#endif
if ((flags = if_addrflags6(ia->iface, &ia->addr, alias)) == -1) {
- logger(ia->iface->ctx, LOG_ERR,
- "%s: if_addrflags6: %m", ia->iface->name);
+ syslog(LOG_ERR, "%s: if_addrflags6: %m", ia->iface->name);
return;
}
struct ipv6_state *state;
struct ipv6_addr *ap;
- logger(ia->iface->ctx, LOG_INFO, "%s: deleting address %s",
- ia->iface->name, ia->saddr);
+ syslog(LOG_INFO, "%s: deleting address %s", ia->iface->name, ia->saddr);
if (if_address6(RTM_DELADDR, ia) == -1 &&
errno != EADDRNOTAVAIL && errno != ESRCH &&
errno != ENXIO && errno != ENODEV)
- logger(ia->iface->ctx, LOG_ERR, "if_address6: %m");
+ syslog(LOG_ERR, "if_address6: %m");
/* NOREJECT is set if we delegated exactly the prefix to another
* address.
ipv6_iffindaddr(ap->iface, &ap->addr, IN6_IFF_NOTUSEABLE))
ap->flags |= IPV6_AF_DADCOMPLETED;
- logger(ap->iface->ctx, ap->flags & IPV6_AF_NEW ? LOG_INFO : LOG_DEBUG,
+ syslog(ap->flags & IPV6_AF_NEW ? LOG_INFO : LOG_DEBUG,
"%s: adding %saddress %s", ap->iface->name,
#ifdef IPV6_AF_TEMPORARY
ap->flags & IPV6_AF_TEMPORARY ? "temporary " : "",
ap->saddr);
if (ap->prefix_pltime == ND6_INFINITE_LIFETIME &&
ap->prefix_vltime == ND6_INFINITE_LIFETIME)
- logger(ap->iface->ctx, LOG_DEBUG,
- "%s: pltime infinity, vltime infinity",
+ syslog(LOG_DEBUG, "%s: pltime infinity, vltime infinity",
ap->iface->name);
else if (ap->prefix_pltime == ND6_INFINITE_LIFETIME)
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: pltime infinity, vltime %"PRIu32" seconds",
ap->iface->name, ap->prefix_vltime);
else if (ap->prefix_vltime == ND6_INFINITE_LIFETIME)
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: pltime %"PRIu32"seconds, vltime infinity",
ap->iface->name, ap->prefix_pltime);
else
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: pltime %"PRIu32" seconds, vltime %"PRIu32" seconds",
ap->iface->name, ap->prefix_pltime, ap->prefix_vltime);
ap->prefix_vltime -= (uint32_t)n.tv_sec;
#if 0
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: acquired %lld.%.9ld, now %lld.%.9ld, diff %lld.%.9ld",
ap->iface->name,
(long long)ap->acquired.tv_sec, ap->acquired.tv_nsec,
(long long)now->tv_sec, now->tv_nsec,
(long long)n.tv_sec, n.tv_nsec);
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: adj pltime %"PRIu32" seconds, "
"vltime %"PRIu32" seconds",
ap->iface->name, ap->prefix_pltime, ap->prefix_vltime);
}
if (if_address6(RTM_NEWADDR, ap) == -1) {
- logger(ap->iface->ctx, LOG_ERR, "if_addaddress6: %m");
+ syslog(LOG_ERR, "if_addaddress6: %m");
/* Restore real pltime and vltime */
ap->prefix_pltime = pltime;
ap->prefix_vltime = vltime;
if ((replaced = ipv6_aliasaddr(ia, &replaced_ia)) == -1)
return -1;
if (blank)
- logger(ia->iface->ctx, LOG_DEBUG, "%s: aliased %s",
- ia->alias, ia->saddr);
+ syslog(LOG_DEBUG, "%s: aliased %s", ia->alias, ia->saddr);
#endif
if ((r = ipv6_addaddr1(ia, now)) == 0) {
&ap->addr, IPV6_AF_ADDED);
if (apf && apf->iface != ap->iface) {
if (apf->iface->metric <= ap->iface->metric) {
- logger(apf->iface->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: preferring %s on %s",
ap->iface->name,
ap->saddr,
apf->iface->name);
continue;
}
- logger(apf->iface->ctx, LOG_INFO,
+ syslog(LOG_INFO,
"%s: preferring %s on %s",
apf->iface->name,
ap->saddr,
ap->iface->name);
if (if_address6(RTM_DELADDR, apf) == -1 &&
errno != EADDRNOTAVAIL && errno != ENXIO)
- logger(apf->iface->ctx, LOG_ERR,
- "if_address6: %m");
+ syslog(LOG_ERR, "if_address6: %m");
apf->flags &=
~(IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED);
} else if (apf)
ifp->if_data[IF_DATA_IPV6] = calloc(1, sizeof(*state));
state = IPV6_STATE(ifp);
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
TAILQ_INIT(&state->addrs);
dbp = inet_ntop(AF_INET6, &addr->s6_addr,
dbuf, INET6_ADDRSTRLEN);
- logger(ctx, LOG_INFO, "%s: cmd %d addr %s",
+ syslog(LOG_INFO, "%s: cmd %d addr %s",
ifname, cmd, dbp);
#endif
const char *cbp;
if ((ia = calloc(1, sizeof(*ia))) == NULL) {
- logger(ctx, LOG_ERR,
- "%s: calloc: %m", __func__);
+ syslog(LOG_ERR, "%s: calloc: %m", __func__);
break;
}
#ifdef ALIAS_ADDR
if (cb == NULL) {
cb = malloc(sizeof(*cb));
if (cb == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return -1;
}
cb->callback = callback;
return -1;
}
- logger(ap2->iface->ctx, LOG_WARNING,
- "%s: waiting for %s to complete",
+ syslog(LOG_WARNING, "%s: waiting for %s to complete",
ap2->iface->name, ap2->saddr);
free(ap);
errno = EEXIST;
wascompleted = (ia->flags & IPV6_AF_DADCOMPLETED);
ia->flags |= IPV6_AF_DADCOMPLETED;
if (ia->flags & IPV6_AF_DUPLICATED)
- logger(ia->iface->ctx, LOG_WARNING, "%s: DAD detected %s",
- ia->iface->name, ia->saddr);
+ syslog(LOG_WARNING, "%s: DAD detected %s", ia->iface->name,
+ ia->saddr);
else if (!wascompleted) {
- logger(ia->iface->ctx, LOG_DEBUG, "%s: IPv6 static DAD completed",
+ syslog(LOG_DEBUG, "%s: IPv6 static DAD completed",
ia->iface->name);
}
ep = env;
n = 0;
- ia = ipv6_iffindaddr(UNCONST(ifp), &ifp->options->req_addr6, IN6_IFF_NOTUSEABLE);
+ ia = ipv6_iffindaddr(UNCONST(ifp), &ifp->options->req_addr6,
+ IN6_IFF_NOTUSEABLE);
if (ia) {
if (env)
- addvar(ifp->ctx, &ep, prefix, "ip6_address", ia->saddr);
+ addvar(&ep, prefix, "ip6_address", ia->saddr);
n++;
}
switch (cmd) {
case RTM_DELADDR:
if (ia->flags & IPV6_AF_ADDED) {
- logger(ia->iface->ctx, LOG_INFO,
- "%s: deleted address %s",
+ syslog(LOG_INFO, "%s: deleted address %s",
ia->iface->name, ia->saddr);
ia->flags &= ~IPV6_AF_ADDED;
}
struct timespec tv;
if (++ia->dadcounter == TEMP_IDGEN_RETRIES) {
- logger(ia->iface->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: too many duplicate temporary addresses",
ia->iface->name);
return;
}
clock_gettime(CLOCK_MONOTONIC, &tv);
if ((ia1 = ipv6_createtempaddr(ia, &tv)) == NULL)
- logger(ia->iface->ctx, LOG_ERR,
- "ipv6_createtempaddr: %m");
+ syslog(LOG_ERR, "ipv6_createtempaddr: %m");
else
ia1->dadcounter = ia->dadcounter;
ipv6_deleteaddr(ia);
struct ipv6_addr *ia = arg, *ia1;
struct timespec tv;
- logger(ia->iface->ctx, LOG_DEBUG, "%s: regen temp addr %s",
- ia->iface->name, ia->saddr);
+ syslog(LOG_DEBUG, "%s: regen temp addr %s", ia->iface->name, ia->saddr);
clock_gettime(CLOCK_MONOTONIC, &tv);
ia1 = ipv6_createtempaddr(ia, &tv);
if (ia1)
ipv6_addaddr(ia1, &tv);
else
- logger(ia->iface->ctx, LOG_ERR, "ipv6_createtempaddr: %m");
+ syslog(LOG_ERR, "ipv6_createtempaddr: %m");
}
static void
break;
}
if (lo0 == NULL)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"cannot find a loopback interface to reject via");
else
ifp = lo0;
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#define ELOOP_QUEUE 3
struct in6_pktinfo pi;
if (ipv6_linklocal(ifp) == NULL) {
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: delaying Router Solicitation for LL address",
ifp->name);
ipv6_addlinklocalcallback(ifp, ipv6nd_sendrsprobe, ifp);
#endif
dst.sin6_scope_id = ifp->index;
if (inet_pton(AF_INET6, ALLROUTERS, &dst.sin6_addr) != 1) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
pi.ipi6_ifindex = ifp->index;
memcpy(CMSG_DATA(cm), &pi, sizeof(pi));
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: sending Router Solicitation", ifp->name);
if (sendmsg(ctx->nd_fd, &ctx->sndhdr, 0) == -1) {
- logger(ifp->ctx, LOG_ERR,
- "%s: %s: sendmsg: %m", ifp->name, __func__);
+ syslog(LOG_ERR, "%s: %s: sendmsg: %m", ifp->name, __func__);
/* Allow IPv6ND to continue .... at most a few errors
* would be logged.
* Generally the error is ENOBUFS when struggling to
eloop_timeout_add_sec(ifp->ctx->eloop,
RTR_SOLICITATION_INTERVAL, ipv6nd_sendrsprobe, ifp);
else {
- logger(ifp->ctx, LOG_WARNING,
- "%s: no IPv6 Routers available", ifp->name);
+ syslog(LOG_WARNING, "%s: no IPv6 Routers available", ifp->name);
ipv6nd_drop(ifp);
dhcp6_dropnondelegates(ifp);
}
if (flags & IPV6ND_REACHABLE) {
if (rap->lifetime && rap->expired) {
- logger(rap->iface->ctx, LOG_INFO,
- "%s: %s is reachable again",
+ syslog(LOG_INFO, "%s: %s is reachable again",
rap->iface->name, rap->sfrom);
rap->expired = 0;
rt_build(rap->iface->ctx, AF_INET6);
}
} else {
if (rap->lifetime && !rap->expired) {
- logger(rap->iface->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: %s is unreachable, expiring it",
rap->iface->name, rap->sfrom);
rap->expired = 1;
case ND_RA_FLAG_RTPREF_LOW:
return (RTPREF_LOW);
default:
- logger(rap->iface->ctx, LOG_ERR,
- "rtpref: impossible RA flag %x", rap->flags);
+ syslog(LOG_ERR, "rtpref: impossible RA flag %x", rap->flags);
return (RTPREF_INVALID);
}
/* NOTREACHED */
{
hasaddress = 1;
if (!(ap->flags & IPV6_AF_DADCOMPLETED) &&
- ipv6_iffindaddr(ap->iface, &ap->addr, IN6_IFF_TENTATIVE))
+ ipv6_iffindaddr(ap->iface, &ap->addr,
+ IN6_IFF_TENTATIVE))
ap->flags |= IPV6_AF_DADCOMPLETED;
if ((ap->flags & IPV6_AF_DADCOMPLETED) == 0) {
- logger(ap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: waiting for Router Advertisement"
" DAD to complete",
rap->iface->name);
#if 0
else if (options & DHCPCD_DAEMONISE &&
!(options & DHCPCD_DAEMONISED) && new_data)
- logger(rap->iface->ctx, LOG_WARNING,
- "%s: did not fork due to an absent"
+ syslog(LOG_WARNING, "%s: did not fork due to an absent"
" RDNSS option in the RA",
ifp->name);
}
ap->flags |= IPV6_AF_DADCOMPLETED;
if (ap->flags & IPV6_AF_DUPLICATED) {
ap->dadcounter++;
- logger(ifp->ctx, LOG_WARNING, "%s: DAD detected %s",
+ syslog(LOG_WARNING, "%s: DAD detected %s",
ifp->name, ap->saddr);
/* Try and make another stable private address.
/* XXX Cache DAD counter per prefix/id/ssid? */
if (ifp->options->options & DHCPCD_SLAACPRIVATE) {
if (ap->dadcounter >= IDGEN_RETRIES) {
- logger(ifp->ctx, LOG_ERR,
- "%s: unable to obtain a"
+ syslog(LOG_ERR, "%s: unable to obtain a"
" stable private address",
ifp->name);
goto try_script;
}
- logger(ifp->ctx, LOG_INFO, "%s: deleting address %s",
- ifp->name, ap->saddr);
+ syslog(LOG_INFO, "%s: deleting address %s",
+ ifp->name, ap->saddr);
if (if_address6(RTM_DELADDR, ap) == -1 &&
errno != EADDRNOTAVAIL && errno != ENXIO)
- logger(ifp->ctx, LOG_ERR, "if_address6: %m");
+ syslog(LOG_ERR, "if_address6: %m");
dadcounter = ap->dadcounter;
if (ipv6_makestableprivate(&ap->addr,
&ap->prefix, ap->prefix_len,
ifp, &dadcounter) == -1)
{
- logger(ifp->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"%s: ipv6_makestableprivate: %m",
ifp->name);
return;
}
if (wascompleted && found) {
- logger(rap->iface->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: Router Advertisement DAD completed",
rap->iface->name);
if (ipv6nd_scriptrun(rap))
if (ifp == NULL) {
#ifdef DEBUG_RS
- logger(ctx, LOG_DEBUG,
- "RA for unexpected interface from %s", ctx->sfrom);
+ syslog(LOG_DEBUG, "RA for unexpected interface from %s",
+ ctx->sfrom);
#endif
return;
}
if (len < sizeof(struct nd_router_advert)) {
- logger(ctx, LOG_ERR,
- "IPv6 RA packet too short from %s", ctx->sfrom);
+ syslog(LOG_ERR, "IPv6 RA packet too short from %s", ctx->sfrom);
return;
}
/* RFC 4861 7.1.2 */
if (hoplimit != 255) {
- logger(ctx, LOG_ERR,
- "invalid hoplimit(%d) in RA from %s", hoplimit, ctx->sfrom);
+ syslog(LOG_ERR, "invalid hoplimit(%d) in RA from %s",
+ hoplimit, ctx->sfrom);
return;
}
if (!IN6_IS_ADDR_LINKLOCAL(&ctx->from.sin6_addr)) {
- logger(ctx, LOG_ERR,
- "RA from non local address %s", ctx->sfrom);
+ syslog(LOG_ERR, "RA from non local address %s", ctx->sfrom);
return;
}
if (!(ifp->options->options & DHCPCD_IPV6RS)) {
#ifdef DEBUG_RS
- logger(ifp->ctx, LOG_DEBUG, "%s: unexpected RA from %s",
+ syslog(LOG_DEBUG, "%s: unexpected RA from %s",
ifp->name, ctx->sfrom);
#endif
return;
/* We could receive a RA before we sent a RS*/
if (ipv6_linklocal(ifp) == NULL) {
#ifdef DEBUG_RS
- logger(ifp->ctx, LOG_DEBUG,
- "%s: received RA from %s (no link-local)",
+ syslog(LOG_DEBUG, "%s: received RA from %s (no link-local)",
ifp->name, ctx->sfrom);
#endif
return;
}
if (ipv6_iffindaddr(ifp, &ctx->from.sin6_addr, IN6_IFF_TENTATIVE)) {
- logger(ifp->ctx, LOG_DEBUG,
- "%s: ignoring RA from ourself %s", ifp->name, ctx->sfrom);
+ syslog(LOG_DEBUG, "%s: ignoring RA from ourself %s",
+ ifp->name, ctx->sfrom);
return;
}
if (rap == NULL) {
rap = calloc(1, sizeof(*rap));
if (rap == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
rap->iface = ifp;
if (rap->data_len == 0) {
rap->data = malloc(len);
if (rap->data == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
if (new_rap)
free(rap);
return;
* routers like to decrease the advertised valid and preferred times
* in accordance with the own prefix times which would result in too
* much needless log spam. */
- logger(ifp->ctx, new_rap ? LOG_INFO : LOG_DEBUG,
+ syslog(new_rap ? LOG_INFO : LOG_DEBUG,
"%s: Router Advertisement from %s",
ifp->name, ctx->sfrom);
p = ((uint8_t *)icp) + sizeof(struct nd_router_advert);
for (; len > 0; p += olen, len -= olen) {
if (len < sizeof(ndo)) {
- logger(ifp->ctx, LOG_ERR,
- "%s: short option", ifp->name);
+ syslog(LOG_ERR, "%s: short option", ifp->name);
break;
}
memcpy(&ndo, p, sizeof(ndo));
olen = (size_t)ndo.nd_opt_len * 8;
if (olen == 0) {
- logger(ifp->ctx, LOG_ERR,
- "%s: zero length option", ifp->name);
+ syslog(LOG_ERR, "%s: zero length option", ifp->name);
break;
}
if (olen > len) {
- logger(ifp->ctx, LOG_ERR,
- "%s: option length exceeds message", ifp->name);
+ syslog(LOG_ERR, "%s: option length exceeds message",
+ ifp->name);
break;
}
break;
}
if (dho != NULL)
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: reject RA (option %s) from %s",
ifp->name, dho->var, ctx->sfrom);
else
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: reject RA (option %d) from %s",
ifp->name, ndo.nd_opt_type, ctx->sfrom);
if (new_rap)
switch (ndo.nd_opt_type) {
case ND_OPT_PREFIX_INFORMATION:
if (ndo.nd_opt_len != 4) {
- logger(ifp->ctx, new_data ? LOG_ERR : LOG_DEBUG,
+ syslog(new_data ? LOG_ERR : LOG_DEBUG,
"%s: invalid option len for prefix",
ifp->name);
continue;
}
memcpy(&pi, p, sizeof(pi));
if (pi.nd_opt_pi_prefix_len > 128) {
- logger(ifp->ctx, new_data ? LOG_ERR : LOG_DEBUG,
+ syslog(new_data ? LOG_ERR : LOG_DEBUG,
"%s: invalid prefix len",
ifp->name);
continue;
}
/* nd_opt_pi_prefix is not aligned. */
- memcpy(&pi_prefix, &pi.nd_opt_pi_prefix, sizeof(pi_prefix));
+ memcpy(&pi_prefix, &pi.nd_opt_pi_prefix,
+ sizeof(pi_prefix));
if (IN6_IS_ADDR_MULTICAST(&pi_prefix) ||
IN6_IS_ADDR_LINKLOCAL(&pi_prefix))
{
- logger(ifp->ctx, new_data ? LOG_ERR : LOG_DEBUG,
+ syslog(new_data ? LOG_ERR : LOG_DEBUG,
"%s: invalid prefix in RA", ifp->name);
continue;
}
if (ntohl(pi.nd_opt_pi_preferred_time) >
ntohl(pi.nd_opt_pi_valid_time))
{
- logger(ifp->ctx, new_data ? LOG_ERR : LOG_DEBUG,
+ syslog(new_data ? LOG_ERR : LOG_DEBUG,
"%s: pltime > vltime", ifp->name);
continue;
}
if (new_ap && ap->prefix_pltime) {
if (ipv6_createtempaddr(ap,
&ap->acquired) == NULL)
- logger(ap->iface->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"ipv6_createtempaddr: %m");
}
}
memcpy(&mtu, p, sizeof(mtu));
mtu.nd_opt_mtu_mtu = ntohl(mtu.nd_opt_mtu_mtu);
if (mtu.nd_opt_mtu_mtu < IPV6_MMTU) {
- logger(ifp->ctx, LOG_ERR, "%s: invalid MTU %d",
+ syslog(LOG_ERR, "%s: invalid MTU %d",
ifp->name, mtu.nd_opt_mtu_mtu);
break;
}
if (has_option_mask(ifp->options->requiremasknd,
dho->option))
{
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: reject RA (no option %s) from %s",
ifp->name, dho->var, ctx->sfrom);
if (new_rap)
#endif
if (rap->flags & ND_RA_FLAG_MANAGED) {
if (new_data && dhcp6_start(ifp, DH6S_INIT) == -1)
- logger(ifp->ctx, LOG_DHCP6,
- "dhcp6_start: %s: %m", ifp->name);
+ syslog(LOG_DHCP6, "dhcp6_start: %s: %m", ifp->name);
} else if (rap->flags & ND_RA_FLAG_OTHER) {
if (new_data && dhcp6_start(ifp, DH6S_INFORM) == -1)
- logger(ifp->ctx, LOG_DHCP6,
- "dhcp6_start: %s: %m", ifp->name);
+ syslog(LOG_DHCP6, "dhcp6_start: %s: %m", ifp->name);
} else {
if (new_data)
- logger(ifp->ctx, LOG_DEBUG,
- "%s: No DHCPv6 instruction in RA", ifp->name);
+ syslog(LOG_DEBUG, "%s: No DHCPv6 instruction in RA",
+ ifp->name);
nodhcp6:
if (ifp->ctx->options & DHCPCD_TEST) {
eloop_exit(ifp->ctx->eloop, EXIT_SUCCESS);
snprintf(ndprefix, sizeof(ndprefix),
"nd%zu", i);
if (env)
- setvar(rap->iface->ctx, &env[n], ndprefix,
- "from", rap->sfrom);
+ setvar(&env[n], ndprefix, "from", rap->sfrom);
n++;
if (env)
- setvard(rap->iface->ctx, &env[n], ndprefix,
- "acquired", (size_t)rap->acquired.tv_sec);
+ setvard(&env[n], ndprefix, "acquired",
+ (size_t)rap->acquired.tv_sec);
n++;
if (env)
- setvard(rap->iface->ctx, &env[n], ndprefix,
- "now", (size_t)now.tv_sec);
+ setvard(&env[n], ndprefix, "now", (size_t)now.tv_sec);
n++;
/* Zero our indexes */
j++;
if (env) {
snprintf(abuf, sizeof(abuf), "addr%zu", j);
- setvar(rap->iface->ctx, &env[n], ndprefix,
- abuf, ia->saddr);
+ setvar(&env[n], ndprefix, abuf, ia->saddr);
}
n++;
}
if (rap->lifetime == 0 || timespeccmp(&now, &expire, >))
{
if (!rap->expired) {
- logger(ifp->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: %s: router expired",
ifp->name, rap->sfrom);
rap->expired = expired = 1;
timespecadd(&ia->acquired, <, &expire);
if (timespeccmp(&now, &expire, >)) {
if (ia->flags & IPV6_AF_ADDED) {
- logger(ia->iface->ctx, LOG_WARNING,
+ syslog(LOG_WARNING,
"%s: expired address %s",
ia->iface->name, ia->saddr);
if (if_address6(RTM_DELADDR, ia)== -1 &&
errno != EADDRNOTAVAIL &&
errno != ENXIO)
- logger(ia->iface->ctx, LOG_ERR,
+ syslog(LOG_ERR,
"if_address6: %m");
}
ia->prefix_vltime = ia->prefix_pltime = 0;
if (ifp == NULL) {
#ifdef DEBUG_NS
- logger(ctx, LOG_DEBUG, "NA for unexpected interface from %s",
+ syslog(LOG_DEBUG, "NA for unexpected interface from %s",
ctx->sfrom);
#endif
return;
}
if ((size_t)len < sizeof(struct nd_neighbor_advert)) {
- logger(ifp->ctx, LOG_ERR, "%s: IPv6 NA too short from %s",
+ syslog(LOG_ERR, "%s: IPv6 NA too short from %s",
ifp->name, ctx->sfrom);
return;
}
/* RFC 4861 7.1.2 */
if (hoplimit != 255) {
- logger(ctx, LOG_ERR,
- "invalid hoplimit(%d) in NA from %s", hoplimit, ctx->sfrom);
+ syslog(LOG_ERR, "invalid hoplimit(%d) in NA from %s",
+ hoplimit, ctx->sfrom);
return;
}
/* nd_na->nd_na_target is not aligned. */
memcpy(&nd_na_target, &nd_na->nd_na_target, sizeof(nd_na_target));
if (IN6_IS_ADDR_MULTICAST(&nd_na_target)) {
- logger(ifp->ctx, LOG_ERR, "%s: NA multicast address %s (%s)",
+ syslog(LOG_ERR, "%s: NA multicast address %s (%s)",
ifp->name, taddr, ctx->sfrom);
return;
}
}
if (rap == NULL) {
#ifdef DEBUG_NS
- logger(ifp->ctx, LOG_DEBUG, "%s: unexpected NA from %s for %s",
+ syslog(LOG_DEBUG, "%s: unexpected NA from %s for %s",
ifp->name, ctx->sfrom, taddr);
#endif
return;
}
#ifdef DEBUG_NS
- logger(ifp->ctx, LOG_DEBUG, "%s: %sNA for %s from %s",
+ syslog(LOG_DEBUG, "%s: %sNA for %s from %s",
ifp->name, is_solicited ? "solicited " : "", taddr, ctx->sfrom);
#endif
/* Node is no longer a router, so remove it from consideration */
if (!is_router && !rap->expired) {
- logger(ifp->ctx, LOG_INFO, "%s: %s not a router (%s)",
+ syslog(LOG_INFO, "%s: %s not a router (%s)",
ifp->name, taddr, ctx->sfrom);
rap->expired = 1;
rt_build(ifp->ctx, AF_INET6);
if (is_solicited && is_router && rap->lifetime) {
if (rap->expired) {
rap->expired = 0;
- logger(ifp->ctx, LOG_INFO, "%s: %s reachable (%s)",
+ syslog(LOG_INFO, "%s: %s reachable (%s)",
ifp->name, taddr, ctx->sfrom);
rt_build(ifp->ctx, AF_INET6);
script_runreason(rap->iface, "ROUTERADVERT"); /* XXX */
CMSG_SPACE(sizeof(int));
len = recvmsg_realloc(ctx->nd_fd, &ctx->rcvhdr, 0);
if (len == -1) {
- logger(ctx, LOG_ERR, "recvmsg: %m");
+ syslog(LOG_ERR, "recvmsg: %m");
eloop_event_delete(ctx->eloop, ctx->nd_fd);
close(ctx->nd_fd);
ctx->nd_fd = -1;
ctx->sfrom = inet_ntop(AF_INET6, &ctx->from.sin6_addr,
ctx->ntopbuf, INET6_ADDRSTRLEN);
if ((size_t)len < sizeof(struct icmp6_hdr)) {
- logger(ctx, LOG_ERR, "IPv6 ICMP packet too short from %s",
+ syslog(LOG_ERR, "IPv6 ICMP packet too short from %s",
ctx->sfrom);
return;
}
}
if (pkt.ipi6_ifindex == 0) {
- logger(ctx, LOG_ERR,
- "IPv6 RA/NA did not contain index from %s",
+ syslog(LOG_ERR, "IPv6 RA/NA did not contain index from %s",
ctx->sfrom);
return;
}
}
}
- logger(ctx, LOG_ERR, "invalid IPv6 type %d or code %d from %s",
+ syslog(LOG_ERR, "invalid IPv6 type %d or code %d from %s",
icp->icmp6_type, icp->icmp6_code, ctx->sfrom);
}
struct interface *ifp = arg;
struct rs_state *state;
- logger(ifp->ctx, LOG_INFO, "%s: soliciting an IPv6 router", ifp->name);
+ syslog(LOG_INFO, "%s: soliciting an IPv6 router", ifp->name);
if (ipv6nd_open(ifp->ctx) == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: ipv6nd_open: %m", __func__);
+ syslog(LOG_ERR, "%s: ipv6nd_open: %m", __func__);
return;
}
ifp->if_data[IF_DATA_IPV6ND] = calloc(1, sizeof(*state));
state = RS_STATE(ifp);
if (state == NULL) {
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return;
}
}
* address could have changed. */
ipv6nd_makersprobe(ifp);
if (state->rs == NULL) {
- logger(ifp->ctx, LOG_ERR,
- "%s: ipv6ns_makersprobe: %m", __func__);
+ syslog(LOG_ERR, "%s: ipv6ns_makersprobe: %m", __func__);
return;
}
tv.tv_nsec = (suseconds_t)arc4random_uniform(
MAX_RTR_SOLICITATION_DELAY * NSEC_PER_SEC);
timespecnorm(&tv);
- logger(ifp->ctx, LOG_DEBUG,
+ syslog(LOG_DEBUG,
"%s: delaying IPv6 router solicitation for %0.1f seconds",
ifp->name, timespec_to_double(&tv));
eloop_timeout_add_tv(ifp->ctx->eloop, &tv, ipv6nd_startrs1, ifp);
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include "config.h"
{
char dest[INET_MAX_ADDRSTRLEN], gateway[INET_MAX_ADDRSTRLEN];
int prefix;
- struct dhcpcd_ctx *ctx;
const char *ifname;
bool gateway_unspec;
assert(rt != NULL);
assert(rt->rt_ifp != NULL);
- ctx = rt->rt_ifp->ctx;
ifname = rt->rt_ifp->name;
sa_addrtop(&rt->rt_dest, dest, sizeof(dest));
prefix = sa_toprefix(&rt->rt_netmask);
if (rt->rt_flags & RTF_HOST) {
if (gateway_unspec)
- logger(ctx, LOG_INFO, "%s: %s host route to %s",
+ syslog(LOG_INFO, "%s: %s host route to %s",
ifname, cmd, dest);
else
- logger(ctx, LOG_INFO, "%s: %s host route to %s via %s",
+ syslog(LOG_INFO, "%s: %s host route to %s via %s",
ifname, cmd, dest, gateway);
} else if (sa_is_unspecified(&rt->rt_dest) &&
sa_is_unspecified(&rt->rt_netmask))
{
if (gateway_unspec)
- logger(ctx, LOG_INFO, "%s: %s default route",
+ syslog(LOG_INFO, "%s: %s default route",
ifname, cmd);
else
- logger(ctx, LOG_INFO, "%s: %s default route via %s",
+ syslog(LOG_INFO, "%s: %s default route via %s",
ifname, cmd, gateway);
} else if (gateway_unspec)
- logger(ctx, LOG_INFO, "%s: %s%s route to %s/%d",
+ syslog(LOG_INFO, "%s: %s%s route to %s/%d",
ifname, cmd,
rt->rt_flags & RTF_REJECT ? " reject" : "",
dest, prefix);
else
- logger(ctx, LOG_INFO, "%s: %s%s route to %s/%d via %s",
+ syslog(LOG_INFO, "%s: %s%s route to %s/%d via %s",
ifname, cmd,
rt->rt_flags & RTF_REJECT ? " reject" : "",
dest, prefix, gateway);
if ((rt = TAILQ_FIRST(&ctx->froutes)) != NULL)
TAILQ_REMOVE(&ctx->froutes, rt, rt_next);
else if ((rt = malloc(sizeof(*rt))) == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
memset(rt, 0, sizeof(*rt));
if (if_route(RTM_CHANGE, nrt) != -1)
return true;
if (errno != ESRCH)
- logger(ctx, LOG_ERR, "if_route (CHG): %m");
+ syslog(LOG_ERR, "if_route (CHG): %m");
}
#ifdef HAVE_ROUTE_METRIC
if (if_route(RTM_ADD, nrt) != -1) {
if (ort != NULL) {
if (if_route(RTM_DELETE, ort) == -1 && errno != ESRCH)
- logger(ctx, LOG_ERR, "if_route (DEL): %m");
+ syslog(LOG_ERR, "if_route (DEL): %m");
rt_kfree(ort);
}
return true;
#endif
if (ort != NULL) {
if (if_route(RTM_DELETE, ort) == -1 && errno != ESRCH)
- logger(ctx, LOG_ERR, "if_route (DEL): %m");
+ syslog(LOG_ERR, "if_route (DEL): %m");
else
rt_kfree(ort);
}
#ifdef HAVE_ROUTE_METRIC
logerr:
#endif
- logger(ctx, LOG_ERR, "if_route (ADD): %m");
+ syslog(LOG_ERR, "if_route (ADD): %m");
return false;
}
rt_desc("deleting", rt);
retval = if_route(RTM_DELETE, rt) == -1 ? false : true;
if (!retval && errno != ENOENT && errno != ESRCH)
- logger(rt->rt_ifp->ctx, LOG_ERR,
- "%s: if_delroute: %m", rt->rt_ifp->name);
+ syslog(LOG_ERR, "%s: if_delroute: %m", rt->rt_ifp->name);
/* Remove the route from our kernel table so we can add a
* IPv4LL default route if possible. */
else
#include <spawn.h>
#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include "config.h"
#ifdef INET
static char *
-make_var(struct dhcpcd_ctx *ctx, const char *prefix, const char *var)
+make_var(const char *prefix, const char *var)
{
size_t len;
char *v;
len = strlen(prefix) + strlen(var) + 2;
if ((v = malloc(len)) == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
return NULL;
}
snprintf(v, len, "%s_%s", prefix, var);
static int
-append_config(struct dhcpcd_ctx *ctx, char ***env, size_t *len,
+append_config(char ***env, size_t *len,
const char *prefix, const char *const *config)
{
size_t i, j, e1;
strncmp(ne[j] + strlen(prefix) + 1,
config[i], e1) == 0)
{
- p = make_var(ctx, prefix, config[i]);
+ p = make_var(prefix, config[i]);
if (p == NULL) {
ret = -1;
break;
}
if (j == *len) {
j++;
- p = make_var(ctx, prefix, config[i]);
+ p = make_var(prefix, config[i]);
if (p == NULL) {
ret = -1;
break;
}
nep = realloc(ne, sizeof(char *) * (j + 1));
if (nep == NULL) {
- logger(ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
free(p);
ret = -1;
break;
goto eexit;
elen += (size_t)n;
}
- if (append_config(ifp->ctx, &env, &elen, "old",
+ if (append_config(&env, &elen, "old",
(const char *const *)ifo->config) == -1)
goto eexit;
}
goto eexit;
elen += (size_t)n;
}
- if (append_config(ifp->ctx, &env, &elen, "new",
+ if (append_config(&env, &elen, "new",
(const char *const *)ifo->config) == -1)
goto eexit;
}
return (ssize_t)elen;
eexit:
- logger(ifp->ctx, LOG_ERR, "%s: %m", __func__);
+ syslog(LOG_ERR, "%s: %m", __func__);
if (env) {
nenv = env;
while (*nenv)
/* Make our env */
elen = (size_t)make_env(ifp, reason, &env);
if (elen == (size_t)-1) {
- logger(ifp->ctx, LOG_ERR, "%s: make_env: %m", ifp->name);
+ syslog(LOG_ERR, "%s: make_env: %m", ifp->name);
return -1;
}
if (ifp->options->script &&
(ifp->options->script[0] == '\0' ||
strcmp(ifp->options->script, "/dev/null") == 0))
- goto send_listeners;
+ goto send_listeners;
argv[0] = ifp->options->script ? ifp->options->script : UNCONST(SCRIPT);
argv[1] = NULL;
- logger(ifp->ctx, LOG_DEBUG, "%s: executing `%s' %s",
- ifp->name, argv[0], reason);
+ syslog(LOG_DEBUG, "%s: executing `%s' %s", ifp->name, argv[0], reason);
/* Resize for PATH and RC_SVCNAME */
svcname = getenv(RC_SVCNAME);
pid = exec_script(ifp->ctx, argv, env);
if (pid == -1)
- logger(ifp->ctx, LOG_ERR, "%s: %s: %m", __func__, argv[0]);
+ syslog(LOG_ERR, "%s: %s: %m", __func__, argv[0]);
else if (pid != 0) {
/* Wait for the script to finish */
while (waitpid(pid, &status, 0) == -1) {
if (errno != EINTR) {
- logger(ifp->ctx, LOG_ERR, "waitpid: %m");
+ syslog(LOG_ERR, "waitpid: %m");
status = 0;
break;
}
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status))
- logger(ifp->ctx, LOG_ERR,
- "%s: %s: WEXITSTATUS %d",
+ syslog(LOG_ERR, "%s: %s: WEXITSTATUS %d",
__func__, argv[0], WEXITSTATUS(status));
} else if (WIFSIGNALED(status))
- logger(ifp->ctx, LOG_ERR, "%s: %s: %s",
+ syslog(LOG_ERR, "%s: %s: %s",
__func__, argv[0], strsignal(WTERMSIG(status)));
}
elen = (size_t)arraytostr((const char *const *)env,
&bigenv);
if ((ssize_t)elen == -1) {
- logger(ifp->ctx, LOG_ERR, "%s: arraytostr: %m",
+ syslog(LOG_ERR, "%s: arraytostr: %m",
ifp->name);
break;
}
}
if (control_queue(fd, bigenv, elen, 1) == -1)
- logger(ifp->ctx, LOG_ERR,
- "%s: control_queue: %m", __func__);
+ syslog(LOG_ERR, "%s: control_queue: %m", __func__);
else
status = 1;
}
free(*ep++);
free(env);
if (elen == 0) {
- logger(ifp->ctx, LOG_ERR, "%s: malloc: %m", __func__);
+ syslog(LOG_ERR, "%s: malloc: %m", __func__);
return -1;
}
return WEXITSTATUS(status);
projects / thirdparty / dhcpcd.git / commitdiff
