TT プログラマ記

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <io.h>
#include <dos.h>
#include <string.h>

#include "config.h"

#include <windows.h>

#include "nnstring.h"
#include "nnvector.h"
#include "nnhash.h"
#include "writer.h"
#include "nndir.h"
#include "shell.h"

#define DUP_STD_HANDLE( type, n ) DuplicateHandle( GetCurrentProcess(),\
                                                   GetStdHandle( type ),\
                                                   GetCurrentProcess(),\
                                                   n, 0, TRUE,\
                                                   DUPLICATE_SAME_ACCESS )
#define SET_INHERIT_FLAG( handle, flag ) DuplicateHandle( GetCurrentProcess(),\
                                                          handle,\
                                                          GetCurrentProcess(),\
                                                          NULL, 0, flag,\
                                                          DUPLICATE_SAME_ACCESS )


enum{
  TOO_LONG_COMMANDLINE = -3  ,
  MAX_COMMANDLINE_SIZE = 127 ,
};

static HANDLE mySpawn( const NnString &execstr, HANDLE input, HANDLE output, HANDLE error_out )
{
  char* _tmp = (char*)malloc( sizeof( char* ) * strlen( execstr.chars() ) + 1 );
  strcpy( _tmp, execstr.chars() );

  STARTUPINFO info ={0};
  info.cb = sizeof( info );
  info.dwFlags = STARTF_USESTDHANDLES;
  info.hStdInput  = input;
  info.hStdOutput = output;
  info.hStdError  = error_out;

  PROCESS_INFORMATION proc = {0};

  if ( CreateProcess( NULL, _tmp, NULL, NULL, TRUE,
                      0, NULL, NULL, &info, &proc ) ) {
    CloseHandle( proc.hThread );
  }
  else {
    proc.hProcess = INVALID_HANDLE_VALUE;
  }
  free( _tmp );
  return proc.hProcess;
}

static void parseRedirect( const char*& cmdline, HANDLE& h )
{
  const char *mode="w";
  if( *cmdline == '>' ) {
    mode = "a";
    ++cmdline;
  }
  NnString path;
  NyadosShell::readNextWord( cmdline , path );
  h = (HANDLE)_get_osfhandle( NnDir::open( path.chars(), mode ) );
  if ( h == INVALID_HANDLE_VALUE ) {
    conErr << path << ": can't open.\n";
  }
}

static void after_lessthan( const char *&sp , HANDLE& h )
{
  if( sp[0] == '&'  &&  isdigit(sp[1]) ){
    /* n>&m */
    DuplicateHandle( GetCurrentProcess(),
                     (HANDLE)_get_osfhandle( sp[1] - '0' ),
                     GetCurrentProcess(),
                     &h, TRUE, 0, DUPLICATE_SAME_ACCESS );
    sp += 2;
  }
  else if( sp[0] == '&' && sp[1] == '-' ) {
    /* n>&- */
    h = (HANDLE)_get_osfhandle( NnDir::open( "nul", "w" ) );
  }
  else {
    /* n> ファイル名 */
    parseRedirect( sp, h );
  }
}


static HANDLE do_one_command( HANDLE input, HANDLE output, const char* cmdline ) {
  NnString execstr;
  HANDLE error_out;

  class HandleCloser {
  private:
    HANDLE _h;
  public:
    HandleCloser() : _h( INVALID_HANDLE_VALUE ) {}
    HandleCloser( HANDLE h ) : _h( h ) {}
    ~HandleCloser() { this->close(); }
    void set( HANDLE h ) {
      this->close();
      _h = h;
    }
    void close() {
      if ( _h != INVALID_HANDLE_VALUE ) {
        CloseHandle( _h );
        _h = INVALID_HANDLE_VALUE;
      }
    }
  };
  HandleCloser input_closer;
  HandleCloser output_closer;
  HandleCloser error_closer( error_out );

  DUP_STD_HANDLE( STD_ERROR_HANDLE, &error_out );
  SET_INHERIT_FLAG( error_out, TRUE );

  int quote = 0;
  while( *cmdline != '\0' ) {
    if( *cmdline == '"' ) {
      quote ^= 1;
    }

    if( quote==0 && cmdline[0]=='<' ) {
      ++cmdline;
      NnString path;
      NyadosShell::readNextWord( cmdline , path );
      input = (HANDLE)_get_osfhandle( NnDir::open( path.chars(), "r" ) );
      if ( input == INVALID_HANDLE_VALUE ) {
        conErr << path << ": can't open.\n";
      }
      SET_INHERIT_FLAG( input, TRUE );
      input_closer.set( input );
    }
    else if( quote==0 && cmdline[0]=='>' ) {
      ++cmdline;
      parseRedirect( cmdline, output );
      output_closer.set( output );
    }
    else if( quote==0 && cmdline[0]=='1' && cmdline[1]=='>' ) {
      cmdline += 2;
      after_lessthan( cmdline, output );
      output_closer.set( output );
    }
    else if( quote==0 && cmdline[0]=='2' && cmdline[1]=='>' ) {
      cmdline += 2;
      after_lessthan( cmdline , error_out );
      error_closer.set( output );
    }
    else {
      execstr << *cmdline++;
    }
  }
  return mySpawn( execstr, input, output, error_out );
}


int mySystem( const char *cmdline )
{
  if ( cmdline[0] == '\0' ) {
    return 0;
  }

  /*
  NnString *mode = (NnString*)properties.get( "standalone" );
  if ( mode == NULL || mode->length() <= 0 ) {
    errno = 0;
    int rc = system( cmdline );
    if ( errno != 0 ) {
      perror( SHELL_NAME );
      return -1;
    }
    return rc;
  }
   */

  NnVector pipeSet;
  { // devidePipes
    NnString one,left( cmdline );
    while( left.splitTo(one,left,"|") , !one.empty() ) {
      while ( one.chars()[0] == ' ' || one.chars()[0] == '\t' ) {
        one.shift();
      }
      pipeSet.append( one.clone() );
    }
  }

  HANDLE prev_pipe_read;
  HANDLE next_pipe_write;

  DUP_STD_HANDLE( STD_INPUT_HANDLE, &prev_pipe_read );

  int result;
  
  for ( int i = 0; i < pipeSet.size(); ++i ) {
    if( i < pipeSet.size() - 1 ) {
      /* パイプラインの末尾でないコマンドの場合、
       * 標準出力の先を、パイプの一方にする必要がある
       */
      HANDLE next_pipe_read;
      SECURITY_ATTRIBUTES sa;
      sa.nLength = sizeof( sa );
      sa.lpSecurityDescriptor = NULL;
      sa.bInheritHandle = TRUE;
      CreatePipe( &next_pipe_read, &next_pipe_write, &sa, 0 );
      SET_INHERIT_FLAG( next_pipe_read, FALSE );
      SET_INHERIT_FLAG( prev_pipe_read, TRUE );
      do_one_command( prev_pipe_read,
                      next_pipe_write,
                      ((NnString*)pipeSet.at( i ))->chars() );
      CloseHandle( prev_pipe_read );
      CloseHandle( next_pipe_write );
      prev_pipe_read = next_pipe_read;
    }
    else {
      DUP_STD_HANDLE( STD_OUTPUT_HANDLE, &next_pipe_write );
      SET_INHERIT_FLAG( prev_pipe_read, TRUE );
      HANDLE last_proc = do_one_command( prev_pipe_read,
                                         next_pipe_write,
                                         ((NnString*)pipeSet.at( i ))->chars() );
      CloseHandle( prev_pipe_read );
      CloseHandle( next_pipe_write );

      if ( last_proc != INVALID_HANDLE_VALUE ) {
        WaitForSingleObject( last_proc, INFINITE );
        GetExitCodeProcess( last_proc, (unsigned long*)&result );
      }
      else {
        result = -1;
      }

      if( result < 0 ) {
        if( ((NnString*)pipeSet.at(i))->length() > 110 ){
          conErr << "Too long command line,"
            " or bad command or file name.\n";
        }
        else {
          conErr << "Bad command or file name.\n";
        }
      }
    }
  }
  return result;
}