[源码]信号可靠信号不可靠信号相关

/* 
 * File:   main.c
 * Author: luv letter
 *
 * Created on 2017年3月14日, 下午4:33
 */


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>


/*
 3、信号可靠信号不可靠信号相关
编程程序，要去实现如下功能：
 父进程创建子进程1和子进程2、子进程1向子进程2发送可靠信号，并传送额外数据为子进程1的pid*2;
 子进程2接受可靠信号的值，并发送给父进程，父进程把接受的值进行打印。
 提示：用sigqueue和sigaction实现
 */
void My_Sigaction(int signum, siginfo_t *st, void *dat)
{
 int ret = 0;
 // 这个是父进程的接收数据信号
 if (SIGRTMIN+1 == signum)
 {
  printf("parent rev signal\n");
  printf("parent rev pid2 signal data = %d\n", st->si_value.sival_int);
 }
 else if (SIGRTMIN == signum) //并将数据发送给父进程
 {
  printf("child recv signal\n");
  union sigval value;
  printf("My_Sigaction : st->si_value.sival_int = %d\n", st->si_value.sival_int);
  value.sival_int = st->si_value.sival_int;
  ret = sigqueue(getppid(), SIGRTMIN+1, value);
  if (-1 == ret)
  {
   perror("pid2: SIGRTMIN func err sigqueue: ");
   return ;
  }
 }
}


int main(int argc, char** argv)
{
 int ret = 0;
 struct sigaction act;
 sigemptyset(&act.sa_mask);
 act.sa_sigaction = My_Sigaction;
 ret = sigaction(SIGRTMIN+1, &act, NULL);
 if (-1 == ret)
 {
  perror("func err sigaction: ");
  return -1;
 }


 pid_t pid1, pid2;


 ///
 //         pid1
 ///
 
 pid1 = fork();
 if (-1 == pid1)
 {
  perror("func err fork() pid 1: ");
  return -1;
 }
 else if (0 == pid1) // 子进程 1
 {
  // 1 子进程1向子进程2发送可靠信号，并传送额外数据为子进程1的pid*2;
  // SIGRTMIN+1
  // pid.txt
   // 读取 子进程2 的 pid
   // 用文件读取
  FILE *fp = NULL;
  while (1)
  {
   fp = fopen("pid.txt", "a+");
   if (NULL == fp)
   {
    continue;
   }
   else
   {
    break;
   }
  }
  printf("pid1: 打开文件成功\n");
  // 这里需要字符串转数字
  char revbuf[32] = {0};
  
  while (1)
  {
   char *tmp = fgets(revbuf, sizeof(revbuf), fp);
   if (NULL == tmp)
   {
    printf("pid1: 读取 pid2 中 ...\n");
    continue;
   }
   else 
   {
    printf("pid1: 读取 pid2 成功pid2 = %s\n", revbuf);
    break;
   }
  }
  if (NULL == fp)
  {
   fclose(fp);
   fp = NULL;
  }
  ret = system("rm -rf pid.txt");
  if (-1 == ret)
  {
   printf("pid1: func err system\n");
   return -1;
  }
  
  pid2 = atoi(revbuf);
  printf("pid1: 转化 pid2 为整数成功 = %d\n", (int )pid2 );
  union sigval value;
  value.sival_int = ((int)pid2) * 2;
  printf("pid1: value.sival_int  = %d\n", value.sival_int);
  ret = sigqueue((pid_t)pid2, SIGRTMIN, value);
  if (-1 == ret)
  {
   perror("pid1: func err sigqueue:");
   return -7;
  }
  printf("子进程退出...\n");
  exit(0);
 }
 ///
 //         pid2
 ///
 pid2 = fork();
 if (-1 == pid2)
 {
  perror("func err fork pid2:");
  return -2;
 }
 else if (0 == pid2) // 子进程 2 
 {
  // 3 接收子进程的信号, 并将数据发送给父进程
  struct sigaction act;
  ret = sigemptyset(&act.sa_mask);
  if (-1 == ret)
  {
   printf("pid2: func err sigemptyset\n");
   return -5;
  }
  act.sa_sigaction = My_Sigaction;
  ret = sigaction(SIGRTMIN, &act, NULL);
  if (-1 == ret)
  {
   perror("pid2: func err sigaction:");
   return -6;
  }
  
  // 1 保存自己的pid, 给子进程使用
  // 这个用文件保存
  FILE *fp = NULL;
  char pid_buf[18] = {0};
  
  fp = fopen("pid.txt", "w+");
  if (NULL == fp)
  {
   printf("pid2: open file failed\n");
   return -3;
  }
  printf("pid2: 打开文件成功...pid2 = %d\n", (int)getpid());
  int pid = (int )getpid();
  sprintf(pid_buf, "%d", pid);
  printf("pid2: pid2 = %s\n", pid_buf);
  ret = fputs(pid_buf, fp);
  if (EOF == ret)
  {
   printf("pid2: write error\n");
   return -4;
  }
  if (NULL != fp)
  {
   fclose(fp);
   fp = NULL;
  }
  printf("pid2: child 2 wait for 5 sec ...\n");
  int n = 5;
  while (n)
  {
   n = sleep(n);
   printf("pid2: child 2 wait end\n");
  }
  printf("pid2: 子进程 2 退出\n");
  exit(0);
 }
 printf("parent wait for 10 sec\n");
 int i = 10;
 while (i)
 {
  i = sleep(i);
  printf("parent wait for 10 sec end \n");
 }
 wait(pid1);
 wait(pid2);
 return (EXIT_SUCCESS);
}

另一套方法

/*
 pid_t pidArray[10];

 void My_Sigaction(int signum, siginfo_t *st, void *dat)
 {
  if (SIGRTMIN+1 == signum)
  {
   // 孩子1 收到了信号
   
   printf("孩子 1 收到信号, 他的值是 : %d\n", st->si_value.sival_int);
   pidArray[1] = st->si_value.sival_int;
  }
  else if (SIGRTMIN+2 == signum)
  {
   // 进程2 收到信号 
   
   printf("孩子 2 收到信号, 他的值是 : %d\n", st->si_value.sival_int);
   pidArray[3] = st->si_value.sival_int;
  }
  else if (SIGRTMIN+3 == signum)
  {
   // 父进程收到信号
   printf("父进程收到信号, 他的大儿子的pid = %d, 他的二儿子的pid = %d\n", pidArray[0], pidArray[1]);
   printf("二儿子发送的礼物是 = %d\n", st->si_value.sival_int);
  }
  else
  {
   printf("other signal recv\n");
  }
 }


int main(void)
{
 int ret = 0;
 
 // 信号发送区
 struct sigaction act;
 act.sa_flags = SA_SIGINFO;
 sigemptyset(&act.sa_mask);
 act.sa_sigaction = My_Sigaction;
 ret = sigaction(SIGRTMIN+1, &act, NULL);
 if (-1 == ret)
 {
  perror("func err sigaction: ");
  return -1;
 }
 
 ret = sigaction(SIGRTMIN+2, &act, NULL);
 if (-1 == ret)
 {
  perror("func err sigaction: ");
  return -2;
 }
 
 ret = sigaction(SIGRTMIN+3, &act, NULL);
 if (-1 == ret)
 {
  perror("func err sigaction: ");
  return -3;
 }
 
 int i = 0;
 pid_t pid = 0;
 for (i = 0; i < 2; i++)
 {
  pidArray[i] = pid = fork();
  if (-1 == pid)
  {
   perror("func err fork:");
   return -4;
  }
  else if (0 == pid)
  {
   break;
  }
 }
 
 // 父进程
 if (pid > 0)
 {
  printf("父进程启动\n");
  // 父进程向子进程 1 发送附加数据(子进程2 的 pid)
  union sigval value;
  value.sival_int = pidArray[1];
  ret = sigqueue(pidArray[0], SIGRTMIN+1, value);
 }
 // 子进程 1 
 if (0 == pid && 0 == i)
 {
  printf("子进程 1 启动\n");
  printf("子进程1 睡眠\n");
  sleep(5);
  printf("子进程1 睡眠醒来\n");
  union sigval value;
  pid_t pid;
  pid = getpid();
  value.sival_int = pid * 2;
  ret = sigqueue(pidArray[1], SIGRTMIN+2, value);
  exit(0);
 }
 // 子进程 2 
 if (0 == pid && 1 == i)
 {
  printf("子进程 2 启动\n");
  printf("子进程 2 睡眠\n");
  sleep(10);
  printf("子进程 2 睡眠醒来\n");
  // 子进程2 发送信号给父进程
  union sigval value;
  value.sival_int = pidArray[3];
  printf("子进程2 给父进程发送信号的数据 %d\n", pidArray[3]);
  ret = sigqueue(getppid(), SIGRTMIN+3, value);
  exit(0);
 }
 sleep(2);
 pid_t mypid = 0;
 while (1)
 {
  while ((mypid = waitpid(-1, NULL, WNOHANG)) > 0)
  {
   printf("pid = %d\n", mypid);
  }
 }
 
 return 0;
}
*/

[源码]信号可靠信号不可靠信号相关

浏览过的版块