ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/saidar/saidar.c

Comparing projects/libstatgrab/src/saidar/saidar.c (file contents):
Revision 1.1 by pajs, Thu Oct 9 15:57:05 2003 UTC vs.
Revision 1.41 by tdb, Fri Jan 5 13:30:36 2007 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream libstatgrab
3	+	* http://www.i-scream.org
4	+	* Copyright (C) 2000-2004 i-scream
5	+	*
6	+	* This program is free software; you can redistribute it and/or
7	+	* modify it under the terms of the GNU General Public License
8	+	* as published by the Free Software Foundation; either version 2
9	+	* of the License, or (at your option) any later version.
10	+	*
11	+	* This program is distributed in the hope that it will be useful,
12	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14	+	* GNU General Public License for more details.
15	+	*
16	+	* You should have received a copy of the GNU General Public License
17	+	* along with this program; if not, write to the Free Software
18	+	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19	+	*
20	+	* $Id$
21	+	*/
22	+
23	+	#ifdef HAVE_CONFIG_H
24	+	#include "config.h"
25	+	#endif
26	+
27		#include <stdio.h>
28		#include <string.h>
29		#include <sys/ioctl.h>
#	Line 10 | Line 36
36		#include <sys/times.h>
37		#include <limits.h>
38		#include <time.h>
39	<	#include <curses.h>
39	>	#include <math.h>
40
41	+	#ifdef HAVE_NCURSES_H
42	+	#define COLOR_SUPPORT
43	+	#endif
44	+	#include CURSES_HEADER_FILE
45	+
46	+	#define THRESHOLD_LOAD 1.0
47	+
48	+	#define THRESHOLD_WARN_ZMB 0
49	+
50	+	#define THRESHOLD_WARN_CPU 60.0
51	+	#define THRESHOLD_ALERT_CPU 90.0
52	+
53	+	#define THRESHOLD_WARN_SWAP 75.0
54	+	#define THRESHOLD_ALERT_SWAP 90.0
55	+
56	+	#define THRESHOLD_WARN_MEM 75.0
57	+	#define THRESHOLD_ALERT_MEM 90.0
58	+
59	+	#define THRESHOLD_WARN_DISK 75.0
60	+	#define THRESHOLD_ALERT_DISK 90.0
61	+
62	+	int sig_winch_flag = 0;
63	+
64		typedef struct{
65	<	cpu_percent_t *cpu_percents;
66	<	mem_stat_t *mem_stats;
67	<	swap_stat_t *swap_stats;
68	<	load_stat_t *load_stats;
69	<	process_stat_t *process_stats;
70	<	page_stat_t *page_stats;
65	>	sg_cpu_percents *cpu_percents;
66	>	sg_mem_stats *mem_stats;
67	>	sg_swap_stats *swap_stats;
68	>	sg_load_stats *load_stats;
69	>	sg_process_count *process_count;
70	>	sg_page_stats *page_stats;
71
72	<	network_stat_t *network_stats;
73	<	int network_entries;
72	>	sg_network_io_stats *network_io_stats;
73	>	int network_io_entries;
74
75	<	diskio_stat_t *diskio_stats;
76	<	int diskio_entries;
75	>	sg_disk_io_stats *disk_io_stats;
76	>	int disk_io_entries;
77
78	<	disk_stat_t *disk_stats;
79	<	int disk_entries;
78	>	sg_fs_stats *fs_stats;
79	>	int fs_entries;
80
81	<	general_stat_t *general_stats;
82	<	user_stat_t *user_stats;
81	>	sg_host_info *host_info;
82	>	sg_user_stats *user_stats;
83		}stats_t;
84	<
84	>
85		stats_t stats;
86
87		char *size_conv(long long number){
88		char type[] = {'B', 'K', 'M', 'G', 'T'};
89		int x=0;
90	+	int sign=1;
91		static char string[10];
92
93	+	if(number < 0){
94	+	sign=-1;
95	+	number=-number;
96	+	}
97	+
98		for(;x<5;x++){
99		if( (number/1024) < (100)) {
100		break;
#	Line 47 | Line 102 | char *size_conv(long long number){
102		number = (number/1024);
103		}
104
105	<	snprintf(string, 10, "%lld%c", number, type[x]);
105	>	number = number*sign;
106	>
107	>	snprintf(string, 10, "%lld%c", number, type[x]);
108		return string;
109	<
109	>
110		}
111
112		char *hr_uptime(time_t time){
113		int day = 0, hour = 0, min = 0;
114		static char uptime_str[25];
115		int sec = (int) time;
116	<
116	>
117		day = sec / (24*60*60);
118		sec = sec % (24*60*60);
119		hour = sec / (60*60);
#	Line 73 | Line 130 | char *hr_uptime(time_t time){
130		}
131
132		void display_headings(){
133	+	int line;
134	+
135		move(0,0);
136		printw("Hostname  :");
137		move(0,27);
#	Line 119 | Line 178 | void display_headings(){
178		printw("Mem Free  :");
179
180		/* Swap */
181	<	move(6, 21);
182	<	printw("Swap Total:");
183	<	move(7, 21);
184	<	printw("Swap Used :");
185	<	move(8, 21);
186	<	printw("Swap Free :");
181	>	move(6, 21);
182	>	printw("Swap Total:");
183	>	move(7, 21);
184	>	printw("Swap Used :");
185	>	move(8, 21);
186	>	printw("Swap Free :");
187
188		/* VM */
189		move(6, 42);
#	Line 146 | Line 205 | void display_headings(){
205		move(10,15);
206		printw("Read");
207		move(10,28);
208	<	printw("Write");
208	>	printw("Write");
209
210	<	/* Network IO */
211	<	move(10, 42);
212	<	printw("Network Interface");
213	<	move(10, 67);
214	<	printw("rx");
215	<	move(10,77);
216	<	printw("tx");
210	>	line = 10;
211	>	if (stats.network_io_stats != NULL) {
212	>	/* Network IO */
213	>	move(line, 42);
214	>	printw("Network Interface");
215	>	move(line, 67);
216	>	printw("rx");
217	>	move(line, 77);
218	>	printw("tx");
219	>	line += 2 + stats.network_io_entries;
220	>	}
221
222	<	move(12+stats.network_entries, 42);
222	>	move(line, 42);
223		printw("Mount Point");
224	<	move(12+stats.network_entries, 65);
224	>	move(line, 65);
225		printw("Free");
226	<	move(12+stats.network_entries, 75);
226	>	move(line, 75);
227		printw("Used");
228
229		refresh();
230		}
231
232	<	void display_data(){
232	>	void display_data(int colors){
233		char cur_time[20];
234		struct tm *tm_time;
235		time_t epoc_time;
236	<	int counter;
236	>	int counter, line;
237		long long r,w;
238		long long rt, wt;
239	<	diskio_stat_t *diskio_stat_ptr;
240	<	network_stat_t *network_stat_ptr;
241	<	disk_stat_t *disk_stat_ptr;
239	>	sg_disk_io_stats *disk_io_stat_ptr;
240	>	sg_network_io_stats *network_stat_ptr;
241	>	sg_fs_stats *disk_stat_ptr;
242	>	/* Size before it will start overwriting "uptime" */
243	>	char hostname[15];
244	>	char *ptr;
245
246	<	move(0,12);
247	<	printw("%s", stats.general_stats->hostname);
248	<	move(0,36);
249	<	printw("%s", hr_uptime(stats.general_stats->uptime));
250	<	epoc_time=time(NULL);
251	<	tm_time = localtime(&epoc_time);
252	<	strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
253	<	move(0,61);
254	<	printw("%s", cur_time);
246	>	if (stats.host_info != NULL) {
247	>	move(0,12);
248	>	strncpy(hostname, stats.host_info->hostname, (sizeof(hostname) - 1));
249	>	/* strncpy does not NULL terminate.. If only strlcpy was on all platforms :) */
250	>	hostname[14] = '\0';
251	>	ptr=strchr(hostname, '.');
252	>	/* Some hosts give back a FQDN for hostname. To avoid this, we'll
253	>	* just blank out everything after the first "."
254	>	*/
255	>	if (ptr != NULL){
256	>	*ptr = '\0';
257	>	}
258	>	if (colors) {
259	>	attron(COLOR_PAIR(1));
260	>	}
261	>	printw("%s", hostname);
262	>	move(0,36);
263	>	printw("%s", hr_uptime(stats.host_info->uptime));
264	>	epoc_time=time(NULL);
265	>	tm_time = localtime(&epoc_time);
266	>	strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
267	>	move(0,61);
268	>	printw("%s", cur_time);
269	>	if (colors) {
270	>	attroff(COLOR_PAIR(1));
271	>	}
272	>	}
273
274	<	/* Load */
275	<	move(2,12);
276	<	printw("%6.2f", stats.load_stats->min1);
277	<	move(3,12);
278	<	printw("%6.2f", stats.load_stats->min5);
279	<	move(4,12);
280	<	printw("%6.2f", stats.load_stats->min15);
274	>	if (stats.load_stats != NULL) {
275	>	/* Load */
276	>	if (colors) {
277	>	attron(COLOR_PAIR(6));
278	>	}
279	>	move(2,12);
280	>	if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min5) > THRESHOLD_LOAD) {
281	>	attron(A_BOLD);
282	>	}
283	>	printw("%6.2f", stats.load_stats->min1);
284	>	if (colors) {
285	>	attroff(A_BOLD);
286	>	}
287	>	move(3,12);
288	>	if (colors && fabs(stats.load_stats->min5 - stats.load_stats->min15) > THRESHOLD_LOAD) {
289	>	attron(A_BOLD);
290	>	}
291	>	printw("%6.2f", stats.load_stats->min5);
292	>	if (colors) {
293	>	attroff(A_BOLD);
294	>	}
295	>	move(4,12);
296	>	if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min15) > THRESHOLD_LOAD) {
297	>	attron(A_BOLD);
298	>	}
299	>	printw("%6.2f", stats.load_stats->min15);
300	>	if (colors) {
301	>	attroff(A_BOLD);
302	>	}
303	>	}
304
305	<	/* CPU */
306	<	move(2,33);
307	<	printw("%6.2f%%", stats.cpu_percents->idle);
308	<	move(3,33);
309	<	printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
310	<	move(4,33);
311	<	printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
305	>	if (stats.cpu_percents != NULL) {
306	>	/* CPU */
307	>	move(2,33);
308	>	printw("%6.2f%%", stats.cpu_percents->idle);
309	>	move(3,33);
310	>	printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
311	>	move(4,33);
312	>	if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_ALERT_CPU) {
313	>	attron(A_STANDOUT);
314	>	attron(A_BOLD);
315	>	}
316	>	else if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_WARN_CPU) {
317	>	attron(A_BOLD);
318	>	}
319	>	printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
320	>	if(colors) {
321	>	attroff(A_BOLD);
322	>	attroff(A_STANDOUT);
323	>	attron(COLOR_PAIR(6));
324	>	}
325	>	}
326
327	<	/* Process */
328	<	move(2, 54);
329	<	printw("%5d", stats.process_stats->running);
330	<	move(2,74);
331	<	printw("%5d", stats.process_stats->zombie);
332	<	move(3, 54);
333	<	printw("%5d", stats.process_stats->sleeping);
334	<	move(3, 74);
335	<	printw("%5d", stats.process_stats->total);
336	<	move(4, 54);
337	<	printw("%5d", stats.process_stats->stopped);
338	<	move(4,74);
339	<	printw("%5d", stats.user_stats->num_entries);
327	>	if (stats.process_count != NULL) {
328	>	/* Process */
329	>	move(2, 54);
330	>	printw("%5d", stats.process_count->running);
331	>	move(2,74);
332	>	if (colors && stats.process_count->zombie > THRESHOLD_WARN_ZMB) {
333	>	attron(A_STANDOUT);
334	>	attron(A_BOLD);
335	>	}
336	>	printw("%5d", stats.process_count->zombie);
337	>	if(colors) {
338	>	attroff(A_STANDOUT);
339	>	attroff(A_BOLD);
340	>	}
341	>	move(3, 54);
342	>	printw("%5d", stats.process_count->sleeping);
343	>	move(3, 74);
344	>	printw("%5d", stats.process_count->total);
345	>	move(4, 54);
346	>	printw("%5d", stats.process_count->stopped);
347	>	}
348	>	if (stats.user_stats != NULL) {
349	>	move(4,74);
350	>	printw("%5d", stats.user_stats->num_entries);
351	>	}
352
353	<	/* Mem */
353	>	if(colors) {
354	>	attroff(COLOR_PAIR(6));
355	>	attron(COLOR_PAIR(5));
356	>	}
357	>	if (stats.mem_stats != NULL) {
358	>	/* Mem */
359	>	move(6, 12);
360	>	printw("%7s", size_conv(stats.mem_stats->total));
361	>	move(7, 12);
362	>	printw("%7s", size_conv(stats.mem_stats->used));
363	>	move(8, 12);
364	>	printw("%7s", size_conv(stats.mem_stats->free));
365	>	}
366
367	<	move(6, 12);
368	<	printw("%7s", size_conv(stats.mem_stats->total));
369	<	move(7, 12);
370	<	printw("%7s", size_conv(stats.mem_stats->used));
371	<	move(8, 12);
372	<	printw("%7s", size_conv(stats.mem_stats->free));
373	<
374	<	/* Swap */
375	<	move(6, 32);
231	<	printw("%8s", size_conv(stats.swap_stats->total));
232	<	move(7, 32);
233	<	printw("%8s", size_conv(stats.swap_stats->used));
234	<	move(8, 32);
235	<	printw("%8s", size_conv(stats.swap_stats->free));
367	>	if (stats.swap_stats != NULL) {
368	>	/* Swap */
369	>	move(6, 32);
370	>	printw("%8s", size_conv(stats.swap_stats->total));
371	>	move(7, 32);
372	>	printw("%8s", size_conv(stats.swap_stats->used));
373	>	move(8, 32);
374	>	printw("%8s", size_conv(stats.swap_stats->free));
375	>	}
376
377		/* VM */
378	<	move(6, 54);
379	<	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total));
380	<	move(7, 54);
381	<	printw("%5.2f%%", (100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total));
382	<	move(8, 54);
383	<	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
378	>	if (stats.mem_stats != NULL && stats.mem_stats->total != 0) {
379	>	float f = 100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total;
380	>	if (colors && f > THRESHOLD_ALERT_MEM) {
381	>	attron(A_STANDOUT);
382	>	attron(A_BOLD);
383	>	}
384	>	else if (colors && f > THRESHOLD_WARN_MEM) {
385	>	attron(A_BOLD);
386	>	}
387	>	move(6, 54);
388	>	printw("%5.2f%%", f);
389	>	if (colors) {
390	>	attroff(A_STANDOUT);
391	>	attroff(A_BOLD);
392	>	attron(COLOR_PAIR(5));
393	>	}
394	>	}
395	>	if (stats.swap_stats != NULL && stats.swap_stats->total != 0) {
396	>	float f = 100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total;
397	>	if (colors && f > THRESHOLD_ALERT_SWAP) {
398	>	attron(A_STANDOUT);
399	>	attron(A_BOLD);
400	>	}
401	>	else if (colors && f > THRESHOLD_WARN_SWAP) {
402	>	attron(A_BOLD);
403	>	}
404	>	move(7, 54);
405	>	printw("%5.2f%%", f);
406	>	if (colors) {
407	>	attroff(A_STANDOUT);
408	>	attroff(A_BOLD);
409	>	attron(COLOR_PAIR(5));
410	>	}
411	>	}
412	>	if (stats.mem_stats != NULL && stats.swap_stats != NULL &&
413	>	stats.mem_stats->total != 0 && stats.swap_stats->total != 0) {
414	>	move(8, 54);
415	>	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
416	>	}
417
418	<	/* Paging */
419	<	move(6, 74);
420	<	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
421	<	move(7, 74);
422	<	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
418	>	if (stats.page_stats != NULL) {
419	>	/* Paging */
420	>	move(6, 74);
421	>	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
422	>	move(7, 74);
423	>	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
424	>	}
425	>	if (colors) {
426	>	attroff(COLOR_PAIR(5));
427	>	}
428
429	<	/* Disk IO */
430	<	diskio_stat_ptr = stats.diskio_stats;
431	<	r=0;
432	<	w=0;
433	<	for(counter=0;counter<stats.diskio_entries;counter++){
434	<	move(11+counter, 0);
435	<	printw("%s", diskio_stat_ptr->disk_name);
436	<	move(11+counter, 12);
437	<	rt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->read_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->read_bytes;
438	<	printw("%7s", size_conv(rt));
439	<	r+=rt;
440	<	move(11+counter, 26);
441	<	wt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->write_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->write_bytes;
442	<	printw("%7s", size_conv(wt));
443	<	w+=wt;
444	<	diskio_stat_ptr++;
429	>	line = 11;
430	>	if (stats.disk_io_stats != NULL) {
431	>	/* Disk IO */
432	>	disk_io_stat_ptr = stats.disk_io_stats;
433	>	r=0;
434	>	w=0;
435	>	for(counter=0;counter<stats.disk_io_entries;counter++){
436	>	char name[12];
437	>	strncpy(name, disk_io_stat_ptr->disk_name, sizeof(name));
438	>	name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
439	>	move(line, 0);
440	>	printw("%s", name);
441	>	move(line, 12);
442	>	rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes;
443	>	if(colors) {
444	>	attron(COLOR_PAIR(4));
445	>	}
446	>	printw("%7s", size_conv(rt));
447	>	r+=rt;
448	>	move(line, 26);
449	>	wt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->write_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->write_bytes;
450	>	printw("%7s", size_conv(wt));
451	>	w+=wt;
452	>	disk_io_stat_ptr++;
453	>	line++;
454	>	if(colors) {
455	>	attroff(COLOR_PAIR(4));
456	>	}
457	>	}
458	>	line++;
459	>	move(line, 0);
460	>	printw("Total");
461	>	move(line, 12);
462	>	if(colors) {
463	>	attron(COLOR_PAIR(4));
464	>	}
465	>	printw("%7s", size_conv(r));
466	>	move(line, 26);
467	>	printw("%7s", size_conv(w));
468	>	if(colors) {
469	>	attroff(COLOR_PAIR(4));
470	>	}
471		}
268	–	move(12+counter, 0);
269	–	printw("Total");
270	–	move(12+counter, 12);
271	–	printw("%7s", size_conv(r));
272	–	move(12+counter, 26);
273	–	printw("%7s", size_conv(w));
472
473	<	/* Network */
474	<	network_stat_ptr = stats.network_stats;
475	<	for(counter=0;counter<stats.network_entries;counter++){
476	<	move(11+counter, 42);
477	<	printw("%s", network_stat_ptr->interface_name);
478	<	move(11+counter, 62);
479	<	rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
480	<	printw("%7s", size_conv(rt));
481	<	move(11+counter, 72);
482	<	wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
483	<	printw("%7s", size_conv(wt));
484	<	network_stat_ptr++;
473	>	line = 11;
474	>	if (stats.network_io_stats != NULL) {
475	>	/* Network */
476	>	network_stat_ptr = stats.network_io_stats;
477	>	for(counter=0;counter<stats.network_io_entries;counter++){
478	>	char name[20];
479	>	strncpy(name, network_stat_ptr->interface_name, sizeof(name));
480	>	name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
481	>	move(line, 42);
482	>	printw("%s", name);
483	>	move(line, 62);
484	>	rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
485	>	if(colors) {
486	>	attron(COLOR_PAIR(4));
487	>	}
488	>	printw("%7s", size_conv(rt));
489	>	move(line, 72);
490	>	wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
491	>	printw("%7s", size_conv(wt));
492	>	network_stat_ptr++;
493	>	line++;
494	>	if(colors) {
495	>	attroff(COLOR_PAIR(4));
496	>	}
497	>	}
498	>	line += 2;
499		}
500
501	<	disk_stat_ptr = stats.disk_stats;
502	<	for(counter=0;counter<stats.disk_entries;counter++){
503	<	move(13+stats.network_entries+counter, 42);
504	<	printw("%s", disk_stat_ptr->mnt_point);
505	<	move(13+stats.network_entries+counter, 62);
506	<	printw("%7s", size_conv(disk_stat_ptr->avail));
507	<	move(13+stats.network_entries+counter, 73);
508	<	printw("%5.2f%%", 100.00 * ((float)disk_stat_ptr->used / (float)disk_stat_ptr->size));
509	<	disk_stat_ptr++;
501	>	if (stats.fs_stats != NULL) {
502	>	/* Disk */
503	>	disk_stat_ptr = stats.fs_stats;
504	>	for(counter=0;counter<stats.fs_entries;counter++){
505	>	char name[20];
506	>	strncpy(name, disk_stat_ptr->mnt_point, sizeof(name));
507	>	name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
508	>	move(line, 42);
509	>	printw("%s", name);
510	>	move(line, 62);
511	>	if(colors) {
512	>	attron(COLOR_PAIR(2));
513	>	}
514	>	printw("%7s", size_conv(disk_stat_ptr->avail));
515	>	move(line, 73);
516	>	if(colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_ALERT_DISK) {
517	>	attron(A_STANDOUT);
518	>	attron(A_BOLD);
519	>	} else if (colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_WARN_DISK) {
520	>	attron(A_BOLD);
521	>	}
522	>	printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
523	>	disk_stat_ptr++;
524	>	line++;
525	>	if(colors) {
526	>	attroff(COLOR_PAIR(2));
527	>	attroff(A_STANDOUT);
528	>	attroff(A_BOLD);
529	>	}
530	>	}
531		}
532
533		refresh();
534		}
535
536	<	void sig_winch_handler(int sig){
537	<	clear();
538	<	display_headings();
306	<	display_data();
307	<	signal(SIGWINCH, sig_winch_handler);
536	>	void sig_winch_handler(int dummy){
537	>	sig_winch_flag = 1;
538	>	signal(SIGWINCH, sig_winch_handler);
539		}
540
541		int get_stats(){
542	<	if((stats.cpu_percents = cpu_percent_usage()) == NULL) return 0;
543	<	if((stats.mem_stats = get_memory_stats()) == NULL) return 0;
544	<	if((stats.swap_stats = get_swap_stats()) == NULL) return 0;
545	<	if((stats.load_stats = get_load_stats()) == NULL) return 0;
546	<	if((stats.process_stats = get_process_stats()) == NULL) return 0;
547	<	if((stats.page_stats = get_page_stats_diff()) == NULL) return 0;
548	<	if((stats.network_stats = get_network_stats_diff(&(stats.network_entries))) == NULL) return 0;
549	<	if((stats.diskio_stats = get_diskio_stats_diff(&(stats.diskio_entries))) == NULL) return 0;
550	<	if((stats.disk_stats = get_disk_stats(&(stats.disk_entries))) == NULL) return 0;
551	<	if((stats.general_stats = get_general_stats()) == NULL) return 0;
552	<	if((stats.user_stats = get_user_stats()) == NULL) return 0;
542	>	stats.cpu_percents = sg_get_cpu_percents();
543	>	stats.mem_stats = sg_get_mem_stats();
544	>	stats.swap_stats = sg_get_swap_stats();
545	>	stats.load_stats = sg_get_load_stats();
546	>	stats.process_count = sg_get_process_count();
547	>	stats.page_stats = sg_get_page_stats_diff();
548	>	stats.network_io_stats = sg_get_network_io_stats_diff(&(stats.network_io_entries));
549	>	stats.disk_io_stats = sg_get_disk_io_stats_diff(&(stats.disk_io_entries));
550	>	stats.fs_stats = sg_get_fs_stats(&(stats.fs_entries));
551	>	stats.host_info = sg_get_host_info();
552	>	stats.user_stats = sg_get_user_stats();
553
554	<	return 1;
554	>	return 1;
555		}
556
557	+	void version_num(char *progname){
558	+	fprintf(stderr, "%s version %s\n", progname, PACKAGE_VERSION);
559	+	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
560	+	exit(1);
561	+	}
562	+
563	+	void usage(char *progname){
564	+	#ifdef COLOR_SUPPORT
565	+	fprintf(stderr, "Usage: %s [-d delay] [-c] [-v] [-h]\n\n", progname);
566	+	#else
567	+	fprintf(stderr, "Usage: %s [-d delay] [-v] [-h]\n\n", progname);
568	+	#endif
569	+	fprintf(stderr, "  -d    Sets the update time in seconds\n");
570	+	#ifdef COLOR_SUPPORT
571	+	fprintf(stderr, "  -c    Enables coloured output\n");
572	+	#endif
573	+	fprintf(stderr, "  -v    Prints version number\n");
574	+	fprintf(stderr, "  -h    Displays this help information.\n");
575	+	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
576	+	exit(1);
577	+	}
578	+
579		int main(int argc, char **argv){
580	+	extern char *optarg;
581	+	int c;
582	+	int colouron = 0;
583
584	<	extern char *optarg;
329	<	extern int optind;
330	<	int c;
584	>	time_t last_update = 0;
585
586		WINDOW *window;
587
334	–	int stdin_fileno;
335	–	fd_set infds;
336	–	struct timeval timeout;
337	–
588		extern int errno;
339	–	char ch;
589
590		int delay=2;
591
592	<	while ((c = getopt(argc, argv, "d:")) != EOF){
593	<	switch (c){
594	<	case 'd':
595	<	delay = atoi(optarg);
596	<	if (delay == 0){
592	>	sg_init();
593	>	if(sg_drop_privileges() != 0){
594	>	fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
595	>	return 1;
596	>	}
597	>
598	>	#ifdef COLOR_SUPPORT
599	>	while ((c = getopt(argc, argv, "d:cvh")) != -1){
600	>	#else
601	>	while ((c = getopt(argc, argv, "d:vh")) != -1){
602	>	#endif
603	>	switch (c){
604	>	case 'd':
605	>	delay = atoi(optarg);
606	>	if (delay < 1){
607		fprintf(stderr, "Time must be 1 second or greater\n");
608		exit(1);
609		}
610	<	delay--;
611	<	break;
612	<	}
613	<	}
610	>	break;
611	>	#ifdef COLOR_SUPPORT
612	>	case 'c':
613	>	colouron = 1;
614	>	break;
615	>	#endif
616	>	case 'v':
617	>	version_num(argv[0]);
618	>	break;
619	>	case 'h':
620	>	default:
621	>	usage(argv[0]);
622	>	return 1;
623	>	break;
624	>	}
625	>	}
626
627		signal(SIGWINCH, sig_winch_handler);
628	<	initscr();
629	<	nonl();
630	<	cbreak();
631	<	noecho();
632	<	window=newwin(0, 0, 0, 0);
628	>	initscr();
629	>	#ifdef COLOR_SUPPORT
630	>	/* turn on colour */
631	>	if (colouron) {
632	>	if (has_colors()) {
633	>	start_color();
634	>	use_default_colors();
635	>	init_pair(1,COLOR_RED,-1);
636	>	init_pair(2,COLOR_GREEN,-1);
637	>	init_pair(3,COLOR_YELLOW,-1);
638	>	init_pair(4,COLOR_BLUE,-1);
639	>	init_pair(5,COLOR_MAGENTA,-1);
640	>	init_pair(6,COLOR_CYAN,-1);
641	>	} else {
642	>	fprintf(stderr, "Colour support disabled: your terminal does not support colour.");
643	>	colouron = 0;
644	>	}
645	>	}
646	>	#endif
647	>	nonl();
648	>	curs_set(0);
649	>	cbreak();
650	>	noecho();
651	>	timeout(delay * 1000);
652	>	window=newwin(0, 0, 0, 0);
653		clear();
654
655		if(!get_stats()){
#	Line 368 | Line 659 | int main(int argc, char **argv){
659		}
660
661		display_headings();
371	–	stdin_fileno=fileno(stdin);
662
663		for(;;){
664	+	time_t now;
665	+	int ch = getch();
666
667	<	FD_ZERO(&infds);
668	<	FD_SET(stdin_fileno, &infds);
377	<	timeout.tv_sec = delay;
378	<	timeout.tv_usec = 0;
379	<
380	<	if((select((stdin_fileno+1), &infds, NULL, NULL, &timeout)) == -1){
381	<	if(errno!=EINTR){
382	<	perror("select failed");
383	<	exit(1);
384	<	}
667	>	if (ch == 'q'){
668	>	break;
669		}
670
671	<	if(FD_ISSET(stdin_fileno, &infds)){
672	<	ch=getch();
673	<	if (ch == 'q'){
674	<	endwin();
675	<	return 0;
676	<	}
671	>	/* To keep the numbers slightly accurate we do not want them
672	>	* updating more frequently than once a second.
673	>	*/
674	>	now = time(NULL);
675	>	if ((now - last_update) >= 1) {
676	>	get_stats();
677		}
678	+	last_update = now;
679
680	<	get_stats();
680	>	if(sig_winch_flag) {
681	>	clear();
682	>	display_headings();
683	>	sig_winch_flag = 0;
684	>	}
685
686	<	display_data();
686	>	display_data(colouron);
687	>	}
688
399	–	/* To keep the numbers slightly accurate we do not want them updating more
400	–	* frequently than once a second.
401	–	*/
402	–	sleep(1);
403	–
404	–	}
405	–
406	–
407	–
689		endwin();
690		return 0;
691	<	}
691	>	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines