New file. (backend_server_private): New struct, formerly known as

2000-11-26  Martin Baulig  <martin@home-of-linux.org>

	* backend-server.h: New file.
	(backend_server_private): New struct, formerly known
	as glibtop_backend_private.

	* glibtop-backend-private.h: Removed.

	* backend-server.c: (_open_server): Use g_object_set_data()
	to set add the backend_server_private data to the glibtop_backend,
	don't override `backend->_priv'.
	(_close_server): Use g_object_get_data() to get the data.
	[FIXME: Use quarks directly.]

	* read.c: (glibtop_read_i): Replaced the glibtop_server and
	glibtop_backend arguments with backend_server_private.
	* read_data.c: (glibtop_read_data_i): Likewise.
	* write.c: (glibtop_write_i): Likewise.

backends/server/ChangeLog

@@ -1,3 +1,22 @@
+2000-11-26  Martin Baulig  <martin@home-of-linux.org>
+
+	* backend-server.h: New file.
+	(backend_server_private): New struct, formerly known
+	as glibtop_backend_private.
+
+	* glibtop-backend-private.h: Removed.
+
+	* backend-server.c: (_open_server): Use g_object_set_data()
+	to set add the backend_server_private data to the glibtop_backend,
+	don't override `backend->_priv'.
+	(_close_server): Use g_object_get_data() to get the data.
+	[FIXME: Use quarks directly.]
+
+	* read.c: (glibtop_read_i): Replaced the glibtop_server and
+	glibtop_backend arguments with backend_server_private.
+	* read_data.c: (glibtop_read_data_i): Likewise.
+	* write.c: (glibtop_write_i): Likewise.
+
 2000-02-22  Martin Baulig  <martin@home-of-linux.org>
 
 	* backend-sysdeps.c (LibGTopBackendInfo): Call this

backends/server/Makefile.am

@@ -19,7 +19,7 @@ backend_DATA = \
 	libgtop-server.backend
 
 noinst_HEADERS = \
-	glibtop-backend-private.h
+	backend-server.h
 
 backendlib_LTLIBRARIES = \
 	libgtop_backend_server.la

backends/server/backend-server.c

@@ -23,18 +23,13 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <glibtop.h>
+#include <backend-server.h>
-#include <glibtop/global.h>
-#include <glibtop/xmalloc.h>
-
-#include <glibtop/backend.h>
-#include <glibtop-backend-private.h>
 
 static int
-_open_server (glibtop *, glibtop_backend *, u_int64_t, const char **);
+_open_server (glibtop_server *, glibtop_backend *, u_int64_t, const char **);
 
 static int
-_close_server (glibtop *, glibtop_backend *);
+_close_server (glibtop_server *, glibtop_backend *);
 
 extern glibtop_call_vector glibtop_backend_server_call_vector;
 
@@ -51,57 +46,69 @@ glibtop_backend_info LibGTopBackendInfo_Server = {
 #endif
 
 static int
-_open_server (glibtop *server, glibtop_backend *backend,
+_open_server (glibtop_server *server, glibtop_backend *backend,
 	      u_int64_t features, const char **backend_args)
 {
-    backend->_priv = glibtop_calloc_r
+    backend_server_private *priv;
-	(server, 1, sizeof (glibtop_backend_private));
+
+    priv = glibtop_calloc_r (server, 1, sizeof (backend_server_private));
+
+    g_object_set_data (G_OBJECT (backend), BACKEND_DATA_KEY, priv);
 
 #ifdef DEBUG
-    fprintf (stderr, "open_server - %p, %p, %p\n", server, backend,
+    fprintf (stderr, "open_server - %p, %p, %p\n", server, backend, priv);
-	     backend->_priv);
 
-    fprintf (stderr, "Opening pipe to server (%s).\n",
+    fprintf (stderr, "Opening pipe to server (%s).\n", LIBGTOP_SERVER);
-	     LIBGTOP_SERVER);
 #endif
 
-    if (pipe (backend->_priv->input) ||
+    if (pipe (priv->input) || pipe (priv->output)) {
-	pipe (backend->_priv->output)) {
 	glibtop_warn_io_r (server, "cannot make a pipe");
 	return -1;
     }
 
-    backend->_priv->pid  = fork ();
+    priv->pid  = fork ();
 
-    if (backend->_priv->pid < 0) {
+    if (priv->pid < 0) {
 	glibtop_warn_io_r (server, "fork failed");
 	return -1;
-    } else if (backend->_priv->pid == 0) {
+    } else if (priv->pid == 0) {
 	close (0); close (1);
-	close (backend->_priv->input [0]);
+	close (priv->input [0]);
-	close (backend->_priv->output [1]);
+	close (priv->output [1]);
-	dup2 (backend->_priv->input [1], 1);
+	dup2 (priv->input [1], 1);
-	dup2 (backend->_priv->output [0], 0);
+	dup2 (priv->output [0], 0);
 	execl (LIBGTOP_SERVER, "libgtop-server", NULL);
 	glibtop_error_io_r (server, "execl (%s)",
 			    LIBGTOP_SERVER);
 	_exit (2);
     }
 
-    close (backend->_priv->input [1]);
+    close (priv->input [1]);
-    close (backend->_priv->output [0]);
+    close (priv->output [0]);
+
+    glibtop_server_ref (server);
+    priv->server = server;
 
     return 0;
 }
 
 static int
-_close_server (glibtop *server, glibtop_backend *backend)
+_close_server (glibtop_server *server, glibtop_backend *backend)
 {
-    kill (backend->_priv->pid, SIGKILL);
+    backend_server_private *priv;
-    close (backend->_priv->input [0]);
-    close (backend->_priv->output [1]);
 
-    backend->_priv->pid = 0;
+    priv = g_object_steal_data (G_OBJECT (backend), BACKEND_DATA_KEY);
+    g_assert (priv != NULL);
+
+    kill (priv->pid, SIGKILL);
+    close (priv->input [0]);
+    close (priv->output [1]);
+
+    glibtop_server_unref (priv->server);
+
+    priv->pid = 0;
+
+    g_free (priv);
 
     return 0;
 }

backends/server/backend-server.h

@@ -23,33 +23,46 @@
    Boston, MA 02111-1307, USA.
 */
 
-#ifndef __GLIBTOP_BACKEND_PRIVATE_H__
+#ifndef __GLIBTOP_BACKEND_COMMON_H__
-#define __GLIBTOP_BACKEND_PRIVATE_H__
+#define __GLIBTOP_BACKEND_COMMON_H__
 
-struct _glibtop_backend_private
+#include <glibtop.h>
+#include <glibtop/global.h>
+
+#include <glibtop/open.h>
+#include <glibtop/xmalloc.h>
+#include <glibtop/glibtop-backend.h>
+#include <glibtop/glibtop-backend-info.h>
+
+typedef struct _backend_server_private backend_server_private;
+
+#define BACKEND_DATA_KEY "backend-server-private"
+
+struct _backend_server_private
 {
     u_int64_t flags;
     int input [2];		/* Pipe client <- server */
     int output [2];		/* Pipe client -> server */
     pid_t pid;			/* PID of the server */
+
+    glibtop_server *server;
 };
 
 void *
-glibtop_call_i (glibtop *server, glibtop_backend *backend, unsigned command,
+glibtop_call_i (glibtop_server *server, glibtop_backend *backend,
-		size_t send_size, const void *send_ptr,
+		unsigned command, size_t send_size, const void *send_ptr,
 		size_t data_size, const void *data_ptr,
 		size_t recv_size, void *recv_ptr,
 		int *retval_ptr);
 
 void
-glibtop_read_i (glibtop *server, glibtop_backend *backend,
+glibtop_read_i (backend_server_private *priv, size_t size, void *buf);
-		size_t size, void *buf);
 
 void *
-glibtop_read_data_i (glibtop *server, glibtop_backend *backend);
+glibtop_read_data_i (backend_server_private *priv);
 
 void
-glibtop_write_i (glibtop *server, glibtop_backend *backend,
+glibtop_write_i (backend_server_private *priv, size_t size, const void *buf);
-		 size_t size, const void *buf);
 
 #endif
+

backends/server/command.c

@@ -23,34 +23,30 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <glibtop/xmalloc.h>
+#include <backend-server.h>
-
-#include <glibtop.h>
-#include <glibtop/error.h>
-#include <glibtop/backend.h>
-
-#include <glibtop-backend-private.h>
 
 #include "command.h"
 
 void *
-glibtop_call_i (glibtop *server, glibtop_backend *backend, unsigned command,
+glibtop_call_i (glibtop_server *server, glibtop_backend *backend,
-		size_t send_size, const void *send_buf,
+		unsigned command, size_t send_size, const void *send_buf,
 		size_t data_size, const void *data_buf,
 		size_t recv_size, void *recv_ptr,
 		int *retval_ptr)
 {
     glibtop_command cmnd;
     glibtop_response resp;
+    backend_server_private *priv;
 #if 0
     int retval;
 #endif
 
-    glibtop_init_r (&server, 0, 0);
-
     memset (&cmnd, 0, sizeof (glibtop_command));
     memset (&resp, 0, sizeof (glibtop_response));
 
+    priv = g_object_get_data (G_OBJECT (backend), BACKEND_DATA_KEY);
+    g_assert (priv != NULL);
+
     cmnd.command = command;
 
     /* If send_size is less than _GLIBTOP_PARAM_SIZE (normally 16 Bytes), we
@@ -66,16 +62,16 @@ glibtop_call_i (glibtop *server, glibtop_backend *backend, unsigned command,
 
     cmnd.data_size = data_size;
 	
-    glibtop_write_i (server, backend, sizeof (glibtop_command), &cmnd);
+    glibtop_write_i (priv, sizeof (glibtop_command), &cmnd);
 
     if (data_size) {
 #ifdef SLAVE_DEBUG
 	fprintf (stderr, "SENDING %d bytes of DATA.\n", data_size);
 #endif
-	glibtop_write_i (server, backend, data_size, data_buf);
+	glibtop_write_i (priv, data_size, data_buf);
     }
 
-    glibtop_read_i (server, backend, sizeof (glibtop_response), &resp);
+    glibtop_read_i (priv, sizeof (glibtop_response), &resp);
 
 #ifdef SLAVE_DEBUG
     fprintf (stderr, "RESPONSE: %d - %d - %ld - %ld - %p - %ld\n",
@@ -94,12 +90,12 @@ glibtop_call_i (glibtop *server, glibtop_backend *backend, unsigned command,
     }
 
     if (recv_ptr)
-	glibtop_read_i (server, backend, recv_size, recv_ptr);
+	glibtop_read_i (priv, recv_size, recv_ptr);
 
     if (resp.data_size) {
 	void *ptr = glibtop_malloc_r (server, resp.data_size);
 
-	glibtop_read_i (server, backend, resp.data_size, ptr);
+	glibtop_read_i (priv, resp.data_size, ptr);
 
 	return ptr;
     }

backends/server/marshal.pl

@@ -24,19 +24,14 @@ print '/* marshal.c */';
 print "/* This is a generated file.  Please modify `marshal.pl' */";
 print '';
 
-print '#include <glibtop.h>';
+print '#include <backend-server.h>';
-print '#include <glibtop/open.h>';
-print '#include <glibtop/xmalloc.h>';
 print '';
 print '#include <glibtop/sysdeps.h>';
 print '#include <glibtop/union.h>';
 print '';
 print '#include "command.h"';
-print '#include <glibtop/backend.h>';
 print '#include <glibtop/call-vector.h>';
 print '';
-print '#include <glibtop-backend-private.h>';
-print '';
 
 $feature_count = 0;
 

backends/server/read.c

@@ -23,31 +23,24 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <glibtop.h>
+#include <backend-server.h>
-#include <glibtop/error.h>
-#include <glibtop/backend.h>
-
-#include <glibtop-backend-private.h>
 
 void
-glibtop_read_i (glibtop *server, glibtop_backend *backend,
+glibtop_read_i (backend_server_private *priv, size_t size, void *buf)
-		size_t size, void *buf)
 {
     int ret = 0;
 
-    glibtop_init_r (&server, 0, 0);
-
 #ifdef DEBUG
     fprintf (stderr, "LIBRARY: really reading %d bytes from %d.\n",
-	     size, backend->_priv->input [0]);
+	     size, priv->input [0]);
 #endif
 
-    ret = read (backend->_priv->input [0], buf, size);
+    ret = read (priv->input [0], buf, size);
 
 #ifdef DEBUG
     fprintf (stderr, "LIBRARY: read %d bytes.\n", ret);
 #endif
 
     if (ret < 0)
-	glibtop_error_io_r (server, "read %d bytes", size);
+	glibtop_error_io_r (priv->server, "read %d bytes", size);
 }

backends/server/read_data.c

@@ -23,15 +23,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <glibtop.h>
+#include <backend-server.h>
-#include <glibtop/error.h>
-#include <glibtop/xmalloc.h>
-#include <glibtop/backend.h>
-
-#include <glibtop-backend-private.h>
 
 void *
-glibtop_read_data_i (glibtop *server, glibtop_backend *backend)
+glibtop_read_data_i (backend_server_private *priv)
 {
     size_t size;
     void *ptr;
@@ -41,11 +36,10 @@ glibtop_read_data_i (glibtop *server, glibtop_backend *backend)
     fprintf (stderr, "LIBRARY: reading %d data bytes.\n", sizeof (size_t));
 #endif
 
-    ret = read (backend->_priv->input [0], (void *)&size,
+    ret = read (priv->input [0], (void *)&size, sizeof (size_t));
-		sizeof (size_t));
 
     if (ret < 0)
-	glibtop_error_io_r (server, "read data size");
+	glibtop_error_io_r (priv->server, "read data size");
 
 #ifdef DEBUG
     fprintf (stderr, "LIBRARY: really reading %d data bytes (ret = %d).\n", size, ret);
@@ -53,12 +47,12 @@ glibtop_read_data_i (glibtop *server, glibtop_backend *backend)
 
     if (!size) return NULL;	
 
-    ptr = glibtop_malloc_r (server, size);
+    ptr = glibtop_malloc_r (priv->server, size);
 	
-    ret = read (backend->_priv->input [0], ptr, size);
+    ret = read (priv->input [0], ptr, size);
 
     if (ret < 0)
-	glibtop_error_io_r (server, "read data %d bytes");
+	glibtop_error_io_r (priv->server, "read data %d bytes");
 
     return ptr;
 }

backends/server/write.c

@@ -23,15 +23,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <glibtop.h>
+#include <backend-server.h>
-#include <glibtop/error.h>
-#include <glibtop/backend.h>
-
-#include <glibtop-backend-private.h>
 
 void
-glibtop_write_i (glibtop *server, glibtop_backend *backend,
+glibtop_write_i (backend_server_private *priv, size_t size, const void *buf)
-		 size_t size, const void *buf)
 {
     int ret;
 
@@ -41,8 +36,8 @@ glibtop_write_i (glibtop *server, glibtop_backend *backend,
     fprintf (stderr, "LIBRARY: really writing %d bytes.\n", size);
 #endif
 
-    ret = write (backend->_priv->output [1], buf, size);
+    ret = write (priv->output [1], buf, size);
 
     if (ret < 0)
-	glibtop_error_io_r (server, "write %d bytes", size);
+	glibtop_error_io_r (priv->server, "write %d bytes", size);
 }