c - memset 无法将字符串设置为零并进入段错误

Question

我正在用 C 语言做一个关于 UDP 套接字的练习。当客户端发送特定消息(例如 hi)时，服务器必须发送“很高兴见到你”。如果没有找到标准回复，服务器将发送“没有合适的回复”。我的问题是memset如果我尝试像这样返回回复，则会失败:

return "No suitable reply";

如果我以这种方式返回回复，则不会:

char* foo = malloc(sizeof(char*));
memset(foo, 0, strlen(ses));
memcpy(foo, "No suitable reply", 17);
return foo;

我尝试用谷歌搜索这个问题的解决方案，发现this和 this ，但它们似乎没有解决我的问题(我首先认为 memset 不适用于声明为 char string[] = "something" 的字符串，但在第二个示例中，它们在静态字符串上使用 memset)。

这是完整的代码(我正在谈论的 memset 就在最后):

   /*
    Alessandro Dussin 5AI
    2018-17-11
    Write a program to handle a single UDP "connection"
    */

//Standard libraries
#include <stdio.h>
#include <stdlib.h>

//Sockets libraries and connection ahndling
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>

//Read/write ops on file descriptors
#include <unistd.h>
//String ops
#include <string.h>

#include <assert.h>
void chopN(char *str, size_t n)
{
    assert(n != 0 && str != 0);
    size_t len = strlen(str);
    if (n > len)
        return;  // Or: n = len;
    memmove(str, str+n, len - n + 1);
}

//Required by the exercise. Given a certain word or phrase, reply with a specific string
char* switchreply(char* str){
    //Extracts the word or phrase (Basically removes the "/command " word)
    chopN(str, strlen("/stdreply "));
    int i = 0;
    for(; i < strlen(str); i++){
        if(str[i] == '\n'){
            str[i] = '\0';
            break;
        }
    }
    if(strcmp(str, "ciao") == 0){
        return "ciao anche a te!";
    }
    else if(strcmp(str, "I hate you") == 0){
        return "I hate you too!";
    }
    return "";
}


char* stdreply(char *str){

    char* tmp = malloc(sizeof(char)*128);
    int i = 0;
    //printf("Entered stdreply... str at the start of the func: %s\n", str);
    for(; i < strlen(str); i++){
        tmp[i] = str[i];
        //printf("tmp: %s\n", tmp); //DEBUG
        if(strcmp(tmp, "/echo ") == 0){ // if(strcmp() == 0) is necessary because
                                        //otherwise 0 would be interpreted as FALSE
            //printf("Echo detected\n"); //DEBUG
            chopN(str, strlen("/echo "));
            str[strlen(str)] = '\0';
            return str;
        }
        else if(strcmp(tmp, "/stdreply ") == 0){
            //printf("I got into the else if\n"); //DEBUG
            char* tmpreply = calloc(strlen(str), sizeof(char*));
            tmpreply = switchreply(str);
            //printf("tmpreply: %s\n", tmpreply);
            str = malloc(sizeof(char*)*strlen(tmpreply));
            memcpy(str, tmpreply, strlen(tmpreply));
            //str[strlen(str)] = '\0'; //DEBUG
            //printf("str: %s\n", str); //DEBUG
            return str;
        }
        else if(strcmp(tmp, "/TODO") == 0){
            char* ses = malloc(sizeof(char*));
            memset(ses, 0, strlen(ses));
            memcpy(ses, "work in progress", 17);
            return ses;
        }

    }
    return "No suitable reply";

    }

    int main(int argc, char **argv){

    if(argc < 2){
        printf("Usage: ./server port");
        exit(0);
    }

    int serverfd;
    serverfd = socket(AF_INET, SOCK_DGRAM, 0);

    struct sockaddr_in server;
    server.sin_port = htons(atoi(argv[1]));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;

    if(bind(serverfd, (struct sockaddr *)&server, sizeof(server)) < 0){
        perror("Bind() error: ");
        fflush(stderr);
    }

    //"UDP message receiver" variables declarations
    int bytes; //Reads how many bytes the funcion recvfrom has read
    struct sockaddr_in from;

    char* buffer = malloc(sizeof(char*)); //String to which save the client message
    memset(buffer, 0, strlen(buffer)); //and set it to zero

    socklen_t fromlen = sizeof(struct sockaddr_in);

    const char stdrep[] = "Message Received: "; //This string will always be
                                                //printed upon receiving a message
    char* reply = malloc(sizeof(char*)); //This is where the return value of
                                        //stdreply() will be stored
    memset(reply, 0, strlen(reply)); //and set it zero

    //This while will keep "listening" for udp messages
    while((bytes = recvfrom(serverfd, buffer, 1024, 0, (struct sockaddr *)&from, &fromlen)) > 0){
        //From teacher's example. Write to stdout
        write(1, stdrep, strlen(stdrep));
        write(1, buffer, bytes);
        //Detect a basically empty string (if the client has pressed only enter)
        if(buffer[0] == '\n'){
            bytes = sendto(serverfd, "You pressed only enter!\n", 18, 0, (struct sockaddr *)&from, fromlen);
        }

        //Act according to the client message
        reply = stdreply(buffer);
        bytes = sendto(serverfd, reply, strlen(reply), 0, (struct sockaddr *)&from, fromlen);
        if (bytes  < 0){
            perror("sendto: ");
            fflush(stderr);
        }
        memset(buffer, 0, 1024);
        memset(reply, 0, strlen(reply)); //The seg fault happens right here
        fflush(stdout);
    }
    return 0;
}

Answer 1

您发布的代码中有很多问题。

1. 正如 @JonBolinger 已经指出的，sizeof(char*) 返回指向 char 的指针的大小(以字节为单位)。在 Intel 平台上，该值为 4 或 8，具体取决于您运行的是 32 位还是 64 位。 (因此您最终会分配 4 或 8 字节的缓冲区)

2. 您始终尝试使用 memset() 清除动态分配的缓冲区。 malloc() 将返回充满垃圾的内存，您可以通过在返回的缓冲区上使用 strlen() 来指示要清除的字节数。 strlen() 将扫描缓冲区，直到找到第一个 0 字符来计算字符串的长度。 由于缓冲区充满了垃圾，这很容易给你一个超出内存块边界的值，最终会破坏内存。

3. 对 malloc() 的每次调用都应与 free() 调用相匹配，否则将会泄漏内存。如果您的程序长时间运行，这一点尤其重要。

当您使用临时本地字符串(不返回给调用者的字符串)时，使用本地 char 数组而不是 malloc() 是很常见的做法。这样，缓冲区就会在堆栈上分配，并在函数退出作用域时自动释放。请务必使用“安全”字符串函数，例如 strncpy()，它将接受缓冲区长度作为参数，以避免覆盖。

void Example(char* anotherString ) {
    char tmpString[256];   // this will create a local buffer with capacity of 256 bytes
    strncpy(tmpString, anotherString, sizeof(tmpString));  // copy string, without risk of overflowing the buffer
}

警告:永远不要尝试返回本地临时缓冲区作为结果，请记住，当函数退出时，它将不再存在，尽管返回的值最初可能具有有意义的结果，但它们肯定会一旦调用另一个函数就被销毁。相反，当您需要字符串返回值时，另一种常见做法是返回使用 malloc() 分配的字符串 - 需要使用 free() 释放该字符串- 您传递一个本地缓冲区，它将保存结果作为参数，如下所示:

void func1() {
    char result[256];
    func2(result, 256);
    // after calling, result will carry "a returned string"
}

void func2(char* result, size_t bufferLen) {
    strncpy(result, "a returned string", bufferLen);
}

我认为，如果您可以将其转换为在适用的情况下使用这种样式，您的代码将会受益匪浅。