进程AB通过命名管道通信

我在路易斯安那

已于 2024-08-11 12:51:48 修改

阅读量339

点赞数 4

文章标签： c语言 linux

于 2024-08-11 11:45:02 首次发布

本文链接：https://blog.youkuaiyun.com/qq_42477169/article/details/141103444

版权

要实现进程A和进程B之间的双向通信，并通过命名管道（FIFO）实现定时消息发送和CRC校验，可以使用以下步骤和代码示例。

进程A（发送消息并接收CRC校验结果）

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <time.h>

#define FIFO_PATH_A "/tmp/myfifoA"
#define FIFO_PATH_B "/tmp/myfifoB"

uint32_t crc32(const void *data, size_t length) {
    // CRC-32 implementation (simplified for demonstration)
    // You can use a more optimized version or library.
    static const uint32_t table[256] = { /* Precomputed CRC table */ };
    uint32_t crc = 0xFFFFFFFF;
    const uint8_t *byte = data;
    while (length--) {
        crc = table[(crc ^ *byte++) & 0xFF] ^ (crc >> 8);
    }
    return crc ^ 0xFFFFFFFF;
}

int main() {
    int fdA, fdB;
    const char *message = "Hello from Program A";
    char buffer[100];
    uint32_t crc;

    // Create FIFOs if they do not exist
    if (mkfifo(FIFO_PATH_A, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo A");
        exit(EXIT_FAILURE);
    }
    if (mkfifo(FIFO_PATH_B, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo B");
        exit(EXIT_FAILURE);
    }

    // Open FIFOs
    fdA = open(FIFO_PATH_A, O_WRONLY);
    if (fdA == -1) {
        perror("open A");
        exit(EXIT_FAILURE);
    }
    fdB = open(FIFO_PATH_B, O_RDONLY);
    if (fdB == -1) {
        perror("open B");
        exit(EXIT_FAILURE);
    }

    while (1) {
        // Send message
        write(fdA, message, strlen(message) + 1);
        
        // Compute CRC of the message
        crc = crc32(message, strlen(message));
        printf("Sent message: %s\n", message);

        // Wait for CRC check result
        read(fdB, buffer, sizeof(buffer));
        printf("Received CRC: %s\n", buffer);

        // Sleep for n seconds
        sleep(5); // Change 5 to the desired interval
    }

    // Clean up
    close(fdA);
    close(fdB);
    unlink(FIFO_PATH_A);
    unlink(FIFO_PATH_B);

    return 0;
}

进程B（接收消息并发送CRC校验结果）

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>

#define FIFO_PATH_A "/tmp/myfifoA"
#define FIFO_PATH_B "/tmp/myfifoB"

uint32_t crc32(const void *data, size_t length) {
    // CRC-32 implementation (simplified for demonstration)
    // You can use a more optimized version or library.
    static const uint32_t table[256] = { /* Precomputed CRC table */ };
    uint32_t crc = 0xFFFFFFFF;
    const uint8_t *byte = data;
    while (length--) {
        crc = table[(crc ^ *byte++) & 0xFF] ^ (crc >> 8);
    }
    return crc ^ 0xFFFFFFFF;
}

int main() {
    int fdA, fdB;
    char buffer[100];
    uint32_t crc;
    char crc_result[100];

    // Create FIFOs if they do not exist
    if (mkfifo(FIFO_PATH_A, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo A");
        exit(EXIT_FAILURE);
    }
    if (mkfifo(FIFO_PATH_B, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo B");
        exit(EXIT_FAILURE);
    }

    // Open FIFOs
    fdA = open(FIFO_PATH_A, O_RDONLY);
    if (fdA == -1) {
        perror("open A");
        exit(EXIT_FAILURE);
    }
    fdB = open(FIFO_PATH_B, O_WRONLY);
    if (fdB == -1) {
        perror("open B");
        exit(EXIT_FAILURE);
    }

    while (1) {
        // Read message
        read(fdA, buffer, sizeof(buffer));
        printf("Received message: %s\n", buffer);

        // Compute CRC of the message
        crc = crc32(buffer, strlen(buffer));
        sprintf(crc_result, "%u", crc);

        // Send CRC result
        write(fdB, crc_result, strlen(crc_result) + 1);
    }

    // Clean up
    close(fdA);
    close(fdB);
    unlink(FIFO_PATH_A);
    unlink(FIFO_PATH_B);

    return 0;
}

使用步骤

编译两个程序：gcc -o progA progA.c 和 gcc -o progB progB.c。
运行进程B（接收和处理消息）：./progB。
运行进程A（发送消息）：./progA。

这将实现进程A每隔n秒发送消息，并从进程B接收CRC校验结果。

#makefile文件

创建一个通用的 Makefile 以支持 proc_A 和 proc_B 两个源文件，并尽可能减少修改的工作量，可以按照以下步骤进行：

示例 `Makefile`

# 定义变量
CC = gcc
CFLAGS = -Wall -g
TARGETS = proc_A proc_B
SOURCES = $(wildcard *.c)
OBJECTS = $(SOURCES:.c=.o)

# 默认目标
all: $(TARGETS)

# 目标规则
proc_A: proc_A.o
	$(CC) -o $@ $^ $(CFLAGS)

proc_B: proc_B.o
	$(CC) -o $@ $^ $(CFLAGS)

# 生成 .o 文件
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# 清理
clean:
	rm -f $(TARGETS) $(OBJECTS)

# 伪目标
.PHONY: all clean