oxmc/libgtop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added additional `int' parameter for the retval from the sysdeps

Browse Source 
1999-10-24  Martin Baulig  <martin@home-of-linux.org>

	* io.c (do_output): Added additional `int' parameter for the
	retval from the sysdeps functions.
This commit is contained in:
Martin Baulig
1999-10-24 20:03:35 +00:00
committed by Martin Baulig
parent 2dc529b19f
commit 1dadfb6d15
5 changed files with 97 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/daemon/ChangeLog
View File

@@ -1,3 +1,8 @@
1999-10-24 Martin Baulig <martin@home-of-linux.org>
* io.c (do_output): Added additional `int' parameter for the
retval from the sysdeps functions.
1999-07-29 Martin Baulig <martin@home-of-linux.org> 1999-07-29 Martin Baulig <martin@home-of-linux.org>
* Makefile.am: Link the `libgtop_daemon' and the `libgtop_server' * Makefile.am: Link the `libgtop_daemon' and the `libgtop_server'

4
src/daemon/daemon.h
View File

@@ -63,11 +63,11 @@ BEGIN_LIBGTOP_DECLS
void handle_parent_connection (int s); void handle_parent_connection (int s);
void handle_slave_connection (int input, int output); void handle_slave_connection (int input, int output);
void handle_slave_command (glibtop_command *cmnd, glibtop_response *resp, int handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
const void *parameter); const void *parameter);
void do_output (int s, glibtop_response *resp, off_t offset, void do_output (int s, glibtop_response *resp, off_t offset,
size_t data_size, const void *data); size_t data_size, const void *data, int retval);
int do_read (int s, void *ptr, size_t total_size); int do_read (int s, void *ptr, size_t total_size);
void syslog_message (int priority, char *format, ...); void syslog_message (int priority, char *format, ...);

13
src/daemon/io.c
View File

@@ -25,7 +25,7 @@
void void
do_output (int s, glibtop_response *resp, off_t offset, do_output (int s, glibtop_response *resp, off_t offset,
size_t data_size, const void *data) size_t data_size, const void *data, int retval)
{ {
#ifdef REAL_DEBUG #ifdef REAL_DEBUG
fprintf (stderr, "Really writing %d bytes at offset %lu.\n", fprintf (stderr, "Really writing %d bytes at offset %lu.\n",
@@ -43,6 +43,15 @@ do_output (int s, glibtop_response *resp, off_t offset,
glibtop_warn_io ("send"); glibtop_warn_io ("send");
} }
if (s == 0) {
if (write (1, &retval, sizeof (int)) < 0)
glibtop_warn_io ("write retval");
} else {
if (send (s, &retval, sizeof (int), 0) < 0)
glibtop_warn_io ("send retval");
}
if (resp->data_size) { if (resp->data_size) {
#ifdef REAL_DEBUG #ifdef REAL_DEBUG
fprintf (stderr, "Writing %d bytes of data.\n", resp->data_size); fprintf (stderr, "Writing %d bytes of data.\n", resp->data_size);
@@ -52,7 +61,7 @@ do_output (int s, glibtop_response *resp, off_t offset,
if (write (1, data, resp->data_size) < 0) if (write (1, data, resp->data_size) < 0)
glibtop_warn_io ("write"); glibtop_warn_io ("write");
} else { } else {
if (send (s, data, resp->data_size, 0) , 0) if (send (s, data, resp->data_size, 0) < 0)
glibtop_warn_io ("send"); glibtop_warn_io ("send");
} }
} }

90
src/daemon/main.c
View File

@@ -42,7 +42,7 @@ handle_parent_connection (int s)
char parameter [BUFSIZ]; char parameter [BUFSIZ];
unsigned short device; unsigned short device;
int64_t *param_ptr; int64_t *param_ptr;
int all_fs; int all_fs, retval;
pid_t pid; pid_t pid;
void *ptr; void *ptr;
@@ -89,48 +89,48 @@ handle_parent_connection (int s)
switch (cmnd->command) { switch (cmnd->command) {
case GLIBTOP_CMND_QUIT: case GLIBTOP_CMND_QUIT:
do_output (s, resp, 0, 0, NULL); do_output (s, resp, 0, 0, NULL, 0);
return; return;
case GLIBTOP_CMND_SYSDEPS: case GLIBTOP_CMND_SYSDEPS:
memcpy (&resp->u.sysdeps, &server->sysdeps, memcpy (&resp->u.sysdeps, &server->sysdeps,
sizeof (glibtop_sysdeps)); sizeof (glibtop_sysdeps));
resp->u.sysdeps.features = GLIBTOP_SYSDEPS_ALL; resp->u.sysdeps.features = GLIBTOP_SYSDEPS_ALL;
do_output (s, resp, _offset_union (sysdeps), 0, NULL); do_output (s, resp, _offset_union (sysdeps), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_CPU: case GLIBTOP_CMND_CPU:
glibtop_get_cpu_l (server, &resp->u.data.cpu); retval = glibtop_get_cpu_l (server, &resp->u.data.cpu);
do_output (s, resp, _offset_data (cpu), 0, NULL); do_output (s, resp, _offset_data (cpu), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_MEM: case GLIBTOP_CMND_MEM:
glibtop_get_mem_l (server, &resp->u.data.mem); retval = glibtop_get_mem_l (server, &resp->u.data.mem);
do_output (s, resp, _offset_data (mem), 0, NULL); do_output (s, resp, _offset_data (mem), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_SWAP: case GLIBTOP_CMND_SWAP:
glibtop_get_swap_l (server, &resp->u.data.swap); retval = glibtop_get_swap_l (server, &resp->u.data.swap);
do_output (s, resp, _offset_data (swap), 0, NULL); do_output (s, resp, _offset_data (swap), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_UPTIME: case GLIBTOP_CMND_UPTIME:
glibtop_get_uptime_l (server, &resp->u.data.uptime); retval = glibtop_get_uptime_l (server, &resp->u.data.uptime);
do_output (s, resp, _offset_data (uptime), 0, NULL); do_output (s, resp, _offset_data (uptime), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_LOADAVG: case GLIBTOP_CMND_LOADAVG:
glibtop_get_loadavg_l (server, &resp->u.data.loadavg); retval = glibtop_get_loadavg_l (server, &resp->u.data.loadavg);
do_output (s, resp, _offset_data (loadavg), 0, NULL); do_output (s, resp, _offset_data (loadavg), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_SHM_LIMITS: case GLIBTOP_CMND_SHM_LIMITS:
glibtop_get_shm_limits_l retval = glibtop_get_shm_limits_l
(server, &resp->u.data.shm_limits); (server, &resp->u.data.shm_limits);
do_output (s, resp, _offset_data (shm_limits), 0, NULL); do_output (s, resp, _offset_data (shm_limits), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_MSG_LIMITS: case GLIBTOP_CMND_MSG_LIMITS:
glibtop_get_msg_limits_l retval = glibtop_get_msg_limits_l
(server, &resp->u.data.msg_limits); (server, &resp->u.data.msg_limits);
do_output (s, resp, _offset_data (msg_limits), 0, NULL); do_output (s, resp, _offset_data (msg_limits), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_SEM_LIMITS: case GLIBTOP_CMND_SEM_LIMITS:
glibtop_get_sem_limits_l retval = glibtop_get_sem_limits_l
(server, &resp->u.data.sem_limits); (server, &resp->u.data.sem_limits);
do_output (s, resp, _offset_data (sem_limits), 0, NULL); do_output (s, resp, _offset_data (sem_limits), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROCLIST: case GLIBTOP_CMND_PROCLIST:
param_ptr = (int64_t *) parameter; param_ptr = (int64_t *) parameter;
@@ -139,7 +139,8 @@ handle_parent_connection (int s)
param_ptr [0], param_ptr [0],
param_ptr [1]); param_ptr [1]);
do_output (s, resp, _offset_data (proclist), do_output (s, resp, _offset_data (proclist),
resp->u.data.proclist.total, ptr); resp->u.data.proclist.total, ptr,
(ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
case GLIBTOP_CMND_PROC_MAP: case GLIBTOP_CMND_PROC_MAP:
@@ -148,7 +149,8 @@ handle_parent_connection (int s)
&resp->u.data.proc_map, &resp->u.data.proc_map,
pid); pid);
do_output (s, resp, _offset_data (proc_map), do_output (s, resp, _offset_data (proc_map),
resp->u.data.proc_map.total, ptr); resp->u.data.proc_map.total, ptr,
(ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
case GLIBTOP_CMND_PROC_ARGS: case GLIBTOP_CMND_PROC_ARGS:
@@ -157,76 +159,78 @@ handle_parent_connection (int s)
&resp->u.data.proc_args, &resp->u.data.proc_args,
pid, 0); pid, 0);
do_output (s, resp, _offset_data (proc_args), do_output (s, resp, _offset_data (proc_args),
ptr ? resp->u.data.proc_args.size+1 : 0, ptr); ptr ? resp->u.data.proc_args.size+1 : 0, ptr,
(ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
case GLIBTOP_CMND_PROC_STATE: case GLIBTOP_CMND_PROC_STATE:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_state_l retval = glibtop_get_proc_state_l
(server, &resp->u.data.proc_state, pid); (server, &resp->u.data.proc_state, pid);
do_output (s, resp, _offset_data (proc_state), 0, NULL); do_output (s, resp, _offset_data (proc_state), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_UID: case GLIBTOP_CMND_PROC_UID:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_uid_l retval = glibtop_get_proc_uid_l
(server, &resp->u.data.proc_uid, pid); (server, &resp->u.data.proc_uid, pid);
do_output (s, resp, _offset_data (proc_uid), 0, NULL); do_output (s, resp, _offset_data (proc_uid), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_MEM: case GLIBTOP_CMND_PROC_MEM:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_mem_l retval = glibtop_get_proc_mem_l
(server, &resp->u.data.proc_mem, pid); (server, &resp->u.data.proc_mem, pid);
do_output (s, resp, _offset_data (proc_mem), 0, NULL); do_output (s, resp, _offset_data (proc_mem), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_TIME: case GLIBTOP_CMND_PROC_TIME:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_time_l retval = glibtop_get_proc_time_l
(server, &resp->u.data.proc_time, pid); (server, &resp->u.data.proc_time, pid);
do_output (s, resp, _offset_data (proc_time), 0, NULL); do_output (s, resp, _offset_data (proc_time), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_SIGNAL: case GLIBTOP_CMND_PROC_SIGNAL:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_signal_l retval = glibtop_get_proc_signal_l
(server, &resp->u.data.proc_signal, pid); (server, &resp->u.data.proc_signal, pid);
do_output (s, resp, _offset_data (proc_signal), 0, NULL); do_output (s, resp, _offset_data (proc_signal), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_KERNEL: case GLIBTOP_CMND_PROC_KERNEL:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_kernel_l retval = glibtop_get_proc_kernel_l
(server, &resp->u.data.proc_kernel, pid); (server, &resp->u.data.proc_kernel, pid);
do_output (s, resp, _offset_data (proc_kernel), 0, NULL); do_output (s, resp, _offset_data (proc_kernel), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PROC_SEGMENT: case GLIBTOP_CMND_PROC_SEGMENT:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_segment_l retval = glibtop_get_proc_segment_l
(server, &resp->u.data.proc_segment, pid); (server, &resp->u.data.proc_segment, pid);
do_output (s, resp, _offset_data (proc_segment), 0, NULL); do_output (s, resp, _offset_data (proc_segment), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_MOUNTLIST: case GLIBTOP_CMND_MOUNTLIST:
memcpy (&all_fs, parameter, sizeof (all_fs)); memcpy (&all_fs, parameter, sizeof (all_fs));
mount_list = glibtop_get_mountlist_l mount_list = glibtop_get_mountlist_l
(server, &resp->u.data.mountlist, all_fs); (server, &resp->u.data.mountlist, all_fs);
do_output (s, resp, _offset_data (mountlist), do_output (s, resp, _offset_data (mountlist),
resp->u.data.mountlist.total, mount_list); resp->u.data.mountlist.total, mount_list,
(mount_list != NULL) ? 0 : -1);
glibtop_free_r (server, mount_list); glibtop_free_r (server, mount_list);
break; break;
case GLIBTOP_CMND_FSUSAGE: case GLIBTOP_CMND_FSUSAGE:
glibtop_get_fsusage_l retval = glibtop_get_fsusage_l
(server, &resp->u.data.fsusage, parameter); (server, &resp->u.data.fsusage, parameter);
do_output (s, resp, _offset_data (fsusage), do_output (s, resp, _offset_data (fsusage),
0, NULL); 0, NULL, retval);
break; break;
case GLIBTOP_CMND_PPP: case GLIBTOP_CMND_PPP:
memcpy (&device, parameter, sizeof (device)); memcpy (&device, parameter, sizeof (device));
glibtop_get_ppp_l retval = glibtop_get_ppp_l
(server, &resp->u.data.ppp, device); (server, &resp->u.data.ppp, device);
do_output (s, resp, _offset_data (ppp), 0, NULL); do_output (s, resp, _offset_data (ppp), 0, NULL, retval);
break; break;
case GLIBTOP_CMND_NETLOAD: case GLIBTOP_CMND_NETLOAD:
glibtop_get_netload_l retval = glibtop_get_netload_l
(server, &resp->u.data.netload, parameter); (server, &resp->u.data.netload, parameter);
do_output (s, resp, _offset_data (netload), do_output (s, resp, _offset_data (netload),
0, NULL); 0, NULL, retval);
break; break;
default: default:
syslog_message (LOG_ERR, "Parent received unknown command %u.", syslog_message (LOG_ERR, "Parent received unknown command %u.",

55
src/daemon/slave.c
View File

@@ -29,6 +29,7 @@ handle_slave_connection (int input, int output)
glibtop *server G_GNUC_UNUSED = glibtop_global_server; glibtop *server G_GNUC_UNUSED = glibtop_global_server;
int64_t *param_ptr G_GNUC_UNUSED; int64_t *param_ptr G_GNUC_UNUSED;
const void *ptr G_GNUC_UNUSED; const void *ptr G_GNUC_UNUSED;
int ret G_GNUC_UNUSED = -1;
unsigned short max_len G_GNUC_UNUSED; unsigned short max_len G_GNUC_UNUSED;
pid_t pid G_GNUC_UNUSED; pid_t pid G_GNUC_UNUSED;
@@ -68,7 +69,7 @@ handle_slave_connection (int input, int output)
switch (cmnd->command) { switch (cmnd->command) {
case GLIBTOP_CMND_QUIT: case GLIBTOP_CMND_QUIT:
do_output (output, resp, 0, 0, NULL); do_output (output, resp, 0, 0, NULL, 0);
return; return;
#if GLIBTOP_SUID_PROCLIST #if GLIBTOP_SUID_PROCLIST
case GLIBTOP_CMND_PROCLIST: case GLIBTOP_CMND_PROCLIST:
@@ -77,7 +78,8 @@ handle_slave_connection (int input, int output)
(server, &resp->u.data.proclist, (server, &resp->u.data.proclist,
param_ptr [0], param_ptr [1]); param_ptr [0], param_ptr [1]);
do_output (output, resp, _offset_data (proclist), do_output (output, resp, _offset_data (proclist),
resp->u.data.proclist.total, ptr); resp->u.data.proclist.total,
ptr, (ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
#endif #endif
@@ -91,7 +93,7 @@ handle_slave_connection (int input, int output)
pid, max_len); pid, max_len);
do_output (output, resp, _offset_data (proc_args), do_output (output, resp, _offset_data (proc_args),
ptr ? resp->u.data.proc_args.size+1 : 0, ptr ? resp->u.data.proc_args.size+1 : 0,
ptr); ptr, (ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
#endif #endif
@@ -102,25 +104,27 @@ handle_slave_connection (int input, int output)
&resp->u.data.proc_map, &resp->u.data.proc_map,
pid); pid);
do_output (output, resp, _offset_data (proc_map), do_output (output, resp, _offset_data (proc_map),
resp->u.data.proc_map.total, ptr); resp->u.data.proc_map.total,
ptr, (ptr != NULL) ? 0 : -1);
glibtop_free_r (server, ptr); glibtop_free_r (server, ptr);
break; break;
#endif #endif
default: default:
handle_slave_command (cmnd, resp, parameter); ret = handle_slave_command (cmnd, resp, parameter);
do_output (output, resp, resp->offset, 0, NULL); do_output (output, resp, resp->offset, 0, NULL, ret);
break; break;
} }
} }
} }
void int
handle_slave_command (glibtop_command *cmnd, glibtop_response *resp, handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
const void *parameter) const void *parameter)
{ {
glibtop *server = glibtop_global_server; glibtop *server = glibtop_global_server;
unsigned device G_GNUC_UNUSED; unsigned device G_GNUC_UNUSED;
pid_t pid G_GNUC_UNUSED; pid_t pid G_GNUC_UNUSED;
int retval G_GNUC_UNUSED = -1;
switch (cmnd->command) { switch (cmnd->command) {
case GLIBTOP_CMND_SYSDEPS: case GLIBTOP_CMND_SYSDEPS:
@@ -130,59 +134,60 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
resp->u.sysdeps.pointer_size = sizeof (void*)*8; resp->u.sysdeps.pointer_size = sizeof (void*)*8;
resp->u.sysdeps.flags = glibtop_server_features; resp->u.sysdeps.flags = glibtop_server_features;
resp->offset = _offset_union (sysdeps); resp->offset = _offset_union (sysdeps);
retval = 0;
break; break;
#if GLIBTOP_SUID_CPU #if GLIBTOP_SUID_CPU
case GLIBTOP_CMND_CPU: case GLIBTOP_CMND_CPU:
glibtop_get_cpu_p (server, &resp->u.data.cpu); retval = glibtop_get_cpu_p (server, &resp->u.data.cpu);
resp->offset = _offset_data (cpu); resp->offset = _offset_data (cpu);
break; break;
#endif #endif
#if GLIBTOP_SUID_MEM #if GLIBTOP_SUID_MEM
case GLIBTOP_CMND_MEM: case GLIBTOP_CMND_MEM:
glibtop_get_mem_p (server, &resp->u.data.mem); retval = glibtop_get_mem_p (server, &resp->u.data.mem);
resp->offset = _offset_data (mem); resp->offset = _offset_data (mem);
break; break;
#endif #endif
#if GLIBTOP_SUID_SWAP #if GLIBTOP_SUID_SWAP
case GLIBTOP_CMND_SWAP: case GLIBTOP_CMND_SWAP:
glibtop_get_swap_p (server, &resp->u.data.swap); retval = glibtop_get_swap_p (server, &resp->u.data.swap);
resp->offset = _offset_data (swap); resp->offset = _offset_data (swap);
break; break;
#endif #endif
#if GLIBTOP_SUID_UPTIME #if GLIBTOP_SUID_UPTIME
case GLIBTOP_CMND_UPTIME: case GLIBTOP_CMND_UPTIME:
glibtop_get_uptime_p (server, &resp->u.data.uptime); retval = glibtop_get_uptime_p (server, &resp->u.data.uptime);
resp->offset = _offset_data (uptime); resp->offset = _offset_data (uptime);
break; break;
#endif #endif
#if GLIBTOP_SUID_LOADAVG #if GLIBTOP_SUID_LOADAVG
case GLIBTOP_CMND_LOADAVG: case GLIBTOP_CMND_LOADAVG:
glibtop_get_loadavg_p (server, &resp->u.data.loadavg); retval = glibtop_get_loadavg_p (server, &resp->u.data.loadavg);
resp->offset = _offset_data (loadavg); resp->offset = _offset_data (loadavg);
break; break;
#endif #endif
#if GLIBTOP_SUID_SHM_LIMITS #if GLIBTOP_SUID_SHM_LIMITS
case GLIBTOP_CMND_SHM_LIMITS: case GLIBTOP_CMND_SHM_LIMITS:
glibtop_get_shm_limits_p (server, &resp->u.data.shm_limits); retval = glibtop_get_shm_limits_p (server, &resp->u.data.shm_limits);
resp->offset = _offset_data (shm_limits); resp->offset = _offset_data (shm_limits);
break; break;
#endif #endif
#if GLIBTOP_SUID_MSG_LIMITS #if GLIBTOP_SUID_MSG_LIMITS
case GLIBTOP_CMND_MSG_LIMITS: case GLIBTOP_CMND_MSG_LIMITS:
glibtop_get_msg_limits_p (server, &resp->u.data.msg_limits); retval = glibtop_get_msg_limits_p (server, &resp->u.data.msg_limits);
resp->offset = _offset_data (msg_limits); resp->offset = _offset_data (msg_limits);
break; break;
#endif #endif
#if GLIBTOP_SUID_SEM_LIMITS #if GLIBTOP_SUID_SEM_LIMITS
case GLIBTOP_CMND_SEM_LIMITS: case GLIBTOP_CMND_SEM_LIMITS:
glibtop_get_sem_limits_p (server, &resp->u.data.sem_limits); retval = glibtop_get_sem_limits_p (server, &resp->u.data.sem_limits);
resp->offset = _offset_data (sem_limits); resp->offset = _offset_data (sem_limits);
break; break;
#endif #endif
#if GLIBTOP_SUID_PROC_STATE #if GLIBTOP_SUID_PROC_STATE
case GLIBTOP_CMND_PROC_STATE: case GLIBTOP_CMND_PROC_STATE:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_state_p retval = glibtop_get_proc_state_p
(server, &resp->u.data.proc_state, pid); (server, &resp->u.data.proc_state, pid);
resp->offset = _offset_data (proc_state); resp->offset = _offset_data (proc_state);
break; break;
@@ -190,7 +195,7 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_UID #if GLIBTOP_SUID_PROC_UID
case GLIBTOP_CMND_PROC_UID: case GLIBTOP_CMND_PROC_UID:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_uid_p retval = glibtop_get_proc_uid_p
(server, &resp->u.data.proc_uid, pid); (server, &resp->u.data.proc_uid, pid);
resp->offset = _offset_data (proc_uid); resp->offset = _offset_data (proc_uid);
break; break;
@@ -198,7 +203,7 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_MEM #if GLIBTOP_SUID_PROC_MEM
case GLIBTOP_CMND_PROC_MEM: case GLIBTOP_CMND_PROC_MEM:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_mem_p retval = glibtop_get_proc_mem_p
(server, &resp->u.data.proc_mem, pid); (server, &resp->u.data.proc_mem, pid);
resp->offset = _offset_data (proc_mem); resp->offset = _offset_data (proc_mem);
break; break;
@@ -206,7 +211,7 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_TIME #if GLIBTOP_SUID_PROC_TIME
case GLIBTOP_CMND_PROC_TIME: case GLIBTOP_CMND_PROC_TIME:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_time_p retval = glibtop_get_proc_time_p
(server, &resp->u.data.proc_time, pid); (server, &resp->u.data.proc_time, pid);
resp->offset = _offset_data (proc_time); resp->offset = _offset_data (proc_time);
break; break;
@@ -214,7 +219,7 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_SIGNAL #if GLIBTOP_SUID_PROC_SIGNAL
case GLIBTOP_CMND_PROC_SIGNAL: case GLIBTOP_CMND_PROC_SIGNAL:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_signal_p retval = glibtop_get_proc_signal_p
(server, &resp->u.data.proc_signal, pid); (server, &resp->u.data.proc_signal, pid);
resp->offset = _offset_data (proc_signal); resp->offset = _offset_data (proc_signal);
break; break;
@@ -222,7 +227,7 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_KERNEL #if GLIBTOP_SUID_PROC_KERNEL
case GLIBTOP_CMND_PROC_KERNEL: case GLIBTOP_CMND_PROC_KERNEL:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_kernel_p retval = glibtop_get_proc_kernel_p
(server, &resp->u.data.proc_kernel, pid); (server, &resp->u.data.proc_kernel, pid);
resp->offset = _offset_data (proc_kernel); resp->offset = _offset_data (proc_kernel);
break; break;
@@ -230,21 +235,21 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
#if GLIBTOP_SUID_PROC_SEGMENT #if GLIBTOP_SUID_PROC_SEGMENT
case GLIBTOP_CMND_PROC_SEGMENT: case GLIBTOP_CMND_PROC_SEGMENT:
memcpy (&pid, parameter, sizeof (pid_t)); memcpy (&pid, parameter, sizeof (pid_t));
glibtop_get_proc_segment_p retval = glibtop_get_proc_segment_p
(server, &resp->u.data.proc_segment, pid); (server, &resp->u.data.proc_segment, pid);
resp->offset = _offset_data (proc_segment); resp->offset = _offset_data (proc_segment);
break; break;
#endif #endif
#if GLIBTOP_SUID_NETLOAD #if GLIBTOP_SUID_NETLOAD
case GLIBTOP_CMND_NETLOAD: case GLIBTOP_CMND_NETLOAD:
glibtop_get_netload_p (server, &resp->u.data.netload, parameter); retval = glibtop_get_netload_p (server, &resp->u.data.netload, parameter);
resp->offset = _offset_data (netload); resp->offset = _offset_data (netload);
break; break;
#endif #endif
#if GLIBTOP_SUID_PPP #if GLIBTOP_SUID_PPP
case GLIBTOP_CMND_PPP: case GLIBTOP_CMND_PPP:
memcpy (&device, parameter, sizeof (unsigned short)); memcpy (&device, parameter, sizeof (unsigned short));
glibtop_get_ppp_p (server, &resp->u.data.ppp, device); retval = glibtop_get_ppp_p (server, &resp->u.data.ppp, device);
resp->offset = _offset_data (ppp); resp->offset = _offset_data (ppp);
break; break;
#endif #endif
@@ -253,4 +258,6 @@ handle_slave_command (glibtop_command *cmnd, glibtop_response *resp,
cmnd->command); cmnd->command);
break; break;
} }
return retval;
} }