Changeset cb5371333692435b9818b9043a26980e404202d1

Timestamp:

06/20/11 22:46:42 (11 months ago)

Author:

Neutron Soutmun <neo.neutron@…>

Children:

4b5d05b46785f944e0d4ba506afeb9df499a6aac

Parents:

215b3eba66c465438d9ed78037766d0f7f7b4dea

git-committer:

Neutron Soutmun <neo.neutron@…> (06/20/11 22:46:42)

Message:

Cherry-picks the code from 0.1.x branch

• The codes have been refactor and fix the compiler warnings.
• Adjust the codes for new API changes from 0.1.x branch.

Files:

• configure.ac (modified) (1 diff)
• data/rahunas.db (modified) (previous)
• src/Makefile.am (modified) (1 diff)
• src/rahunasd.c (modified) (13 diffs)
• src/rahunasd.h (modified) (2 diffs)
• src/rh-config.c (modified) (5 diffs)
• src/rh-config.h (modified) (1 diff)
• src/rh-ipset.c (modified) (9 diffs)
• src/rh-ipset.h (modified) (3 diffs)
• src/rh-server.c (modified) (16 diffs)
• src/rh-server.h (modified) (2 diffs)
• src/rh-serviceclass.h (modified) (1 diff)
• src/rh-task-bandwidth.c (modified) (16 diffs)
• src/rh-task-bandwidth.h (modified) (3 diffs)
• src/rh-task-dbset.c (modified) (15 diffs)
• src/rh-task-dbset.h (modified) (1 diff)
• src/rh-task-ipset.c (modified) (12 diffs)
• src/rh-task-ipset.h (modified) (1 diff)
• src/rh-task-iptables.c (modified) (13 diffs)
• src/rh-task-iptables.h (modified) (1 diff)
• src/rh-task-memset.c (modified) (14 diffs)
• src/rh-task-memset.h (modified) (1 diff)
• src/rh-task-serviceclass.c (modified) (11 diffs)
• src/rh-task-serviceclass.h (modified) (2 diffs)
• src/rh-task.c (modified) (9 diffs)
• src/rh-task.h (modified) (1 diff)
• src/rh-utils.c (modified) (4 diffs)
• src/rh-utils.h (modified) (2 diffs)
• src/rh-xmlrpc-cmd.c (modified) (1 diff)
• src/rh-xmlrpc-cmd.h (modified) (1 diff)
• src/rh-xmlrpc-server.c (modified) (13 diffs)
• tools/Makefile.am (modified) (1 diff)
• weblogin/locale/th_TH/LC_MESSAGES/messages.mo (modified) (previous)

configure.ac

@@ -29 +29 @@
 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]) ])
 

src/Makefile.am

@@ -17 +17 @@
   -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 = \

src/rahunasd.c

@@ -27 +27 @@
 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)
@@ -63 +80 @@
 }
 
-size_t expired_check(void *data)
+static int
+expired_check(void *data)
 {
   struct processing_set *process = (struct processing_set *) data;
@@ -83 +101 @@
 
   while (runner != NULL) {
+    time_t time_now = time (NULL);
+
     member = (struct rahunas_member *)runner->data;
     runner = g_list_next(runner);
@@ -94 +114 @@
     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
@@ -105 +124 @@
       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));
@@ -115 +138 @@
       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);
-    }
-  }
-}
-
-int polling_expired_check(struct main_server *ms, struct vserver *vs) {
-  walk_through_set(&expired_check, vs);
+      pthread_mutex_unlock (&RHMtxLock);
+    }
+  }
+}
+
+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()
-{
-  walk_through_vserver(&rh_task_cleanup, rh_main_server);
+static void
+rh_exit (void)
+{
+  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);
-}
-
-void rh_reload()
+  rh_closelog(rh_main_server->log_fd);
+}
+
+static void
+rh_reload (void)
 {
   logmsg(RH_LOG_NORMAL, "Reloading config files");
@@ -187 +213 @@
   }
 
-  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);
   
@@ -306 +332 @@
 
 
-int main(int argc, char **argv) 
+int main(int argc, char *argv[])
 {
   gchar* addr = "localhost";
@@ -328 +354 @@
   GNetXmlRpcServer *server = NULL;
   GMainLoop* main_loop     = NULL;
+  pthread_t  polling_tid;
 
   signal(SIGTERM, &rh_sighandler);
@@ -384 +411 @@
 
   if (rh_main_server->main_config->serviceclass)
-    walk_through_serviceclass(&serviceclass_init, rh_main_server);
-
-  walk_through_vserver(&rh_task_init, rh_main_server);
+    walk_through_serviceclass(do_serviceclass_init, rh_main_server);
+
+  walk_through_vserver(do_task_init, rh_main_server);
 
   gnet_init();
@@ -396 +423 @@
   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);
   }
@@ -418 +445 @@
 
   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);
@@ -427 +464 @@
   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);
+    }
+}

src/rahunasd.h

@@ -12 +12 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <pthread.h>
 #include <time.h>
 #include <linux/if_ether.h>
@@ -24 +25 @@
 
 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 {

src/rh-config.c

@@ -4 +4 @@
  * Date:   2008-11-26
  */
+
+#include <string.h>
+#include <stdlib.h>
 #include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
 #include <syslog.h>
 #include <dirent.h>
@@ -298 +299 @@
 
   
-  rh_free(&clone_key);
+  rh_free((void **) &clone_key);
 
   return lcfg_status_ok;
@@ -349 +350 @@
 }
 
-int get_vservers_config(const char *conf_dir, struct main_server *server)
+int get_vservers_config(const char *conf_dir, RHMainServer *server)
 {
   DIR *dp;
@@ -411 +412 @@
 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)
-{
-  rh_free(&(config->serviceclass_name));
-  rh_free(&(config->description));
-  rh_free(&(config->network));
-  rh_free(&(config->fake_arpd));
-  rh_free(&(config->fake_arpd_iface));
+int
+cleanup_serviceclass_config(struct rahunas_serviceclass_config *config)
+{
+  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;
@@ -461 +463 @@
 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;

src/rh-config.h

@@ -130 +130 @@
 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);

src/rh-ipset.c

@@ -7 +7 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <errno.h>
 #include <unistd.h>
@@ -107 +108 @@
 }
 
-int kernel_getfrom_handleerrno(void *data, size_t * size)
+int kernel_getfrom_handleerrno(void *data, socklen_t * size)
 {
   int res = wrapped_getsockopt(data, size);
@@ -234 +235 @@
   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);
@@ -381 +382 @@
 }
 
-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)
@@ -448 +449 @@
 }
 
-int get_header_from_set (struct vserver *vs)
+int get_header_from_set (RHVServer *vs)
 {
   struct ip_set_req_rahunas_create *header = NULL;
@@ -510 +511 @@
 }
 
-int walk_through_set (int (*callback)(void *), struct vserver *vs)
+int walk_through_set (int (*callback)(void *), RHVServer *vs)
 {
   struct processing_set process;
@@ -517 +518 @@
   socklen_t size, req_size;
   int res = 0;
-   
-  check_protocolversion ();
+
+  check_protocolversion ();
+
+  pthread_mutex_lock (&RHMtxLock);
 
   size = req_size = load_set_list(vs, vs->vserver_config->vserver_name, &idx, 
@@ -534 +537 @@
     if (res != 0 || size != req_size) {
       rh_free(&data);
+      pthread_mutex_unlock (&RHMtxLock);
       return -EAGAIN;
     }
@@ -542 +546 @@
     process.vs = vs;
     process.list = data;
+
+    pthread_mutex_unlock (&RHMtxLock);
     (*callback)(&process);
-  }
-
-  rh_free(&data);
-  return res;
+    rh_free (&data);
+    return 0;
+  }
+
+  pthread_mutex_unlock (&RHMtxLock);
+  return 0;
 }
 

src/rh-ipset.h

@@ -29 +29 @@
 
 struct processing_set {
-  struct vserver *vs;
+  RHVServer *vs;
   void *list;
 };
@@ -77 +77 @@
 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, 
@@ -92 +92 @@
 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);

src/rh-server.c

@@ -5 +5 @@
  */
 #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)
-{
-  GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
-
-  while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+RHVServer *
+vserver_exists (GList *vserver_list, int vserver_id, const char *vserver_name)
+{
+  GList *runner = g_list_first(vserver_list);
+  RHVServer *lvserver = NULL;
+
+  while (runner != NULL) {
+    lvserver = (RHVServer *)runner->data;
    
     if (lvserver->vserver_config->vserver_id == vserver_id)
@@ -29 +30 @@
 }
 
-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;
-
-  while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+  RHVServer *lvserver = NULL;
+
+  while (runner != NULL) {
+    lvserver = (RHVServer *)runner->data;
    
     if (lvserver->vserver_config->vserver_id == search_id) {
@@ -46 +47 @@
 }
 
-int vserver_cleanup(struct vserver *vs)
+int vserver_cleanup(RHVServer *vs)
 {
   if (vs == NULL)
@@ -57 +58 @@
 }
 
-int mainserver_cleanup(struct main_server *ms)
+int mainserver_cleanup(RHMainServer *ms)
 {
   if (ms == NULL)
@@ -68 +69 @@
 }
 
-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;
@@ -77 +78 @@
   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 = {
@@ -130 +131 @@
       if (old_vserver->dummy_config != NULL) {
         DP("Cleanup old dummy config");
-        rh_free(&old_vserver->dummy_config);
+        rh_free((void **) &old_vserver->dummy_config);
       }
 
@@ -167 +168 @@
   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;
@@ -182 +183 @@
 }
 
-int unregister_vserver(struct main_server *ms, int vserver_id)
-{
-  GList *vserver_list = ms->vserver_list;
-  GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
-
-  while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+int unregister_vserver(RHMainServer *ms, int vserver_id)
+{
+  GList *vserver_list = ms->vserver_list;
+  GList *runner = g_list_first(vserver_list);
+  RHVServer *lvserver = NULL;
+
+  while (runner != NULL) {
+    lvserver = (RHVServer *)runner->data;
     if (lvserver->vserver_config->vserver_id == vserver_id) {
       vserver_cleanup(lvserver);
@@ -202 +203 @@
 }
 
-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;
-
-  while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+  RHVServer *lvserver = NULL;
+
+  while (runner != NULL) {
+    lvserver = (RHVServer *)runner->data;
     vserver_cleanup(lvserver);
     deleting = runner;
@@ -222 +223 @@
 }
 
-int walk_through_vserver(int (*callback)(void *, void *), struct main_server *ms)
-{
-  GList *vserver_list = ms->vserver_list;
-  GList *runner = g_list_first(vserver_list);
-  struct vserver *vs = NULL;
-
-  while (runner != NULL) {
-    vs = (struct vserver *)runner->data;
+int walk_through_vserver(int (*callback)(RHMainServer *, RHVServer*),
+                         RHMainServer *ms)
+{
+  GList *vserver_list = ms->vserver_list;
+  GList *runner = g_list_first(vserver_list);
+  RHVServer *vs = NULL;
+
+  while (runner != NULL) {
+    vs = (RHVServer *)runner->data;
 
     (*callback)(ms, vs);
@@ -239 +241 @@
 }
 
-void vserver_init_done(struct main_server *ms, struct vserver *vs)
+void vserver_init_done(RHMainServer *ms, RHVServer *vs)
 {
   if (vs != NULL) {
@@ -247 +249 @@
 }
 
-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) {
@@ -287 +289 @@
         memcpy(vs->vserver_config, vs->dummy_config, 
           sizeof(struct rahunas_vserver_config));
-        rh_free(&vs->dummy_config);
+        rh_free((void **) &vs->dummy_config);
       }
 
@@ -299 +301 @@
 
 
-void vserver_unused_cleanup(struct main_server *ms)
-{
-  GList *vserver_list = ms->vserver_list;
-  GList *runner = g_list_first(vserver_list);
-  struct vserver *lvserver = NULL;
-
-  while (runner != NULL) {
-    lvserver = (struct vserver *)runner->data;
+void vserver_unused_cleanup(RHMainServer *ms)
+{
+  GList *vserver_list = ms->vserver_list;
+  GList *runner = g_list_first(vserver_list);
+  RHVServer *lvserver = NULL;
+
+  while (runner != NULL) {
+    lvserver = (RHVServer *)runner->data;
     if (lvserver->vserver_config->init_flag == VS_NONE) {
       logmsg(RH_LOG_NORMAL, "[%s] - Config removed",
@@ -319 +321 @@
     }
   }
-  
-  return 0;
-}
+}

src/rh-server.h

@@ -9 +9 @@
 #include <glib.h>
 #include "rh-config.h"
+
+typedef struct vserver     RHVServer;
+typedef struct main_server RHMainServer;
 
 struct main_server {
@@ -24 +27 @@
   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

src/rh-serviceclass.h

@@ -11 +11 @@
 
 #define SERVICECLASS_SET_NAME   "rahunas_serviceclass"
+
+typedef struct serviceclass RHSvClass;
 
 struct serviceclass {

src/rh-task-bandwidth.c

@@ -6 +6 @@
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <sys/types.h>
@@ -67 +68 @@
 }
 
-int bandwidth_exec(struct vserver *vs, char *const args[])
+int bandwidth_exec(RHVServer *vs, char *const args[])
 {
   pid_t ws;
@@ -135 +136 @@
 }
 
-int bandwidth_start(struct vserver *vs)
+int bandwidth_start(RHVServer *vs)
 {
   char *args[5];
@@ -153 +154 @@
 }
 
-int bandwidth_stop(struct vserver *vs)
+int bandwidth_stop(RHVServer *vs)
 {
   char *args[5];
@@ -171 +172 @@
 }
 
-int bandwidth_add(struct vserver *vs, struct bandwidth_req *bw_req)
+int bandwidth_add(RHVServer *vs, struct bandwidth_req *bw_req)
 {
   char *args[9];
@@ -192 +193 @@
 }
 
-int bandwidth_del(struct vserver *vs, struct bandwidth_req *bw_req)
+int bandwidth_del(RHVServer *vs, struct bandwidth_req *bw_req)
 {
   char *args[6];
@@ -222 +223 @@
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   struct interfaces *iface = NULL;
@@ -244 +245 @@
 
 /* Cleanup */
-static int cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   struct interfaces *iface = NULL;
@@ -264 +265 @@
 
 /* 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;
@@ -283 +284 @@
   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
@@ -316 +321 @@
 
 /* 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;
@@ -348 +353 @@
 
 /* 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 */
@@ -354 +359 @@
 
 /* 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 */
@@ -360 +365 @@
 
 /* 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 */
@@ -366 +371 @@
 
 /* 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 */
@@ -386 +391 @@
 };
 
-void rh_task_bandwidth_reg(struct main_server *ms) {
+void rh_task_bandwidth_reg(RHMainServer *ms) {
   task_register(ms, &taskbandwidth);
 }

src/rh-task-bandwidth.h

@@ -6 +6 @@
 #ifndef __RH_TASK_BANDWIDTH_H
 #define __RH_TASK_BANDWIDTH_H
+
+#include "rh-server.h"
 
 /* MAX_SLOT_PAGE is calculated from the formula of
@@ -18 +20 @@
 #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 {
@@ -27 +29 @@
 };
 
-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

src/rh-task-dbset.c

@@ -14 +14 @@
 #include "rh-ipset.h"
 #include "rh-utils.h"
+#include "rh-task-memset.h"
 
 struct dbset_row {
@@ -51 +52 @@
 }
 
-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;
@@ -201 +203 @@
 }
 
-gboolean restore_set(GList **data_list, struct vserver *vs)
+gboolean restore_set(GList **data_list, RHVServer *vs)
 {
   GList *node = NULL;
@@ -234 +236 @@
     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;
@@ -252 +254 @@
 }
 
-
-GdaConnection *openconn (GdaConnectionOptions options)
+GdaConnection *
+openconn (GdaConnectionOptions options)
 {
   GdaConnection *connection = NULL;
@@ -302 +304 @@
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   GdaConnection *connection;
@@ -335 +337 @@
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   /* Do nothing */
@@ -341 +343 @@
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   GdaConnection *connection;
@@ -353 +355 @@
   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));
 
@@ -392 +394 @@
 
 /* Stop session task */
-static int stopsess (struct vserver *vs, struct task_req *req)
+static int stopsess (RHVServer *vs, struct task_req *req)
 {
   GdaConnection *connection;
@@ -428 +430 @@
 
 /* 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 */
@@ -434 +436 @@
 
 /* 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 */
@@ -440 +442 @@
 
 /* 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 */
@@ -446 +448 @@
 
 /* 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 */
@@ -466 +468 @@
 };
 
-void rh_task_dbset_reg(struct main_server *ms) {
+void rh_task_dbset_reg(RHMainServer *ms) {
   task_register(ms, &task_dbset);
 }

src/rh-task-dbset.h

@@ -7 +7 @@
 #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

src/rh-task-ipset.c

@@ -6 +6 @@
  */
 
+#include <string.h>
 #include <syslog.h>
 
@@ -13 +14 @@
 #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;
@@ -40 +42 @@
     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);
@@ -60 +62 @@
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   if (vs->vserver_config->init_flag == VS_RELOAD)
@@ -79 +81 @@
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   if (vs->vserver_config->init_flag == VS_RELOAD)
@@ -90 +92 @@
 
   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;
@@ -107 +108 @@
 
 /* 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;
@@ -119 +120 @@
 
 /* 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 */
@@ -125 +126 @@
 
 /* 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 */
@@ -131 +132 @@
 
 /* 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 */
@@ -137 +138 @@
 
 /* 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 */
@@ -157 +158 @@
 };
 
-void rh_task_ipset_reg(struct main_server *ms) {
+void rh_task_ipset_reg(RHMainServer *ms) {
   task_register(ms, &task_ipset);
 }

src/rh-task-ipset.h

@@ -7 +7 @@
 #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

src/rh-task-iptables.c

@@ -6 +6 @@
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <sys/types.h>
@@ -17 +18 @@
 #include "rh-utils.h"
 
-int iptables_exec(struct vserver *vs, char *const args[])
+int iptables_exec(RHVServer *vs, char *const args[])
 {
   pid_t ws;
@@ -106 +107 @@
 }
 
-int iptables_start(struct vserver *vs)
+int iptables_start(RHVServer *vs)
 {
   char *args[3];
@@ -119 +120 @@
 }
 
-int iptables_stop(struct vserver *vs)
+int iptables_stop(RHVServer *vs)
 {
   char *args[3];
@@ -145 +146 @@
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   logmsg(RH_LOG_NORMAL, "[%s] Task IPTABLES initialize..", 
@@ -154 +155 @@
 
 /* Cleanup */
-static int cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   logmsg(RH_LOG_NORMAL, "[%s] Task IPTABLES cleanup..",
@@ -163 +164 @@
 
 /* Start session task */
-static int startsess (struct vserver *vs, struct task_req *req)
+static int startsess (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing */
@@ -170 +171 @@
 
 /* Stop session task */
-static int stopsess  (struct vserver *vs, struct task_req *req)
+static int stopsess  (RHVServer *vs, struct task_req *req)
 {
   /* Do nothing */
@@ -177 +178 @@
 
 /* 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 */
@@ -183 +184 @@
 
 /* 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 */
@@ -189 +190 @@
 
 /* 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 */
@@ -195 +196 @@
 
 /* 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 */
@@ -215 +216 @@
 };
 
-void rh_task_iptables_reg(struct main_server *ms) {
+void rh_task_iptables_reg(RHMainServer *ms) {
   task_register(ms, &taskiptables);
 }

src/rh-task-iptables.h

@@ -7 +7 @@
 #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

src/rh-task-memset.c

@@ -6 +6 @@
 
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 #include <time.h>
@@ -13 +14 @@
 #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);
@@ -30 +31 @@
 }
 
-gint idcmp(struct rahunas_member *a, struct rahunas_member *b)
-{
-  if (a != NULL && b != NULL)
-    return (a->id - b->id);
+static gint
+idcmp(gconstpointer a, gconstpointer b)
+{
+  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;
@@ -53 +58 @@
 
 /* Initialize */
-static void init (struct vserver *vs)
+static void init (RHVServer *vs)
 {
   int size;
@@ -79 +84 @@
 
 /* Cleanup */
-static void cleanup (struct vserver *vs)
+static void cleanup (RHVServer *vs)
 {
   GList *runner = NULL;
@@ -109 +114 @@
     g_list_free(vs->v_map->members);
 
-    rh_free(&(vs->v_map->members));
-    rh_free(&(vs->v_map));
-  }
-
-  return 0;
+    rh_free((void **) &vs->v_map->members);
+    rh_free((void **) &vs->v_map);
+  }
 }
 
 /* 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;
@@ -157 +160 @@
   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;
@@ -196 +199 @@
 
 /* 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;
@@ -227 +230 @@
   }
   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, "
@@ -249 +252 @@
 
 /* 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 */
@@ -255 +258 @@
 
 /* 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 */
@@ -261 +264 @@
 
 /* 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 */
@@ -267 +270 @@
 
 /* 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 */
@@ -287 +290 @@
 };
 
-void rh_task_memset_reg(struct main_server *ms) {
+void rh_task_memset_reg(RHMainServer *ms) {
   task_register(ms, &task_memset);
 }

src/rh-task-memset.h

@@ -7 +7 @@
 #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
 

src/rh-task-serviceclass.c

@@ -1 +1 @@
 /**
- * RahuNAS task serviceclass implementation 
+ * RahuNAS task serviceclass implementation
  * Author: Neutron Soutmun <neo.neutron@gmail.com>
  * Date:   2010-07-29
@@ -18 +18 @@
 {
   uint32_t slot_id = 0;
-  time_t random_time; 
+  time_t random_time;
   int  retry = 30;
   char select_cmd[256];
@@ -56 +56 @@
         free_data_list(data_list);
         break;
-      } else { 
+      } else {
         // Not available, retry
         free_data_list(data_list);
@@ -86 +86 @@
     logmsg(RH_LOG_NORMAL, "Service Class: Flushing set ...");
     set_flush (SERVICECLASS_SET_NAME);
-    rh_free(&rh_serviceclass_set); 
+    rh_free(&rh_serviceclass_set);
   }
 
@@ -93 +93 @@
 
 /* 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;
@@ -199 +199 @@
 
 /* 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;
@@ -270 +270 @@
 
 /* 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 */
@@ -276 +276 @@
 
 /* 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 */
@@ -282 +282 @@
 
 /* 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 */
@@ -288 +288 @@
 
 /* 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 */
@@ -308 +308 @@
 };
 
-void rh_task_serviceclass_reg(struct main_server *ms) {
+void rh_task_serviceclass_reg(RHMainServer *ms) {
   task_register(ms, &task_serviceclass);
 }

src/rh-task-serviceclass.h

@@ -1 +1 @@
 /**
- * RahuNAS task serviceclass implementation 
+ * RahuNAS task serviceclass implementation
  * Author: Neutron Soutmun <neo.neutron@gmail.com>
  * Date:   2010-07-29
@@ -7 +7 @@
 #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

src/rh-task.c

@@ -13 +13 @@
 #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;
@@ -46 +46 @@
 }
 
-void rh_task_register(struct main_server *ms)
+void rh_task_register(RHMainServer *ms)
 {
   static int task_registered = 0;
@@ -67 +67 @@
 }
 
-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);
@@ -88 +88 @@
 }
 
-int rh_task_stopservice(struct main_server *ms)
+int rh_task_stopservice(RHMainServer *ms)
 {  
   GList *runner = g_list_last(ms->task_list);
@@ -105 +105 @@
 }
 
-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);
@@ -119 +119 @@
 }
 
-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);
@@ -133 +133 @@
 }
 
-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;
@@ -150 +150 @@
 }
 
-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;
@@ -167 +167 @@
 }
 
-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)
 {
 }

src/rh-task.h

@@ -40 +40 @@
 
   /* 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);
+extern void task_register(RHMainServer *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);
+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

src/rh-utils.c

@@ -5 +5 @@
  */
 
+#include <string.h>
 #include <syslog.h>
 #include <glib.h>
@@ -41 +42 @@
 }
 
-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;
@@ -136 +137 @@
   fprintf(stderr, "%s : %s\n", timemsg(), p);
 
-  rh_free(&p);
-  rh_free(&np);
+  rh_free((void **) &p);
+  rh_free((void **) &np);
 }
 
@@ -181 +182 @@
 }
 
-char *idtoip(struct rahunas_map *map, uint32_t id) {
+const char *idtoip(struct rahunas_map *map, uint32_t id) {
   struct in_addr sess_addr;
 

src/rh-utils.h

@@ -14 +14 @@
 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);
@@ -23 +23 @@
 
 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

src/rh-xmlrpc-cmd.c

@@ -10 +10 @@
 #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;

src/rh-xmlrpc-cmd.h

@@ -8 +8 @@
 #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

src/rh-xmlrpc-server.c

@@ -8 +8 @@
 #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"
@@ -24 +27 @@
                     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;
@@ -41 +44 @@
   struct rahunas_member *member = NULL;
 
+  pthread_mutex_lock (&RHMtxLock);
+
   if (param == NULL)
     goto out;
@@ -77 +82 @@
   /* Check if client already registered */
   member_node = member_get_node_by_id(vs, id);
+
   if (member_node != NULL)
     goto greeting;
@@ -84 +90 @@
   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;
@@ -124 +130 @@
 out:
   *reply_string = g_strdup("Invalid input parameters");
-  goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);
@@ -146 +153 @@
                    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;
@@ -160 +167 @@
   struct rahunas_member *member = NULL;
 
+  pthread_mutex_lock (&RHMtxLock);
+
   if (param == NULL)
     goto out;
@@ -187 +196 @@
   }
 
-  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);
@@ -227 +236 @@
 out:
   *reply_string = g_strdup("Invalid input parameters");
-  goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);
@@ -244 +254 @@
                       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;
@@ -251 +261 @@
   GList *member_node = NULL;
   struct rahunas_member *member = NULL;
+
+  pthread_mutex_lock (&RHMtxLock);
 
   if (param == NULL)
@@ -305 +317 @@
 out:
   *reply_string = g_strdup("Invalid input parameters");
-   goto cleanup;
 
 cleanup:
+  pthread_mutex_unlock (&RHMtxLock);
+
   DP("RPC Reply: %s", *reply_string);
   g_free(ip);

tools/Makefile.am

@@ -15 +15 @@
         -I$(top_srcdir)/lcfg \
         -I$(top_srcdir)/xmlrpc \
-        $(LIBGNET_CFLAGS)
+        $(LIBGNET_CFLAGS) \
+        -D_GNU_SOURCE
 squid_auth_helper_LDADD = \
         $(top_builddir)/lcfg/liblcfg.a \