C 创建进程和匿名管道

更新问题：所以我已经能够创建进程并编译程序。然而，我遇到了一个新问题。当我尝试将源程序导入过滤器程序时。它似乎没有为sink程序提供任何输入。没有错误消息。我还使用Windows的cmd中的pipe操作符测试了我所有的独立程序

我正试图做这个小项目来了解匿名管道和创建流程。我创建了3个独立的小程序，称为源、过滤器和接收器。这3个已编译并运行良好。下面是3个独立程序的说明

Source：从命令行获取源文本文件名，打开该文件，一次读取一个字符的文件内容并将其复制到标准输出（stdout）。复制文件后，源终止（关闭所有打开的文件句柄）

筛选程序不使用任何文件名命令行参数。相反，过滤器从标准输入（stdin）读取一个文本文件，并将所有大写字母转换为小写的输入副本写入标准输出（stdout）。过滤器必须专门设计为读取一个字符，转换它，输出它，然后循环直到输入数据完成

Sink程序从其命令行获取目标文本文件名，打开文件进行写入，然后从标准输入文件（stdin）中一次读取一个字符，并将每个传入字符直接写入目标Sink文件

接下来，我将分别驱动一个主驱动程序，该程序创建2个管道并生成3个独立的子级，输入和输出配置为执行指定的并发执行和数据流。大概是这样的：

• srcfile->Source->pipe1->Filter->Pipe2->Sink->destfile

驱动程序需要2个命令行参数：

• C:\>Driver.exe srcfile destfile

其中srcfile是现有的数据文本文件，destfile是将由接收器应用程序创建的新目标文件的文件名

这是我的驱动程序代码。它还没有完成。但是我在尝试为源程序创建进程时遇到了一个小问题

更新代码：

#include <windows.h>
#include <WinBase.h>
#include <stdio.h>


#define DELAY_A_WHILE() {volatile long j; for(j = 1; j< 10000; j++) ; } 

int main(int argc, char *argv[])
{
    HANDLE hPipeRead, hPipeWrite, hPipeRead2, hPipeWrite2;
    STARTUPINFO StartupInfoSource;
    STARTUPINFO StartupInfoFilter;
    STARTUPINFO StartupInfoSink;
    PROCESS_INFORMATION ProcInfoSource;
    PROCESS_INFORMATION ProcInfoFilter;
    PROCESS_INFORMATION ProcInfoSink;
    SECURITY_ATTRIBUTES PipeAttributes;
    SECURITY_ATTRIBUTES PipeAttributes2;
    char cmdline[200];

    PipeAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
    PipeAttributes.lpSecurityDescriptor = NULL;     //ignore
    PipeAttributes.bInheritHandle = TRUE;           //child can inherit

    //Create first pipe
    if (!CreatePipe(&hPipeRead, &hPipeWrite, &PipeAttributes, 0)) {
        fprintf(stderr, "Error creating pipe: %d\n", GetLastError());
        exit(1);
    }

    sprintf_s(cmdline, 200, "Source.exe %s", argv[1]);
    printf("Create process: %s\n", cmdline);

    GetStartupInfo(&StartupInfoSource);
    StartupInfoSource.dwFlags = StartupInfoSource.dwFlags | STARTF_USESTDHANDLES;


    //Mapping
    StartupInfoSource.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    StartupInfoSource.hStdOutput = hPipeWrite;
    StartupInfoSource.hStdError = GetStdHandle(STD_ERROR_HANDLE);

    if (!CreateProcess(
        NULL, cmdline, NULL, NULL,
        TRUE,
        CREATE_NEW_CONSOLE, NULL, NULL,
        &StartupInfoSource,
        &ProcInfoSource))
    {
        fprintf(stderr, "Error creating child process: %d",GetLastError());
        exit(1);
    }

    CloseHandle(hPipeWrite);
    CloseHandle(ProcInfoSource.hProcess);
    CloseHandle(ProcInfoSource.hThread);

    PipeAttributes2.nLength = sizeof(SECURITY_ATTRIBUTES);
    PipeAttributes2.lpSecurityDescriptor = NULL;        //ignore
    PipeAttributes2.bInheritHandle = TRUE;          //child can inherit
    //Create Second Pipe
    if (!CreatePipe(&hPipeRead2, &hPipeWrite2, &PipeAttributes2, 0)) {
        fprintf(stderr, "Error creating pipe: %d\n", GetLastError());
        exit(1);
    } 

    GetStartupInfo(&StartupInfoFilter);
    StartupInfoFilter.dwFlags = StartupInfoFilter.dwFlags | STARTF_USESTDHANDLES;

    //Mapping
    StartupInfoFilter.hStdInput = hPipeRead;
    StartupInfoFilter.hStdOutput = hPipeWrite2;
    StartupInfoFilter.hStdError = GetStdHandle(STD_ERROR_HANDLE);

    sprintf_s(cmdline, 200, "Filter.exe");
    printf("Create process: %s\n", cmdline);

    //Filter
    GetStartupInfo(&StartupInfoFilter);
    if (!CreateProcess(
        NULL, cmdline, NULL, NULL,
        TRUE,
        CREATE_NEW_CONSOLE, NULL, NULL,
        &StartupInfoFilter,
        &ProcInfoFilter))
    {
        fprintf(stderr, "Error creating child process: %d", GetLastError());
        exit(1);
    }
//  int exitStatus;
    //  GetExitCodeProcess(ProcInfoFilter.hProcess, &exitStatus);
    CloseHandle(hPipeRead);
    CloseHandle(hPipeWrite2);
    CloseHandle(ProcInfoFilter.hProcess);
    CloseHandle(ProcInfoFilter.hThread);


    GetStartupInfo(&StartupInfoSink);
    StartupInfoSink.dwFlags = StartupInfoSink.dwFlags | STARTF_USESTDHANDLES;



    //Mapping
    StartupInfoSink.hStdInput = hPipeRead2;
    StartupInfoSink.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    StartupInfoSink.hStdError = GetStdHandle(STD_ERROR_HANDLE);

    sprintf_s(cmdline, 200, "Sink.exe %s", argv[2]);
    printf("Create process: %s\n", cmdline);

    GetStartupInfo(&StartupInfoSink);
    if (!CreateProcess(
        NULL, cmdline, NULL, NULL,
        TRUE,
        CREATE_NEW_CONSOLE, NULL, NULL,
        &StartupInfoSink,
        &ProcInfoSink))
    {
        fprintf(stderr, "Error creating child process: %d", GetLastError());
        exit(1);
    }

    CloseHandle(hPipeRead2);
    CloseHandle(ProcInfoSink.hProcess);
    CloseHandle(ProcInfoSink.hThread);


    return 0;
}

#包括
#包括
#包括
#定义DELAY_A_WHILE（）{volatile long j；for（j=1；j<10000；j++）；}
int main（int argc，char*argv[]）
{
处理hPipeRead、HPIPERWRITE、hPipeRead2、HPIPERWRITE2；
STARTUPINFO StartupInfoSource；
STARTUPINFO StartupInfoFilter；
STARTUPINFO StartupInfoSink；
过程信息源；
过程信息过滤器；
处理信息库；
安全属性；
安全属性2；
char-cmdline[200]；
PipeAttributes.nLength=sizeof（安全属性）；
PipeAttributes.lpSecurityDescriptor=NULL；//忽略
PipeAttributes.bInheritHandle=TRUE；//子级可以继承
//创建第一个管道
如果（！CreatePipe（&hPipeRead，&hPipeWrite，&PipeAttributes，0））{
fprintf（stderr，“创建管道时出错：%d\n”，GetLastError（））；
出口（1）；
}
sprintf_s（cmdline，200，“Source.exe%s”，argv[1]）；
printf（“创建进程：%s\n”，cmdline）；
GetStartupInfo（和StartupInfoSource）；
StartupInfoSource.dwFlags=StartupInfoSource.dwFlags | STARTF_USESTDHANDLES；
//映射
StartupInfoSource.hStdInput=GetStdHandle（标准输入句柄）；
StartupInfoSource.hstOutput=hPipeWrite；
StartupInfoSource.hStdError=GetStdHandle（标准错误句柄）；
如果（！CreateProcess(
NULL，cmdline，NULL，NULL，
是的，
创建新控制台，空，空，
&StartupInfoSource，
&ProcInfoSource）
{
fprintf（stderr，“创建子进程时出错：%d”，GetLastError（））；
出口（1）；
}
CloseHandle（hPipeWrite）；
CloseHandle（ProcInfoSource.hProcess）；
CloseHandle（ProcInfoSource.hThread）；
PipeAttributes2.nLength=sizeof（安全属性）；
PipeAttributes2.lpSecurityDescriptor=NULL；//忽略
PipeAttributes2.bInheritHandle=TRUE；//子级可以继承
//创建第二个管道
如果（！CreatePipe（&hPipeRead2，&hPipeWrite2，&PipeAttributes2，0））{
fprintf（stderr，“创建管道时出错：%d\n”，GetLastError（））；
出口（1）；
} 
GetStartupInfo（&StartupInfoFilter）；
StartupInfoFilter.dwFlags=StartupInfoFilter.dwFlags | STARTF_USESTDHANDLES；
//映射
StartupInfoFilter.hstInput=hPipeRead；
StartupInfoFilter.hstOutput=hPipeWrite2；
StartupInfoFilter.hStdError=GetStdHandle（标准错误句柄）；
sprintf_s（cmdline，200，“Filter.exe”）；
printf（“创建进程：%s\n”，cmdline）；
//滤器
GetStartupInfo（&StartupInfoFilter）；
如果（！CreateProcess(
NULL，cmdline，NULL，NULL，
是的，
创建新控制台，空，空，
&StartupInfoFilter，
&ProcInfoFilter）
{
fprintf（stderr，“创建子进程时出错：%d”，GetLastError（））；
出口（1）；
}
//内部存在状态；
//GetExitCodeProcess（ProcInfoFilter.hProcess，&exitStatus）；
闭合手柄（hPipeRead）；
关闭手柄（hPipeWrite2）；
CloseHandle（ProcInfoFilter.hProcess）；
CloseHandle（ProcInfoFilter.hThread）；
GetStartupInfo（&StartupInfoSink）；
StartupInfoSink.dwFlags=StartupInfoSink.dwFlags | STARTF_USESTDHANDLES；
//映射
StartupInfoSink.hStdInput=hPipeRead2；
StartupInfoSink.hstOutput=GetStdHandle（标准输出句柄）；
StartupInfoSink.hStdError=GetStdHandle（标准错误句柄）；
sprintf_s（cmdline，200，“Sink.exe%s”，argv[2]）；
printf（“创建进程：%s\n”，cmdline）；
GetStartupInfo（&StartupInfoSink）；
如果（！CreateProcess(
NULL，cmdline，NULL，NULL，
是的，
创建新控制台，空，空，
&StartupInfoSink，
&ProcInfoSink）
{