Clean up with new debug flags and gcc.
authorRoy Marples <roy@marples.name>
Sun, 15 Mar 2015 10:22:12 +0000 (10:22 +0000)
committerRoy Marples <roy@marples.name>
Sun, 15 Mar 2015 10:22:12 +0000 (10:22 +0000)
configure
src/dhcpcd-curses/dhcpcd-curses.c
src/dhcpcd-curses/eloop.c
src/dhcpcd-curses/eloop.h
src/libdhcpcd/dhcpcd.c
src/libdhcpcd/wpa.c

index 3a0713a8d28c1864a80d266aea125eb14eab3c61..3c509d5c78c2b07b31f35100e3024e9f269b31c1 100755 (executable)
--- a/configure
+++ b/configure
@@ -234,14 +234,15 @@ fi
 if [ "$DEBUG" != no -a "$DEBUG" != false ]; then
        echo "Adding debugging CFLAGS"
        cat <<EOF >>$CONFIG_MK
-CFLAGS+=       -g -Wall -Wextra -Wshadow -Wformat=2
+CFLAGS+=       -g -Wall -Wextra
 CFLAGS+=       -Wmissing-prototypes -Wmissing-declarations
-CFLAGS+=       -Wmissing-noreturn -Wmissing-format-attribute
-CFLAGS+=       -Wnested-externs
-CFLAGS+=       -Winline -Wwrite-strings -Wcast-align -Wcast-qual
-CFLAGS+=       -Wpointer-arith -Wstrict-overflow
-CFLAGS+=       -Wdeclaration-after-statement
+CFLAGS+=       -Wmissing-format-attribute -Wnested-externs
+CFLAGS+=       -Winline -Wcast-align -Wcast-qual -Wpointer-arith
+CFLAGS+=       -Wreturn-type -Wswitch -Wshadow
+CFLAGS+=       -Wcast-qual -Wwrite-strings
 CFLAGS+=       -Wconversion
+CFLAGS+=       -Wformat=2
+CFLAGS+=       -Wpointer-sign -Wmissing-noreturn
 EOF
        case "$OS" in
        mirbsd*|openbsd*);; # OpenBSD has many redundant decs in system headers
index 7c4d0834353588b8c7107775ae5c584546d2c3e6..eebb53c322ac16570478458f8ae320e9b9e83dad 100644 (file)
@@ -59,11 +59,11 @@ static void try_open(void *);
 static void
 set_status(struct ctx *ctx, const char *status)
 {
-       int h, w;
+       int w;
        size_t slen;
 
-       getmaxyx(ctx->win_status, h, w);
-       w -= (slen = strlen(status));
+       w = getmaxx(ctx->win_status);
+       w -= (int)(slen = strlen(status));
        if (ctx->status_len > slen) {
                wmove(ctx->win_status, 0, w - (int)(ctx->status_len - slen));
                wclrtoeol(ctx->win_status);
index e381189f6ba17762dacd2ab3ec88277771ba6aaa..f70f04ef36262824c7e527dfc59d239c6f07a14c 100644 (file)
 #define IN_ELOOP
 
 #include "config.h"
+#include "common.h"
 #include "eloop.h"
 
-#ifndef TIMEVAL_TO_TIMESPEC
-#define        TIMEVAL_TO_TIMESPEC(tv, ts) do {                                \
-       (ts)->tv_sec = (tv)->tv_sec;                                    \
-       (ts)->tv_nsec = (tv)->tv_usec * 1000;                           \
-} while (0 /* CONSTCOND */)
-#endif
-
 /* Handy function to get the time.
  * We only care about time advancements, not the actual time itself
  * Which is why we use CLOCK_MONOTONIC, but it is not available on all
  */
 #define NO_MONOTONIC "host does not support a monotonic clock - timing can skew"
 static int
-get_monotonic(struct timeval *tp)
+get_monotonic(struct timespec *ts)
 {
-#if defined(_POSIX_MONOTONIC_CLOCK) && defined(CLOCK_MONOTONIC)
-       struct timespec ts;
 
-       if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
-               tp->tv_sec = ts.tv_sec;
-               tp->tv_usec = (suseconds_t)(ts.tv_nsec / 1000);
+#if defined(_POSIX_MONOTONIC_CLOCK) && defined(CLOCK_MONOTONIC)
+       return clock_gettime(CLOCK_MONOTONIC, ts);
                return 0;
-       }
 #elif defined(__APPLE__)
-#define NSEC_PER_SEC 1000000000
        /* We can use mach kernel functions here.
         * This is crap though - why can't they implement clock_gettime?*/
        static struct mach_timebase_info info = { 0, 0 };
@@ -84,13 +73,12 @@ get_monotonic(struct timeval *tp)
                nano = mach_absolute_time();
                if ((info.denom != 1 || info.numer != 1) && factor != 0.0)
                        nano *= factor;
-               tp->tv_sec = nano / NSEC_PER_SEC;
-               rem = nano % NSEC_PER_SEC;
-               if (rem < 0) {
-                       tp->tv_sec--;
-                       rem += NSEC_PER_SEC;
+               ts->tv_sec = nano / NSEC_PER_SEC;
+               ts->tv_nsec = nano % NSEC_PER_SEC;
+               if (ts->tv_nsec < 0) {
+                       ts->tv_sec--;
+                       ts->tv_nsec += NSEC_PER_SEC;
                }
-               tp->tv_usec = rem / 1000;
                return 0;
        }
 #endif
@@ -102,7 +90,15 @@ get_monotonic(struct timeval *tp)
                posix_clock_set = 1;
        }
 #endif
-       return gettimeofday(tp, NULL);
+       {
+               struct timeval tv;
+               if (gettimeofday(&tv, NULL) == 0) {
+                       TIMEVAL_TO_TIMESPEC(&tv, ts);
+                       return 0;
+               }
+       }
+
+       return -1;
 }
 
 static void
@@ -219,16 +215,16 @@ eloop_event_delete(ELOOP_CTX *ctx, int fd, void (*callback)(void *), void *arg,
 
 int
 eloop_q_timeout_add_tv(ELOOP_CTX *ctx, int queue,
-    const struct timeval *when, void (*callback)(void *), void *arg)
+    const struct timespec *when, void (*callback)(void *), void *arg)
 {
-       struct timeval now;
-       struct timeval w;
+       struct timespec now;
+       struct timespec w;
        struct eloop_timeout *t, *tt = NULL;
 
        get_monotonic(&now);
-       timeradd(&now, when, &w);
+       timespecadd(&now, when, &w);
        /* Check for time_t overflow. */
-       if (timercmp(&w, &now, <)) {
+       if (timespeccmp(&w, &now, <)) {
                errno = ERANGE;
                return -1;
        }
@@ -254,8 +250,7 @@ eloop_q_timeout_add_tv(ELOOP_CTX *ctx, int queue,
                }
        }
 
-       t->when.tv_sec = w.tv_sec;
-       t->when.tv_usec = w.tv_usec;
+       t->when = *when;
        t->callback = callback;
        t->arg = arg;
        t->queue = queue;
@@ -263,7 +258,7 @@ eloop_q_timeout_add_tv(ELOOP_CTX *ctx, int queue,
        /* The timeout list should be in chronological order,
         * soonest first. */
        TAILQ_FOREACH(tt, &ctx->timeouts, next) {
-               if (timercmp(&t->when, &tt->when, <)) {
+               if (timespeccmp(&t->when, &tt->when, <)) {
                        TAILQ_INSERT_BEFORE(tt, t, next);
                        return 0;
                }
@@ -276,30 +271,22 @@ int
 eloop_q_timeout_add_sec(ELOOP_CTX *ctx, int queue, time_t when,
     void (*callback)(void *), void *arg)
 {
-       struct timeval tv;
+       struct timespec tv;
 
        tv.tv_sec = when;
-       tv.tv_usec = 0;
+       tv.tv_nsec = 0;
        return eloop_q_timeout_add_tv(ctx, queue, &tv, callback, arg);
 }
 
-#define USEC_PER_SEC           1000000L
-#define timernorm(tv) do {                                             \
-       while ((tv)->tv_usec >=  USEC_PER_SEC) {                        \
-               (tv)->tv_sec++;                                         \
-               (tv)->tv_usec -= USEC_PER_SEC;                          \
-       }                                                               \
-} while (0 /* CONSTCOND */);
-
 int
 eloop_q_timeout_add_msec(ELOOP_CTX *ctx, int queue, suseconds_t when,
     void (*callback)(void *), void *arg)
 {
-       struct timeval tv;
+       struct timespec tv;
 
        tv.tv_sec = 0;
-       tv.tv_usec = when * 1000;
-       timernorm(&tv);
+       tv.tv_nsec = when * MSEC_PER_NSEC;
+       timespecnorm(&tv);
        return eloop_q_timeout_add_tv(ctx, queue, &tv, callback, arg);
 }
 
@@ -391,12 +378,10 @@ void eloop_free(ELOOP_CTX *ctx)
 int
 eloop_start(ELOOP_CTX *ctx)
 {
-       struct timeval now;
        int n;
        struct eloop_event *e;
        struct eloop_timeout *t;
-       struct timeval tv;
-       struct timespec ts, *tsp;
+       struct timespec now, ts, tv, *tsp;
        void (*t0)(void *);
        int timeout;
 
@@ -413,14 +398,13 @@ eloop_start(ELOOP_CTX *ctx)
                }
                if ((t = TAILQ_FIRST(&ctx->timeouts))) {
                        get_monotonic(&now);
-                       if (timercmp(&now, &t->when, >)) {
+                       if (timespeccmp(&now, &t->when, >)) {
                                TAILQ_REMOVE(&ctx->timeouts, t, next);
                                t->callback(t->arg);
                                TAILQ_INSERT_TAIL(&ctx->free_timeouts, t, next);
                                continue;
                        }
-                       timersub(&t->when, &now, &tv);
-                       TIMEVAL_TO_TIMESPEC(&tv, &ts);
+                       timespecsub(&t->when, &now, &tv);
                        tsp = &ts;
                } else
                        /* No timeouts, so wait forever */
index 23e4d6b6d3556107df719e814a0f52aa8f829997..dc1dd5c3bf493d5bbac9c8bfdcb7a331b8ebe362 100644 (file)
@@ -53,14 +53,14 @@ struct eloop_event {
 
 struct eloop_timeout {
        TAILQ_ENTRY(eloop_timeout) next;
-       struct timeval when;
+       struct timespec when;
        void (*callback)(void *);
        void *arg;
        int queue;
 };
 
 typedef struct eloop_ctx {
-       size_t events_len;
+       nfds_t events_len;
        TAILQ_HEAD (event_head, eloop_event) events;
        struct event_head free_events;
 
@@ -71,7 +71,7 @@ typedef struct eloop_ctx {
        void *timeout0_arg;
 
        struct pollfd *fds;
-       size_t fds_len;
+       nfds_t fds_len;
 
        int exitnow;
        int exitcode;
@@ -98,7 +98,7 @@ int eloop_q_timeout_add_sec(ELOOP_CTX *, int queue,
 int eloop_q_timeout_add_msec(ELOOP_CTX *, int queue,
     suseconds_t, void (*)(void *), void *);
 int eloop_q_timeout_add_tv(ELOOP_CTX *, int queue,
-    const struct timeval *, void (*)(void *), void *);
+    const struct timespec *, void (*)(void *), void *);
 int eloop_timeout_add_now(ELOOP_CTX *, void (*)(void *), void *);
 void eloop_q_timeout_delete(ELOOP_CTX *, int, void (*)(void *), void *);
 ELOOP_CTX * eloop_init(void);
index f9a932d2c9a7dcce94a5d740881d585a9a9eed2f..8e0a0e96912e4fb6d568bd9a5d5969eccb289044 100644 (file)
@@ -260,12 +260,12 @@ dhcpcd_encode_string_escape(char *dst, size_t len, const char *src, size_t slen)
 {
        const char *end;
        size_t bytes;
-       int c;
+       unsigned char c;
 
        end = src + slen;
        bytes = 0;
        while (src < end) {
-               c = *src++;
+               c = (unsigned char)*src++;
                if ((c == '\\' || !isascii(c) || !isprint(c))) {
                        if (c == '\\') {
                                if (dst) {
@@ -285,9 +285,9 @@ dhcpcd_encode_string_escape(char *dst, size_t len, const char *src, size_t slen)
                                        return -1;
                                }
                                *dst++ = '\\';
-                               *dst++ = (((unsigned char)c >> 6) & 03) + '0';
-                               *dst++ = (((unsigned char)c >> 3) & 07) + '0';
-                               *dst++ = ( (unsigned char)c       & 07) + '0';
+                               *dst++ = (char)(((c >> 6) & 03) + '0');
+                               *dst++ = (char)(((c >> 3) & 07) + '0');
+                               *dst++ = (char)(( c       & 07) + '0');
                                len -= 4;
                        }
                        bytes += 4;
index 59b6e2d7df28a06c551e9e54c46aec922624cdc8..4aa214c7b651b2537531f4d56b69c92640fd179a 100644 (file)
@@ -173,7 +173,7 @@ dhcpcd_attach_detach(DHCPCD_WPA *wpa, bool attach)
 }
 
 bool
-dhcpcd_wpa_can_background_scan(DHCPCD_WPA *wpa)
+dhcpcd_wpa_can_background_scan(__unused DHCPCD_WPA *wpa)
 {
 
        wpa = NULL; /* BSD will use this moving forwards */