Cherry-picks the code from 0.1.x branch
authorNeutron Soutmun <neo.neutron@gmail.com>
Mon, 20 Jun 2011 15:46:42 +0000 (22:46 +0700)
committerNeutron Soutmun <neo.neutron@gmail.com>
Mon, 20 Jun 2011 15:46:42 +0000 (22:46 +0700)
  * The codes have been refactor and fix the compiler warnings.
  * Adjust the codes for new API changes from 0.1.x branch.

33 files changed:
configure.ac
data/rahunas.db
src/Makefile.am
src/rahunasd.c
src/rahunasd.h
src/rh-config.c
src/rh-config.h
src/rh-ipset.c
src/rh-ipset.h
src/rh-server.c
src/rh-server.h
src/rh-serviceclass.h
src/rh-task-bandwidth.c
src/rh-task-bandwidth.h
src/rh-task-dbset.c
src/rh-task-dbset.h
src/rh-task-ipset.c
src/rh-task-ipset.h
src/rh-task-iptables.c
src/rh-task-iptables.h
src/rh-task-memset.c
src/rh-task-memset.h
src/rh-task-serviceclass.c
src/rh-task-serviceclass.h
src/rh-task.c
src/rh-task.h
src/rh-utils.c
src/rh-utils.h
src/rh-xmlrpc-cmd.c
src/rh-xmlrpc-cmd.h
src/rh-xmlrpc-server.c
tools/Makefile.am
weblogin/locale/th_TH/LC_MESSAGES/messages.mo

index 5e20749..17e3382 100644 (file)
@@ -28,8 +28,8 @@ PKG_CHECK_MODULES(LIBGNET, [ gnet-2.0 >= $GNET_REQ ], , [ AC_MSG_ERROR([GNet is
 AC_SUBST(LIBGNET_CFLAGS)
 AC_SUBST(LIBGNET_LIBS)
 
-dnl Check for LibGDA 3.x
-LIBGDA_REQ=3.0.2
+dnl Check for LibGDA 4.x
+LIBGDA_REQ=4.0
 PKG_CHECK_MODULES(LIBGDA, [ libgda-4.0 >= $LIBGDA_REQ ], , [ AC_MSG_ERROR([LibGDA is required]) ])
 
 AC_SUBST(LIBGDA_CFLAGS)
index 1df2862..428c39e 100644 (file)
Binary files a/data/rahunas.db and b/data/rahunas.db differ
index 8ded29d..0fc751f 100644 (file)
@@ -16,7 +16,8 @@ AM_CFLAGS = \
   -DRAHUNAS_LOG_DIR=\"$(localstatedir)/log/rahunas/\" \
   -DRAHUNAS_RUN_DIR=\"$(localstatedir)/run/\" \
   -DRAHUNAS_FIREWALL_WRAPPER=\"$(sbindir)/rahunas-firewall\" \
-  -DRAHUNAS_BANDWIDTH_WRAPPER=\"$(sbindir)/rahunas-bandwidth\"
+  -DRAHUNAS_BANDWIDTH_WRAPPER=\"$(sbindir)/rahunas-bandwidth\" \
+  -D_GNU_SOURCE
 
 rahunasd_SOURCES = \
   rahunasd.c \
index db0c728..88d8a40 100644 (file)
 const char *termstring = '\0';
 pid_t pid, sid;
 
-struct main_server rh_main_server_instance = {
+pthread_mutex_t RHMtxLock        = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t RHPollingMtxLock = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t  RHPollingCond    = PTHREAD_COND_INITIALIZER;
+
+static void rh_exit               (void);
+static void rh_reload             (void);
+static int  expired_check         (void *data);
+static int  polling_expired_check (RHMainServer *ms, RHVServer *vs);
+static int  do_task_init          (RHMainServer *ms, RHVServer *vs);
+static int  do_task_cleanup       (RHMainServer *ms, RHVServer *vs);
+static int  do_task_stopservice   (RHMainServer *ms, RHVServer *vs);
+static int  do_vserver_reload     (RHMainServer *ms, RHVServer *vs);
+static int  do_vserver_init_done  (RHMainServer *ms, RHVServer *vs);
+static int  do_serviceclass_init  (RHMainServer *ms, RHSvClass *sc);
+static int  do_serviceclass_reload(RHMainServer *ms, RHSvClass *sc);
+static void *polling_service      (void *data);
+
+RHMainServer rh_main_server_instance = {
   .vserver_list = NULL,
   .serviceclass_list = NULL,
   .task_list = NULL,
 };
-struct main_server *rh_main_server = &rh_main_server_instance;
+RHMainServer *rh_main_server = &rh_main_server_instance;
 
 void rh_sighandler(int sig)
 {
@@ -62,7 +79,8 @@ void rh_sighandler(int sig)
   return;
 }
 
-size_t expired_check(void *data)
+static int
+expired_check(void *data)
 {
   struct processing_set *process = (struct processing_set *) data;
   struct ip_set_req_rahunas *d = NULL;
@@ -82,6 +100,8 @@ size_t expired_check(void *data)
   runner = g_list_first(process->vs->v_map->members);
 
   while (runner != NULL) {
+    time_t time_now = time (NULL);
+
     member = (struct rahunas_member *)runner->data;
     runner = g_list_next(runner);
 
@@ -93,63 +113,69 @@ size_t expired_check(void *data)
 
     DP("Processing id = %d", id);
 
-    DP("Time now: %d, Time get: %d", time(NULL), d->timestamp);
-    DP("Time diff = %d, idle_timeout=%d", (time(NULL) - d->timestamp),
+    DP("Time diff = %d, idle_timeout=%d", (time_now - d->timestamp),
          process->vs->vserver_config->idle_timeout);
 
-    if ((time(NULL) - d->timestamp) >
+    if (time_now - d->timestamp >
          process->vs->vserver_config->idle_timeout) {
       // Idle Timeout
       DP("Found IP: %s idle timeout", idtoip(process->vs->v_map, id));
       req.id = id;
       memcpy(req.mac_address, &d->ethernet, ETH_ALEN);
       req.req_opt = RH_RADIUS_TERM_IDLE_TIMEOUT;
+
       send_xmlrpc_stopacct(process->vs, id, 
                            RH_RADIUS_TERM_IDLE_TIMEOUT);
+
+      pthread_mutex_lock (&RHMtxLock);
       res = rh_task_stopsess(process->vs, &req);
+      pthread_mutex_unlock (&RHMtxLock);
     } else if (member->session_timeout != 0 && 
-               time(NULL) > member->session_timeout) {
+               time_now > member->session_timeout) {
       // Session Timeout (Expired)
       DP("Found IP: %s session timeout", idtoip(process->vs->v_map, id));
       req.id = id;
       memcpy(req.mac_address, &d->ethernet, ETH_ALEN);
       req.req_opt = RH_RADIUS_TERM_SESSION_TIMEOUT;
+
       send_xmlrpc_stopacct(process->vs, id, 
                            RH_RADIUS_TERM_SESSION_TIMEOUT);
+
+      pthread_mutex_lock (&RHMtxLock);
       res = rh_task_stopsess(process->vs, &req);
+      pthread_mutex_unlock (&RHMtxLock);
     }
   }
 }
 
-int polling_expired_check(struct main_server *ms, struct vserver *vs) {
-  walk_through_set(&expired_check, vs);
+static int
+polling_expired_check (RHMainServer *ms, RHVServer *vs) {
+  walk_through_set(expired_check, vs);
   return 0;
 }
 
 gboolean polling(gpointer data) {
-  struct main_server *ms = (struct main_server *)data;
-  struct vserver *vs = NULL;
-  
-  if (ms->polling_blocked) {
-    DP("%s", "Skip polling!");
-    return TRUE;
-  }
-  
-  DP("%s", "Start polling!");
-  walk_through_vserver(&polling_expired_check, ms);
+  if (pthread_mutex_trylock (&RHPollingMtxLock) == 0)
+    {
+      DP("%s", "Start polling!");
+      pthread_cond_signal (&RHPollingCond);
+      pthread_mutex_unlock (&RHPollingMtxLock);
+    }
   return TRUE;
 }
 
-void rh_exit()
+static void
+rh_exit (void)
 {
-  walk_through_vserver(&rh_task_cleanup, rh_main_server);
+  walk_through_vserver(do_task_cleanup, rh_main_server);
   rh_task_stopservice(rh_main_server);
   rh_task_unregister(rh_main_server);
   unregister_vserver_all(rh_main_server);
-  rh_closelog(rh_main_server->main_config->log_file);
+  rh_closelog(rh_main_server->log_fd);
 }
 
-void rh_reload()
+static void
+rh_reload (void)
 {
   logmsg(RH_LOG_NORMAL, "Reloading config files");
   /* Block polling */
@@ -186,10 +212,10 @@ void rh_reload()
     exit(EXIT_FAILURE);
   }
 
-  walk_through_serviceclass(&serviceclass_reload, rh_main_server);
+  walk_through_serviceclass(do_serviceclass_reload, rh_main_server);
   serviceclass_unused_cleanup(rh_main_server);
 
-  walk_through_vserver(&vserver_reload, rh_main_server);
+  walk_through_vserver(do_vserver_reload, rh_main_server);
   vserver_unused_cleanup(rh_main_server);
   
   /* Unblock polling */
@@ -305,7 +331,7 @@ void rh_free_member (struct rahunas_member *member)
 }
 
 
-int main(int argc, char **argv) 
+int main(int argc, char *argv[])
 {
   gchar* addr = "localhost";
   int port    = 8123;
@@ -327,6 +353,7 @@ int main(int argc, char **argv)
 
   GNetXmlRpcServer *server = NULL;
   GMainLoop* main_loop     = NULL;
+  pthread_t  polling_tid;
 
   signal(SIGTERM, &rh_sighandler);
   signal(SIGHUP, &rh_sighandler);
@@ -383,9 +410,9 @@ int main(int argc, char **argv)
   rh_task_startservice(rh_main_server);
 
   if (rh_main_server->main_config->serviceclass)
-    walk_through_serviceclass(&serviceclass_init, rh_main_server);
+    walk_through_serviceclass(do_serviceclass_init, rh_main_server);
 
-  walk_through_vserver(&rh_task_init, rh_main_server);
+  walk_through_vserver(do_task_init, rh_main_server);
 
   gnet_init();
   main_loop = g_main_loop_new (NULL, FALSE);
@@ -395,7 +422,7 @@ int main(int argc, char **argv)
 
   if (!server) {
     syslog(LOG_ERR, "Could not start XML-RPC server!");
-    walk_through_vserver(&rh_task_stopservice, rh_main_server);
+    walk_through_vserver(do_task_stopservice, rh_main_server);
     exit (EXIT_FAILURE);
   }
 
@@ -417,12 +444,87 @@ int main(int argc, char **argv)
   DP("Polling interval = %d", rh_main_server->main_config->polling_interval);
 
   g_timeout_add_seconds (rh_main_server->main_config->polling_interval, 
-                         polling, rh_main_server);
-
+                         polling, NULL);
  
-  walk_through_vserver(&vserver_init_done, rh_main_server);
+  walk_through_vserver(do_vserver_init_done, rh_main_server);
+
+  if (pthread_create (&polling_tid, NULL, polling_service,
+                      (void *) rh_main_server) != 0)
+    {
+      perror ("Create polling service");
+    }
+  else
+    {
+      pthread_detach (polling_tid);
+    }
+
   logmsg(RH_LOG_NORMAL, "Ready to serve...");
   g_main_loop_run(main_loop);
 
   exit(EXIT_SUCCESS);
 }
+
+static int
+do_task_init (RHMainServer *ms, RHVServer *vs)
+{
+  rh_task_init (ms, vs);
+  return 0;
+}
+
+static int
+do_task_cleanup (RHMainServer *ms, RHVServer *vs)
+{
+  rh_task_cleanup (ms, vs);
+  return 0;
+}
+
+static int
+do_task_stopservice (RHMainServer *ms, RHVServer *vs)
+{
+  rh_task_stopservice (ms);
+  return 0;
+}
+
+static int
+do_vserver_reload (RHMainServer *ms, RHVServer *vs)
+{
+  vserver_reload (ms, vs);
+  return 0;
+}
+
+static int
+do_vserver_init_done (RHMainServer *ms, RHVServer *vs)
+{
+  vserver_init_done (ms, vs);
+  return 0;
+}
+
+static int
+do_serviceclass_init  (RHMainServer *ms, RHSvClass *sc)
+{
+  serviceclass_init (ms, sc);
+  return 0;
+}
+
+static int
+do_serviceclass_reload(RHMainServer *ms, RHSvClass *sc)
+{
+  serviceclass_reload (ms, sc);
+  return 0;
+}
+
+static void *
+polling_service (void *data)
+{
+  RHMainServer *ms = (RHMainServer *)data;
+
+  for (;;)
+    {
+      pthread_mutex_lock (&RHPollingMtxLock);
+      pthread_cond_wait (&RHPollingCond, &RHPollingMtxLock);
+
+      walk_through_vserver(polling_expired_check, ms);
+
+      pthread_mutex_unlock (&RHPollingMtxLock);
+    }
+}
index d23f5df..972ff39 100644 (file)
@@ -11,6 +11,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <pthread.h>
 #include <time.h>
 #include <linux/if_ether.h>
 #include <errno.h>
@@ -23,7 +24,8 @@
 #define DEFAULT_MAC "00:00:00:00:00:00"
 
 extern const char *termstring; 
-extern struct main_server rh_main_server_instance;
+extern RHMainServer rh_main_server_instance;
+extern pthread_mutex_t RHMtxLock;
 
 enum RH_LOG {
   RH_LOG_DEBUG,
index 7e388bd..9b6694e 100755 (executable)
@@ -3,9 +3,10 @@
  * Author: Suriya Soutmun <darksolar@gmail.com>
  * Date:   2008-11-26
  */
-#include <ctype.h>
-#include <stdlib.h>
+
 #include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
 #include <syslog.h>
 #include <dirent.h>
 #include <errno.h>
@@ -297,7 +298,7 @@ enum lcfg_status rahunas_visitor(const char *key, void *data, size_t size,
   }
 
   
-  rh_free(&clone_key);
+  rh_free((void **) &clone_key);
 
   return lcfg_status_ok;
 }
@@ -348,7 +349,7 @@ int get_value(const char *cfg_file, const char *key, void **data, size_t *len)
   return 0;
 }
 
-int get_vservers_config(const char *conf_dir, struct main_server *server)
+int get_vservers_config(const char *conf_dir, RHMainServer *server)
 {
   DIR *dp;
   struct dirent *dirp;
@@ -410,60 +411,61 @@ int get_serviceclass_config(const char *conf_dir, struct main_server *server)
 
 int cleanup_vserver_config(struct rahunas_vserver_config *config)
 {
-  rh_free(&(config->vserver_name));  
-  rh_free(&(config->dev_external));
-  rh_free(&(config->dev_internal));
-  rh_free(&(config->vlan));
-  rh_free(&(config->vlan_raw_dev_external));
-  rh_free(&(config->vlan_raw_dev_internal));
-  rh_free(&(config->bridge));
-  rh_free(&(config->masquerade));
-  rh_free(&(config->ignore_mac));
-  rh_free(&(config->vserver_ip));
-  rh_free(&(config->vserver_fqdn));
-  rh_free(&(config->vserver_ports_allow));
-  rh_free(&(config->vserver_ports_intercept));
-  rh_free(&(config->clients));
-  rh_free(&(config->excluded));
-  rh_free(&(config->dns));
-  rh_free(&(config->ssh));
-  rh_free(&(config->proxy));
-  rh_free(&(config->proxy_host));
-  rh_free(&(config->proxy_port));
-  rh_free(&(config->bittorrent));
-  rh_free(&(config->bittorrent_allow));
-  rh_free(&(config->radius_host));
-  rh_free(&(config->radius_secret));
-  rh_free(&(config->radius_encrypt));
-  rh_free(&(config->radius_auth_port));
-  rh_free(&(config->radius_account_port));
-  rh_free(&(config->nas_identifier));
-  rh_free(&(config->nas_port));
-  rh_free(&(config->nas_login_title));
-  rh_free(&(config->nas_default_redirect));
-  rh_free(&(config->nas_default_language));
-  rh_free(&(config->nas_weblogin_template));
+  rh_free((void **) &config->vserver_name);
+  rh_free((void **) &config->dev_external);
+  rh_free((void **) &config->dev_internal);
+  rh_free((void **) &config->vlan);
+  rh_free((void **) &config->vlan_raw_dev_external);
+  rh_free((void **) &config->vlan_raw_dev_internal);
+  rh_free((void **) &config->bridge);
+  rh_free((void **) &config->masquerade);
+  rh_free((void **) &config->ignore_mac);
+  rh_free((void **) &config->vserver_ip);
+  rh_free((void **) &config->vserver_fqdn);
+  rh_free((void **) &config->vserver_ports_allow);
+  rh_free((void **) &config->vserver_ports_intercept);
+  rh_free((void **) &config->clients);
+  rh_free((void **) &config->excluded);
+  rh_free((void **) &config->dns);
+  rh_free((void **) &config->ssh);
+  rh_free((void **) &config->proxy);
+  rh_free((void **) &config->proxy_host);
+  rh_free((void **) &config->proxy_port);
+  rh_free((void **) &config->bittorrent);
+  rh_free((void **) &config->bittorrent_allow);
+  rh_free((void **) &config->radius_host);
+  rh_free((void **) &config->radius_secret);
+  rh_free((void **) &config->radius_encrypt);
+  rh_free((void **) &config->radius_auth_port);
+  rh_free((void **) &config->radius_account_port);
+  rh_free((void **) &config->nas_identifier);
+  rh_free((void **) &config->nas_port);
+  rh_free((void **) &config->nas_login_title);
+  rh_free((void **) &config->nas_default_redirect);
+  rh_free((void **) &config->nas_default_language);
+  rh_free((void **) &config->nas_weblogin_template);
 
   return 0;
 }
 
-int cleanup_serviceclass_config(struct rahunas_serviceclass_config *config)
+int
+cleanup_serviceclass_config(struct rahunas_serviceclass_config *config)
 {
-  rh_free(&(config->serviceclass_name));
-  rh_free(&(config->description));
-  rh_free(&(config->network));
-  rh_free(&(config->fake_arpd));
-  rh_free(&(config->fake_arpd_iface));
+  rh_free((void **) &config->serviceclass_name);
+  rh_free((void **) &config->description);
+  rh_free((void **) &config->network);
+  rh_free((void **) &config->fake_arpd);
+  rh_free((void **) &config->fake_arpd_iface);
 
   return 0;
 }
 
 int cleanup_mainserver_config(struct rahunas_main_config *config)
 {
-  rh_free(&(config->conf_dir));  
-  rh_free(&(config->serviceclass_conf_dir));
-  rh_free(&(config->log_file));
-  rh_free(&(config->dhcp));
+  rh_free((void **) &config->conf_dir);
+  rh_free((void **) &config->serviceclass_conf_dir);
+  rh_free((void **) &config->log_file);
+  rh_free((void **) &config->dhcp);
 
   return 0;
 }
index a885405..065110d 100644 (file)
@@ -129,8 +129,8 @@ extern GList *interfaces_list;
 
 int get_config(const char *cfg_file, union rahunas_config *config);
 int get_value(const char *cfg_file, const char *key, void **data, size_t *len);
-int get_vservers_config(const char *conf_dir, struct main_server *server);
-int get_serviceclass_config(const char *conf_dir, struct main_server *server);
+int get_vservers_config(const char *conf_dir, RHMainServer *server);
+int get_serviceclass_config(const char *conf_dir, RHMainServer *server);
 int cleanup_vserver_config(struct rahunas_vserver_config *config);
 int cleanup_serviceclass_config(struct rahunas_serviceclass_config *config);
 int cleanup_mainserver_config(struct rahunas_main_config *config);
index 6c4fd9e..3184a59 100644 (file)
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <syslog.h>
@@ -106,7 +107,7 @@ void kernel_sendto(void *data, size_t size)
     DP("res=%d errno=%d", res, errno);
 }
 
-int kernel_getfrom_handleerrno(void *data, size_t * size)
+int kernel_getfrom_handleerrno(void *data, socklen_t * size)
 {
   int res = wrapped_getsockopt(data, size);
 
@@ -233,7 +234,7 @@ int set_adtip(struct set *rahunas_set, const char *adtip, const char *adtmac,
   ip_set_ip_t ip;
   unsigned char mac[ETH_ALEN] = {0,0,0,0,0,0};
   parse_ip(adtip, &ip);  
-  parse_mac(adtmac, &mac);
+  parse_mac(adtmac, mac);
 
   return set_adtip_nb(rahunas_set, &ip, mac, op);
 }
@@ -380,7 +381,7 @@ void set_flush(const char *name)
   kernel_sendto(&req, sizeof(struct ip_set_req_std));
 }
 
-size_t load_set_list(struct vserver *vs, const char name[IP_SET_MAXNAMELEN],
+size_t load_set_list(RHVServer *vs, const char name[IP_SET_MAXNAMELEN],
           ip_set_id_t *idx,
           unsigned op, unsigned cmd)
 {
@@ -447,7 +448,7 @@ tryagain:
   return size;
 }
 
-int get_header_from_set (struct vserver *vs)
+int get_header_from_set (RHVServer *vs)
 {
   struct ip_set_req_rahunas_create *header = NULL;
   void *data = NULL;
@@ -509,16 +510,18 @@ int get_header_from_set (struct vserver *vs)
   return res;
 }
 
-int walk_through_set (int (*callback)(void *), struct vserver *vs)
+int walk_through_set (int (*callback)(void *), RHVServer *vs)
 {
   struct processing_set process;
   void *data = NULL;
   ip_set_id_t idx;
   socklen_t size, req_size;
   int res = 0;
-   
+
   check_protocolversion ();
 
+  pthread_mutex_lock (&RHMtxLock);
+
   size = req_size = load_set_list(vs, vs->vserver_config->vserver_name, &idx, 
                                   IP_SET_OP_LIST_SIZE, CMD_LIST); 
 
@@ -533,6 +536,7 @@ int walk_through_set (int (*callback)(void *), struct vserver *vs)
 
     if (res != 0 || size != req_size) {
       rh_free(&data);
+      pthread_mutex_unlock (&RHMtxLock);
       return -EAGAIN;
     }
     size = 0;
@@ -541,11 +545,15 @@ int walk_through_set (int (*callback)(void *), struct vserver *vs)
   if (data != NULL) {
     process.vs = vs;
     process.list = data;
+
+    pthread_mutex_unlock (&RHMtxLock);
     (*callback)(&process);
+    rh_free (&data);
+    return 0;
   }
 
-  rh_free(&data);
-  return res;
+  pthread_mutex_unlock (&RHMtxLock);
+  return 0;
 }
 
 struct ip_set_req_rahunas *get_data_from_set (void *data, unsigned int id,
index 334531a..963121e 100644 (file)
@@ -28,7 +28,7 @@ struct set {
 };
 
 struct processing_set {
-  struct vserver *vs;
+  RHVServer *vs;
   void *list;
 };
 
@@ -76,7 +76,7 @@ int wrapped_setsockopt(void *data, socklen_t size);
 void kernel_getfrom(void *data, socklen_t * size);
 int kernel_sendto_handleerrno(unsigned op, void *data, socklen_t size);
 void kernel_sendto(void *data, size_t size);
-int kernel_getfrom_handleerrno(void *data, size_t * size);
+int kernel_getfrom_handleerrno(void *data, socklen_t * size);
 struct set *set_adt_get(const char *name);
 int set_adtip(struct set *rahunas_set, const char *adtip, const char *adtmac, 
               unsigned op);
@@ -91,13 +91,13 @@ int set_ipiphash_adtip_nb(struct set *rahunas_set, ip_set_ip_t *ip,
 
 void set_flush(const char *name);
 
-size_t load_set_list(struct vserver *vs, const char name[IP_SET_MAXNAMELEN],
+size_t load_set_list(RHVServer *vs, const char name[IP_SET_MAXNAMELEN],
           ip_set_id_t *idx,
           unsigned op, unsigned cmd);
 
-int get_header_from_set (struct vserver *vs);
+int get_header_from_set (RHVServer *vs);
 
-int walk_through_set (int (*callback)(void *), struct vserver *vs);
+int walk_through_set (int (*callback)(void *), RHVServer *vs);
 
 void parse_ip(const char *str, ip_set_ip_t *ip);
 void parse_mac(const char *mac, unsigned char *ethernet);
index 3a0a92b..51473a6 100644 (file)
@@ -4,18 +4,19 @@
  * Date:   2009-03-24
  */
 #include <stdio.h>
+#include <string.h>
 #include "rahunasd.h"
 #include "rh-server.h"
 #include "rh-utils.h"
 
-struct vserver *vserver_exists(GList *vserver_list, int vserver_id, 
-                   const char *vserver_name)
+RHVServer *
+vserver_exists (GList *vserver_list, int vserver_id, const char *vserver_name)
 {
   GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
+  RHVServer *lvserver = NULL;
 
   while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+    lvserver = (RHVServer *)runner->data;
    
     if (lvserver->vserver_config->vserver_id == vserver_id)
       return lvserver; 
@@ -28,13 +29,13 @@ struct vserver *vserver_exists(GList *vserver_list, int vserver_id,
   return NULL;
 }
 
-struct vserver *vserver_get_by_id(struct main_server *ms, int search_id)
+RHVServer *vserver_get_by_id(RHMainServer *ms, int search_id)
 {
   GList *runner = g_list_first(ms->vserver_list);
-  struct vserver *lvserver = NULL;
+  RHVServer *lvserver = NULL;
 
   while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+    lvserver = (RHVServer *)runner->data;
    
     if (lvserver->vserver_config->vserver_id == search_id) {
       return lvserver;
@@ -45,7 +46,7 @@ struct vserver *vserver_get_by_id(struct main_server *ms, int search_id)
   return NULL;
 }
 
-int vserver_cleanup(struct vserver *vs)
+int vserver_cleanup(RHVServer *vs)
 {
   if (vs == NULL)
     return 0;
@@ -56,7 +57,7 @@ int vserver_cleanup(struct vserver *vs)
   return 0;
 }
 
-int mainserver_cleanup(struct main_server *ms)
+int mainserver_cleanup(RHMainServer *ms)
 {
   if (ms == NULL)
     return 0;
@@ -67,7 +68,7 @@ int mainserver_cleanup(struct main_server *ms)
   return 0;
 }
 
-int register_vserver(struct main_server *ms, const char *vserver_cfg_file)
+int register_vserver(RHMainServer *ms, const char *vserver_cfg_file)
 {
   GList *vserver_list = ms->vserver_list;
   GList *chk = NULL;
@@ -76,8 +77,8 @@ int register_vserver(struct main_server *ms, const char *vserver_cfg_file)
   
   union rahunas_config *cfg_get = NULL;
   struct rahunas_vserver_config *vserver_config = NULL;
-  struct vserver *new_vserver = NULL;
-  struct vserver *old_vserver = NULL;
+  RHVServer *new_vserver = NULL;
+  RHVServer *old_vserver = NULL;
 
   union rahunas_config config = {
     .rh_vserver.vserver_name = NULL,
@@ -129,7 +130,7 @@ int register_vserver(struct main_server *ms, const char *vserver_cfg_file)
     if (old_vserver != NULL) {
       if (old_vserver->dummy_config != NULL) {
         DP("Cleanup old dummy config");
-        rh_free(&old_vserver->dummy_config);
+        rh_free((void **) &old_vserver->dummy_config);
       }
 
       old_vserver->dummy_config = 
@@ -166,12 +167,12 @@ int register_vserver(struct main_server *ms, const char *vserver_cfg_file)
 
   memcpy(vserver_config, &config, sizeof(struct rahunas_vserver_config));
 
-  new_vserver = (struct vserver *) rh_malloc(sizeof(struct vserver));
+  new_vserver = (RHVServer *) rh_malloc(sizeof(RHVServer));
 
   if (new_vserver == NULL)
     return -1;
 
-  memset(new_vserver, 0, sizeof(struct vserver));
+  memset(new_vserver, 0, sizeof(RHVServer));
 
   new_vserver->vserver_config = vserver_config;
 
@@ -181,14 +182,14 @@ int register_vserver(struct main_server *ms, const char *vserver_cfg_file)
   return 0; 
 }
 
-int unregister_vserver(struct main_server *ms, int vserver_id)
+int unregister_vserver(RHMainServer *ms, int vserver_id)
 {
   GList *vserver_list = ms->vserver_list;
   GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
+  RHVServer *lvserver = NULL;
 
   while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+    lvserver = (RHVServer *)runner->data;
     if (lvserver->vserver_config->vserver_id == vserver_id) {
       vserver_cleanup(lvserver);
 
@@ -201,15 +202,15 @@ int unregister_vserver(struct main_server *ms, int vserver_id)
   return 0;
 }
 
-int unregister_vserver_all(struct main_server *ms)
+int unregister_vserver_all(RHMainServer *ms)
 {
   GList *vserver_list = ms->vserver_list;
   GList *runner = g_list_first(vserver_list);
   GList *deleting = NULL;
-  struct vserver *lvserver = NULL;
+  RHVServer *lvserver = NULL;
 
   while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+    lvserver = (RHVServer *)runner->data;
     vserver_cleanup(lvserver);
     deleting = runner;
     runner = g_list_next(runner);
@@ -221,14 +222,15 @@ int unregister_vserver_all(struct main_server *ms)
   return 0;
 }
 
-int walk_through_vserver(int (*callback)(void *, void *), struct main_server *ms)
+int walk_through_vserver(int (*callback)(RHMainServer *, RHVServer*),
+                         RHMainServer *ms)
 {
   GList *vserver_list = ms->vserver_list;
   GList *runner = g_list_first(vserver_list);
-  struct vserver *vs = NULL;
+  RHVServer *vs = NULL;
 
   while (runner != NULL) {
-    vs = (struct vserver *)runner->data;
+    vs = (RHVServer *)runner->data;
 
     (*callback)(ms, vs);
 
@@ -238,7 +240,7 @@ int walk_through_vserver(int (*callback)(void *, void *), struct main_server *ms
   return 0;
 }
 
-void vserver_init_done(struct main_server *ms, struct vserver *vs)
+void vserver_init_done(RHMainServer *ms, RHVServer *vs)
 {
   if (vs != NULL) {
     vs->vserver_config->init_flag = VS_DONE;
@@ -246,7 +248,7 @@ void vserver_init_done(struct main_server *ms, struct vserver *vs)
   }
 }
 
-void vserver_reload(struct main_server *ms, struct vserver *vs)
+void vserver_reload(RHMainServer *ms, RHVServer *vs)
 {
   if (vs->vserver_config->init_flag == VS_DONE) {
     // Indicate the unused virtual server
@@ -286,7 +288,7 @@ void vserver_reload(struct main_server *ms, struct vserver *vs)
         cleanup_vserver_config(vs->vserver_config);
         memcpy(vs->vserver_config, vs->dummy_config, 
           sizeof(struct rahunas_vserver_config));
-        rh_free(&vs->dummy_config);
+        rh_free((void **) &vs->dummy_config);
       }
 
       vs->vserver_config->init_flag = VS_INIT;
@@ -298,14 +300,14 @@ void vserver_reload(struct main_server *ms, struct vserver *vs)
 }
 
 
-void vserver_unused_cleanup(struct main_server *ms)
+void vserver_unused_cleanup(RHMainServer *ms)
 {
   GList *vserver_list = ms->vserver_list;
   GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
+  RHVServer *lvserver = NULL;
 
   while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+    lvserver = (RHVServer *)runner->data;
     if (lvserver->vserver_config->init_flag == VS_NONE) {
       logmsg(RH_LOG_NORMAL, "[%s] - Config removed",
              lvserver->vserver_config->vserver_name);
@@ -318,6 +320,4 @@ void vserver_unused_cleanup(struct main_server *ms)
       runner = g_list_next(runner);
     }
   }
-  
-  return 0;
 }
index 71d4848..cc4da69 100644 (file)
@@ -9,6 +9,9 @@
 #include <glib.h>
 #include "rh-config.h"
 
+typedef struct vserver     RHVServer;
+typedef struct main_server RHMainServer;
+
 struct main_server {
   struct rahunas_main_config *main_config;
   GList *vserver_list;
@@ -23,20 +26,23 @@ struct vserver {
   struct rahunas_vserver_config *dummy_config;
   struct rahunas_map *v_map;
   struct set *v_set;
-  struct main_server *main_server;
+  RHMainServer *main_server;
 };
 
-struct vserver *vserver_exists(GList *vserver_list, int vserver_id, 
-                   const char *vserver_name);
-struct vserver *vserver_get_by_id(struct main_server *ms, int search_id);
-int vserver_cleanup(struct vserver *vs);
-int mainserver_cleanup(struct main_server *ms);
-int walk_through_vserver(int (*callback)(void *, void *), struct main_server *ms);
-int register_vserver(struct main_server *ms, const char *vserver_cfg_file);
-int unregister_vserver(struct main_server *ms, int vserver_id);
-int unregister_vserver_all(struct main_server *ms);
-void vserver_init_done(struct main_server *ms, struct vserver *vs);
-void vserver_reload(struct main_server *ms, struct vserver *vs);
-void vserver_unused_cleanup(struct main_server *ms);
+RHVServer *vserver_exists    (GList *vserver_list, int vserver_id,
+                                   const char *vserver_name);
+RHVServer *vserver_get_by_id (RHMainServer *ms, int search_id);
+
+int vserver_cleanup    (RHVServer *vs);
+int mainserver_cleanup (RHMainServer *ms);
+
+int walk_through_vserver    (int (*callback)(RHMainServer *, RHVServer *),
+                             RHMainServer  *ms);
+int register_vserver        (RHMainServer  *ms, const char *vserver_cfg_file);
+int unregister_vserver      (RHMainServer  *ms, int vserver_id);
+int unregister_vserver_all  (RHMainServer  *ms);
+void vserver_init_done      (RHMainServer  *ms, RHVServer *vs);
+void vserver_reload         (RHMainServer  *ms, RHVServer *vs);
+void vserver_unused_cleanup (RHMainServer  *ms);
 
 #endif // __RH_SERVER_H
index 9b527c2..2a0307c 100644 (file)
@@ -11,6 +11,8 @@
 
 #define SERVICECLASS_SET_NAME   "rahunas_serviceclass"
 
+typedef struct serviceclass RHSvClass;
+
 struct serviceclass {
   struct rahunas_serviceclass_config *serviceclass_config;
   struct rahunas_serviceclass_config *dummy_config;
index f07876b..bad4e6e 100644 (file)
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -66,7 +67,7 @@ void mark_reserved_slot_id(unsigned int slot_id)
   slot_flags[page] |= 1 << id_on_page;
 }
 
-int bandwidth_exec(struct vserver *vs, char *const args[])
+int bandwidth_exec(RHVServer *vs, char *const args[])
 {
   pid_t ws;
   pid_t pid;
@@ -134,7 +135,7 @@ int bandwidth_exec(struct vserver *vs, char *const args[])
   return ret;
 }
 
-int bandwidth_start(struct vserver *vs)
+int bandwidth_start(RHVServer *vs)
 {
   char *args[5];
   struct interfaces *iface = vs->vserver_config->iface;
@@ -152,7 +153,7 @@ int bandwidth_start(struct vserver *vs)
   return ret; 
 }
 
-int bandwidth_stop(struct vserver *vs)
+int bandwidth_stop(RHVServer *vs)
 {
   char *args[5];
   struct interfaces *iface = vs->vserver_config->iface;
@@ -170,7 +171,7 @@ int bandwidth_stop(struct vserver *vs)
   return ret; 
 }
 
-int bandwidth_add(struct vserver *vs, struct bandwidth_req *bw_req)
+int bandwidth_add(RHVServer *vs, struct bandwidth_req *bw_req)
 {
   char *args[9];
   struct interfaces *iface = vs->vserver_config->iface;
@@ -191,7 +192,7 @@ int bandwidth_add(struct vserver *vs, struct bandwidth_req *bw_req)
   return bandwidth_exec(vs, args);
 }
 
-int bandwidth_del(struct vserver *vs, struct bandwidth_req *bw_req)
+int bandwidth_del(RHVServer *vs, struct bandwidth_req *bw_req)
 {
   char *args[6];
   struct interfaces *iface = vs->vserver_config->iface;
@@ -221,7 +222,7 @@ static int stopservice (void)
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   struct interfaces *iface = NULL;
   if (!vs)
@@ -243,7 +244,7 @@ initial:
 }
 
 /* Cleanup */
-static int cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   struct interfaces *iface = NULL;
   if (!vs)
@@ -263,7 +264,7 @@ static int cleanup (struct vserver *vs)
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   struct bandwidth_req bw_req;
   unsigned short slot_id;
@@ -282,6 +283,10 @@ static int startsess (struct vserver *vs, struct task_req *req)
 
   if (member->bandwidth_slot_id > 0)
     return 0;
+
+  memset (bw_req.ip, 0, sizeof (bw_req.ip));
+  memset (bw_req.bandwidth_max_down, 0, sizeof (bw_req.bandwidth_max_down));
+  memset (bw_req.bandwidth_max_up, 0, sizeof (bw_req.bandwidth_max_up));
   
   // Formating the bandwidth request
   snprintf(bw_req.ip, sizeof (bw_req.ip), "%s", idtoip(vs->v_map, req->id));
@@ -315,7 +320,7 @@ static int startsess (struct vserver *vs, struct task_req *req)
 }
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   struct bandwidth_req bw_req;
   unsigned short slot_id = 0;
@@ -347,25 +352,25 @@ static int stopsess  (struct vserver *vs, struct task_req *req)
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -385,6 +390,6 @@ static struct task taskbandwidth = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_bandwidth_reg(struct main_server *ms) {
+void rh_task_bandwidth_reg(RHMainServer *ms) {
   task_register(ms, &taskbandwidth);
 }
index 4a73f0a..b57808f 100644 (file)
@@ -6,6 +6,8 @@
 #ifndef __RH_TASK_BANDWIDTH_H
 #define __RH_TASK_BANDWIDTH_H
 
+#include "rh-server.h"
+
 /* MAX_SLOT_PAGE is calculated from the formula of
    MAX_SLOT_PAGE = ceil(MAX_SLOT_ID/PAGE_SIZE)
 
@@ -17,7 +19,7 @@
 #define PAGE_SIZE      16
 #define MAX_SLOT_PAGE  619
 
-extern void rh_task_bandwidth_reg(struct main_server *ms);
+extern void rh_task_bandwidth_reg(RHMainServer *ms);
 
 struct bandwidth_req {
   char slot_id[5];
@@ -26,7 +28,7 @@ struct bandwidth_req {
   char bandwidth_max_up[15];
 };
 
-int bandwidth_add(struct vserver *vs, struct bandwidth_req *bw_req);
-int bandwidth_exec(struct vserver *vs, char *const args[]);
+int bandwidth_add(RHVServer *vs, struct bandwidth_req *bw_req);
+int bandwidth_exec(RHVServer *vs, char *const args[]);
 void mark_reserved_slot_id(unsigned int slot_id);
 #endif // __RH_TASK_BANDWIDTH_H
index 9d09ac5..a1b2aeb 100644 (file)
@@ -13,6 +13,7 @@
 #include "rh-task.h"
 #include "rh-ipset.h"
 #include "rh-utils.h"
+#include "rh-task-memset.h"
 
 struct dbset_row {
   gchar *session_id;
@@ -50,12 +51,13 @@ gboolean get_errors (GdaConnection * connection)
   }
 }
 
-gboolean *parse_dm_to_struct(GList **data_list, GdaDataModel *dm) {
+gboolean
+parse_dm_to_struct(GList **data_list, GdaDataModel *dm) {
   gint  row_id;
   gint  column_id;
-  GValue *value;
+  const GValue *value;
   gchar  *str;
-  gchar  *title;
+  const gchar  *title;
   GdaNumeric *num;
   struct dbset_row *row;
   struct tm tm;
@@ -200,7 +202,7 @@ void free_data_list(GList *data_list)
   g_list_free (data_list);  
 }
 
-gboolean restore_set(GList **data_list, struct vserver *vs)
+gboolean restore_set(GList **data_list, RHVServer *vs)
 {
   GList *node = NULL;
   struct dbset_row *row = NULL;
@@ -233,8 +235,8 @@ gboolean restore_set(GList **data_list, struct vserver *vs)
     req.vserver_id = atoi(row->vserver_id);
     req.username = row->username;
     req.session_id = row->session_id;
-    parse_mac(row->mac, &ethernet);
-    memcpy(req.mac_address, &ethernet, ETH_ALEN);
+    parse_mac(row->mac, ethernet);
+    memcpy(req.mac_address, ethernet, ETH_ALEN);
 
     req.session_start = row->session_start;
     req.session_timeout = row->session_timeout;
@@ -251,8 +253,8 @@ gboolean restore_set(GList **data_list, struct vserver *vs)
   return TRUE;
 }
 
-
-GdaConnection *openconn (GdaConnectionOptions options)
+GdaConnection *
+openconn (GdaConnectionOptions options)
 {
   GdaConnection *connection = NULL;
   GdaSqlParser  *parser = NULL;
@@ -301,7 +303,7 @@ static int stopservice  ()
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   GdaConnection *connection;
   GList *data_list;
@@ -334,13 +336,13 @@ static void init (struct vserver *vs)
 }
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   /* Do nothing */
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   GdaConnection *connection;
   gint res;
@@ -352,8 +354,8 @@ static int startsess (struct vserver *vs, struct task_req *req)
 
   connection = openconn (GDA_CONNECTION_OPTIONS_NONE);
 
-  strftime(&time_str, sizeof time_str, "%s", localtime(&req->session_start));
-  strftime(&time_str2, sizeof time_str2, "%s", 
+  strftime(time_str, sizeof time_str, "%s", localtime(&req->session_start));
+  strftime(time_str2, sizeof time_str2, "%s",
     localtime(&req->session_timeout));
 
   member_node = member_get_node_by_id(vs, req->id);
@@ -391,7 +393,7 @@ static int startsess (struct vserver *vs, struct task_req *req)
 }
 
 /* Stop session task */
-static int stopsess (struct vserver *vs, struct task_req *req)
+static int stopsess (RHVServer *vs, struct task_req *req)
 {
   GdaConnection *connection;
   gint res;
@@ -427,25 +429,25 @@ static int stopsess (struct vserver *vs, struct task_req *req)
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -465,6 +467,6 @@ static struct task task_dbset = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_dbset_reg(struct main_server *ms) {
+void rh_task_dbset_reg(RHMainServer *ms) {
   task_register(ms, &task_dbset);
 }
index c0de20a..b39fdba 100644 (file)
@@ -6,7 +6,9 @@
 #ifndef __RH_TASK_DBSET_H
 #define __RH_TASK_DBSET_H
 
-extern void rh_task_dbset_reg(struct main_server *ms);
+#include "rh-server.h"
+
+extern void rh_task_dbset_reg(RHMainServer *ms);
 
 #endif // __RH_TASK_MEMSET_H
 
index a19286e..6e617f0 100644 (file)
@@ -5,6 +5,7 @@
  * Date:   2008-09-07
  */
 
+#include <string.h>
 #include <syslog.h>
 
 #include "rahunasd.h"
@@ -12,7 +13,8 @@
 #include "rh-task.h"
 #include "rh-xmlrpc-cmd.h"
 
-size_t set_cleanup(void *data)
+static int
+set_cleanup(void *data)
 {
   struct processing_set *process = (struct processing_set *) data;
   struct ip_set_list *setlist = (struct ip_set_list *) process->list;
@@ -39,7 +41,7 @@ size_t set_cleanup(void *data)
 
     DP("Found IP: %s in set, try logout", idtoip(process->vs->v_map, id));
     req.id = id;
-    memcpy(req.mac_address, &table[id].ethernet, ETH_ALEN);
+    memcpy(req.mac_address, table[id].ethernet, ETH_ALEN);
     req.req_opt = RH_RADIUS_TERM_NAS_REBOOT;
     send_xmlrpc_stopacct(process->vs, id, RH_RADIUS_TERM_NAS_REBOOT);
     rh_task_stopsess(process->vs, &req);
@@ -59,7 +61,7 @@ static int stopservice  ()
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   if (vs->vserver_config->init_flag == VS_RELOAD)
     return;
@@ -78,7 +80,7 @@ static void init (struct vserver *vs)
 }
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   if (vs->vserver_config->init_flag == VS_RELOAD)
     return;
@@ -89,12 +91,11 @@ static void cleanup (struct vserver *vs)
   walk_through_set(&set_cleanup, vs);
 
   set_flush(vs->vserver_config->vserver_name);
-
-  rh_free(&(vs->v_set));
+  rh_free((void **) &vs->v_set);
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   int res = 0;
   ip_set_ip_t ip;
@@ -106,7 +107,7 @@ static int startsess (struct vserver *vs, struct task_req *req)
 }
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   int res = 0;
   ip_set_ip_t ip;
@@ -118,25 +119,25 @@ static int stopsess  (struct vserver *vs, struct task_req *req)
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -156,6 +157,6 @@ static struct task task_ipset = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_ipset_reg(struct main_server *ms) {
+void rh_task_ipset_reg(RHMainServer *ms) {
   task_register(ms, &task_ipset);
 }
index ee92786..ac6078d 100644 (file)
@@ -6,7 +6,9 @@
 #ifndef __RH_TASK_MEMSET_H
 #define __RH_TASK_MEMSET_H
 
-extern void rh_task_ipset_reg(struct main_server *ms);
+#include "rh-server.h"
+
+extern void rh_task_ipset_reg(RHMainServer *ms);
 
 #endif // __RH_TASK_MEMSET_H
 
index 8990f81..231e67c 100644 (file)
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -16,7 +17,7 @@
 #include "rh-task.h"
 #include "rh-utils.h"
 
-int iptables_exec(struct vserver *vs, char *const args[])
+int iptables_exec(RHVServer *vs, char *const args[])
 {
   pid_t ws;
   pid_t pid;
@@ -105,7 +106,7 @@ int iptables_exec(struct vserver *vs, char *const args[])
   return ret;
 }
 
-int iptables_start(struct vserver *vs)
+int iptables_start(RHVServer *vs)
 {
   char *args[3];
 
@@ -118,7 +119,7 @@ int iptables_start(struct vserver *vs)
   return iptables_exec(vs, args);
 }
 
-int iptables_stop(struct vserver *vs)
+int iptables_stop(RHVServer *vs)
 {
   char *args[3];
 
@@ -144,7 +145,7 @@ static int stopservice  ()
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   logmsg(RH_LOG_NORMAL, "[%s] Task IPTABLES initialize..", 
          vs->vserver_config->vserver_name);  
@@ -153,7 +154,7 @@ static void init (struct vserver *vs)
 }
 
 /* Cleanup */
-static int cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   logmsg(RH_LOG_NORMAL, "[%s] Task IPTABLES cleanup..",
          vs->vserver_config->vserver_name);  
@@ -162,39 +163,39 @@ static int cleanup (struct vserver *vs)
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing */
   return 0;
 }
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing */
   return 0; 
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -214,6 +215,6 @@ static struct task taskiptables = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_iptables_reg(struct main_server *ms) {
+void rh_task_iptables_reg(RHMainServer *ms) {
   task_register(ms, &taskiptables);
 }
index 6af9fe5..5266654 100644 (file)
@@ -6,6 +6,8 @@
 #ifndef __RH_TASK_IPTABLES_H
 #define __RH_TASK_IPTABLES_H
 
-extern void rh_task_iptables_reg(struct main_server *ms);
+#include "rh-server.h"
+
+extern void rh_task_iptables_reg(RHMainServer *ms);
 
 #endif // __RH_TASK_BANDWIDTH_H
index 5b9371a..d5a798b 100644 (file)
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <time.h>
 #include "rahunasd.h"
@@ -12,7 +13,7 @@
 #include "rh-task.h"
 #include "rh-ipset.h"
 
-GList *member_get_node_by_id(struct vserver *vs, uint32_t id) 
+GList *member_get_node_by_id(RHVServer *vs, uint32_t id)
 {
   GList *runner = g_list_first(vs->v_map->members);
   struct rahunas_member *member = NULL;
@@ -29,10 +30,14 @@ GList *member_get_node_by_id(struct vserver *vs, uint32_t id)
   return NULL;
 }
 
-gint idcmp(struct rahunas_member *a, struct rahunas_member *b)
+static gint
+idcmp(gconstpointer a, gconstpointer b)
 {
-  if (a != NULL && b != NULL)
-    return (a->id - b->id);
+  struct rahunas_member *rh_a = (struct rahunas_member *) a;
+  struct rahunas_member *rh_b = (struct rahunas_member *) b;
+
+  if (rh_a != NULL && rh_b != NULL)
+    return (rh_a->id - rh_b->id);
 
   return -1;
 }
@@ -52,7 +57,7 @@ static int stopservice  ()
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   int size;
 
@@ -78,7 +83,7 @@ static void init (struct vserver *vs)
 }
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   GList *runner = NULL;
   GList *deleting = NULL;
@@ -108,15 +113,13 @@ static void cleanup (struct vserver *vs)
 
     g_list_free(vs->v_map->members);
 
-    rh_free(&(vs->v_map->members));
-    rh_free(&(vs->v_map));
+    rh_free((void **) &vs->v_map->members);
+    rh_free((void **) &vs->v_map);
   }
-
-  return 0;
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   uint32_t id = req->id;
   GList *member_node = NULL;
@@ -156,11 +159,11 @@ static int startsess (struct vserver *vs, struct task_req *req)
 
   member->username   = strdup(req->username);
   if (!member->username)
-    member->username = termstring;
+    member->username = strdup(termstring);
 
   member->session_id = strdup(req->session_id);
   if (!member->session_id)
-    member->session_id = termstring;
+    member->session_id = strdup(termstring);
 
   member->serviceclass_name    = NULL;
   member->serviceclass_description = termstring;
@@ -195,7 +198,7 @@ static int startsess (struct vserver *vs, struct task_req *req)
 }
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   uint32_t id = req->id;
   GList *member_node = NULL;
@@ -226,10 +229,10 @@ static int stopsess  (struct vserver *vs, struct task_req *req)
       break;
   }
   if (!member->username)
-    member->username = termstring;
+    member->username = strdup(termstring);
 
   if (!member->session_id)
-    member->session_id = termstring;
+    member->session_id = strdup(termstring);
 
   logmsg(RH_LOG_NORMAL, "[%s] Session Stop (%s), User: %s, IP: %s, "
                         "Session ID: %s, MAC: %s",
@@ -248,25 +251,25 @@ static int stopsess  (struct vserver *vs, struct task_req *req)
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -286,6 +289,6 @@ static struct task task_memset = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_memset_reg(struct main_server *ms) {
+void rh_task_memset_reg(RHMainServer *ms) {
   task_register(ms, &task_memset);
 }
index b32b4c5..d2a7b9f 100644 (file)
@@ -6,9 +6,11 @@
 #ifndef __RH_TASK_MEMSET_H
 #define __RH_TASK_MEMSET_H
 
-extern void rh_task_memset_reg(struct main_server *ms);
+#include <glib.h>
+#include "rh-server.h"
 
-GList *member_get_node_by_id(struct vserver *vs, uint32_t id);
-gint idcmp(struct rahunas_member *a, struct rahunas_member *b);
+extern void rh_task_memset_reg(RHMainServer *ms);
+
+GList *member_get_node_by_id(RHVServer *vs, uint32_t id);
 #endif // __RH_TASK_MEMSET_H
 
index 7720a8b..922ed61 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * RahuNAS task serviceclass implementation 
+ * RahuNAS task serviceclass implementation
  * Author: Neutron Soutmun <neo.neutron@gmail.com>
  * Date:   2010-07-29
  */
@@ -17,7 +17,7 @@ static struct set *rh_serviceclass_set = NULL;
 static uint32_t _sc_get_slot_id(struct rahunas_serviceclass_config *sc_config)
 {
   uint32_t slot_id = 0;
-  time_t random_time; 
+  time_t random_time;
   int  retry = 30;
   char select_cmd[256];
   GdaConnection *connection = NULL;
@@ -55,7 +55,7 @@ static uint32_t _sc_get_slot_id(struct rahunas_serviceclass_config *sc_config)
         // Available
         free_data_list(data_list);
         break;
-      } else { 
+      } else {
         // Not available, retry
         free_data_list(data_list);
         slot_id = 0;
@@ -85,24 +85,24 @@ static int stopservice  ()
   if (rh_serviceclass_set != NULL) {
     logmsg(RH_LOG_NORMAL, "Service Class: Flushing set ...");
     set_flush (SERVICECLASS_SET_NAME);
-    rh_free(&rh_serviceclass_set); 
+    rh_free(&rh_serviceclass_set);
   }
 
   return 0;
 }
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
 }
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
 }
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   struct serviceclass *sc = NULL;
   struct rahunas_serviceclass_config *sc_config = NULL;
@@ -198,7 +198,7 @@ out:
 }
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   struct serviceclass *sc = NULL;
   struct rahunas_serviceclass_config *sc_config = NULL;
@@ -269,25 +269,25 @@ failed:
 }
 
 /* Commit start session task */
-static int commitstartsess (struct vserver *vs, struct task_req *req)
+static int commitstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Commit stop session task */
-static int commitstopsess  (struct vserver *vs, struct task_req *req)
+static int commitstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback start session task */
-static int rollbackstartsess (struct vserver *vs, struct task_req *req)
+static int rollbackstartsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
 
 /* Rollback stop session task */
-static int rollbackstopsess  (struct vserver *vs, struct task_req *req)
+static int rollbackstopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing or need to implement */
 }
@@ -307,6 +307,6 @@ static struct task task_serviceclass = {
   .rollbackstopsess = &rollbackstopsess,
 };
 
-void rh_task_serviceclass_reg(struct main_server *ms) {
+void rh_task_serviceclass_reg(RHMainServer *ms) {
   task_register(ms, &task_serviceclass);
 }
index ba40e96..f8f50b4 100644 (file)
@@ -1,12 +1,14 @@
 /**
- * RahuNAS task serviceclass implementation 
+ * RahuNAS task serviceclass implementation
  * Author: Neutron Soutmun <neo.neutron@gmail.com>
  * Date:   2010-07-29
  */
 #ifndef __RH_TASK_SERVICECLASS_H
 #define __RH_TASK_SERVICECLASS_H
 
-extern void rh_task_serviceclass_reg(struct main_server *ms);
+#include "rh-server.h"
+
+extern void rh_task_serviceclass_reg(RHMainServer *ms);
 
 #endif // __RH_TASK_SERVICECLASS_H
 
index 90f0c44..90cfb15 100644 (file)
@@ -12,7 +12,7 @@
 #include "rh-task-dbset.h"
 #include "rh-task-bandwidth.h"
 
-void task_register(struct main_server *ms, struct task *task)
+void task_register(RHMainServer *ms, struct task *task)
 {
   GList *chk  = NULL;
   GList *node = NULL;
@@ -45,7 +45,7 @@ void task_register(struct main_server *ms, struct task *task)
   ms->task_list = g_list_insert_before(ms->task_list, node, task);
 }
 
-void rh_task_register(struct main_server *ms)
+void rh_task_register(RHMainServer *ms)
 {
   static int task_registered = 0;
 
@@ -66,11 +66,11 @@ void rh_task_register(struct main_server *ms)
   }
 }
 
-void rh_task_unregister(struct main_server *ms) {
+void rh_task_unregister(RHMainServer *ms) {
   g_list_free(ms->task_list);
 }
 
-int  rh_task_startservice(struct main_server *ms)
+int  rh_task_startservice(RHMainServer *ms)
 {
   GList *runner = g_list_first(ms->task_list);
   struct task *ltask = NULL;
@@ -87,7 +87,7 @@ int  rh_task_startservice(struct main_server *ms)
   return 0;
 }
 
-int rh_task_stopservice(struct main_server *ms)
+int rh_task_stopservice(RHMainServer *ms)
 {  
   GList *runner = g_list_last(ms->task_list);
   struct task *ltask = NULL;
@@ -104,7 +104,7 @@ int rh_task_stopservice(struct main_server *ms)
   return 0;
 }
 
-void rh_task_init (struct main_server *ms, struct vserver *vs)
+void rh_task_init (RHMainServer *ms, RHVServer *vs)
 {
   GList *runner = g_list_first(ms->task_list);
   struct task *ltask = NULL;
@@ -118,7 +118,7 @@ void rh_task_init (struct main_server *ms, struct vserver *vs)
   }
 }
 
-void rh_task_cleanup(struct main_server *ms, struct vserver *vs)
+void rh_task_cleanup(RHMainServer *ms, RHVServer *vs)
 {
   GList *runner = g_list_last(ms->task_list);
   struct task *ltask = NULL;
@@ -132,9 +132,9 @@ void rh_task_cleanup(struct main_server *ms, struct vserver *vs)
   }  
 }
 
-int  rh_task_startsess(struct vserver *vs, struct task_req *req)
+int  rh_task_startsess(RHVServer *vs, struct task_req *req)
 {
-  struct main_server *ms = &rh_main_server_instance;
+  RHMainServer *ms = &rh_main_server_instance;
   GList *runner = g_list_first(ms->task_list);
   struct task *ltask = NULL;
 
@@ -149,9 +149,9 @@ int  rh_task_startsess(struct vserver *vs, struct task_req *req)
   return 0;
 }
 
-int  rh_task_stopsess(struct vserver *vs, struct task_req *req)
+int  rh_task_stopsess(RHVServer *vs, struct task_req *req)
 {
-  struct main_server *ms = &rh_main_server_instance;
+  RHMainServer *ms = &rh_main_server_instance;
   GList *runner = g_list_last(ms->task_list);
   struct task *ltask = NULL;
 
@@ -166,18 +166,18 @@ int  rh_task_stopsess(struct vserver *vs, struct task_req *req)
   return 0;
 }
 
-int  rh_task_commitstartsess(struct vserver *vs, struct task_req *req)
+int  rh_task_commitstartsess(RHVServer *vs, struct task_req *req)
 {
 }
 
-int  rh_task_commitstopsess(struct vserver *vs, struct task_req *req)
+int  rh_task_commitstopsess(RHVServer *vs, struct task_req *req)
 {
 }
 
-int  rh_task_rollbackstartsess(struct vserver *vs, struct task_req *req)
+int  rh_task_rollbackstartsess(RHVServer *vs, struct task_req *req)
 {
 }
 
-int  rh_task_rollbackstopsess(struct vserver *vs, struct task_req *req)
+int  rh_task_rollbackstopsess(RHVServer *vs, struct task_req *req)
 {
 }
index 38437b0..24849ef 100644 (file)
@@ -39,43 +39,43 @@ struct task {
   int (*stopservice) (void);
 
   /* Initialize */
-  void (*init) (struct vserver *vs);
+  void (*init) (RHVServer  *vs);
 
   /* Cleanup */
-  void (*cleanup) (struct vserver *vs);
+  void (*cleanup) (RHVServer  *vs);
 
   /* Start session task */
-  int (*startsess) (struct vserver *vs, struct task_req *req);
+  int (*startsess) (RHVServer  *vs, struct task_req *req);
 
   /* Stop session task */
-  int (*stopsess) (struct vserver *vs, struct task_req *req);
+  int (*stopsess) (RHVServer  *vs, struct task_req *req);
 
   /* Commit start session task */
-  int (*commitstartsess) (struct vserver *vs, struct task_req *req);
+  int (*commitstartsess) (RHVServer  *vs, struct task_req *req);
 
   /* Commit stop session task */
-  int (*commitstopsess) (struct vserver *vs, struct task_req *req);
+  int (*commitstopsess) (RHVServer  *vs, struct task_req *req);
 
   /* Rollback start session task */
-  int (*rollbackstartsess) (struct vserver *vs, struct task_req *req);
+  int (*rollbackstartsess) (RHVServer  *vs, struct task_req *req);
 
   /* Rollback stop session task */
-  int (*rollbackstopsess) (struct vserver *vs, struct task_req *req);
+  int (*rollbackstopsess) (RHVServer  *vs, struct task_req *req);
 };
 
-extern void task_register(struct main_server *ms, struct task *task);
-
-void rh_task_register(struct main_server *ms);
-void rh_task_unregister(struct main_server *ms);
-int  rh_task_startservice(struct main_server *ms);
-int  rh_task_stopservice(struct main_server *ms);
-void rh_task_init(struct main_server *ms, struct vserver *vs);
-void rh_task_cleanup(struct main_server *ms, struct vserver *vs);
-int  rh_task_startsess(struct vserver *vs, struct task_req *req);
-int  rh_task_stopsess(struct vserver *vs, struct task_req *req);
-int  rh_task_commitstartsess(struct vserver *vs, struct task_req *req);
-int  rh_task_commitstopsess(struct vserver *vs, struct task_req *req);
-int  rh_task_rollbackstartsess(struct vserver *vs, struct task_req *req);
-int  rh_task_rollbackstopsess(struct vserver *vs, struct task_req *req);
+extern void task_register(RHMainServer *ms, struct task *task);
+
+void rh_task_register          (RHMainServer *ms);
+void rh_task_unregister        (RHMainServer *ms);
+int  rh_task_startservice      (RHMainServer *ms);
+int  rh_task_stopservice       (RHMainServer *ms);
+void rh_task_init              (RHMainServer *ms, RHVServer  *vs);
+void rh_task_cleanup           (RHMainServer *ms, RHVServer  *vs);
+int  rh_task_startsess         (RHVServer  *vs, struct task_req *req);
+int  rh_task_stopsess          (RHVServer  *vs, struct task_req *req);
+int  rh_task_commitstartsess   (RHVServer  *vs, struct task_req *req);
+int  rh_task_commitstopsess    (RHVServer  *vs, struct task_req *req);
+int  rh_task_rollbackstartsess (RHVServer  *vs, struct task_req *req);
+int  rh_task_rollbackstopsess  (RHVServer  *vs, struct task_req *req);
 
 #endif // __RH_TASK_H
index 0dde135..5aee6c7 100644 (file)
@@ -4,6 +4,7 @@
  * Date:   2008-08-31
  */
 
+#include <string.h>
 #include <syslog.h>
 #include <glib.h>
 #include <time.h>
@@ -40,13 +41,13 @@ void rh_free(void **data)
   *data = NULL;
 }
 
-const char *rh_string_get_sep(const char *haystack, const char *sep, 
-                              unsigned short idx)
+gchar *rh_string_get_sep(const char *haystack, const char *sep,
+                         unsigned short idx)
 {
-  char  *result = NULL;
-  gchar *pStart = NULL;
-  gchar *pEnd   = NULL;
-  gchar *pLast  = NULL;
+  gchar *result = NULL;
+  const gchar *pStart = NULL;
+  const gchar *pEnd   = NULL;
+  const gchar *pLast  = NULL;
   unsigned short current_idx = 0;
   unsigned short isFound = 0;
 
@@ -135,8 +136,8 @@ int logmsg(int priority, const char *msg, ...)
 
   fprintf(stderr, "%s : %s\n", timemsg(), p);
 
-  rh_free(&p);
-  rh_free(&np);
+  rh_free((void **) &p);
+  rh_free((void **) &np);
 }
 
 
@@ -180,7 +181,7 @@ uint32_t iptoid(struct rahunas_map *map, const char *ip) {
   return ret; 
 }
 
-char *idtoip(struct rahunas_map *map, uint32_t id) {
+const char *idtoip(struct rahunas_map *map, uint32_t id) {
   struct in_addr sess_addr;
 
   if (!map)
index 68dc35e..83ab1ce 100644 (file)
@@ -13,8 +13,8 @@
 void *rh_malloc(size_t size);
 void rh_free(void **data);
 
-const char *rh_string_get_sep(const char *haystack, const char *sep, 
-                              unsigned short idx);
+gchar *rh_string_get_sep(const char *haystack, const char *sep,
+                         unsigned short idx);
 int rh_openlog(const char *filename);
 int rh_closelog(int fd);
 int rh_logselect(int fd);
@@ -22,6 +22,6 @@ int rh_writepid(const char *pidfile, int pid);
 int logmsg(int priority, const char *msg, ...);
 
 uint32_t iptoid(struct rahunas_map *map, const char *ip);
-char *idtoip(struct rahunas_map *map, uint32_t id);
+const char *idtoip(struct rahunas_map *map, uint32_t id);
 
 #endif // __RH_UTILS_H
index 7bdf353..df6b0ea 100644 (file)
@@ -9,7 +9,7 @@
 #include "rh-xmlrpc-cmd.h"
 #include "rh-task-memset.h"
 
-int send_xmlrpc_stopacct(struct vserver *vs, uint32_t id, int cause) {
+int send_xmlrpc_stopacct(RHVServer *vs, uint32_t id, int cause) {
   GNetXmlRpcClient *client = NULL;
   gchar *reply  = NULL;
   gchar *params = NULL;
index 4c30ec2..2c26dd9 100644 (file)
@@ -7,6 +7,6 @@
 #define __RH_XMLRPC_CMD_H
 #include "rh-radius.h"
 
-int send_xmlrpc_stopacct(struct vserver *vs, uint32_t id, int cause);
+int send_xmlrpc_stopacct(RHVServer *vs, uint32_t id, int cause);
 
 #endif // __RH_XMLRPC_CMD_H
index f80dbe2..f5e6209 100644 (file)
@@ -7,7 +7,10 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
 #include "rahunasd.h"
+#include "rh-server.h"
 #include "rh-xmlrpc-server.h"
 #include "rh-radius.h"
 #include "rh-ipset.h"
@@ -23,8 +26,8 @@ int do_startsession(GNetXmlRpcServer *server,
                     gpointer user_data,
                     gchar **reply_string) 
 {
-  struct main_server *ms = (struct main_server *)user_data; 
-  struct vserver *vs = NULL;
+  RHMainServer *ms = (RHMainServer *)user_data;
+  RHVServer    *vs = NULL;
   unsigned char ethernet[ETH_ALEN] = {0,0,0,0,0,0};
   struct task_req req;
   gchar *ip = NULL;
@@ -40,6 +43,8 @@ int do_startsession(GNetXmlRpcServer *server,
   GList *member_node = NULL;
   struct rahunas_member *member = NULL;
 
+  pthread_mutex_lock (&RHMtxLock);
+
   if (param == NULL)
     goto out;
 
@@ -76,6 +81,7 @@ int do_startsession(GNetXmlRpcServer *server,
 
   /* Check if client already registered */
   member_node = member_get_node_by_id(vs, id);
+
   if (member_node != NULL)
     goto greeting;
 
@@ -83,8 +89,8 @@ int do_startsession(GNetXmlRpcServer *server,
   req.vserver_id = atoi(vserver_id);
   req.username = username;
   req.session_id = session_id;
-  parse_mac(mac_address, &ethernet);
-  memcpy(req.mac_address, &ethernet, ETH_ALEN);
+  parse_mac(mac_address, ethernet);
+  memcpy(req.mac_address, ethernet, ETH_ALEN);
   req.session_start = 0;
   req.session_timeout = 0;
 
@@ -123,9 +129,10 @@ greeting:
 
 out:
   *reply_string = g_strdup("Invalid input parameters");
-  goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);
   g_free(username);
@@ -145,8 +152,8 @@ int do_stopsession(GNetXmlRpcServer *server,
                    gpointer user_data,
                    gchar **reply_string)
 {
-  struct main_server *ms = (struct main_server *)user_data;
-  struct vserver *vs = NULL;
+  RHMainServer *ms = (RHMainServer *)user_data;
+  RHVServer    *vs = NULL;
   struct task_req req;
   gchar *ip = NULL;
   gchar *mac_address = NULL;
@@ -159,6 +166,8 @@ int do_stopsession(GNetXmlRpcServer *server,
   GList *member_node = NULL;
   struct rahunas_member *member = NULL;
 
+  pthread_mutex_lock (&RHMtxLock);
+
   if (param == NULL)
     goto out;
 
@@ -186,8 +195,8 @@ int do_stopsession(GNetXmlRpcServer *server,
     goto cleanup;
   }
 
-  parse_mac(mac_address, &ethernet);
-  memcpy(req.mac_address, &ethernet, ETH_ALEN);
+  parse_mac(mac_address, ethernet);
+  memcpy(req.mac_address, ethernet, ETH_ALEN);
 
   member_node = member_get_node_by_id(vs, id);
 
@@ -226,9 +235,10 @@ int do_stopsession(GNetXmlRpcServer *server,
 
 out:
   *reply_string = g_strdup("Invalid input parameters");
-  goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);
   g_free(mac_address);
@@ -243,14 +253,16 @@ int do_getsessioninfo(GNetXmlRpcServer *server,
                       gpointer user_data,
                       gchar **reply_string)
 {
-  struct main_server *ms = (struct main_server *)user_data;
-  struct vserver *vs = NULL;
+  RHMainServer *ms = (RHMainServer *)user_data;
+  RHVServer    *vs = NULL;
   gchar *ip = NULL;
   gchar *vserver_id = NULL;
   uint32_t   id;
   GList *member_node = NULL;
   struct rahunas_member *member = NULL;
 
+  pthread_mutex_lock (&RHMtxLock);
+
   if (param == NULL)
     goto out;
 
@@ -304,9 +316,10 @@ int do_getsessioninfo(GNetXmlRpcServer *server,
 
 out:
   *reply_string = g_strdup("Invalid input parameters");
-   goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);
   g_free(vserver_id);
index 251929c..80ee191 100644 (file)
@@ -14,7 +14,8 @@ squid_auth_helper_SOURCES = \
 squid_auth_helper_CPPFLAGS = \
        -I$(top_srcdir)/lcfg \
        -I$(top_srcdir)/xmlrpc \
-       $(LIBGNET_CFLAGS)
+       $(LIBGNET_CFLAGS) \
+        -D_GNU_SOURCE
 squid_auth_helper_LDADD = \
        $(top_builddir)/lcfg/liblcfg.a \
        $(top_builddir)/xmlrpc/libgnetxmlrpc.a  \
index d3e7e84..f347f4f 100644 (file)
Binary files a/weblogin/locale/th_TH/LC_MESSAGES/messages.mo and b/weblogin/locale/th_TH/LC_MESSAGES/messages.mo differ