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

这是问题的根源，即message：

char str [0];

这不是C ++中的犹太人（也不是你在C中使用它的方式）。在堆栈上分配int时，您将为一个char和0 read(fd, &msg, (size_t)size);分配空间。然后在这一行

message

你写的超出你的堆栈分配到neverland。然后，您将返回int对象，该对象的大小只有一个struct message { int type; char str[ 16 ]; };。

将您的结构更改为此，它应该“正常”

INSERT INTO dept (deptno, dname) VALUES (dept_seq.nextval, 1);

C ++ / Gcc - 当func返回一个结构时，堆栈粉碎

1 个答案: