C++ / Gcc - 函数返回结构时堆栈粉碎

Question

我实际上在使用一个简单的程序时遇到了麻烦，该程序应该通过命名管道传递结构。

这是我的 main.cpp：

#include <cstdlib>                                                                                                   
#include <cstdio>
#include <iostream>
#include <string>
#include "NamedPipe.hh"

int             main()                                                                                               
{                                                                                                                    
  pid_t         pid;                                                                                                 
  std::string   str("test_namedPipe");                                                                               
  NamedPipe     pipe(str);                                                                                           
  message       *msg;                                                                                                

  //Initialisation of my struct                                                                                      
  msg = (message *)malloc(sizeof(message) + sizeof(char) * 12);                                                      
  msg->type = 1;                                                                                                     
  sprintf(msg->str, "Hello World");                                                                                  

  //Forking                                                                                                          
  pid = fork();                                                                                                      
  if (pid != 0) {                                                                                                    
    pipe.send(msg);                                                                                                  
  } else {                                                                                                           
    message msg_receive = pipe.receive(); //Here is the overflow                                                     
    std::cout << "type: " << msg_receive.type << " file: " << msg_receive.str << std::endl;                          
  }                                                                                                                  
  return (0);                                                                                                        
}

我的 NamedPipe.cpp：

#include "NamedPipe.hh"                                                                                              
#include <stdio.h>

NamedPipe::NamedPipe(std::string const &_name) : name("/tmp/" + _name) {                                             
  mkfifo(name.c_str(), 0666);                                                                                        
  // std::cout << "create fifo " << name << std::endl;                                                               
}

NamedPipe::~NamedPipe() {                                                                                            
  unlink(name.c_str());                                                                                              
}

void            NamedPipe::send(message *msg) {                                                                      
  int           fd;                                                                                                  
  int           size = sizeof(char) * 12 + sizeof(message);                                                          

  fd = open(name.c_str(), O_WRONLY);                                                                                 
  write(fd, &size, sizeof(int));                                                                                     
  write(fd, msg, (size_t)size);                                                                                      
  close(fd);                                                                                                         
}

message         NamedPipe::receive() {                                                                               
  int           fd;                                                                                                  
  int           size;                                                                                                
  message       msg;                                                                                                 

  fd = open(name.c_str(), O_RDONLY);                                                                                 
  read(fd, &size, sizeof(int));                                                                                      
  read(fd, &msg, (size_t)size);                                                                                      
  close(fd);                                                                                                         
  return (msg); //I debugged with printf. This actually reach this point before overflow                             
}

我的结构定义如下：

struct                          message {                                                                            
  int                           type;                                                                                
  char                          str[0];                                                                              
};

我实际上认为这可能是内存分配的问题，但我真的不知道该怎么做才能解决这个问题。

感谢阅读/帮助！

Answer 1

这是你问题的根源，你的struct message：

字符 str[0];

这在 C++ 中不是 kosher（在 C 中您使用它的方式也不是 kosher）。当您在堆栈上分配message 时，您正在为一个int 和0 个chars 分配空间。然后在这一行

read(fd, &msg, (size_t)size);

您将超出堆栈分配的内容写入梦幻岛。然后你返回你的message 对象，它的大小只有一个int。

将您的结构更改为此，它应该“工作”

    struct message
    {
        int type;
        char str[ 16 ];
    };