Implement module.entryGetField()

3 files changed, 280 insertions, 212 deletions

diff --git a/hardinfo2/hardinfo.h b/hardinfo2/hardinfo.h
index 31b1365a..0aabfe72 100644
--- a/hardinfo2/hardinfo.h
+++ b/hardinfo2/hardinfo.h
@@ -114,6 +114,7 @@ void	      module_entry_reload(ShellModuleEntry *module_entry);
 void	      module_entry_scan(ShellModuleEntry *module_entry);
 gchar	     *module_entry_function(ShellModuleEntry *module_entry);
 const gchar  *module_entry_get_note(ShellModuleEntry *module_entry);
+gchar        *module_entry_get_field(ShellModuleEntry * module_entry, gchar * field);
 
 /* BinReloc stuff */
 gboolean binreloc_init(gboolean try_hardcoded);
diff --git a/hardinfo2/util.c b/hardinfo2/util.c
index 9cef2cef..3aaa541b 100644
--- a/hardinfo2/util.c
+++ b/hardinfo2/util.c
@@ -1056,6 +1056,16 @@ void module_entry_scan(ShellModuleEntry * module_entry)
     }
 }
 
+gchar *module_entry_get_field(ShellModuleEntry * module_entry, gchar * field)
+{
+   if (module_entry->fieldfunc) {
+   	DEBUG("field=%s, entry=%s", field, module_entry->name);
+   	return module_entry->fieldfunc(field);
+   }
+   
+   return NULL;
+}
+
 gchar *module_entry_function(ShellModuleEntry * module_entry)
 {
     if (module_entry->func) {
diff --git a/hardinfo2/xmlrpc-server.c b/hardinfo2/xmlrpc-server.c
index 8ddefffc..cf77d44e 100644
--- a/hardinfo2/xmlrpc-server.c
+++ b/hardinfo2/xmlrpc-server.c
@@ -18,7 +18,7 @@
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  */
- 
+
 #include "config.h"
 
 #ifdef HAS_LIBSOUP
@@ -31,22 +31,29 @@
 
 #define XMLRPC_SERVER_VERSION		1
 /* server namespace */
-static void method_get_api_version(SoupMessage *msg, GValueArray *params);
-static void method_shutdown_server(SoupMessage *msg, GValueArray *params);
+static void method_get_api_version(SoupMessage * msg,
+				   GValueArray * params);
+static void method_shutdown_server(SoupMessage * msg,
+				   GValueArray * params);
 /* module namespace */
-static void method_get_module_list(SoupMessage *msg, GValueArray *params);
-static void method_get_entry_list(SoupMessage *msg, GValueArray *params);
-static void method_entry_reload(SoupMessage *msg, GValueArray *params);
-static void method_entry_scan(SoupMessage *msg, GValueArray *params);
-static void method_entry_scan_all(SoupMessage *msg, GValueArray *params);
-static void method_entry_scan_all_except(SoupMessage *msg, GValueArray *params);
-static void method_entry_get_field(SoupMessage *msg, GValueArray *params);
-static void method_entry_get_moreinfo(SoupMessage *msg, GValueArray *params);
-static void method_entry_get_note(SoupMessage *msg, GValueArray *params);
-static void method_entry_function(SoupMessage *msg, GValueArray *params);
-static void method_get_about_info(SoupMessage *msg, GValueArray *params);
-static void method_call_method(SoupMessage *msg, GValueArray *params);
-static void method_call_method_param(SoupMessage *msg, GValueArray *params);
+static void method_get_module_list(SoupMessage * msg,
+				   GValueArray * params);
+static void method_get_entry_list(SoupMessage * msg, GValueArray * params);
+static void method_entry_reload(SoupMessage * msg, GValueArray * params);
+static void method_entry_scan(SoupMessage * msg, GValueArray * params);
+static void method_entry_scan_all(SoupMessage * msg, GValueArray * params);
+static void method_entry_scan_all_except(SoupMessage * msg,
+					 GValueArray * params);
+static void method_entry_get_field(SoupMessage * msg,
+				   GValueArray * params);
+static void method_entry_get_moreinfo(SoupMessage * msg,
+				      GValueArray * params);
+static void method_entry_get_note(SoupMessage * msg, GValueArray * params);
+static void method_entry_function(SoupMessage * msg, GValueArray * params);
+static void method_get_about_info(SoupMessage * msg, GValueArray * params);
+static void method_call_method(SoupMessage * msg, GValueArray * params);
+static void method_call_method_param(SoupMessage * msg,
+				     GValueArray * params);
 
 /* method handler table */
 static const struct {
@@ -72,284 +79,334 @@ static const struct {
   { "module.callMethodParam",		method_call_method_param },
   { NULL }
 };
-  
+
 static GHashTable *handlers = NULL;
 static GMainLoop *loop = NULL;
 
 static void
-args_error (SoupMessage *msg, GValueArray *params, int expected)
+args_error(SoupMessage * msg, GValueArray * params, int expected)
 {
-  soup_xmlrpc_set_fault (msg,
-                         SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS,
-                         "Wrong number of parameters: expected %d, got %d",
-                         expected, params->n_values);
+    soup_xmlrpc_set_fault(msg,
+			  SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS,
+			  "Wrong number of parameters: expected %d, got %d",
+			  expected, params->n_values);
 }
 
 static void
-type_error (SoupMessage *msg, GType expected, GValueArray *params, int bad_value)
+type_error(SoupMessage * msg, GType expected, GValueArray * params,
+	   int bad_value)
 {
-  soup_xmlrpc_set_fault (msg,
-                         SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS,
-                         "Bad parameter #%d: expected %s, got %s",
-                         bad_value + 1, g_type_name (expected),
-                         g_type_name (G_VALUE_TYPE (&params->values[bad_value])));
+    soup_xmlrpc_set_fault(msg,
+			  SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS,
+			  "Bad parameter #%d: expected %s, got %s",
+			  bad_value + 1, g_type_name(expected),
+			  g_type_name(G_VALUE_TYPE
+				      (&params->values[bad_value])));
 }
 
-static void method_entry_get_field(SoupMessage *msg, GValueArray *params)
+static void method_get_module_list(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
-}
+    GValueArray *out;
+    GSList *modules;
 
-static void method_entry_get_moreinfo(SoupMessage *msg, GValueArray *params)
-{
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    out = soup_value_array_new();
+
+    for (modules = modules_get_list(); modules; modules = modules->next) {
+	ShellModule *module = (ShellModule *) modules->data;
+
+	soup_value_array_append(out, G_TYPE_STRING, module->name);
+    }
+
+    soup_xmlrpc_set_response(msg, G_TYPE_VALUE_ARRAY, out);
+    g_value_array_free(out);
 }
 
-static void method_get_module_list(SoupMessage *msg, GValueArray *params)
+static void method_get_entry_list(SoupMessage * msg, GValueArray * params)
 {
-  GValueArray *out;
-  GSList *modules;
-  
-  out = soup_value_array_new();
-  
-  for (modules = modules_get_list(); modules; modules = modules->next) {
-    ShellModule *module = (ShellModule *)modules->data;
-    
-    soup_value_array_append(out, G_TYPE_STRING, module->name);
-  }
-  
-  soup_xmlrpc_set_response(msg, G_TYPE_VALUE_ARRAY, out);
-  g_value_array_free(out);
+    ShellModule *module;
+    ShellModuleEntry *module_entry;
+    GSList *entry, *modules;
+    GValueArray *out;
+    gboolean found = FALSE;
+    gchar *module_name;
+
+    if (params->n_values != 1) {
+	args_error(msg, params, 1);
+	return;
+    }
+
+    if (!soup_value_array_get_nth(params, 0, G_TYPE_STRING, &module_name)) {
+	type_error(msg, G_TYPE_STRING, params, 0);
+	return;
+    }
+
+    for (modules = modules_get_list(); modules; modules = modules->next) {
+	ShellModule *module = (ShellModule *) modules->data;
+
+	if (!strncmp(module->name, module_name, strlen(module->name))) {
+	    found = TRUE;
+	    break;
+	}
+    }
+
+    out = soup_value_array_new();
+
+    if (found) {
+      module = (ShellModule *) modules->data;
+      for (entry = module->entries; entry; entry = entry->next) {
+          GValueArray *tuple;
+
+          module_entry = (ShellModuleEntry *) entry->data;
+          tuple = soup_value_array_new();
+
+          soup_value_array_append(tuple, G_TYPE_STRING, module_entry->name);
+          soup_value_array_append(tuple, G_TYPE_INT, module_entry->number);
+          soup_value_array_append(out, G_TYPE_VALUE_ARRAY, tuple);
+
+          g_value_array_free(tuple);
+      }
+    }
+
+    soup_xmlrpc_set_response(msg, G_TYPE_VALUE_ARRAY, out);
+    g_value_array_free(out);
 }
 
-static void method_get_entry_list(SoupMessage *msg, GValueArray *params)
+static void method_entry_get_field(SoupMessage * msg, GValueArray * params)
 {
-  ShellModule *module;
-  ShellModuleEntry *module_entry;
-  GSList *entry;
-  GValueArray *out;
-  gboolean found = FALSE;
-  gchar *module_name;
-  GSList *modules;
-
-  if (params->n_values != 1) {
-    args_error(msg, params, 1);
-    return;
-  }  
-  
-  if (!soup_value_array_get_nth(params, 0, G_TYPE_STRING, &module_name)) {
-    type_error(msg, G_TYPE_STRING, params, 0);
-    return;
-  }
-  
-  for (modules = modules_get_list(); modules; modules = modules->next) {
-    ShellModule *module = (ShellModule *)modules->data;
+    ShellModule *module;
+    GSList *modules;
+    gchar *module_name, *field_name, *answer = NULL;
+    gint entry_number;
+    gboolean found = FALSE;
     
-    if (!strncmp(module->name, module_name, strlen(module->name))) {
-      found = TRUE;
-      break;
+    if (params->n_values != 3) {
+	args_error(msg, params, 2);
+	return;
     }
-  }
-  
-  out = soup_value_array_new();
-
-  if (!found) {
-    goto bad;
-  }
-  
-  module = (ShellModule *)modules->data;
-  for (entry = module->entries; entry; entry = entry->next) {
-    GValueArray *tuple;
     
-    module_entry = (ShellModuleEntry *)entry->data;
-    tuple = soup_value_array_new();
+    if (!soup_value_array_get_nth(params, 0, G_TYPE_STRING, &module_name)) {
+        type_error(msg, G_TYPE_STRING, params, 0);
+        return;
+    }
     
-    soup_value_array_append(tuple, G_TYPE_STRING, module_entry->name);
-    soup_value_array_append(tuple, G_TYPE_INT, module_entry->number);
-    soup_value_array_append(out, G_TYPE_VALUE_ARRAY, tuple);
+    if (!soup_value_array_get_nth(params, 1, G_TYPE_INT, &entry_number)) {
+        type_error(msg, G_TYPE_INT, params, 1);
+        return;
+    }
     
-    g_value_array_free(tuple);
-  }
-  
-bad:
-  soup_xmlrpc_set_response(msg, G_TYPE_VALUE_ARRAY, out);
-  g_value_array_free(out);
+    if (!soup_value_array_get_nth(params, 2, G_TYPE_STRING, &field_name)) {
+        type_error(msg, G_TYPE_STRING, params, 2);
+        return;
+    }
+
+    for (modules = modules_get_list(); modules; modules = modules->next) {
+	module = (ShellModule *) modules->data;
+
+	if (!strncmp(module->name, module_name, strlen(module->name))) {
+	    found = TRUE;
+	    break;
+	}
+    }
+    
+    if (found) {
+        if (entry_number <= g_slist_length(module->entries)) {
+          GSList *entry_node = g_slist_nth(module->entries, entry_number);
+          ShellModuleEntry *entry = (ShellModuleEntry *)entry_node->data;
+
+          answer = module_entry_get_field(entry, field_name);
+        }
+    }
+    
+    if (!answer) {
+        answer = g_strdup("");
+    }
+
+    soup_xmlrpc_set_response(msg, G_TYPE_STRING, answer);
 }
 
-static void method_entry_reload(SoupMessage *msg, GValueArray *params)
+static void method_entry_get_moreinfo(SoupMessage * msg,
+				      GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_entry_scan(SoupMessage *msg, GValueArray *params)
+static void method_entry_reload(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_entry_function(SoupMessage *msg, GValueArray *params)
+static void method_entry_scan(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_entry_get_note(SoupMessage *msg, GValueArray *params)
+static void method_entry_function(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_entry_scan_all(SoupMessage *msg, GValueArray *params)
+static void method_entry_get_note(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_entry_scan_all_except(SoupMessage *msg, GValueArray *params)
+static void method_entry_scan_all(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_get_about_info(SoupMessage *msg, GValueArray *params)
+static void method_entry_scan_all_except(SoupMessage * msg,
+					 GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_call_method(SoupMessage *msg, GValueArray *params)
+static void method_get_about_info(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_call_method_param(SoupMessage *msg, GValueArray *params)
+static void method_call_method(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_get_api_version(SoupMessage *msg, GValueArray *params)
+static void method_call_method_param(SoupMessage * msg,
+				     GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_INT, XMLRPC_SERVER_VERSION);
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, FALSE);
 }
 
-static void method_shutdown_server(SoupMessage *msg, GValueArray *params)
+static void method_get_api_version(SoupMessage * msg, GValueArray * params)
 {
-  soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, TRUE);
-  
-  g_main_loop_quit(loop);
+    soup_xmlrpc_set_response(msg, G_TYPE_INT, XMLRPC_SERVER_VERSION);
+}
+
+static void method_shutdown_server(SoupMessage * msg, GValueArray * params)
+{
+    soup_xmlrpc_set_response(msg, G_TYPE_BOOLEAN, TRUE);
+
+    g_main_loop_quit(loop);
 }
-#endif /* HAS_LIBSOUP */
+#endif				/* HAS_LIBSOUP */
 
 void xmlrpc_server_init(void)
 {
 #ifdef HAS_LIBSOUP
-  if (!loop) {
-    loop = g_main_loop_new(NULL, FALSE);
-  }
-  
-  if (!handlers) {
-    int i;
-    handlers = g_hash_table_new(g_str_hash, g_str_equal);
-    
-    for (i = 0; handler_table[i].method_name; i++) {
-      g_hash_table_insert(handlers,
-                          handler_table[i].method_name, handler_table[i].callback);
+    if (!loop) {
+	loop = g_main_loop_new(NULL, FALSE);
+    }
+
+    if (!handlers) {
+	int i;
+	handlers = g_hash_table_new(g_str_hash, g_str_equal);
+
+	for (i = 0; handler_table[i].method_name; i++) {
+	    g_hash_table_insert(handlers,
+				handler_table[i].method_name,
+				handler_table[i].callback);
+	}
     }
-  }
-#endif /* HAS_LIBSOUP */
+#endif				/* HAS_LIBSOUP */
 }
 
 #ifdef HAS_LIBSOUP
 static SoupServer *xmlrpc_server_new(void)
 {
-  SoupServer *server;
-  
-  DEBUG("creating server");
-  server = soup_server_new(SOUP_SERVER_SSL_CERT_FILE, NULL,
-                           SOUP_SERVER_SSL_KEY_FILE, NULL,
-                           SOUP_SERVER_ASYNC_CONTEXT, NULL,
-                           SOUP_SERVER_PORT, 4242,
-                           NULL);
-  if (!server) {
-    return NULL;
-  }
-  
-  soup_server_run_async(server);
-  
-  return server;
+    SoupServer *server;
+
+    DEBUG("creating server");
+    server = soup_server_new(SOUP_SERVER_SSL_CERT_FILE, NULL,
+			     SOUP_SERVER_SSL_KEY_FILE, NULL,
+			     SOUP_SERVER_ASYNC_CONTEXT, NULL,
+			     SOUP_SERVER_PORT, 4242, NULL);
+    if (!server) {
+	return NULL;
+    }
+
+    soup_server_run_async(server);
+
+    return server;
 }
 
-static void xmlrpc_server_callback(SoupServer *server,
-                                   SoupMessage *msg,
-                                   const char *path,
-                                   GHashTable *query,
-                                   SoupClientContext *context,
-                                   gpointer data)
+static void xmlrpc_server_callback(SoupServer * server,
+				   SoupMessage * msg,
+				   const char *path,
+				   GHashTable * query,
+				   SoupClientContext * context,
+				   gpointer data)
 {
-  if (msg->method == SOUP_METHOD_POST) {
-    gchar *method_name;
-    GValueArray *params;
-    void (*callback)(SoupMessage *msg, GValueArray *params);
-    
-    DEBUG("received POST request");
-  
-    if (!soup_xmlrpc_parse_method_call(msg->request_body->data,
-                                       msg->request_body->length,
-                                       &method_name, &params)) {
-      soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
-      return;
-    }
-    
-    DEBUG("method: %s", method_name);
-    
-    if ((callback = g_hash_table_lookup(handlers, method_name))) {
-      soup_message_set_status(msg, SOUP_STATUS_OK);
-      
-      DEBUG("found callback: %p", callback);
-      callback(msg, params);
+    if (msg->method == SOUP_METHOD_POST) {
+	gchar *method_name;
+	GValueArray *params;
+	void (*callback) (SoupMessage * msg, GValueArray * params);
+
+	DEBUG("received POST request");
+
+	if (!soup_xmlrpc_parse_method_call(msg->request_body->data,
+					   msg->request_body->length,
+					   &method_name, &params)) {
+	    soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
+	    return;
+	}
+
+	DEBUG("method: %s", method_name);
+
+	if ((callback = g_hash_table_lookup(handlers, method_name))) {
+	    soup_message_set_status(msg, SOUP_STATUS_OK);
+
+	    DEBUG("found callback: %p", callback);
+	    callback(msg, params);
+	} else {
+	    DEBUG("callback not found");
+	    soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	}
+
+	g_value_array_free(params);
+	g_free(method_name);
     } else {
-      DEBUG("callback not found");
-      soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	DEBUG("received request of unknown method");
+	soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
     }
-    
-    g_free(method_name);
-    g_value_array_free(params);
-  } else {
-    DEBUG("received request of unknown method");
-    soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
-  }
 }
-#endif /* HAS_LIBSOUP */
+#endif				/* HAS_LIBSOUP */
 
 void xmlrpc_server_start(void)
 {
 #ifdef HAS_LIBSOUP
-  SoupServer *server;
-  
-  if (!loop || !handlers) {
-    xmlrpc_server_init();
-  }
-  
-  server = xmlrpc_server_new();
-  if (!server) {
-    g_error("Cannot create XML-RPC server. Aborting");
-  }
-  
-  soup_server_add_handler(server, "/xmlrpc", xmlrpc_server_callback, NULL, NULL);
-  
-  DEBUG("starting server");
-  g_main_loop_run(loop);
-
-  DEBUG("shutting down server");
-  g_main_loop_unref(loop);
-  soup_server_quit(server);
-  g_object_unref(server);
-#endif /* HAS_LIBSOUP */
+    SoupServer *server;
+
+    if (!loop || !handlers) {
+	xmlrpc_server_init();
+    }
+
+    server = xmlrpc_server_new();
+    if (!server) {
+	g_error("Cannot create XML-RPC server. Aborting");
+    }
+
+    soup_server_add_handler(server, "/xmlrpc", xmlrpc_server_callback,
+			    NULL, NULL);
+
+    DEBUG("starting server");
+    g_main_loop_run(loop);
+
+    DEBUG("shutting down server");
+    g_main_loop_unref(loop);
+    soup_server_quit(server);
+    g_object_unref(server);
+#endif				/* HAS_LIBSOUP */
 }
 
 #ifdef XMLRPC_SERVER_TEST
 int main(void)
 {
 #ifdef HAS_LIBSOUP
-  g_type_init();
-  g_thread_init(NULL);
-  
-  xmlrpc_server_init();
-  xmlrpc_server_start();
-#endif /* HAS_LIBSOUP */
+    g_type_init();
+    g_thread_init(NULL);
+
+    xmlrpc_server_init();
+    xmlrpc_server_start();
+#endif				/* HAS_LIBSOUP */
 }
-#endif /* XMLRPC_SERVER_TEST */ 
+#endif				/* XMLRPC_SERVER_TEST */