链表IPC C语言

Question

我用守护进程提供简单的服务，从任何ip中嗅探互联网数据包。我面临的问题是，我不知道如何将IP的链表及其数据包计数从守护进程进程存储到另一个进程(cli((我将它们存储在链表中(。我在互联网上搜索信息，发现我应该使用IPC，如共享内存、管道/fifo、配对套接字等。但我不知道如何使用其中的任何一个来将完整链接列表发送到CLI。你能告诉我，我的任务应该使用哪种IPC吗？以及如何通过传输链接列表。

要点是makecli，它可以与我的守护进程交互

链表结构：

typedef struct s_ip
{
uint64_t address;
size_t packets;
struct s_ip *next;
}               t_ip;    

我只能通过共享内存存储单个变量，比如char*，但不能存储其他变量，比如链表或结构的mallocated数组

另外，我应该使用结构数组而不是链表来将数据传输到另一个进程吗？

如果可能的话，给我举个这样的例子：

DAEMON

/* Daemon code side */
void sendlist_daemon(t_ip *ip_list)
{
/* code that store linked list */
}

CLI

/* CLI code side */
t_ip *getlist_cli(void)
{
t_ip *ip_list;
ip_list = /* here i can get list */
return (ip_list);
}

注意：守护程序总是在监听数据包，所以我决定制作链表，只推送传入数据包的元素。但有时，当cli的用户从所有ip请求有关所有数据包的信息时，我必须将它们发送给他

谢谢。

Answer 1

不要传输Next地址。这无关紧要。仅传输所需信息。您需要建立将要使用的数据格式。你会用什么endianes？哪个位是第一位，MSB是第一位还是LSB是第一位？你将使用什么字符集？二进制流还是可读文本？用特殊字符分隔还是不分隔？压缩？加密？哪种压缩？哪种加密？最后，数据是如何格式化的？如何处理错误？最后，api会是什么样子？它应该采用FILE指针、文件描述符编号、依赖于平台的输入/输出句柄还是函数指针？这些都是工程师在设计系统时要回答的问题。

最好的办法是尽可能地保持便携性(size_t没有那么便携，但我把它留下了(。

#include <stdio.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>
#include <inttypes.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <assert.h>
typedef struct s_ip
{
uint64_t address;
size_t packets;
struct s_ip *next;
} ip_t;
#define IP_LIST_INIT() {0}
void ip_list_elem_init(ip_t *elem, uint64_t address, size_t packets)
{
elem->address = address;
elem->packets = packets;
elem->next = NULL;
}
int ip_list_add(ip_t **head, uint64_t address, size_t packets)
{
if (*head == NULL) {
*head = malloc(sizeof(**head));
if (*head == NULL) return -__LINE__;
ip_list_elem_init(*head, address, packets);
} else {
ip_t *i;
for (i = *head; i->next != NULL; i = i->next) {
continue;
}
i->next = malloc(sizeof(*i->next));
if (i->next == NULL) return -__LINE__;
ip_list_elem_init(i->next, address, packets);
}
return 0;
}
void ip_list_free(ip_t *head)
{
// use system deallocator.... :)
return;
}
int ip_list_send(ip_t *head, FILE *f)
{
char start_of_text = 'x02'; // STX START_OF_TEXT ascii character
char end_of_text = 'x03'; // ETX END_OF_TEXT ascii character
if (fprintf(f, "%cn", start_of_text) < 0) return -__LINE__;
size_t tmp = 0;
for (ip_t *i = head; i != NULL; i = i->next) {
tmp++;
}
if (fprintf(f, "%zun", tmp) < 0) return -__LINE__;
for (ip_t *i = head; i != NULL; i = i->next) {
if (fprintf(f, "%" PRIu64 " %zun", i->address, i->packets) < 0) return -__LINE__;
}
if (fprintf(f, "%cn", end_of_text) < 0) return -__LINE__;
return 0;
}
int ip_list_recv(ip_t **head, FILE *f)
{
if (fcntl(fileno(f), F_SETFL, O_NONBLOCK) < 0) return -__LINE__;
enum {
START_TEXT,
READING_COUNT,
READING_ELEMS,
STOP_TEXT,
END,
} state = START_TEXT;
size_t cnt = 0;
ip_t *prev = NULL;
while (state != END) {
struct pollfd pfd = { .fd = fileno(f), .events = POLLIN };
int pollret = poll(&pfd, 1, 100);
if (pollret < 0) return -__LINE__;
if (pollret == 0) break;
if (pfd.revents != POLLIN) return -__LINE__;
switch (state) {
case START_TEXT: {
char c;
if (fscanf(f, "%cn", &c) != 1) return -__LINE__; // start of transmission
if (c != 'x02') return -__LINE__;
state = READING_COUNT;
break;
}
case READING_COUNT: {
if (fscanf(f, "%zun", &cnt) != 1) return -__LINE__;
state = READING_ELEMS;
break;
}
case READING_ELEMS: {
ip_t *next = malloc(sizeof(*next));
if (next == NULL) return -__LINE__;
if (fscanf(f, "%" SCNu64 " %zun", &next->address, &next->packets) != 2) return -__LINE__;
ip_list_elem_init(next, next->address, next->packets);
if (prev) {
prev->next = next;
} else {
*head = next;
}
prev = next;
cnt--;
if (cnt == 0) {
state = STOP_TEXT;
}
break;
}
case STOP_TEXT: {
char c;
if (fscanf(f, "%cn", &c) != 1) return -__LINE__;
if (c != 'x03') return -__LINE__; // end of transmission
state = END;
break;
}
default:
assert(0);
break;
}
}
return 0;
}
void ip_list_print(ip_t *head)
{
for (ip_t *i = head; i != NULL; i = i->next) {
fprintf(stdout, "%p %" PRIu64 " %zun", (void*)i, i->address, i->packets);
}
fprintf(stdout, "n");
}
int main() 
{
int ret;

FILE *f = tmpfile();
if (!f) return -__LINE__;
{
printf("Sending side:n");
ip_t *head = IP_LIST_INIT();
if (ip_list_add(&head, 1, 1)) return -__LINE__;
if (ip_list_add(&head, 2, 2)) return -__LINE__;
if (ip_list_add(&head, 3, 3)) return -__LINE__;
ip_list_print(head);
if ((ret = ip_list_send(head, f))) return ret;
ip_list_free(head);
}
rewind(f);
{
printf("Receiving side:n");
ip_t *head = IP_LIST_INIT();
if ((ret = ip_list_recv(&head, f))) return -ret;
ip_list_print(head);
ip_list_free(head);
}
}

一方只是在ip_list_send中使用简单的fprintf调用来序列化列表。首先，它发送ASCII字符"\x02"，该字符被称为带有换行符的START OF TEXT。然后，它将用换行符以ASCII字符写入的元素计数。然后为每个元素添加一个换行符。在末尾'\x03'被传输，即带有换行符的END OF TEXT。

ip_list_recv对数据进行反序列化。它使用一个简单的状态机来记住它所处的状态，跟踪计数并分配内存，使用fscanf读取数据。这段代码可能有很多错误，恶意攻击者可以使用它。这段代码中的poll调用大多是无用的，它只在换行后调用，是好代码的种子。好的代码应该在每个读取字符后调用poll将一行读取到缓冲区中，并调用fgetc或更好的read(..., 1)一次读取一个字符并将其添加到缓冲区，对fscanf的所有调用都可以是sscanf(line, ...)。可能还可以为函数实现全局/函数范围参数指定的超时。此外，当fprintf需要文件指针时，可以重写函数以使用文件描述符并将fdopen(fd, ...)与fclose()一起使用。