fd leak, custom Shell

by

Let’s be accurate regarding the file descriptors and bear in mind that during fork and execvp file descriptors are inherited by child processes unless marked as w/ CLOEXEC flag. Check the man pages:

fork(2):
The child inherits copies of the parent’s set of open file descriptors. Each file descriptor in the child refers to the same open file description (see open(2)) as the corresponding file descriptor in the parent.

open(2):
By default, the new file descriptor is set to remain open across an execve(2) (i.e., the FD_CLOEXEC file descriptor flag described in fcntl(2) is initially disabled); the O_CLOEXEC flag, described below, can be used to change this default. The file offset is set to the beginning of the file (see lseek(2)).

But this behaviour, I supposed, exactly what you were relying on by calling fork after pipe…

No other words, lets’ draw this:

             stdin, stdout                                                                   
                   /\                                                                        
                  /  \                                                                       
                 /    \                                                                      
                /      \                                                                     
               / R; W;  \                                                                    
              /          \                                                                   
       Child -            - Parent                                                           
 stdin/out, R(del),W       stdin/out, R(fd_backup), W(del)                                   
                                  /\                                                         
                                 /  \                                                        
                                /    \                                                       
                               /      \                                                      
                              / R1; W1;\                                                     
                             /          \                                                    
                      Child -            - Parent                                            
               stdin/out, R(fd_backup),   stdin, stdout                                      
                            R1(del), W1   R(fd_backup - old);                                
                                          R1(fd_backup - new); W1(del)                       
                                                    / \                                      
                                                   /   \                                     
                                                  /     \                                    
                                                 /R2; W2;\                                   
                                                /         \                                  
                                               /           \                                 
                                        Child -             - Parent                         
                                 stdin, stdout,             stdin, stdout                    
                                R(fd_backup - old),         R (fd_backup - old),             
                                R1(fd_backup - new),        R1 (fd_backup - new),            
                                R2(del),W2                  R2 (fd_backup - newest!),

I hope the picture is self explanatory.

Child processes will die anyway and all their fds will be closed (so no issue with them). But the parent process is left with 3 opened fds and they keep growing with each pipe executed.

More Related Contents:

  1. printf anomaly after “fork()”
  2. How to make child process die after parent exits?
  3. How to capture Control+D signal?
  4. C Minishell Adding Pipelines
  5. Why does this program print “forked!” 4 times?
  6. In C how do you redirect stdin/stdout/stderr to files when making an execvp() or similar call?
  7. stdout thread-safe in C on Linux?
  8. What does the brk() system call do?
  9. Why does ENOENT mean “No such file or directory”?
  10. Merge multiple .so shared libraries
  11. Re-opening stdout and stdin file descriptors after closing them
  12. Turn a simple socket into an SSL socket
  13. How to execute a shell script from C in Linux?
  14. How do I get a thread ID from an arbitrary pthread_t?
  15. Are there any platforms where using structure copy on an fd_set (for select() or pselect()) causes problems?
  16. How can I convert a file pointer ( FILE* fp ) to a file descriptor (int fd)?
  17. After forking, are global variables shared?
  18. Set environment variables in C
  19. Are file descriptors shared when fork()ing?
  20. Detecting 64bit compile in C
  21. Implementation of multiple pipes in C
  22. Questions about putenv() and setenv()
  23. Executing shell script with system() returns 256. What does that mean?
  24. Pipes, dup2 and exec()
  25. In C, what’s the size of stdout buffer?
  26. What can cause a “Resource temporarily unavailable” on sock send() command
  27. argv: Sanitizing wildcards
  28. Creating a daemon in Linux
  29. strtok function thread safety
  30. Finding out if a message over tcp was delivered

Leave a Comment