对比windows和linux的对父进程的文件描述符继承的设置

「爱情、让人受尽委屈。」 2022-08-19 11:15 259阅读 0赞

需要实现一个fopen中的子进程是否继承父进程的文件句柄的功能。

由于在多平台上，所以需要考虑windows和Linux及类Unix系统。

Linux实现的阻碍：

Linux中是默认子进程能够继承fd的。

1.由于需要在fopen函数中实现，但是看了下关于O\_CLOEXEC属性(since Linux 2.6.23)是在open函数中的。

其含义就是在获取新的文件描述符时，使能close-on-exec flag，即使得在调用exec函数集时主动预先关闭父进程的文件描述符。

这在open中是一个Flag，也就是说是一个int型值。

2.正由于open中是一个int型值，而其他的文件属性相关的大部分在fopen都是rw等以char\*形式提供的mode。所以出现了不好统一的的情况。

汇集一点：open中提供了对应的int型的flag，但是我们要打开的是文件需要调用fopen，fopen又没有提供int型的设置参数，只有字符串类型的mode作为设置参数。

解决办法：

还是查资料，发现了在glibc中，fopen已经提供了类似的参数在mode中，以字符'e'表示**O\_CLOEXEC** **flag**。但是这里有一个限制，就是必须要是glibc 2.7版本以后才会有这种解析。如果是之前的版本，就只好先用open接口加上O\_CLOEXEC的flag做为参数获取到fd，然后再利用fdopen，来进行mode的设置。

windows的实现阻碍：

windows中是默认子进程能够不能继承fd的，因为要提前设置好条件。

其实关键在于，这个实现的有没有意义。因为下面的资料上也有提及，如果要继承父进程的句柄，则需要有两步

1.在创建获取句柄(类似于文件描述符)的时候，就要明确在属性中设置是可以用于子进程继承的。

2.在创建子子进程时，是否允许继承的参数就要设置成true，否则仍然不能继承。

摘自：http://man7.org/linux/man-pages/man3/fopen.3.htm

## NAME [top][] ##

fopen, fdopen, freopen - stream open functions

## SYNOPSIS [top][] ##

#include <stdio.h>
    
           FILE *fopen(const char *path, const char *mode);
    
           FILE *fdopen(int fd, const char *mode);
    
           FILE *freopen(const char *path, const char *mode, FILE *stream);
    
       Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
    
           fdopen(): _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE

## DESCRIPTION [top][] ##

The fopen() function opens the file whose name is the string pointed
           to by path and associates a stream with it.
    
           The argument mode points to a string beginning with one of the
           following sequences (possibly followed by additional characters, as
           described below):
    
           r      Open text file for reading.  The stream is positioned at the
                  beginning of the file.
    
           r+     Open for reading and writing.  The stream is positioned at the
                  beginning of the file.
    
           w      Truncate file to zero length or create text file for writing.
                  The stream is positioned at the beginning of the file.
    
           w+     Open for reading and writing.  The file is created if it does
                  not exist, otherwise it is truncated.  The stream is
                  positioned at the beginning of the file.
    
           a      Open for appending (writing at end of file).  The file is
                  created if it does not exist.  The stream is positioned at the
                  end of the file.
    
           a+     Open for reading and appending (writing at end of file).  The
                  file is created if it does not exist.  The initial file
                  position for reading is at the beginning of the file, but
                  output is always appended to the end of the file.
    
           The mode string can also include the letter 'b' either as a last
           character or as a character between the characters in any of the two-
           character strings described above.  This is strictly for
           compatibility with C89 and has no effect; the 'b' is ignored on all
           POSIX conforming systems, including Linux.  (Other systems may treat
           text files and binary files differently, and adding the 'b' may be a
           good idea if you do I/O to a binary file and expect that your program
           may be ported to non-UNIX environments.)
    
           See NOTES below for details of glibc extensions for mode.
    
           Any created files will have mode S_IRUSR | S_IWUSR | S_IRGRP |
           S_IWGRP | S_IROTH | S_IWOTH (0666), as modified by the process's
           umask value (see umask(2)).
    
           Reads and writes may be intermixed on read/write streams in any
           order.  Note that ANSI C requires that a file positioning function
           intervene between output and input, unless an input operation
           encounters end-of-file.  (If this condition is not met, then a read
           is allowed to return the result of writes other than the most
           recent.)  Therefore it is good practice (and indeed sometimes
           necessary under Linux) to put an fseek(3) or fgetpos(3) operation
           between write and read operations on such a stream.  This operation
           may be an apparent no-op (as in fseek(..., 0L, SEEK_CUR) called for
           its synchronizing side effect).
    
           Opening a file in append mode (a as the first character of mode)
           causes all subsequent write operations to this stream to occur at
           end-of-file, as if preceded the call:
    
               fseek(stream, 0, SEEK_END);
    
           The fdopen() function associates a stream with the existing file
           descriptor, fd.  The mode of the stream (one of the values "r", "r+",
           "w", "w+", "a", "a+") must be compatible with the mode of the file
           descriptor.  The file position indicator of the new stream is set to
           that belonging to fd, and the error and end-of-file indicators are
           cleared.  Modes "w" or "w+" do not cause truncation of the file.  The
           file descriptor is not dup'ed, and will be closed when the stream
           created by fdopen() is closed.  The result of applying fdopen() to a
           shared memory object is undefined.
    
           The freopen() function opens the file whose name is the string
           pointed to by path and associates the stream pointed to by stream
           with it.  The original stream (if it exists) is closed.  The mode
           argument is used just as in the fopen() function.  The primary use of
           the freopen() function is to change the file associated with a
           standard text stream (stderr, stdin, or stdout).

## RETURN VALUE [top][] ##

Upon successful completion fopen(), fdopen() and freopen() return a
           FILE pointer.  Otherwise, NULL is returned and errno is set to
           indicate the error.

## NOTES [top][] ##

Glibc notes
           The GNU C library allows the following extensions for the string
           specified in mode:
    
           c (since glibc 2.3.3)
                  Do not make the open operation, or subsequent read and write
                  operations, thread cancellation points.  This flag is ignored
                  for fdopen().
    
           e (since glibc 2.7)
                  Open the file with the O_CLOEXEC flag.  See open(2) for more
                  information.  This flag is ignored for fdopen().
    
           m (since glibc 2.3)
                  Attempt to access the file using mmap(2), rather than I/O
                  system calls (read(2), write(2)).  Currently, use of mmap(2)
                  is attempted only for a file opened for reading.
    
           x      Open the file exclusively (like the O_EXCL flag of open(2)).
                  If the file already exists, fopen() fails, and sets errno to
                  EEXIST.  This flag is ignored for fdopen().
    
           In addition to the above characters, fopen() and freopen() support
           the following syntax in mode:
    
               ,ccs=string
    
           The given string is taken as the name of a coded character set and
           the stream is marked as wide-oriented.  Thereafter, internal
           conversion functions convert I/O to and from the character set
           string.  If the ,ccs=string syntax is not specified, then the wide-
           orientation of the stream is determined by the first file operation.
           If that operation is a wide-character operation, the stream is marked
           wide-oriented, and functions to convert to the coded character set
           are loaded.

## BUGS [top][] ##

摘自：https://msdn.microsoft.com/en-us/library/windows/desktop/ms683463(v=vs.85).aspx

# Inheritance #

A child process can inherit several properties and resources from its parent process. You can also prevent a child process from inheriting properties from its parent process. The following can be inherited:

*  Open handles returned by the [**CreateFile**][CreateFile] function. This includes handles to files, console input buffers, console screen buffers, named pipes, serial communication devices, and mailslots.
 *  Open handles to process, thread, mutex, event, semaphore, named-pipe, anonymous-pipe, and file-mapping objects. These are returned by the [**CreateProcess**][CreateProcess], [**CreateThread**][CreateThread], [**CreateMutex**][CreateMutex], [**CreateEvent**][CreateEvent], [**CreateSemaphore**][CreateSemaphore], [**CreateNamedPipe**][CreateNamedPipe],[**CreatePipe**][CreatePipe], and [**CreateFileMapping**][CreateFileMapping] functions, respectively.
 *  Environment variables.
 *  The current directory.
 *  The console, unless the process is detached or a new console is created. A child console process can also inherits the parent's standard handles, as well as access to the input buffer and the active screen buffer.
 *  The error mode, as set by the [**SetErrorMode**][SetErrorMode] function.
 *  The process affinity mask.
 *  The association with a job.

The child process does not inherit the following:

*  Priority class.
 *  Handles returned by [**LocalAlloc**][LocalAlloc], [**GlobalAlloc**][GlobalAlloc], [**HeapCreate**][HeapCreate], and [**HeapAlloc**][HeapAlloc].
 *  Pseudo handles, as in the handles returned by the [**GetCurrentProcess**][GetCurrentProcess] or [**GetCurrentThread**][GetCurrentThread] function. These handles are valid only for the calling process.
 *  DLL module handles returned by the [**LoadLibrary**][LoadLibrary] function.
 *  GDI or USER handles, such as **HBITMAP** or **HMENU**.

## Inheriting Handles ##

A child process can inherit some of its parent's handles, but not inherit others. To cause a handle to be inherited, you must do two things:

*  Specify that the handle is to be inherited when you create, open, or duplicate the handle. Creation functions typically use the**bInheritHandle** member of a [**SECURITY\_ATTRIBUTES**][SECURITY_ATTRIBUTES] structure for this purpose. [**DuplicateHandle**][DuplicateHandle] uses the *bInheritHandles*parameter.
 *  Specify that inheritable handles are to be inherited by setting the *bInheritHandles* parameter to TRUE when calling the[**CreateProcess**][CreateProcess] function. Additionally, to inherit the standard input, standard output, and standard error handles, the **dwFlags**member of the [**STARTUPINFO**][STARTUPINFO] structure must include STARTF\_USESTDHANDLES.

An inherited handle refers to the same object in the child process as it does in the parent process. It also has the same value and access privileges. Therefore, when one process changes the state of the object, the change affects both processes. To use a handle, the child process must retrieve the handle value and "know" the object to which it refers. Usually, the parent process communicates this information to the child process through its command line, environment block, or some form of [interprocess communication][].

The [**DuplicateHandle**][DuplicateHandle] function is useful if a process has an inheritable open handle that you do not want to be inherited by the child process. In this case, use **DuplicateHandle** to open a duplicate of the handle that cannot be inherited, then use the[**CloseHandle**][CloseHandle] function to close the inheritable handle. You can also use the **DuplicateHandle** function to open an inheritable duplicate of a handle that cannot be inherited.

## Inheriting Environment Variables ##

A child process inherits the environment variables of its parent process by default. However, [**CreateProcess**][CreateProcess] enables the parent process to specify a different block of environment variables. For more information, see [Environment Variables][].

## Inheriting the Current Directory ##

The [**GetCurrentDirectory**][GetCurrentDirectory] function retrieves the current directory of the calling process. A child process inherits the current directory of its parent process by default. However, [**CreateProcess**][CreateProcess] enables the parent process to specify a different current directory for the child process. To change the current directory of the calling process, use the [**SetCurrentDirectory**][SetCurrentDirectory] function.

[top]: http://man7.org/linux/man-pages/man3/fopen.3.html#top_of_page
[CreateFile]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858%28v=vs.85%29.aspx
[CreateProcess]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425%28v=vs.85%29.aspx
[CreateThread]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682453%28v=vs.85%29.aspx
[CreateMutex]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682411%28v=vs.85%29.aspx
[CreateEvent]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682396%28v=vs.85%29.aspx
[CreateSemaphore]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682438%28v=vs.85%29.aspx
[CreateNamedPipe]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365150%28v=vs.85%29.aspx
[CreatePipe]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365152%28v=vs.85%29.aspx
[CreateFileMapping]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366537%28v=vs.85%29.aspx
[SetErrorMode]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680621%28v=vs.85%29.aspx
[LocalAlloc]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366723%28v=vs.85%29.aspx
[GlobalAlloc]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366574%28v=vs.85%29.aspx
[HeapCreate]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366599%28v=vs.85%29.aspx
[HeapAlloc]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa366597%28v=vs.85%29.aspx
[GetCurrentProcess]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms683179%28v=vs.85%29.aspx
[GetCurrentThread]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms683182%28v=vs.85%29.aspx
[LoadLibrary]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684175%28v=vs.85%29.aspx
[SECURITY_ATTRIBUTES]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa379560%28v=vs.85%29.aspx
[DuplicateHandle]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms724251%28v=vs.85%29.aspx
[STARTUPINFO]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms686331%28v=vs.85%29.aspx
[interprocess communication]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365574%28v=vs.85%29.aspx
[CloseHandle]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms724211%28v=vs.85%29.aspx
[Environment Variables]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682653%28v=vs.85%29.aspx
[GetCurrentDirectory]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364934%28v=vs.85%29.aspx
[SetCurrentDirectory]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365530%28v=vs.85%29.aspx