C 内存泄漏演示问题

我正在尝试创建一个程序，演示心脏出血等问题是如何发生的。这就是我到目前为止所做的：

#include <stdio.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>

#define LPORT 5555
#define ACCEPT_QUEUE_SIZE 10

typedef struct sockaddr_in sockaddr_in;
typedef struct sockaddr sockaddr;

const char *login_msg = "=== Welcome to super secure admin control panel! ===\nPlease enter the password:";
const char *login_len_msg = "\nPlease enter the length of the password you entered: ";
const char *incorrect_password_msg = "\nACCESS DENIED USING PASSWORD: ";
const char *correct_password_msg = "\nACCESS GRANTED.\n";


int sockfd = 0;
sockaddr_in serv_addr;
void connection_handler(int connfd, const char *secret_password, char *client_address) {
    pid_t my_pid = fork();
    if (my_pid < 0) {
        fprintf(stderr, "[!] Failed to fork a new process for connection handler\n");
        exit(EXIT_FAILURE);
    }
    if (my_pid == 0) {
    if (1) {
        send(connfd, login_msg, strlen(login_msg), 0);
        char user_resp[51], secret_key[10];
        char user_resp_len_msg[6];
        int user_resp_len = 0;
        bzero(&user_resp, sizeof(user_resp));
        bzero(&user_resp_len_msg, sizeof(user_resp_len_msg));
        recv(connfd, &user_resp, 50, 0);
        fprintf(stderr, "[*] Client %s sent password %s\n", client_address, user_resp);
        send(connfd, login_len_msg, strlen(login_len_msg), 0);
        recv(connfd, &user_resp_len_msg, 5, 0);
        fprintf(stderr, "[*] Client %s sent password length string %s\n", client_address, user_resp_len_msg);
        sscanf(user_resp_len_msg, "%d\n", &user_resp_len);
        if (strncmp(secret_password, user_resp, strlen(secret_password)) == 0) {
            fprintf(stderr, "[+] %s successfully completed the challenge\n", client_address);
            send(connfd, correct_password_msg, strlen(correct_password_msg), 0);
        }
        else {
            send(connfd, incorrect_password_msg, strlen(incorrect_password_msg), 0);
            send(connfd, user_resp, user_resp_len, 0);
        }
        close(connfd);
        exit(EXIT_SUCCESS);
    }
}

void interrupt_handler(int signum) {
    fprintf(stderr, "[*] Caught interrupt signal, dying\n");
    close(sockfd);
    exit(EXIT_SUCCESS);
}

int main(int argc, const char * argv[]) {
    if (argc != 2) {
        fprintf(stderr, "[!] Usage: %s [server password]\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    setpgrp();
    signal(SIGHUP, SIG_IGN);
    signal(SIGINT, interrupt_handler);

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        fprintf(stderr, "[!] Failed fo create socket\n");
        exit(EXIT_FAILURE);
    }

    int optval = 1;
    if( setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) != 0) {
        fprintf(stderr, "[!] Failed to set SO_REUSEADDR option on socket\n");
        exit(EXIT_FAILURE);
    }

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(LPORT);

    if (bind(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) != 0) {
        fprintf(stderr, "[!] Failed to bind to port %d\n", LPORT);
        exit(EXIT_FAILURE);
    }

    if (listen(sockfd, ACCEPT_QUEUE_SIZE) != 0) {
        fprintf(stderr, "[!] Failed to listen on port %d with queue size %d\n", LPORT, ACCEPT_QUEUE_SIZE);
        exit(EXIT_FAILURE);
    }

    sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char client_addr_str[INET_ADDRSTRLEN];
    while (1) {
        bzero(&client_addr, sizeof(client_addr));
        bzero(&client_addr_str, sizeof(client_addr_str));
        int connfd = accept(sockfd, (sockaddr*)&client_addr, &client_addr_len);
        inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, client_addr_str, client_addr_len);
        fprintf(stderr, "[*] Got new connection from %s\n", client_addr_str);
        connection_handler(connfd, argv[1], client_addr_str);
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义LPORT 5555
#定义接受队列大小10
sockaddr_中的typedef结构sockaddr_；
类型定义结构sockaddr sockaddr；
const char*login_msg=“==欢迎来到超级安全管理控制面板！===\n请输入密码：”；
const char*login\u len\u msg=“\n请输入您输入的密码长度：”；
const char*密码不正确\u msg=“\n使用密码拒绝访问：”；
const char*correct_password_msg=“\n已授予访问权。\n”；
int-sockfd=0；
服务地址中的sockaddr\u；
无效连接处理程序（int connfd，const char*密码，char*客户端地址）{
pid_t my_pid=fork（）；
如果（我的pid<0）{
fprintf（stderr，“[！]未能为连接处理程序派生新进程\n”）；
退出（退出失败）；
}
如果（my_pid==0）{
如果（1）{
发送（connfd，login\u msg，strlen（login\u msg），0）；
char user_resp[51]，secret_key[10]；
char user_resp_len_msg[6]；
int user_resp_len=0；
bzero（&user_resp，sizeof（user_resp））；
bzero（&user_resp_len_msg，sizeof（user_resp_len_msg））；
recv（connfd和user_resp，50,0）；
fprintf（stderr，“[*]客户端%s已发送密码%s\n”，客户端地址，用户响应）；
发送（connfd，login\u len\u msg，strlen（login\u len\u msg），0）；
recv（connfd和user_resp_len_msg，5,0）；
fprintf（stderr，“[*]客户端%s已发送密码长度字符串%s\n”，客户端地址，用户响应长度消息）；
sscanf（用户响应消息、%d\n、&user响应消息）；
if（strncmp（秘密密码，用户响应，秘密密码））==0）{
fprintf（stderr，“[+]%s成功完成质询\n”，客户端地址）；
发送（connfd，正确的密码信息，strlen（正确的密码信息），0）；
}
否则{
发送（connfd，不正确的密码消息，strlen（不正确的密码消息），0）；
发送（connfd，user_resp，user_resp len，0）；
}
关闭（connfd）；
退出（退出成功）；
}
}
无效中断处理程序（int信号）{
fprintf（stderr，“[*]捕获的中断信号，正在消失\n”）；
关闭（sockfd）；
退出（退出成功）；
}
int main（int argc，const char*argv[]{
如果（argc！=2）{
fprintf（stderr，“[！]用法：%s[服务器密码]\n”，argv[0]）；
退出（退出失败）；
}
setpgrp（）；
信号（信号灯、信号灯）；
信号（SIGINT，中断处理程序）；
if（（sockfd=socket（AF_INET，SOCK_STREAM，0））<0）{
fprintf（stderr，“[！]创建套接字失败\n”）；
退出（退出失败）；
}
int optval=1；
if（setsockopt（sockfd，SOL_SOCKET，SO_REUSEADDR，&optval，sizeof（optval））！=0）{
fprintf（stderr，“[！]未能在套接字上设置SO_REUSEADDR选项\n”）；
退出（退出失败）；
}
bzero（&serv_addr，sizeof（serv_addr））；
serv_addr.sin_family=AF_INET；
serv_addr.sin_addr.s_addr=INADDR_ANY；
serv_addr.sin_port=htons（LPORT）；
if（bind（sockfd，（sockaddr*）和serv_addr，sizeof（serv_addr））！=0）{
fprintf（stderr，“[！]无法绑定到端口%d\n”，LPORT）；
退出（退出失败）；
}
如果（侦听（sockfd，接受队列大小）！=0）{
fprintf（stderr，“[！]在队列大小为%d的端口%d上侦听失败\n”，LPORT，ACCEPT_queue_size）；
退出（退出失败）；
}
客户机地址中的sockaddr\u；
socklen\u t client\u addr\u len=sizeof（client\u addr）；
char client_addr_str[INET_ADDRSTRLEN]；
而(1){
bzero（和客户地址，大小（客户地址））；
bzero（和客户地址str，sizeof（客户地址str））；
int connfd=accept（sockfd，（sockaddr*）和客户地址，以及客户地址）；
inet\u ntop（AF\u inet和客户地址sin\u addr.s\u addr、客户地址str、客户地址len）；
fprintf（stderr，“[*]从%s获得了新连接\n”，client\u addr\u str）；
连接处理程序（connfd，argv[1]，client\u addr\u str）；
}
返回0；
}

它以

/program[password]

的形式运行。在OSX上，我注意到argv被泄露了，所以我决定密码应该放在那里。但是，当我在ubuntu上测试它时，情况并非如此。有没有一种简单的方法来确保内存相邻部分中存在两个缓冲区

---

我认识到预测未定义的行为非常困难，而且这个问题可能没有简单的答案。

请注意，您的消息最好声明为

const char login\u msg[]=“…”；

-一个数组而不是一个

字符*

。除此之外，它还节省了空间；对于数组，只分配字符串的长度，但是对于指针，您得到一个（4或8字节）指针和分配的字符串。此外，您无意更改指针指向的对象，但代码中没有任何内容可以阻止您这样做（出于偶然或设计）。对于常量为

的数组，您不能（合法地）更改更改数据。@JonathanLeffler关于将其设置为常量，您有一个非常好的观点，我还将尝试将其从指针更改为实际数组