mm_main_bk.c

linux下的人机对话编程

#include<gnome.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include<sys/stat.h>
#include<sys/time.h>//setpriority
#include<sys/resource.h>//setpriority
#include<signal.h>
#include <stdio.h>
#include <unistd.h>
#include<stdlib.h>
#include<fcntl.h>
#include<errno.h>
#include<time.h>
#include"socket.h"
#include"socket_a.h"
#include"socket_b.h"
#include"M_check_Mstate_bk.h"
#include"M_check_Astate_bk.h"
#include"M_check_Bstate_bk.h"
#include"sys_check_gtk.h"
#include"Mserver_B_getdata.h"
#include"Mserver_B_getdata_bk.h"
#include"Mserver_A_getdata.h"
#include"Mserver_A_getdata_bk.h"
/*include windows*/
#include"M_window.h"
#include"popmenu.h"
#include"bg.h"
#include"SySInfo.h"
#include"toggle.h"
#include"sg.h"
#include"switch.h"
#include"field.h"
#include"line.h"
#include"text.h"
#include"sig.h"
#include"frame.h"
#define OBFILE "/proc/stat"
#define LEN 16348
#define NUM 6 
#define FALSE_sg 0
#define TRUE_sg 1
int Okay;
void sig_child()
 {
   signal(SIGCHLD, sig_child);
   Okay = FALSE_sg;
 }
gint main(gint argc,gchar *argv[])
{
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
   /* union semun is defined by including <sys/sem.h> */
#else
   /* otherwise, according to X/OPEN we have to define it ourselves */
   union semun
   {
      int val;                    /* value for SETVAL */
      struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */
      unsigned short int *array;  /* array for GETALL, SETALL */
      struct seminfo *__buf;      /* buffer for IPC_INFO */
   };
#endif 
   union semun un;
   int flag = (IPC_CREAT | IPC_EXCL | 0660);
   int size = sizeof(struct area);
   key_t skey = 0x00123001; /* sample keys */
   key_t mkey = 0x00123422;
//   int semid; /* semaphore id */
//   int shmid; /* shared memory id */
   int pid_Sys_check;  /* Sys_check_state process child task pid */
   int pid_server_cmd;  /*Mserver_cmd process  child task pid */
	int pids[NUM];
	int i;
	int pid;
   char inbuf[80];
   /* get a shared memory area */
   shmid=shmget(mkey, size, flag);
   /* attach the shared memory area */
   ap=(struct area *)shmat(shmid, 0, 0);
   /* initialize account info in shared memory */
   	ap->Mstate_gl=1;
	ap->Astate_gl=1;
	ap->Bstate_gl=1;
        ap->Sys_main_cpu_gl=1;
	ap->Sys_main_hub_gl=1;
        ap->Mhost_name_gl="192.168.1.1";
        ap->Ahost_name_gl="192.168.1.3";
        ap->Bhost_name_gl="192.168.1.5";
	ap->flag_sys_check=1;
   /* get and initialize a semaphore */
   semid=semget(skey, 1, flag);
   /* set semaphore available */
   un.val=1;
   semctl(semid, 0, SETVAL, un);
   /* first and only semaphore */
   buf_sem.sem_num=0;
   /* wait if set */
   buf_sem.sem_flg=0;


/*init the window share memory A */
   union semun un_win;
   int flag_win = (IPC_CREAT | IPC_EXCL | 0660);
   int size_win = sizeof(struct area_window);
   key_t skey_win = 0x00123020; /* sample keys */
   key_t mkey_win = 0x01034532;
   /* get a shared memory area */
   shmid_win=shmget(mkey_win, size_win, flag_win);
   /* attach the shared memory area */
   aw=(struct area_window *)shmat(shmid_win, 0, 0);
   /* initialize account info in shared memory */
	aw->flag_sg=0;
	 int j;
	for(i=0;i<30;i++)
		{
		for(j=2;j<6;j++)
		aw->SgNode_DynTab[i][j]=0x55;
		}
	for(i=0;i<30;i++)
		{
		j=0x8000;
		aw->SgNode_DynTab[i][0]=j++;
		}
	aw->SgNode_DynTab[0][1]=0x01;
	aw->SgNode_DynTab[1][1]=0x01;
	aw->SgNode_DynTab[2][1]=0x01;
	aw->SgNode_DynTab[3][1]=0x01;
	aw->SgNode_DynTab[4][1]=0x01;
	aw->SgNode_DynTab[5][1]=0x01;
	aw->SgNode_DynTab[6][1]=0x01;
	aw->SgNode_DynTab[7][1]=0x01;
	aw->SgNode_DynTab[8][1]=0x01;
	aw->SgNode_DynTab[9][1]=0x01;
	aw->SgNode_DynTab[10][1]=0x67;
	aw->SgNode_DynTab[11][1]=0x0B;
	aw->SgNode_DynTab[12][1]=0x0d;
	aw->SgNode_DynTab[13][1]=0x0d;
	aw->SgNode_DynTab[14][1]=0x15;
	aw->SgNode_DynTab[15][1]=0x15;
	aw->SgNode_DynTab[16][1]=0x01;
	aw->SgNode_DynTab[17][1]=0x01;
	aw->SgNode_DynTab[18][1]=0x01;
	aw->SgNode_DynTab[19][1]=0x01;
	aw->SgNode_DynTab[20][1]=0x0b;
	aw->SgNode_DynTab[21][1]=0x05;
	aw->SgNode_DynTab[22][1]=0x01;
	aw->SgNode_DynTab[23][1]=0x01;
	aw->SgNode_DynTab[24][1]=0x01;
	aw->SgNode_DynTab[25][1]=0x00;
	aw->SgNode_DynTab[26][1]=0x00;
	aw->SgNode_DynTab[27][1]=0x00;
	aw->SgNode_DynTab[28][1]=0x00;
	aw->SgNode_DynTab[29][1]=0x00;
	
	aw->flag_sw=0;
        for(i=0;i<17;i++)
                {
                j=0x4000;
                aw->SwNode_DynTab[i][0]=j++;
		aw->SwNode_DynTab[i][2]=0xaa;
		aw->SwNode_DynTab[i][3]=0x55;
		aw->SwNode_DynTab[i][4]=0xaa;
		}
	aw->SwNode_DynTab[0][1]=0xaa;
	aw->SwNode_DynTab[1][1]=0xaa;
	aw->SwNode_DynTab[2][1]=0x55;
	aw->SwNode_DynTab[3][1]=0xaa;
	aw->SwNode_DynTab[4][1]=0xaa;
	aw->SwNode_DynTab[5][1]=0x55;
	aw->SwNode_DynTab[6][1]=0x55;
	aw->SwNode_DynTab[7][1]=0x55;
	aw->SwNode_DynTab[8][1]=0xaa;
	aw->SwNode_DynTab[9][1]=0xaa;
	aw->SwNode_DynTab[10][1]=0xaa;
	aw->SwNode_DynTab[11][1]=0x55;
	aw->SwNode_DynTab[12][1]=0x55;
	aw->SwNode_DynTab[13][1]=0xaa;
	aw->SwNode_DynTab[14][1]=0x55;
	aw->SwNode_DynTab[15][1]=0x55;
	aw->SwNode_DynTab[16][1]=0x55;

	aw->flag_fd=0;
	for(i=0;i<24;i++)
                {
                j=0x2000;
                aw->FdNode_DynTab[i][0]=j++;
                aw->FdNode_DynTab[i][2]=0xaa;
                aw->FdNode_DynTab[i][3]=0xaa;
                }
	aw->FdNode_DynTab[0][1]=0xaa;
	aw->FdNode_DynTab[1][1]=0x55;
	aw->FdNode_DynTab[2][1]=0xaa;
	aw->FdNode_DynTab[3][1]=0xaa;
	aw->FdNode_DynTab[4][1]=0xaa;
	aw->FdNode_DynTab[5][1]=0x55;
	aw->FdNode_DynTab[6][1]=0x55;
	aw->FdNode_DynTab[7][1]=0xaa;
	aw->FdNode_DynTab[8][1]=0xaa;
	aw->FdNode_DynTab[9][1]=0x55;
	aw->FdNode_DynTab[10][1]=0xaa;
	aw->FdNode_DynTab[11][1]=0xaa;
	aw->FdNode_DynTab[12][1]=0xaa;
	aw->FdNode_DynTab[13][1]=0xaa;
	aw->FdNode_DynTab[14][1]=0xaa;
	aw->FdNode_DynTab[15][1]=0xaa;
	aw->FdNode_DynTab[16][1]=0xaa;
	aw->FdNode_DynTab[17][1]=0xaa;
	aw->FdNode_DynTab[18][1]=0xaa;
	aw->FdNode_DynTab[19][1]=0xaa;
	aw->FdNode_DynTab[20][1]=0xaa;
	aw->FdNode_DynTab[21][1]=0xaa;
	aw->FdNode_DynTab[22][1]=0x55;
	aw->FdNode_DynTab[23][1]=0x55;

   /* get and initialize a semaphore */
   semid_win=semget(skey_win, 1, flag_win);
   /* set semaphore available */
   un_win.val=1;
   semctl(semid_win, 0, SETVAL, un_win);
   /* first and only semaphore */
   buf_win.sem_num=0;
   /* wait if set */
   buf_win.sem_flg=0;




/*init the window share memory B */
   union semun un_winb;
   int flag_winb = (IPC_CREAT | IPC_EXCL | 0660);
   int size_winb = sizeof(struct area_window);
   key_t skey_winb = 0x01123021; /* sample keys */
   key_t mkey_winb = 0x01134532;
   /* get a shared memory area */
   shmid_winb=shmget(mkey_winb, size_winb, flag_winb);
   /* attach the shared memory area */
   bw=(struct area_window *)shmat(shmid_winb, 0, 0);
   /* initialize account info in shared memory */
	bw->flag_sg=0;
	 for(i=0;i<30;i++)
		{
		for(j=2;j<6;j++)
		bw->SgNode_DynTab[i][j]=0x55;
		}
	for(i=0;i<30;i++)
		{
		j=0x8000;
		bw->SgNode_DynTab[i][0]=j++;
		}
	bw->SgNode_DynTab[0][1]=0x01;
	bw->SgNode_DynTab[1][1]=0x01;
	bw->SgNode_DynTab[2][1]=0x01;
	bw->SgNode_DynTab[3][1]=0x01;
	bw->SgNode_DynTab[4][1]=0x01;
	bw->SgNode_DynTab[5][1]=0x01;
	bw->SgNode_DynTab[6][1]=0x01;
	bw->SgNode_DynTab[7][1]=0x01;
	bw->SgNode_DynTab[8][1]=0x01;
	bw->SgNode_DynTab[9][1]=0x01;
	bw->SgNode_DynTab[10][1]=0x67;
	bw->SgNode_DynTab[11][1]=0x0B;
	bw->SgNode_DynTab[12][1]=0x0d;
	bw->SgNode_DynTab[13][1]=0x0d;
	bw->SgNode_DynTab[14][1]=0x15;
	bw->SgNode_DynTab[15][1]=0x15;
	bw->SgNode_DynTab[16][1]=0x01;
	bw->SgNode_DynTab[17][1]=0x01;
	bw->SgNode_DynTab[18][1]=0x01;
	bw->SgNode_DynTab[19][1]=0x01;
	bw->SgNode_DynTab[20][1]=0x0b;
	bw->SgNode_DynTab[21][1]=0x05;
	bw->SgNode_DynTab[22][1]=0x01;
	bw->SgNode_DynTab[23][1]=0x01;
	bw->SgNode_DynTab[24][1]=0x01;
	bw->SgNode_DynTab[25][1]=0x00;
	bw->SgNode_DynTab[26][1]=0x00;
	bw->SgNode_DynTab[27][1]=0x00;
	bw->SgNode_DynTab[28][1]=0x00;
	bw->SgNode_DynTab[29][1]=0x00;
	
	bw->flag_sw=0;
        for(i=0;i<17;i++)
                {
                j=0x4000;
                bw->SwNode_DynTab[i][0]=j++;
		bw->SwNode_DynTab[i][2]=0xaa;
		bw->SwNode_DynTab[i][3]=0x55;
		bw->SwNode_DynTab[i][4]=0xaa;
		}
	bw->SwNode_DynTab[0][1]=0xaa;
	bw->SwNode_DynTab[1][1]=0xaa;
	bw->SwNode_DynTab[2][1]=0x55;
	bw->SwNode_DynTab[3][1]=0xaa;
	bw->SwNode_DynTab[4][1]=0xaa;
	bw->SwNode_DynTab[5][1]=0x55;
	bw->SwNode_DynTab[6][1]=0x55;
	bw->SwNode_DynTab[7][1]=0x55;
	bw->SwNode_DynTab[8][1]=0xaa;
	bw->SwNode_DynTab[9][1]=0xaa;
	bw->SwNode_DynTab[10][1]=0xaa;
	bw->SwNode_DynTab[11][1]=0x55;
	bw->SwNode_DynTab[12][1]=0x55;
	bw->SwNode_DynTab[13][1]=0xaa;
	bw->SwNode_DynTab[14][1]=0x55;
	bw->SwNode_DynTab[15][1]=0x55;
	bw->SwNode_DynTab[16][1]=0x55;

	bw->flag_fd=0;
	for(i=0;i<24;i++)
                {
                j=0x2000;
                bw->FdNode_DynTab[i][0]=j++;
                bw->FdNode_DynTab[i][2]=0xaa;
                bw->FdNode_DynTab[i][3]=0xaa;
                }
	bw->FdNode_DynTab[0][1]=0xaa;
	bw->FdNode_DynTab[1][1]=0x55;
	bw->FdNode_DynTab[2][1]=0xaa;
	bw->FdNode_DynTab[3][1]=0xaa;
	bw->FdNode_DynTab[4][1]=0xaa;
	bw->FdNode_DynTab[5][1]=0x55;
	bw->FdNode_DynTab[6][1]=0x55;
	bw->FdNode_DynTab[7][1]=0xaa;
	bw->FdNode_DynTab[8][1]=0xaa;
	bw->FdNode_DynTab[9][1]=0x55;
	bw->FdNode_DynTab[10][1]=0xaa;
	bw->FdNode_DynTab[11][1]=0xaa;
	bw->FdNode_DynTab[12][1]=0xaa;
	bw->FdNode_DynTab[13][1]=0xaa;
	bw->FdNode_DynTab[14][1]=0xaa;
	bw->FdNode_DynTab[15][1]=0xaa;
	bw->FdNode_DynTab[16][1]=0xaa;
	bw->FdNode_DynTab[17][1]=0xaa;
	bw->FdNode_DynTab[18][1]=0xaa;
	bw->FdNode_DynTab[19][1]=0xaa;
	bw->FdNode_DynTab[20][1]=0xaa;
	bw->FdNode_DynTab[21][1]=0xaa;
	bw->FdNode_DynTab[22][1]=0x55;
	bw->FdNode_DynTab[23][1]=0x55;

   /* get and initialize a semaphore */
   semid_winb=semget(skey_winb, 1, flag_winb);
   /* set semaphore available */
   un_winb.val=1;
   semctl(semid_winb, 0, SETVAL, un_winb);
   /* first and only semaphore */
   buf_winb.sem_num=0;
   /* wait if set */
   buf_winb.sem_flg=0;

   /* setup SIGCHLD handler */
   signal(SIGCHLD, sig_child);
if((pids[0]=fork())==0)/*Mserver_A_getdata*/
	{
        printf("\tMserver_A_getdata is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[0],-5);
	Mserver_A_getdata();
	}
if((pids[1]=fork())==0)/*Mserver_A_getdata_bk*/
        {
        printf("\tMserver_A_getdata_bk is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[1],-5);
	Mserver_A_getdata_bk();
	}
if((pids[2]=fork())==0)/*Mserver_B_gtdata*/
        {
        printf("\tMserver_B_getdata is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[2],-5);
	Mserver_B_getdata();
 	}
if((pids[3]=fork())==0)/*Mserver_B_gtdata_bk*/
        {
        printf("\tMserver_B_getdata_bk is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[3],-5);
	Mserver_B_getdata_bk();
        }

if((pids[4]=fork())==0)   /* Sys_check_state */
   {
	printf("\tSys_check_state is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[4],-3);
	sys_check_gtk(argc,argv);
   }
if((pids[5]=fork())==0) /*Mserver_cmd*/
  {
	printf("\tMserver_cmd is started up pid= %d\n",getpid());
	setpriority(PRIO_PROCESS,pids[5],-1);
	M_window(argc,argv);
  }//if

while(1)
{
	Okay=TRUE_sg;
      while(Okay) /* pause */
         usleep(1);
      pid=wait(NULL); /* exiting pid */
      for(i=0;i<NUM;i++)
        {
	if(pid==pids[i])
        break;
	}
      printf("\tSubtask #%d ended, pid = %d\n", i, pids[i]);
	switch(i)
	{
		case 0:
			{
				if((pids[0]=fork())==0)/*Mserver_A_getdata*/
        			{
				printf("\tMserver_A_getdata is started up pid= %d\n",getpid());
			        setpriority(PRIO_PROCESS,pids[0],-5);
				Mserver_A_getdata();
        			}
			break;
			}
		 case 1:
                        {
				if((pids[1]=fork())==0)/*Mserver_A_getdata_bk*/
        			{
				 printf("\tMserver_A_getdata_bk is started up pid= %d\n",getpid());
				 setpriority(PRIO_PROCESS,pids[1],-5);
			         Mserver_A_getdata_bk();
			        }
			break;                                                                                             
                      }
		 case 2:
                        {
			        if((pids[2]=fork())==0)/*Mserver_B_gtdata*/
        			{
				printf("\tMserver_B_getdata is started up pid= %d\n",getpid());
			        setpriority(PRIO_PROCESS,pids[2],-5);
			        Mserver_B_getdata();
        			}
			break;                
                        }
		 case 3:
                        {
				if((pids[3]=fork())==0)/*Mserver_B_gtdata_bk*/
        			{
				 printf("\tMserver_B_getdata_bk is started up pid= %d\n",getpid());
			        setpriority(PRIO_PROCESS,pids[3],-5);
			        Mserver_B_getdata_bk();
			        }
                        break;                                                                            
                        }
		 case 4:
                        {
				if((pids[4]=fork())==0)   /* Sys_check_state */
   				{
				 printf("\tSys_check_state is started up pid= %d\n",getpid());
				setpriority(PRIO_PROCESS,pids[4],-3);
			        sys_check_gtk(argc,argv);
   				}
                        break;                                                                   
                        }
		case 5:
			{
				if((pids[5]=fork())==0) /*M_window*/
				{
				printf("\tMserver_cmd is started up pid= %d\n",getpid());
			        setpriority(PRIO_PROCESS,pids[5],-1);
			        M_window(argc,argv);
 				}
			break;
			}

	}//switch
}//while(1)
	//waitpid(pid_Sys_check);
    /* remove shared memory, semaphore, and exit */
   shmctl(shmid, IPC_RMID, (struct shmid_ds *) 0);
   semctl(semid, 0, IPC_RMID, un);
   return;
}//main