Changeset 469

Timestamp:

02/20/05 17:55:20 (8 years ago)

Author:

minaguib

Message:

* Partial merge from CaptiveDNS branch: Consolidated much of the networking calls to the auth servers into a magical function called connect_auth_server() that's responsible for dns lookup, connecting, marking servers bad, marking online/auth_online, and refreshing the firewall rules.
* Partial merge from CaptiveDNS branch: Added new functions mark_auth_online(), mark_auth_offline() and is_auth_online() - similar in nature to is_online() etc. except tailored to decide on auth servers status - currently being called by connect_auth_server()
* Partial merge from CaptiveDNS branch: Different apology in 404 handler depending on whether internet is down or just auth server is down
* Partial merge from CaptiveDNS branch: wdctl status now shows status of is_online and is_auth_online

Location:

trunk/wifidog

Files:

• ChangeLog (modified) (1 diff)
• src/centralserver.c (modified) (6 diffs)
• src/centralserver.h (modified) (1 diff)
• src/conf.c (modified) (2 diffs)
• src/fw_iptables.c (modified) (1 diff)
• src/http.c (modified) (2 diffs)
• src/ping_thread.c (modified) (5 diffs)
• src/util.c (modified) (4 diffs)
• src/util.h (modified) (1 diff)
• src/wdctl_thread.c (modified) (2 diffs)

trunk/wifidog/ChangeLog

@@ -6 +6 @@
         instances of original with safe versions in all files
         * Fix memory leak in iptables_fw_counters_update
+        * Partial merge from CaptiveDNS branch: Consolidated much of the networking
+        calls to the auth servers into a magical function called connect_auth_server()
+        that's responsible for dns lookup, connecting, marking servers bad, marking
+        online/auth_online, and refreshing the firewall rules.
+        * Partial merge from CaptiveDNS branch: Added new functions mark_auth_online(),
+        mark_auth_offline() and is_auth_online() - similar in nature to is_online()
+        etc. except tailored to decide on auth servers status - currently being called by
+        connect_auth_server()
+        * Partial merge from CaptiveDNS branch: Different apology in 404 handler
+        depending on whether internet is down or just auth server is down
+        * Partial merge from CaptiveDNS branch: wdctl status now shows status of
+        is_online and is_auth_online
 
 2005-02-16 Philippe April <philippe@ilesansfil.org>

trunk/wifidog/src/centralserver.c

@@ -40 +40 @@
 
 #include "common.h"
-
+#include "safe.h"
 #include "util.h"
 #include "auth.h"
@@ -47 +47 @@
 #include "centralserver.h"
 #include "../config.h"
+
+extern pthread_mutex_t  config_mutex;
 
 /** Initiates a transaction with the auth server, either to authenticate or to update the traffic counters at the server
@@ -60 +62 @@
 auth_server_request(t_authresponse *authresponse, char *request_type, char *ip, char *mac, char *token, long int incoming, long int outgoing)
 {
-        int sockfd, num_tries, done;
-        size_t  numbytes, totalbytes;
+        int sockfd;
+        size_t  numbytes, totalbytes;
         char buf[MAX_BUF];
-        struct in_addr *h_addr;
-        struct sockaddr_in their_addr;
         char *tmp;
-        s_config *config = config_get_config();
-        t_auth_serv *auth_server = NULL;
 
         /* Blanket default is failed. */
         authresponse->authcode = AUTH_VALIDATION_FAILED;
         
-        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
-                debug(LOG_ERR, "socket(): %s", strerror(errno));
-                exit(1);
-        }
-
-        num_tries = 0;
-        done = 0;
-        while (!done && ((auth_server = get_auth_server()) != NULL)) {
-                if ((h_addr = wd_gethostbyname(auth_server->authserv_hostname)) == NULL) {
-                        debug(LOG_ERR, "Failed to resolve %s via gethostbyname"
-                                "(): %s", auth_server->authserv_hostname, 
-                                strerror(errno));
-                        close(sockfd);
-                        return(-1);
-                }
-        
-                their_addr.sin_family = AF_INET;
-                their_addr.sin_port = htons(auth_server->authserv_http_port);
-                their_addr.sin_addr = *h_addr;
-                memset(&(their_addr.sin_zero), '\0', sizeof(their_addr.sin_zero));
-
-                debug(LOG_INFO, "Connecting to auth server %s on port %d", 
-                        auth_server->authserv_hostname, 
-                        auth_server->authserv_http_port);
-
-                if (connect(sockfd, (struct sockaddr *)&their_addr,
-                                        sizeof(struct sockaddr)) == -1) {
-                        debug(LOG_ERR, "connect(): %s", strerror(errno));
-                        debug(LOG_ERR, "Trying next Auth Server (if any)");
-                        mark_auth_server_bad(auth_server);
-                        if (++num_tries > config->authserv_maxtries) {
-                                debug(LOG_ERR, "Aborting request");
-                                free(h_addr);
-                                close(sockfd);
-                                return(-1); /* non-fatal */
-                        }
-                } else {
-                        done = 1;
-                }
-                free(h_addr);
-        }
-
-        mark_online();
+        sockfd = connect_auth_server();
+        if (sockfd == -1) {
+                /* Could not connect to any auth server */
+                return (-1);
+        }
 
         /**
@@ -126 +86 @@
                 "Host: %s\n"
                 "\n",
-            auth_server->authserv_path, request_type, ip, mac, 
+            config_get_config()->auth_servers->authserv_path, request_type, ip, mac, 
             token, incoming, outgoing, VERSION, 
-            auth_server->authserv_hostname);
+            config_get_config()->auth_servers->authserv_hostname);
+
+        debug(LOG_DEBUG, "Sending HTTP request to auth server: [%s]\n", buf);
         send(sockfd, buf, strlen(buf), 0);
-
-        debug(LOG_DEBUG, "Sending HTTP request to auth server: [%s]\n", buf);
 
         numbytes = totalbytes = 0;
@@ -139 +99 @@
         
         if (numbytes == -1) {
-                debug(LOG_ERR, "read(): %s", strerror(errno));
+                debug(LOG_ERR, "Error reading from auth server: %s", strerror(errno));
                 close(sockfd);
                 return(-1);
         }
-
-        numbytes = totalbytes;
-        
-        buf[numbytes] = '\0';
-
         close(sockfd);
 
+        buf[totalbytes] = '\0';
         debug(LOG_DEBUG, "HTTP Response from Server: [%s]", buf);
         
         if ((tmp = strstr(buf, "Auth: "))) {
                 if (sscanf(tmp, "Auth: %d", (int *)&authresponse->authcode) == 1) {
-                        debug(LOG_INFO, "Auth server returned authentication code %d",
-                                authresponse->authcode);
+                        debug(LOG_INFO, "Auth server returned authentication code %d", authresponse->authcode);
                         return(authresponse->authcode);
                 } else {
-                        debug(LOG_WARNING, "Auth server did not return expected information");
+                        debug(LOG_WARNING, "Auth server did not return expected authentication code");
                         return(AUTH_ERROR);
                 }
@@ -168 +123 @@
 }
 
+/* Tries really hard to connect to an auth server. Returns a file descriptor, -1 on error
+ */
+int connect_auth_server() {
+        int sockfd;
+
+        LOCK_CONFIG();
+        sockfd = _connect_auth_server(0);
+        UNLOCK_CONFIG();
+
+        if (sockfd == -1) {
+                debug(LOG_ERR, "Failed to connect to any of the auth servers");
+                mark_auth_offline();
+        }
+        else {
+                debug(LOG_DEBUG, "Connected to auth server");
+                mark_auth_online();
+        }
+        return (sockfd);
+}
+
+/* Helper function called by connect_auth_server() to do the actual work including recursion - do not call directly
+@param level recursion level indicator
+ */
+int _connect_auth_server(int level) {
+        s_config *config = config_get_config();
+        t_auth_serv *auth_server = NULL;
+        struct in_addr *h_addr;
+        int num_servers = 0;
+        char * hostname = NULL;
+        char * popular_servers[] = {
+                  "www.google.com"
+                , "www.yahoo.com"
+                , NULL
+        };
+        char ** popularserver;
+        char * ip;
+        struct sockaddr_in their_addr;
+        int sockfd;
+
+        level++;
+
+        /*
+         * Let's calculate the number of servers we have
+         */
+        for (auth_server = config->auth_servers; auth_server; auth_server = auth_server->next) {
+                num_servers++;
+        }
+        debug(LOG_DEBUG, "Level %d: Calculated %d auth servers in list", level, num_servers);
+
+        if (level > num_servers) {
+                /*
+                 * We've called ourselves too many times
+                 * That means we've cycled through all the servers in the server list at least once and none are accessible
+                 */
+                return (-1);
+        }
+
+        /*
+         * Let's resolve the hostname of the top server to an IP address
+         */
+        auth_server = config->auth_servers;
+        hostname = auth_server->authserv_hostname;
+        debug(LOG_DEBUG, "Level %d: Resolving auth server [%s]", level, hostname);
+        h_addr = wd_gethostbyname(hostname);
+        if (!h_addr) {
+                /*
+                 * DNS resolving it failed
+                 *
+                 * Can we resolve any of the popular servers ?
+                 */
+                debug(LOG_DEBUG, "Level %d: Resolving auth server [%s] failed", level, hostname);
+
+                for (popularserver = popular_servers; *popularserver; popularserver++) {
+                        debug(LOG_DEBUG, "Level %d: Resolving popular server [%s]", level, *popularserver);
+                        h_addr = wd_gethostbyname(*popularserver);
+                        if (h_addr) {
+                                debug(LOG_DEBUG, "Level %d: Resolving popular server [%s] succeeded = [%s]", level, *popularserver, inet_ntoa(*h_addr));
+                                break;
+                        }
+                        else {
+                                debug(LOG_DEBUG, "Level %d: Resolving popular server [%s] failed", level, *popularserver);
+                        }
+                }
+
+                if (h_addr) {
+                        free (h_addr);
+                        /*
+                         * Yes
+                         *
+                         * The auth server's DNS server is probably dead. Try the next auth server
+                         */
+                        debug(LOG_DEBUG, "Level %d: Marking auth server [%s] as bad and trying next if possible", level, hostname);
+                        if (auth_server->last_ip) {
+                                free(auth_server->last_ip);
+                                auth_server->last_ip = NULL;
+                        }
+                        mark_auth_server_bad(auth_server);
+                        return _connect_auth_server(level);
+                }
+                else {
+                        /*
+                         * No
+                         *
+                         * It's probably safe to assume that the internet connection is malfunctioning
+                         * and nothing we can do will make it work
+                         */
+                        debug(LOG_DEBUG, "Level %d: Failed to resolve auth server and all popular servers. The internet connection is probably down", level);
+                        return(-1);
+                }
+        }
+        else {
+                /*
+                 * DNS resolving was successful
+                 */
+                ip = safe_strdup(inet_ntoa(*h_addr));
+                debug(LOG_DEBUG, "Level %d: Resolving auth server [%s] succeeded = [%s]", level, hostname, ip);
+
+                if (!auth_server->last_ip || strcmp(auth_server->last_ip, ip) != 0) {
+                        /*
+                         * But the IP address is different from the last one we knew
+                         * Update it
+                         */
+                        debug(LOG_DEBUG, "Level %d: Updating last_ip IP of server [%s] to [%s]", level, hostname, ip);
+                        if (auth_server->last_ip) free(auth_server->last_ip);
+                        auth_server->last_ip = ip;
+
+                        /* Update firewall rules */
+                        fw_clear_authservers();
+                        fw_set_authservers();
+                }
+                else {
+                        /*
+                         * IP is the same as last time
+                         */
+                        free(ip);
+                }
+
+                /*
+                 * Connect to it
+                 */
+                debug(LOG_DEBUG, "Level %d: Connecting to auth server %s:%d", level, hostname, auth_server->authserv_http_port);
+                their_addr.sin_family = AF_INET;
+                their_addr.sin_port = htons(auth_server->authserv_http_port);
+                their_addr.sin_addr = *h_addr;
+                memset(&(their_addr.sin_zero), '\0', sizeof(their_addr.sin_zero));
+                free (h_addr);
+
+                if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
+                        debug(LOG_ERR, "Level %d: Failed to create a new SOCK_STREAM socket: %s", strerror(errno));
+                        return(-1);
+                }
+
+                if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
+                        /*
+                         * Failed to connect
+                         * Mark the server as bad and try the next one
+                         */
+                        debug(LOG_DEBUG, "Level %d: Failed to connect to auth server %s:%d (%s). Marking it as bad and trying next if possible", level, hostname, auth_server->authserv_http_port, strerror(errno));
+                        close(sockfd);
+                        mark_auth_server_bad(auth_server);
+                        return _connect_auth_server(level);
+                }
+                else {
+                        /*
+                         * We have successfully connected
+                         */
+                        debug(LOG_DEBUG, "Level %d: Successfully connected to auth server %s:%d", level, hostname, auth_server->authserv_http_port);
+                        return sockfd;
+                }
+        }
+}
+
+/* config->authserv_maxtries */

trunk/wifidog/src/centralserver.h

@@ -38 +38 @@
 int auth_server_request(t_authresponse *authresponse, char *request_type, char *ip, char *mac, char *token, long int incoming, long int outgoing);
 
+/** @brief Tries really hard to connect to an auth server.  Returns a connected file descriptor or -1 on error */
+int connect_auth_server();
+
+/** @brief Helper function called by connect_auth_server() to do the actual work including recursion - do not call directly */
+int _connect_auth_server(int level);
+
 #endif /* _CENTRALSERVER_H_ */

trunk/wifidog/src/conf.c

@@ -746 +746 @@
         t_auth_serv     *tmp;
 
-        /* lock mutex so two different threads both don't mark the same
-         * server as bad */
-        pthread_mutex_lock(&config_mutex);
-
         if (config.auth_servers == bad_server && bad_server->next != NULL) {
                 /* Go to the last */
@@ -761 +757 @@
         }
 
-        mark_offline();
-
-        pthread_mutex_unlock(&config_mutex);
-
-        fw_clear_authservers();
-        fw_set_authservers();
-}
+}

trunk/wifidog/src/fw_iptables.c

@@ -168 +168 @@
     config = config_get_config();
     
-    LOCK_CONFIG();
-    
     for (auth_server = config->auth_servers; auth_server != NULL; auth_server = auth_server->next) {
-            if (auth_server->last_ip == NULL || strcmp(auth_server->last_ip, "0.0.0.0") == 0) {
-                iptables_do_command("-t filter -A " TABLE_WIFIDOG_AUTHSERVERS " -d %s -j ACCEPT", auth_server->authserv_hostname);
-            } else {
+            if (auth_server->last_ip && strcmp(auth_server->last_ip, "0.0.0.0") != 0) {
                 iptables_do_command("-t filter -A " TABLE_WIFIDOG_AUTHSERVERS " -d %s -j ACCEPT", auth_server->last_ip);
             }
     }
 
-    UNLOCK_CONFIG();
 }
 

trunk/wifidog/src/http.c

@@ -78 +78 @@
         
         if (!is_online()) {
-                /* No point re-directing them to the auth server if we haven't been able to talk
-                 * to it for a while */
-                httpdOutput(r, "<html><head><title>Currently unavailable</title></head><body><h1>Uh oh!</h1>");
+                /* The internet connection is down at the moment  - apologize and do not redirect anywhere */
+                httpdOutput(r, "<html><head><title>Internet access currently unavailable</title></head><body><h1>Uh oh!</h1>");
+                httpdOutput(r, "We apologize, but it seems that the internet connection that powers this hotspot is temporarily unavailable.");
+                httpdOutput(r, "<p>");
+                httpdOutput(r, "If at all possible, please notify the owners of this hotspot that the internet connection is out of service.");
+                httpdOutput(r, "<p>");
+                httpdOutput(r, "The maintainers of this network are aware of this disruption.  We hope that this situation will be resolved soon.");
+                httpdOutput(r, "<p>");
+                httpdPrintf(r, "In a while please <a href='%s'>click here</a> to try your request again.", tmp_url);
+                httpdOutput(r, "</body></html>");
+                debug(LOG_INFO, "Sent %s an apology since I am not online - no point sending them to auth server", r->clientAddr);
+        }
+        else if (!is_auth_online()) {
+                /* The auth server is down at the moment - apologize and do not redirect anywhere */
+                httpdOutput(r, "<html><head><title>Login screen currently unavailable</title></head><body><h1>Uh oh!</h1>");
                 httpdOutput(r, "We apologize, but it seems that we are currently unable to re-direct you to the login screen.");
                 httpdOutput(r, "<p>");
                 httpdOutput(r, "The maintainers of this network are aware of this disruption.  We hope that this situation will be resolved soon.");
                 httpdOutput(r, "<p>");
-                httpdPrintf(r, "In a while please <a href='%s'>click here</a> to try again.", tmp_url);
+                httpdPrintf(r, "In a couple of minutes please <a href='%s'>click here</a> to try your request again.", tmp_url);
                 httpdOutput(r, "</body></html>");
-                debug(LOG_INFO, "Sent %s an apology since I am not online - no point sending them to auth server", r->clientAddr);
+                debug(LOG_INFO, "Sent %s an apology since auth server not online - no point sending them to auth server", r->clientAddr);
         }
         else {
@@ -114 +126 @@
                                 config->gw_id,
                                 url);
-                debug(LOG_INFO, "Captured %s and re-directed them to login "
-                        "page", r->clientAddr);
+                debug(LOG_INFO, "Captured %s and re-directed them to login page", r->clientAddr);
                 free(newlocation);
         }

trunk/wifidog/src/ping_thread.c

@@ -98 +98 @@
         size_t                  numbytes,
                                 totalbytes;
-        int                     sockfd,
-                                nfds,
-                                done,
-                                i;
-        t_auth_serv             *auth_server;
-        char                    request[MAX_BUF],
-                                *tmp_addr;
-        struct in_addr          *h_addr;
-        struct sockaddr_in      their_addr;
+        int                     sockfd, nfds, done;
+        char                    request[MAX_BUF];
         fd_set                  readfds;
         struct timeval          timeout;
@@ -117 +110 @@
         debug(LOG_DEBUG, "Entering ping()");
         
-        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
-                debug(LOG_ERR, "socket(): %s", strerror(errno));
-                exit(1);
-        }
-
-        auth_server = get_auth_server();
-
-        debug(LOG_DEBUG, "Using auth server %s",
-                        auth_server->authserv_hostname);
-        
-        debug(LOG_DEBUG, "Resolving IP");
-        if ((h_addr = (struct in_addr *)wd_gethostbyname(auth_server->authserv_hostname)) == NULL) {
-                debug(LOG_ERR, "Failed to resolve %s via gethostbyname"
-                                "(): %s", auth_server->authserv_hostname, 
-                                strerror(errno));
-                debug(LOG_ERR, "Bumping auth server to last in line.");
-                mark_auth_server_bad(auth_server);
-                close(sockfd);
+        sockfd = connect_auth_server();
+        if (sockfd == -1) {
+                /*
+                 * No auth servers for me to talk to
+                 */
                 return;
         }
-
-        if (auth_server->last_ip == NULL) {
-                auth_server->last_ip = safe_strdup(inet_ntoa(*h_addr));
-        } else {
-                tmp_addr = safe_strdup(inet_ntoa(*h_addr));
-                if (strcmp(auth_server->last_ip, tmp_addr) != 0) {
-                        free(auth_server->last_ip);
-                        auth_server->last_ip = tmp_addr;
-                        fw_clear_authservers();
-                        fw_set_authservers();
-                } else {
-                        free(tmp_addr);
-                }
-        }
-
-        their_addr.sin_family = AF_INET;
-        their_addr.sin_port = htons(auth_server->authserv_http_port);
-        their_addr.sin_addr = *h_addr;
-        memset(&(their_addr.sin_zero), '\0', sizeof(their_addr.sin_zero));
-
-        debug(LOG_INFO, "Connecting to auth server %s on port %d", 
-                        auth_server->authserv_hostname, 
-                        auth_server->authserv_http_port);
-
-        if (connect(sockfd, (struct sockaddr *)&their_addr,
-                                sizeof(struct sockaddr)) == -1) {
-                debug(LOG_ERR, "connect(): %s", strerror(errno));
-                debug(LOG_ERR, "Bumping auth server to last in line.");
-                mark_auth_server_bad(auth_server);
-                close(sockfd);
-                free(h_addr);
-                return;
-        }
-        free(h_addr);
-                
-        mark_online();
 
         /*
@@ -206 +150 @@
                         "Host: %s\n"
                         "\n",
-                        auth_server->authserv_path,
+                        config_get_config()->auth_servers->authserv_path,
                         config_get_config()->gw_id,
                         sys_uptime,
@@ -213 +157 @@
                         (long unsigned int)((long unsigned int)time(NULL) - (long unsigned int)started_time),
                         VERSION,
-                        auth_server->authserv_hostname);
+                        config_get_config()->auth_servers->authserv_hostname);
 
         debug(LOG_DEBUG, "HTTP Request to Server: [%s]", request);
@@ -238 +182 @@
                                         MAX_BUF - (totalbytes + 1));
                         if (numbytes < 0) {
-                                debug(LOG_ERR, "read(): %s", strerror(errno));
-                                mark_auth_server_bad(auth_server);
+                                debug(LOG_ERR, "An error occurred while reading from auth server: %s", strerror(errno));
+                                /* FIXME */
                                 close(sockfd);
                                 return;
-                        } else if (numbytes == 0) {
+                        }
+                        else if (numbytes == 0) {
                                 done = 1;
-                        } else {
+                        }
+                        else {
                                 totalbytes += numbytes;
-                                debug(LOG_DEBUG, "Read %d bytes, total now %d",
-                                                numbytes, totalbytes);
-                        }
-                } else if (nfds == 0) {
-                        debug(LOG_ERR, "select() timed out");
-                        mark_auth_server_bad(auth_server);
+                                debug(LOG_DEBUG, "Read %d bytes, total now %d", numbytes, totalbytes);
+                        }
+                }
+                else if (nfds == 0) {
+                        debug(LOG_ERR, "Timed out reading data via select() from auth server");
+                        /* FIXME */
                         close(sockfd);
                         return;
-                } else if (nfds < 0) {
-                        debug(LOG_ERR, "select(): %s", strerror(errno));
-                        mark_auth_server_bad(auth_server);
+                }
+                else if (nfds < 0) {
+                        debug(LOG_ERR, "Error reading data via select() from auth server: %s", strerror(errno));
+                        /* FIXME */
                         close(sockfd);
                         return;
                 }
         } while (!done);
+        close(sockfd);
 
         debug(LOG_DEBUG, "Done reading reply, total %d bytes", totalbytes);
 
-        numbytes = totalbytes;
-        
-        request[numbytes] = '\0';
-
-        close(sockfd);
+        request[totalbytes] = '\0';
 
         debug(LOG_DEBUG, "HTTP Response from Server: [%s]", request);
         
-        if (!strstr(request, "Pong")) {
-                debug(LOG_ERR, "Primary auth server offline");
-                debug(LOG_ERR, "Bumping auth server to last in line.");
-                mark_auth_server_bad(auth_server);
-                return;
-        }
-        
-        debug(LOG_DEBUG, "Auth Server Says: Pong");
+        if (strstr(request, "Pong") == 0) {
+                debug(LOG_WARNING, "Auth server did NOT say pong!");
+                /* FIXME */
+        }
+        else {
+                debug(LOG_DEBUG, "Auth Server Says: Pong");
+        }
+
         return; 
 }

trunk/wifidog/src/util.c

@@ -56 +56 @@
 static time_t last_online_time = 0;
 static time_t last_offline_time = 0;
+static time_t last_auth_online_time = 0;
+static time_t last_auth_offline_time = 0;
 
 /** Fork a child and execute a shell command, the parent
@@ -110 +112 @@
         if (he == NULL) {
                 free(h_addr);
+                UNLOCK_GHBN();
                 mark_offline();
-                UNLOCK_GHBN();
                 return NULL;
         }
@@ -154 +156 @@
 
 void mark_online() {
+        int isonline;
+        isonline = is_online();
         time(&last_online_time);
+        if (!isonline) {
+                debug(LOG_INFO, "ONLINE status changed to ON");
+        }
 }
 
 void mark_offline() {
+        int isonline;
+        isonline = is_online();
         time(&last_offline_time);
+        /* If we're offline it definately means the auth server is offline */
+        mark_auth_offline();
+        if (isonline) {
+                debug(LOG_INFO, "ONLINE status changed to OFF");
+        }
 }
 
@@ -172 +186 @@
 }
 
+void mark_auth_online() {
+        int isauthonline;
+        isauthonline = is_auth_online();
+        time(&last_auth_online_time);
+        /* If auth server is online it means we're definately online */
+        mark_online();
+        if (!isauthonline) {
+                debug(LOG_INFO, "AUTH_ONLINE status changed to ON");
+        }
+}
+
+void mark_auth_offline() {
+        int isauthonline;
+        isauthonline = is_auth_online();
+        time(&last_auth_offline_time);
+        if (isauthonline) {
+                debug(LOG_INFO, "AUTH_ONLINE status changed to OFF");
+        }
+}
+
+int is_auth_online() {
+        if (!is_online()) {
+                /* If we're not online auth is definately not online :) */
+                return (0);
+        }
+        else if (last_auth_online_time == 0 || (last_auth_offline_time - last_auth_online_time) >= (config_get_config()->checkinterval * 2) ) {
+                /* Auth is  probably offline */
+                return (0);
+        }
+        else {
+                /* Auth is probably online */
+                return (1);
+        }
+}
+

trunk/wifidog/src/util.h

@@ -43 +43 @@
 int is_online();
 
+/* @brief Sets hint that an auth server online action succeeded */
+void mark_auth_online();
+/* @brief Sets hint that an auth server online action failed */
+void mark_auth_offline();
+/* @brief Returns a guess (true or false) on whether we're an auth server is online or not based on previous calls to mark_auth_online and mark_auth_offline */
+int is_auth_online();
+
 #define LOCK_GHBN() do { \
         debug(LOG_DEBUG, "Locking wd_gethostbyname()"); \

trunk/wifidog/src/wdctl_thread.c

@@ -225 +225 @@
         uptime -= minutes * 60;
         seconds = uptime;
-        snprintf((buffer + len), (sizeof(buffer) - len), "Uptime: %ud %uh %um %us\n\n", days, hours, minutes, seconds);
+
+        snprintf((buffer + len), (sizeof(buffer) - len), "Uptime: %ud %uh %um %us\n", days, hours, minutes, seconds);
+        len = strlen(buffer);
+        
+        snprintf((buffer + len), (sizeof(buffer) - len), "is_online: %s\n", (is_online() ? "yes" : "no"));
+        len = strlen(buffer);
+        
+        snprintf((buffer + len), (sizeof(buffer) - len), "is_auth_online: %s\n\n", (is_auth_online() ? "yes" : "no"));
         len = strlen(buffer);
 
@@ -277 +284 @@
 
     UNLOCK_CONFIG();
-        
+
         write(fd, buffer, len);
 }