20155339 《信息安全系统设计》第十周课下作业-IPC

20155339 《信息安全系统设计》第十周课下作业-IPC

共享内存

共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，由IPC为进程创建的一个特殊地址范围，它将出现在该进程的地址空间中。

使用共享内存，不同进程可以对同一块内存进行读写。

优点：由于所有进程对共享内存的访问就和访问自己的内存空间一样，而不需要进行额外系统调用或内核操作，同时还避免了多余的内存拷贝，所以，这种方式是效率最高、速度最快的进程间通信方式。

缺点：内核并不提供任何对共享内存访问的同步机制，即引发读写问题。

Linux下一般一个page大小是4k。

创建共享内存空间后，内核将不同进程虚拟地址的映射到同一个页面：所以在不同进程中，对共享内存所在的内存地址的访问最终都被映射到同一页面。

共享内存的使用过程可分为 创建->连接->使用->分离->销毁 这几步。

下图展示了共享内存的工作机制：



使用帮助文档，查看共享内存的创建函数，如下：



由上图可知：分配共享内存使用shmget函数:



使用方法如下：

int shmget(key_t key, size_t size, int shmflg)

由于帮助文档不怎么看得懂，又找到了下图进行学习：



创建后，为了使共享内存可以被当前进程使用，必须紧接着进行连接操作。使用函数shmat（SHared Memory ATtach），参数传入通过shmget返回的共享内存id。

shamt函数：连接共享内存标识符为shmid的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。函数原型：

void *shmat(int shmid, const void *shmaddr, int shmflg)

。返回附加好的共享内存地址。

shmat函数：断开共享内存连接。

shmctl函数：共享内存管理。

代码练习（读写数据）：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
typedef struct{
char name[8];
int age;
} people;
int main(int argc, char** argv)
{
int shm_id,i;
key_t key;
char temp[8];
people *p_map;
char pathname[30] ;

strcpy(pathname,"/tmp") ;
key = ftok(pathname,0x03);
if(key==-1)
{
perror("ftok error");
return -1;
}
printf("key=%d\n",key) ;
shm_id=shmget(key,4096,IPC_CREAT|IPC_EXCL|0600);
if(shm_id==-1)
{
perror("shmget error");
return -1;
}
printf("shm_id=%d\n", shm_id) ;
p_map=(people*)shmat(shm_id,NULL,0);
memset(temp, 0x00, sizeof(temp)) ;
strcpy(temp,"test") ;
temp[4]='0';
for(i = 0;i<3;i++)
{
temp[4]+=1;
strncpy((p_map+i)->name,temp,5);
(p_map+i)->age=0+i;
}
shmdt(p_map) ;
return 0 ;
}

#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
typedef struct{
char name[8];
int age;
} people;
int main(int argc, char** argv)
{
int shm_id,i;
key_t key;
people *p_map;
char pathname[30] ;

strcpy(pathname,"/tmp") ;
key = ftok(pathname,0x03);
if(key == -1)
{
perror("ftok error");
return -1;
}
printf("key=%d\n", key) ;
shm_id = shmget(key,0, 0);
if(shm_id == -1)
{
perror("shmget error");
return -1;
}
printf("shm_id=%d\n", shm_id) ;
p_map = (people*)shmat(shm_id,NULL,0);
for(i = 0;i<3;i++)
{
printf( "name:%s\n",(*(p_map+i)).name );
printf( "age %d\n",(*(p_map+i)).age );
}
if(shmdt(p_map) == -1)
{

perror("detach error");
return -1;
}
return 0 ;
}

运行结果



可看出读和写两段代码都是在同一段地址上进行的。

管道

管道实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端将其读取出来。

管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。

只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。比如fork或exec创建的新进程，在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。

数据由缓冲区的尾部写入，头部读出。先进先出原则。

PIPE函数：



代码练习

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<wait.h>
#include<sys/types.h>
int main(int argc ,char *argv[])
{
int pipefd[2],result;
char buf[1024];
int flag=0;
pid_t pid;
result= pipe(pipefd);//创建一个管道
if(result==-1){
perror("pipe error:");
exit(EXIT_FAILURE);
}
pid=fork();//创建一个子进程
if(pid==-1)
{
perror("fork  error:");
exit(EXIT_FAILURE);
}
else if(pid==0){
if((close(pipefd[1]))==-1)//close write only read
{
perror("close write  error:");
exit(EXIT_FAILURE);
}
while(1){ //循环读取数据
read(pipefd[0],buf,1024);//最多读取1024个字节
printf("read from pipe :  %s\n",buf);
if(strcmp(buf,"quit")==0){// if 读取到的字符串是exit 这是
//父进程会接受到一个终止进程的信号，父进程会回收子进程的资                   // 源等
exit(EXIT_SUCCESS);
}
}
}else{
//close read only write
if((close(pipefd[0]))==-1){
perror("close read error:");
exit(EXIT_FAILURE);
}
while(1)//循环写入内容
{
waitpid(pid,NULL,WNOHANG);//等待子进程退出
if(flag==1)
exit(0);
scanf("%s",buf);
write(pipefd[1],buf,strlen(buf)+1);//具体写多少个字节
if(strcmp(buf,"quit")==0){
flag=1;
sleep(1);//让子进程完全退出。
}
}
}
return 1;
}

FIFO（命名管道）

我觉得是管道的升级版，因为命名管道是一种特殊类型的文件，它在系统中以文件形式存在。这样克服了管道的弊端，他可以允许没有亲缘关系的进程间通信。

操作方法只要创建了一个命名管道然后就可以使用open、read、write等系统调用来操作。

代码练习：

#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int data_fd = -1;
int res = 0;
const int open_mode = O_WRONLY;
int bytes_sent = 0;
char buffer[PIPE_BUF + 1];

if(access(fifo_name, F_OK) == -1)
{
//管道文件不存在
//创建命名管道
res = mkfifo(fifo_name, 0777);
if(res != 0)
{
fprintf(stderr, "Could not create fifo %s\n", fifo_name);
exit(EXIT_FAILURE);
}
}

printf("Process %d opening FIFO O_WRONLY\n", getpid());
//以只写阻塞方式打开FIFO文件，以只读方式打开数据文件
pipe_fd = open(fifo_name, open_mode);
data_fd = open("Data.txt", O_RDONLY);
printf("Process %d result %d\n", getpid(), pipe_fd);

if(pipe_fd != -1)
{
int bytes_read = 0;
//向数据文件读取数据
bytes_read = read(data_fd, buffer, PIPE_BUF);
buffer[bytes_read] = '\0';
while(bytes_read > 0)
{
//向FIFO文件写数据
res = write(pipe_fd, buffer, bytes_read);
if(res == -1)
{
fprintf(stderr, "Write error on pipe\n");
exit(EXIT_FAILURE);
}
//累加写的字节数，并继续读取数据
bytes_sent += res;
bytes_read = read(data_fd, buffer, PIPE_BUF);
buffer[bytes_read] = '\0';
}
close(pipe_fd);
close(data_fd);
}
else
exit(EXIT_FAILURE);

printf("Process %d finished\n", getpid());
exit(EXIT_SUCCESS);
}

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <string.h>

int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int data_fd = -1;
int res = 0;
int open_mode = O_RDONLY;
char buffer[PIPE_BUF + 1];
int bytes_read = 0;
int bytes_write = 0;
//清空缓冲数组
memset(buffer, '\0', sizeof(buffer));

printf("Process %d opening FIFO O_RDONLY\n", getpid());
//以只读阻塞方式打开管道文件，注意与fifowrite.c文件中的FIFO同名
pipe_fd = open(fifo_name, open_mode);
//以只写方式创建保存数据的文件
data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);
printf("Process %d result %d\n",getpid(), pipe_fd);

if(pipe_fd != -1)
{
do
{
//读取FIFO中的数据，并把它保存在文件DataFormFIFO.txt文件中
res = read(pipe_fd, buffer, PIPE_BUF);
bytes_write = write(data_fd, buffer, res);
bytes_read += res;
}while(res > 0);
close(pipe_fd);
close(data_fd);
}
else
exit(EXIT_FAILURE);

printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);
exit(EXIT_SUCCESS);
}

运行结果：



管道和命名管道有什么区别

1.在命名管道中，管道可以是事先已经创建好的，而在管道中，管道已经在主进程里创建好了，然后在fork时直接复制相关数据或者是用exec创建的新进程时把管道的文件描述符当参数传递进去。

2.一般来说FIFO和PIPE一样总是处于阻塞状态。如果不希望命名管道操作的时候发生阻塞，可以在open的时候使用O_NONBLOCK标志，以关闭默认的阻塞操作。

信号

一个信号的生命周期中有两个阶段：生成和传送。

内核为进程生产信号，来响应不同的事件，这些事件就是信号源。主要的信号源如下：

1.异常：进程运行过程中出现异常；

2.其它进程：一个进程可以向另一个或一组进程发送信号；

3.终端中断：Ctrl-C，Ctrl-/等；

4.作业控制：前台、后台进程的管理；

5.分配额：CPU超时或文件大小突破限制；

6.通知：通知进程某事件发生，如I/O就绪等；

7.报警：计时器到期。

代码练习：

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <signal.h>

int main()
{
char buffer[100];

struct sigaction act;

if(sigaction(SIGINT,&act, NULL) == -1)
{
printf("sigaction error exit now\n");
exit(0);
}

while(1)
{
fgets(buffer,sizeof(buffer),stdin);
printf("%s\n",buffer);
}

return 0;
}

消息队列

消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用IPC标识符唯一地进行识别。

内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。

每个消息队列中的消息，又构成一个独立的链表。

Linux的消息队列(queue)实质上是一个链表，它有消息队列标识符(queue ID)。

msgget创建一个新队列或打开一个存在的队列；

msgsnd向队列末端添加一条新消息；

msgrcv从队列中取消息，取消息是不一定遵循先进先出的， 也可以按消息的类型字段取消息。

代码练习：

#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<string.h>
#include<unistd.h>
#define MAX_TEXT 1024
#define MSG_SIZE 512
struct msg_st{
long int msg_type; //消息类型
char text[MAX_TEXT];//消息内容
};
int main()
{
struct msg_st data;
char buf[MSG_SIZE];
int msgid=msgget((key_t)2456,0666|IPC_CREAT);
if(msgid==-1){
perror("msgget");
exit(1);
}
while(1){
printf("接收:");
if(msgrcv(msgid,(void*)&data,MAX_TEXT,1,0)==-1){
perror("msgrcv");
exit(2);
}
printf("%s\n",data.text);
}
return 0;
}

#include<stdio.h>
#include<sys/ipc.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/msg.h>
#include<unistd.h>
#include<string.h>
#define MAX_TEXT 512
#define MSG_SIZE 512
struct msg_st
{
long int msg_type;  //消息类型
char text[MAX_TEXT];//消息内容
};
int main()
{
struct msg_st data;
char buf[MSG_SIZE];
//创建消息队列
int msgid=msgget((key_t)2456,0666|IPC_CREAT);
if(msgid==-1)
{
perror("msgget");
exit(1);
}
printf("消息队列创建成功\n");
//发送消息
while(1)
{
//从键盘输入发送的消息
printf("发送：");
fgets(buf,MSG_SIZE,stdin);
data.msg_type=1;
strcpy(data.text,buf);
//将消息发送到消息队列
if(msgsnd(msgid,(void*)&data,MAX_TEXT,0)==-1){
perror("msgsnd");
exit(1);
}
}
return 0;
}

运行截图

参考链接

Linux IPC之共享内存

linux编程之pipe()函数

进程间通信(IPC):FIFO

【IPC】管道和FIFO

linux c语言学习笔记之IPC-信号

IPC之消息队列详解与使用