同样不一定要用管道,比如文件,SOCKET等都可以重定向.
如果是用SOCKET,根据网上的名词,可以创建一个"零管道后门"程序.比如在服务器端上的后门程序监听某个端口,一旦有连接请求,接受后创建SOCKET,就在这个时候开启CMD.EXE,并重定向输入输出到服务器上的这个SOCKET,这样便为远程的这个连接请求开了一个服务器上的后门，从而远程连接可以执行服务器并返回结果.
演示代码如下:
//
// File: Main.cpp
// Purpose: Creates a process( cmd.exe for example ), and redirect its standard input
//   by using creating a pipe, then writes some bytes as commands to pipe.
//
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <stdio.h>
#include <stdlib.h>

// Error report
void Error( const char *szErrMsg );

int main( int argc, char **argv )
{
 // Create pipe
 BOOL bRet;
 HANDLE hPipeRead, hPipeWrite;
 HANDLE hPipeReadII, hPipeWriteII;
 SECURITY_ATTRIBUTES sa;
 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
 sa.bInheritHandle = TRUE;
 sa.lpSecurityDescriptor = NULL;
 bRet = ::CreatePipe( &hPipeRead, &hPipeWrite, &sa, 512 );
 bRet &= ::CreatePipe( &hPipeReadII, &hPipeWriteII, &sa, 512 );
 if ( !bRet )
 {
  Error( "Can't create pipe!" );
  return -1;
 }
 // Spawn a process
 STARTUPINFO StartInfo;
 PROCESS_INFORMATION ProcessInfo;
// memset( &StartInfo, 0, sizeof(StartInfo) );
// memset( &ProcessInfo, 0, sizeof(ProcessInfo) );
 ::GetStartupInfo( &StartInfo );
 StartInfo.cb = sizeof(StartInfo);
 StartInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
 StartInfo.wShowWindow = SW_HIDE;
 StartInfo.hStdInput = hPipeRead;
 StartInfo.hStdOutput = hPipeWriteII; //::GetStdHandle( STD_OUTPUT_HANDLE );
 StartInfo.hStdError = hPipeWriteII; //::GetStdHandle( STD_OUTPUT_HANDLE );
 bRet = ::CreateProcess( TEXT("c:\\windows\\system32\\cmd.exe"), NULL, NULL, NULL, TRUE, 0, NULL, NULL, &StartInfo, &ProcessInfo );
 ::Sleep(1000);
 printf("wake up...\n");
 if ( !bRet )
 {
  Error( "Can't create process!" );
  return -1;
 }
 // Write commands to pipe
 char *szCmd = "netstat\r\n";
 DWORD dwDummy;
 ::WriteFile( hPipeWrite, szCmd, 10, &dwDummy, NULL );
 ::Sleep(2000);
 printf("had written...\n");
 // Read from pipe
 char szBuf[1024];
 memset(szBuf, 0, sizeof(szBuf));
 ::ReadFile( hPipeReadII, szBuf, sizeof(szBuf), &dwDummy, NULL );
 // Don't leave till the spawned process goes end
// ::Sleep(2000);
 printf("had read...\n");
// ::WaitForSingleObject( ProcessInfo.hProcess, INFINITE );
 printf("%s\n", szBuf);

 return 0;
}

void Error( const char *szErrMsg )
{
 printf( "Error: %s\n", szErrMsg );
}

以下是一个Script Demo:

GO
    BEGIN
        1.0 0.0 500
    END
    BEGIN
        -1.0 0.0 500
    END
    REPEAT 4
        BEGIN
             0.0 1.0 500
        END
        BEGIN
             1.0 0.0 500
        END
        BEGIN
             0.0 -1.0 500
        END
        BEGIN
            -1.0 0.0 500
        END
    END
END

表示先左右移动一次，然后向下，向右，向上，向左呈矩形移动4次，通过设置速度分量可以实现任何路线的移动以及其他特征。
该脚本语言解释器采用了2个设计模式，Facade和Interpret模式，其中的解释器使用了几乎和任何设计模式书上介绍的一样的结构，很经典呐~

附上语言的文法定义:
program ::= GO command_list
command_list ::= command* END
command ::= begin_end_block | repeat
begin_end_block ::= BEGIN primitive END // Leaf Node on the Syntax tree
repeat ::= REPEAT INT command_list
primitive ::= SpeedX,SpeedY,Time // Recursive exit

// TestScript.txt
GO
  BEGIN
   1.0,0.0,500
  END
  BEGIN
   -1.0,0.0,500
  END
  REPEAT 4
   BEGIN
    0.0,1.0,500
   END
   BEGIN
    0.0,-1.0,500
   END
  END
END

// Execute result:

 while (*pp != 0) {
  printf("%s\n", *pp);
  ++pp;
 }

少的可怜，1个小时浪费了....