systemwatch.c

这是一个基于linux系统的程序

#include <gtk-2.0/gtk/gtk.h>
#include <gdk/gdk.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/reboot.h>
#include <sys/time.h>
#include <string.h>
#include <ctype.h>

char *entrytext;
char *entrytext1;
GtkWidget *statusbar1;
GtkWidget *statusbar2;
GtkWidget *statusbar3;
GtkWidget *statusbar4;
GtkWidget* gtkentry;
GtkWidget* gtkentry1;
GtkWidget *userbar;
GtkWidget *systembar;
GtkWidget *nicebar;
GtkWidget *idlebar;
GtkWidget* labelt;
int flag=0;
long  user0,system0,nice0,idle0,total0;
long pagei, pageo;
double buser0,bsystem0,bnice0,bidle0;

void close_win(GtkWidget *widget, gpointer data){                         //to close a window
gtk_widget_destroy(data);
}


gint timeout_callback1(gpointer  data)                                 //get  currenttime
{ struct timeval now;
  gettimeofday(&now,NULL);
 
  gtk_statusbar_push(GTK_STATUSBAR(statusbar1),0,ctime(&now.tv_sec));
  return(TRUE); 
}

gint timeout_callback2(gpointer data)                       //get cpu using rate
{
char buffer[35];
char * buffer1;
char buffer6[30];
char buffer2[10];
char buffer3[10];
char buffer4[10];
char buffer5[10];
int i;
long  user1,system1,nice1,idle1;
double total1,buser1,bsystem1,bnice1,bidle1,btotal;


buffer1=malloc(30*sizeof(char));

sprintf(buffer1,"");
int fd;

if((fd=open("/proc/stat",O_RDONLY))==-1)
{
printf("Can not open proc file!\n");
return(-1);
}
read(fd,buffer,35);
close(fd);
strncat(buffer1,buffer,30);


for(buffer1=buffer1+3;!isdigit(*buffer1);buffer1++)
		;
for(i=0,buffer2[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer2[i]=(*buffer1);
      buffer2[i]='\0';
      user1=atol(buffer2);

for(;!isdigit(*buffer1);buffer1++)
		;
for(i=0,buffer3[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer3[i]=(*buffer1);
      buffer3[i]='\0';
      system1=atol(buffer3);

for(;!isdigit(*buffer1);buffer1++)
		;
for(i=0,buffer4[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer4[i]=(*buffer1);
      buffer4[i]='\0';
      nice1=atol(buffer4);

for(;!isdigit(*buffer1);buffer1++)
		;
for(i=0,buffer5[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer5[i]=(*buffer1);
      buffer5[i]='\0';
      idle1=atol(buffer5);
      total0=(user0+system0+nice0+idle0);
      total1=(user1+system1+nice1+idle1);
      btotal=total1-total0;
      buser1=100*(user1-user0)/btotal;
      bsystem1=100*(system1-system0)/btotal;
      bnice1=100*(nice1-nice0)/btotal;
      bidle1=100*(idle1-idle0)/btotal;

      
sprintf(buffer6,"");
sprintf(buffer6,"%g%s%s%g%s%s%g%s%s%g%s%c",buser1,"%user"," ",bnice1,"%system"," ",bsystem1,"%nice"," ",bidle1,"%idle",'\0');

gtk_statusbar_push(GTK_STATUSBAR(statusbar2),GPOINTER_TO_INT(data),buffer6);

user0=user1;
system0=system1;
nice0=nice1;
idle0=idle1;
buser0=buser1;
bsystem0=bsystem1;
bnice0=bnice1;
bidle0=bidle1;

return(TRUE); 
}

gint timeout_callback3(gpointer* data)                                   //memory using status
{ char buffer[128]; 
  char * buffer1;
  char buffer2[10];
  char buffer3[10];
  char buffer4[30];
  long pagei1;
  long pageo1;
  int i=0;
  double btotal,bpagei,bpageo;
  
  buffer1=malloc(85*sizeof(char));

  sprintf(buffer1,"");
  int fd;

  if((fd=open("/proc/stat",O_RDONLY))==-1)
  {
    printf("Can not open proc file!\n");
    return(-1); 
  } 
  read(fd,buffer,128);
  close(fd);
 strncat(buffer1,buffer,85);
 buffer1=strchr(buffer1,(int)'e');
 for(;!isdigit(*buffer1);buffer1++)
		;
 for(i=0,buffer2[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer2[i]=(*buffer1);
      buffer2[i]='\0';
      pagei1=atol(buffer2);  
 for(;!isdigit(*buffer1);buffer1++)
		;
 for(i=0,buffer3[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer3[i]=(*buffer1);
      buffer3[i]='\0';
      pageo1=atol(buffer3);  
      btotal=pagei1+pageo1-pagei-pageo;
      if(!btotal)  btotal=100;
      bpagei=100*(pagei1-pagei)/btotal;
      bpageo=100-bpagei;
      
      sprintf(buffer4,"");  
      sprintf(buffer4,"%g%s  %g%s  %ld%c%ld",bpagei,"%page in",bpageo,"%page out",pagei1,'/',pageo1);
      gtk_statusbar_push(GTK_STATUSBAR(statusbar3),GPOINTER_TO_INT(data),buffer4);
      pagei=pagei1;
      pageo=pageo1;
      return(TRUE); 
}

gint timeout_callback4(gpointer * data)
{   
  gtk_progress_bar_set_fraction ( userbar, buser0/100 ); 
  gtk_progress_bar_set_fraction ( systembar, bnice0/100 ); 
  gtk_progress_bar_set_fraction ( nicebar, bsystem0/100 ); 
  gtk_progress_bar_set_fraction ( idlebar, bidle0/100 ); 
  return(TRUE);

}    
gint timeout_callback5(gpointer * data)
{   
int i,fd;
char * buffer1;
char buffer2[10];
char buffer3[15];
long sec;
int hour,min,second;
buffer1=malloc(20*sizeof(char));
if((fd=open("/proc/uptime",O_RDONLY,0))==-1)
{
printf("Can not open proc file!\n");
return(-1);
}
read(fd,buffer1,20);
close(fd);

for(;!isdigit(*buffer1);buffer1++)
		;
 for(i=0,buffer2[0]=(*buffer1);isdigit(*buffer1);i++,buffer1++)
      buffer2[i]=(*buffer1);
      buffer2[i]='\0';
     sec=atol(buffer2);
     hour=sec/3600;
     min=(sec-hour*3600)/60;
     second=sec-hour*3600-min*60;
sprintf(buffer3,"%d%c%d%c%d%c",hour,':',min,':',second,'\0');
gtk_statusbar_push(GTK_STATUSBAR(statusbar4),0,buffer3);
  
  return(TRUE); 

}
gint timeout_callback6(gpointer * data)
{

if(!flag)
{
gtk_label_set_text(labelt,"THANK YOU FOR INSTRUCTION!");
flag=1;
}
else{
gtk_label_set_text(labelt,"OS DESIGN : TASK SUPERVISOR");
flag=0;
}
return(TRUE); 
}

void processinformation(GtkWidget *widget, gpointer data)    
{   sync();
    system("ps -e >/root/processinfo.c");
    GtkWidget *scwin;
    GtkWidget *table;
    GtkWidget *window;
    int fdd;
    char buffer1[3000];
    if((fdd=open("/root/processinfo.c",O_RDONLY,0))==-1)
    {
      exit(0);
     }
     read(fdd,buffer1,3000);
     close(fdd);
     GtkWidget *label;
     
     window = gtk_dialog_new ();
     label=gtk_label_new(buffer1);
    
    gtk_window_set_title (GTK_WINDOW (window), "GtkScrolledWindow example");
    gtk_container_set_border_width (GTK_CONTAINER (window), 0);
    gtk_widget_set_size_request (window, 500, 350);
    scwin=gtk_scrolled_window_new(NULL,NULL);
    void gtk_scrolled_window_set_policy( scwin,
                                     GTK_POLICY_AUTOMATIC,
                                     GTK_POLICY_ALWAYS ); 
    gtk_container_set_border_width(GTK_CONTAINER (scwin), 5);
    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scwin,
			TRUE, TRUE, 0);
    table = gtk_table_new (40,30, FALSE);
    gtk_scrolled_window_add_with_viewport (
                   GTK_SCROLLED_WINDOW (scwin), table);

    gtk_table_attach_defaults(table,label,0,30,0,38);
    

    gtk_widget_show (label);
    gtk_widget_show (table);
    gtk_widget_show (window);
    gtk_widget_show (scwin);
}

void cpuratedisplay(GtkWidget *widget, gpointer data)            //display cpurate by progressbar
{GtkWidget *win,*tablet;
 GtkWidget *label1,*label2,*label3,*label4;
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win),"CPURATE DISPLAY");
gtk_widget_set_usize(win,340,240);
gtk_container_border_width(GTK_CONTAINER(win),1);
gtk_widget_show(win); 
userbar=gtk_progress_bar_new(); 
gtk_progress_bar_set_orientation(userbar,GTK_PROGRESS_BOTTOM_TO_TOP); 
systembar=gtk_progress_bar_new(); 
gtk_progress_bar_set_orientation(systembar,GTK_PROGRESS_BOTTOM_TO_TOP); 
nicebar=gtk_progress_bar_new(); 
gtk_progress_bar_set_orientation(nicebar,GTK_PROGRESS_BOTTOM_TO_TOP); 
idlebar=gtk_progress_bar_new(); 
gtk_progress_bar_set_orientation(idlebar,GTK_PROGRESS_BOTTOM_TO_TOP); 
gtk_signal_connect(GTK_OBJECT(win),"delete_event",GTK_SIGNAL_FUNC (close_win),NULL); 
tablet=gtk_table_new(24,24,TRUE);
gtk_container_add(GTK_CONTAINER(win),tablet);
gtk_widget_show(tablet);   
label1=gtk_label_new("user");
label2=gtk_label_new("system");
label3=gtk_label_new("nice");
label4=gtk_label_new("idle");
gtk_widget_show(label1);   
gtk_widget_show(label2);   
gtk_widget_show(label3);   
gtk_widget_show(label4);   
gtk_timeout_add(500,GTK_SIGNAL_FUNC(timeout_callback4),NULL);
gtk_table_attach_defaults(tablet,userbar,4,6,2,19);
gtk_table_attach_defaults(tablet,systembar,8,10,2,19);
gtk_table_attach_defaults(tablet,nicebar,12,14,2,19);
gtk_table_attach_defaults(tablet,idlebar,16,18,2,19);
gtk_table_attach_defaults(tablet,label1,4,6,22,24);
gtk_table_attach_defaults(tablet,label2,8,11,22,24);
gtk_table_attach_defaults(tablet,label3,12,14,22,24);
gtk_table_attach_defaults(tablet,label4,16,18,22,24);
gtk_widget_show(userbar);                                                   
gtk_widget_show(systembar);   
gtk_widget_show(nicebar);   
gtk_widget_show(idlebar);   

}

void realimp(GtkWidget *widget, gpointer *data){ 
                     //implement a process
char *lpath;
char *path;
GtkWidget * etable;


GtkWidget *win1,*label1,*button;
int fd;
win1=gtk_window_new(GTK_WINDOW_TOPLEVEL);


etable=gtk_table_new(50,50,TRUE);
gtk_container_add(GTK_CONTAINER(win1),etable);


entrytext1=gtk_entry_get_text(gtkentry1);


if((fd=open(entrytext1,O_RDONLY,0))==-1)
{
gtk_window_set_title(GTK_WINDOW(win1),"path wrong!");
label1=gtk_label_new("this path does not exist!");
gtk_table_attach_defaults(etable,label1,10,35,15,30);
}
else
{ if (fork()==0){ sync();
             system(entrytext1);}
  else return;
}

gtk_widget_set_usize(win1,300,200);
gtk_container_border_width(GTK_CONTAINER(win1),1);
gtk_container_add(GTK_CONTAINER(win1),label1);
gtk_widget_show(label1);
gtk_widget_show(win1);
gtk_widget_show(etable);
}




void implementprocess(GtkWidget *widget, gpointer *data){                       //implement interface
GtkWidget * ilabel;

GtkWidget * itable;
GtkWidget * iwin;

gtkentry1=gtk_entry_new();
gtk_signal_connect(GTK_OBJECT (gtkentry1),"activate",GTK_SIGNAL_FUNC (realimp), NULL);     


ilabel=gtk_label_new("please input the path of the process:");
iwin=gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(iwin),"implement interface");
gtk_widget_set_usize(iwin,400,200);
gtk_container_border_width(GTK_CONTAINER(iwin),1);           


itable=gtk_table_new(20,30,TRUE);
gtk_container_add(GTK_CONTAINER(iwin),itable);


gtk_table_attach_defaults(itable,ilabel,4,26,5,8);
gtk_table_attach_defaults(itable,gtkentry1,8,25,10,13);
gtk_widget_show(ilabel);  
gtk_widget_show(gtkentry1); 
gtk_widget_show(itable);    
gtk_widget_show(iwin);   


}


void kill(GtkWidget *widget, gpointer data){                    //real kill process
sync();
char* buff[30];
sprintf(buff,"kill 9 ");
strcat(buff,entrytext);
system(buff);

}



void killprocess(GtkWidget *widget, gpointer data){                  //ask kill process

GtkWidget *win1,*label1,*table1,*button_y,*button_n;
win1=gtk_window_new(GTK_WINDOW_TOPLEVEL);
label1=gtk_label_new("Are you sure to kill the process?");
gtk_window_set_title(GTK_WINDOW(win1),"KILL PROCESS");
gtk_widget_set_usize(win1,240,180);
gtk_container_border_width(GTK_CONTAINER(win1),1);
gtk_widget_show(win1);

table1=gtk_table_new(20,24,TRUE);
gtk_container_add(GTK_CONTAINER(win1),table1);
gtk_widget_show(table1);   

gtk_table_attach_defaults(table1,label1,4,22,7,11);
gtk_widget_show(label1);

button_y=gtk_button_new_with_label ("Yes");
gtk_table_attach_defaults(table1,button_y,3,9,14,17);
gtk_widget_show(button_y);
gtk_signal_connect(GTK_OBJECT(button_y),"clicked",GTK_SIGNAL_FUNC(kill), NULL);  

button_n=gtk_button_new_with_label ("No");
gtk_table_attach_defaults(table1,button_n,15,21,14,17);
gtk_widget_show(button_n);
gtk_signal_connect(GTK_OBJECT(button_n),"clicked",GTK_SIGNAL_FUNC (close_win), win1); 

}




void entryenter(GtkWidget *widget, gpointer data){			//to surf the process by the input process pid

char *lpath;
char *path;
GtkWidget * etable;
char ebuffer[512];
char pbuffer[32];
GtkWidget *win1,*label1,*button;
int fd;
win1=gtk_window_new(GTK_WINDOW_TOPLEVEL);


etable=gtk_table_new(50,50,TRUE);
gtk_container_add(GTK_CONTAINER(win1),etable);

sprintf(pbuffer,"");
entrytext=gtk_entry_get_text(gtkentry);
sprintf(pbuffer,"/proc/");
strcat(pbuffer,entrytext);
path=strcat(pbuffer,"/status");


if((fd=open(path,O_RDONLY,0))==-1)
{
gtk_window_set_title(GTK_WINDOW(win1),"process pid wrong!");
label1=gtk_label_new("this process does not exist!");