Question

我正在尝试使用C中的AF_UNIX套接字实现我的第一个客户端服务器应用程序。

对于客户端发送的查询，我必须遵守特定的通信协议。提供三种查询类型：

1) <command_name> <object_name> <obj_len> \n <obj_data>

2) <command_name> <object_name> \n

3) <command_name> \n

请注意，除第一个查询外，每个查询都以\ n特殊字符终止，并且每个消息的长度都是未知的。

我没问题阅读2）和3），因为我知道消息将以\ n结尾，所以我只需要检查缓冲区中读取的最后一个字节是否为\ n，否则，我将继续从套接字读取，并将随后的调用追加到缓冲区。

相反，对于第一个操作，上述方法不起作用，因为\ n字符不在消息末尾，而是在缓冲区的任意点。我要做的是读取（在这种情况下）直到到达\ n，然后从缓冲区中解析 obj_len 令牌，并从套接字中最后读取 obj_len 个字节包含 obj_data 的全部内容。

这是我的readLine函数的代码，仅适用于1）和2）类型的消息：

char * readLine(int fd){
    char * buf=NULL; //here i store the content 
    char * tmp=calloc(CHUNK,sizeof(char));
    if(!tmp)
        return NULL;
    if(!buf)
        return NULL;
    buf[0]='\0';
    size_t byte_read=-1; 
    int len=0;
    do{ 
        bzero(tmp,CHUNK); //reset tmp for read
        byte_read=read(fd,(void *)tmp,CHUNK);
        if(byte_read==-1){
            perror("read");
            if(tmp)free(tmp);
            if(buf)free(buf);
            return NULL;
        }
        len=len+byte_read; //update the len of message
        buf=realloc(buf,len+1);
        if(!buf){
            perror("realloc");
            if(tmp)free(tmp);
            return NULL;
        }
        buf=strncat(buf,tmp,byte_read);//append each call of read
        if(byte_read>0 && buf[byte_read-1]=='\n')
        //the last byte read is  the special character
            break;
    }   
    while(byte_read!=0);
    if(byte_read==0)
        //read error SIGPIPE
    if(tmp)free(tmp);
    return buf;
    }

您认为要实现从套接字读取格式为2），3）和1）的消息的功能，我应该怎么做？

Answer 1

我建议使用另一种方法。首先读取一行，然后确定它是哪种消息，然后再确定这是结束还是需要读取更多字节。

因此，让我们从阅读一行开始：

int socket_readline(int fd, char *buf, size_t *inout_size)
{   
    char c = 0;
    size_t capacity = *inout_size;
    *inout_size = 0;

    while(c != '\n') {
        int rc = read(fd, &c, 1);

        if (rc != 1) return -1;

        buf[*inout_size] = c;
        *inout_size += 1;

        if (capacity - *inout_size == 0) return -1;
    }

    buf[*inout_size] = '\0';

    return 0;
}

此例程成功返回0，否则返回-1。

在成功的情况下，缓冲区用NUL终止，并且inout_size将是缓冲区中字符串的长度（不包括NUL终止字节）。如果发生错误，则应检查inout_size的值。如果发生溢出（行太长），它将等于给定缓冲区的大小（输入缓冲区将不会NUL终止！），并且对于读取错误，它将包含已读取的字节数在发生错误之前。

现在，一旦我们有了一个读取内衬例程，就可以使用它来解析传入的行：

int rc;
size_t size;
char buf[MAX_INPUT_LENGTH];

int object_len;
char command_name[MAX_INPUT_LENGTH], object_name[MAX_INPUT_LENGTH];

do {
    size = sizeof(buf);
    rc = socket_readline(fd, buf, &size);
    if (rc == 0) {
        int tokens_matched = sscanf(buf, "%s %s %d \n", command_name, object_name, &object_len);

        switch(tokens_matched) {
            case 1:
                printf("This is a command: %s\n", command_name);
                break;
            case 2:
                printf("This is a command: %s with object name: %s\n", command_name, object_name);
                break;
            case 3:
                printf("This is a command: %s with object name: %s of length %d\n", command_name, object_name, object_len);
                printf("TODO read up remaining: %d bytes\n", object_len);
                break;
            default:
                printf("Error unable to match command format\n");
                break;
        }

    } else if (size == sizeof(buf)) {
        printf("Overflow! Bytes read: %lu. \n", size);
        // TODO How to handle overflows?
    } else {
        printf("Read error must have occured. Read %lu bytes.\n", size);
    }

} while (rc == 0 || size == sizeof(buf));

管理通讯协议本地套接字c

1 个答案: