嵌入式学习——虚拟机通信

目次

虚拟机talk通信
自主编程实现通信（1）
自主编程实现通信（2）

---

虚拟机talk通信

如果我们想在虚拟机上与其他同学或朋侪取得接洽，我们可以使用talk程序举行交流。首先我们要打开虚拟机，执行以下下令，安装talk程序；
   sudo apt update
  sudo apt installbsd-talk
  

然后使用下令启动程序；
   sudo systemctl start talk
  sudo ufw allow talk
  接着我们就可以使用下令举行通信；
   talk fangjq
  （这里talk 后面接上你想要通信的用户）
  

这里要注意输入内容以及一些快捷键，否则会出现一些问题；例如^Z是使用了CTRL快捷键，回复的Hello后面的问号是输入问题。
自主编程实现通信（1）

在同一终端下，子进程与父进程的通信；
首先创建一个目次：chat_program用来存放我们的相关文件
   mkdir chat_program //创建目次
  cd chat_program //进入目次
  nano chat.c //创建文件
  然后粘贴以下的代码，

1. #include <stdio.h>
3. #include <stdlib.h>
5. #include <string.h>
7. #include <unistd.h>
9. #include <sys/select.h>
11. #define BUFFER_SIZE 1024
13. #define EXIT_CMD "exit"
15. int main() {
17.     int pipefd[2]; // 父进程到子进程的管道
19.     int pipefd2[2]; // 子进程到父进程的管道
21.     pid_t pid;
23.     // 创建两个管道
25.     if (pipe(pipefd) == -1 || pipe(pipefd2) == -1) {
27.         perror("pipe");
29.         exit(EXIT_FAILURE);
31.     }
33.     // 创建子进程
35.     pid = fork();
37.     if (pid == -1) {
39.         perror("fork");
41.         exit(EXIT_FAILURE);
43.     }
45.     if (pid == 0) {
47.         // 子进程：从父进程接收消息并通过另一个管道发送消息
49.         close(pipefd[1]); // 关闭写端
51.         close(pipefd2[0]); // 关闭读端
53.         char buffer[BUFFER_SIZE];
55.         fd_set readfds;
57.         int max_fd = (pipefd[0] > pipefd2[1]) ? pipefd[0] : pipefd2[1];
59.         while (1) {
61.             FD_ZERO(&readfds);
63.             FD_SET(STDIN_FILENO, &readfds);
65.             FD_SET(pipefd[0], &readfds);
67.             if (select(max_fd + 1, &readfds, NULL, NULL, NULL) == -1) {
69.                 perror("select");
71.                 exit(EXIT_FAILURE);
73.             }
75.             if (FD_ISSET(STDIN_FILENO, &readfds)) {
77.                 // 从标准输入读取消息并发送给父进程
79.                 ssize_t bytes_read = read(STDIN_FILENO, buffer, BUFFER_SIZE);
81.                 if (bytes_read <= 0) {
83.                     break;
85.                 }
87.                 buffer[bytes_read - 1] = '\0'; // 去掉换行符
89.                 if (strcmp(buffer, EXIT_CMD) == 0) {
91.                     write(pipefd2[1], buffer, strlen(buffer) + 1);
93.                     break;
95.                 }
97.                 write(pipefd2[1], buffer, strlen(buffer) + 1);
99.             }
101.             if (FD_ISSET(pipefd[0], &readfds)) {
103.                 // 从父进程接收消息并输出
105.                 ssize_t bytes_read = read(pipefd[0], buffer, BUFFER_SIZE);
107.                 if (bytes_read <= 0) {
109.                     break;
111.                 }
113.                 buffer[bytes_read] = '\0';
115.                 printf("Parent: %s\n", buffer);
117.                 if (strcmp(buffer, EXIT_CMD) == 0) {
119.                     break;
121.                 }
123.             }
125.         }
127.         close(pipefd[0]);
129.         close(pipefd2[1]);
131.         exit(EXIT_SUCCESS);
133.     } else {
135.         // 父进程：从子进程接收消息并通过另一个管道发送消息
137.         close(pipefd[0]); // 关闭读端
139.         close(pipefd2[1]); // 关闭写端
141.         char buffer[BUFFER_SIZE];
143.         fd_set readfds;
145.         int max_fd = (pipefd2[0] > pipefd[1]) ? pipefd2[0] : pipefd[1];
147.         while (1) {
149.             FD_ZERO(&readfds);
151.             FD_SET(STDIN_FILENO, &readfds);
153.             FD_SET(pipefd2[0], &readfds);
155.             if (select(max_fd + 1, &readfds, NULL, NULL, NULL) == -1) {
157.                 perror("select");
159.                 exit(EXIT_FAILURE);
161.             }
163.             if (FD_ISSET(STDIN_FILENO, &readfds)) {
165.                 // 从标准输入读取消息并发送给子进程
167.                 ssize_t bytes_read = read(STDIN_FILENO, buffer, BUFFER_SIZE);
169.                 if (bytes_read <= 0) {
171.                     break;
173.                 }
175.                 buffer[bytes_read - 1] = '\0'; // 去掉换行符
177.                 if (strcmp(buffer, EXIT_CMD) == 0) {
179.                     write(pipefd[1], buffer, strlen(buffer) + 1);
181.                     break;
183.                 }
185.                 write(pipefd[1], buffer, strlen(buffer) + 1);
187.             }
189.             if (FD_ISSET(pipefd2[0], &readfds)) {
191.                 // 从子进程接收消息并输出
193.                 ssize_t bytes_read = read(pipefd2[0], buffer, BUFFER_SIZE);
195.                 if (bytes_read <= 0) {
197.                     break;
199.                 }
201.                 buffer[bytes_read] = '\0';
203.                 printf("Child: %s\n", buffer);
205.                 if (strcmp(buffer, EXIT_CMD) == 0) {
207.                     break;
209.                 }
211.             }
213.         }
215.         close(pipefd[1]);
217.         close(pipefd2[0]);
219.         wait(NULL); // 等待子进程结束
221.     }
223.     return 0;
225. }

复制代码

随后通过gcc编译器编译一遍，接着运行，尝试通信；
   gcc chat.c -o chat
  ./chat
  

完成过后可以通过CTRL+C退出程序。在这段程序中，使用两个进程相互通信，首先根据用户输入的内容，子进程接收过后输出，发出第一段对话，然后用户再输入，接着父进程接收并输出，完成对子进程的回应，这段代码是子进程与父进程轮流对话，机动性较低，不能多段输出，只能轮回。
除了这种，还有两个终端的对话。

自主编程实现通信（2）

在同一个账号两个终端之间通信；
这里建议先使用IPC或消息管道、消息槽等模式，然后举行实践。
使用以下下令创建管道文件，
   mkfifo mypipe
  在虚拟机中，管道文件（通常指命名管道或 FIFO 文件）是一种进程间通信（IPC）机制，用于在虚拟机内部或虚拟机与主机之间传递数据。通过创建命名管道文件（如 mkfifo 下令），虚拟机内部的进程可以实现通信。
首先创建两个文件，sender.c和receiver.c，然后输入以下代码；
   nano sender.c
  nano receive.c
  sender.c：

1. #include <stdio.h>
3. #include <fcntl.h>
5. #include <unistd.h>
7.  
9. int main() {
11.     int fd = open("mypipe", O_WRONLY);
13.     if (fd == -1) {
15.         perror("open");
17.         return 1;
19.     }
21.  
23.     char buffer[100];
25.     printf("Enter message: ");
27.     fgets(buffer, sizeof(buffer), stdin);
29.     write(fd, buffer, strlen(buffer)+1);
31.     close(fd);
33.     return 0;
35. }

复制代码

receiver.c：

1. #include <stdio.h>
3. #include <fcntl.h>
5. #include <unistd.h>
7.  
9. int main() {
11.     int fd = open("mypipe", O_RDONLY);
13.     if (fd == -1) {
15.         perror("open");
17.         return 1;
19.     }
21.  
23.     char buffer[100];
25.     read(fd, buffer, sizeof(buffer));
27.     printf("Received message: %s", buffer);
29.     close(fd);
31.     return 0;
33. }

复制代码

同样的操作举行编译，编译过后终端一运行sender.c，终端二运行receive.c，测试运行结果。

可以看到，发送hello，也能接收到hello，这个程序的问题在于只能一条一条发送，而且单项发送。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。