pipex_win32.c

   1 // pipex_win32.c
   2
   3 #ifdef _WIN32
   4
   5 // includes
   6
   7 #include <io.h>
   8 #include <fcntl.h>
   9 #include "pipex.h"
  10 #include "util.h"
  11
  12 // defines
  13
  14 #define ErrorBufferSize 4096
  15 #define dwMaxHandles      32
  16
  17 // variables
  18
  19 static char ErrorBuffer[ErrorBufferSize];
  20
  21 // prototypes
  22
  23 static bool pipex_eof_input(pipex_t *pipex);
  24 static void pipex_set_eof_input(pipex_t *pipex);
  25 static void pipex_set_active(pipex_t *pipex);
  26 static int  pipex_read_data(pipex_t *pipex);
  27 static void pipex_read_input(pipex_t *pipex);
  28
  29 // functions
  30
  31 // win32_error()
  32
  33 static char * win32_error(){
  34     FormatMessage(
  35         FORMAT_MESSAGE_FROM_SYSTEM,
  36         NULL,
  37         GetLastError(),
  38         LANG_USER_DEFAULT,
  39         ErrorBuffer,
  40         ErrorBufferSize,
  41         NULL);
  42     return ErrorBuffer;
  43 }
  44
  45 // TreadProc()
  46
  47 static DWORD WINAPI ThreadProc(LPVOID lpParam){
  48     pipex_t *p=(pipex_t *) lpParam;
  49     while(!pipex_eof_input(p)){
  50         if(p->nReadEnd<LINE_INPUT_MAX_CHAR-1){
  51             pipex_read_input(p);
  52         }else{
  53                 // wait until there is room in buffer
  54             Sleep(10);
  55         }
  56     }
  57     return 0;
  58 }
  59
  60 // pipex_open()
  61
  62 void pipex_open(pipex_t *pipex,
  63                 const char *szName,
  64                 const char *szWorkingDir,
  65                 const char *szProcFile) {
  66     DWORD dwMode, dwThreadId;
  67     HANDLE hStdinRead, hStdinWrite, hStdoutRead, hStdoutWrite, hThread;
  68     SECURITY_ATTRIBUTES sa;
  69     STARTUPINFO si;
  70     PROCESS_INFORMATION pi;
  71     int fdInput;
  72     char *szCurrentDir;
  73     pipex->state=0;
  74     pipex->name=szName;
  75     pipex->command=szProcFile;
  76     pipex->quit_pending=FALSE;
  77     pipex->hProcess=NULL;
  78     if (szProcFile == NULL) {
  79         pipex->hInput = GetStdHandle(STD_INPUT_HANDLE);
  80         pipex->hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  81         pipex->bConsole = GetConsoleMode(pipex->hInput, &dwMode);
  82         pipex->bPipe=FALSE;
  83     } else {
  84         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  85         sa.bInheritHandle = TRUE;
  86         sa.lpSecurityDescriptor = NULL;
  87         CreatePipe(&hStdinRead, &hStdinWrite, &sa, 0);
  88         CreatePipe(&hStdoutRead, &hStdoutWrite, &sa, 0);
  89         si.cb = sizeof(STARTUPINFO);
  90         si.lpReserved = si.lpDesktop = si.lpTitle = NULL;
  91         si.dwFlags = STARTF_USESTDHANDLES;
  92         si.cbReserved2 = 0;
  93         si.lpReserved2 = NULL;
  94         si.hStdInput = hStdinRead;
  95         si.hStdOutput = hStdoutWrite;
  96         si.hStdError = hStdoutWrite;
  97         if((szCurrentDir = (char*)_getcwd( NULL, 0 )) == NULL )
  98             my_fatal("pipex_open(): no current directory: %s\n",
  99                      strerror(errno));
 100         if(_chdir(szWorkingDir)){
 101             my_fatal("pipex_open(): %s: %s\n",
 102                      szWorkingDir,
 103                      strerror(errno));
 104         }
 105        if(CreateProcess(NULL,
 106                          (LPSTR) szProcFile,
 107                          NULL,
 108                          NULL,
 109                          TRUE,
 110                          DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
 111                          NULL,
 112                          NULL,
 113                          &si,
 114                          &pi)){
 115             pipex->hProcess=pi.hProcess;
 116             CloseHandle(pi.hThread);
 117             CloseHandle(hStdinRead);
 118             CloseHandle(hStdoutWrite);
 119             pipex->hInput = hStdoutRead;
 120             pipex->hOutput = hStdinWrite;
 121             pipex->bConsole = FALSE;
 122             pipex->bPipe=TRUE;
 123         }else{
 124           my_fatal("pipex_open(): %s: %s",szProcFile,win32_error());
 125         }
 126         _chdir(szCurrentDir);
 127     }
 128     if (pipex->bConsole) {
 129         SetConsoleMode(pipex->hInput,
 130                        dwMode & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
 131         FlushConsoleInputBuffer(pipex->hInput);
 132     }
 133     fdInput=_open_osfhandle((long) pipex->hInput,_O_RDONLY);
 134     if(fdInput==-1){
 135         my_fatal("pipex_open(): %s",strerror(errno));
 136     }
 137     pipex->fpInput=fdopen(fdInput,"r");
 138     if(pipex->fpInput==NULL){
 139         my_fatal("pipex_open(): %s",strerror(errno));
 140     }
 141     pipex->nReadEnd = 0;
 142     pipex->lpFeedEnd = NULL;
 143     InitializeCriticalSection(&(pipex->CriticalSection));
 144     pipex->hEvent=CreateEvent(NULL,           // default security
 145                        FALSE,          // auto reset
 146                        FALSE,          // not signaled
 147                        NULL            // nameless
 148                        );
 149     if(!(pipex->hEvent)){
 150         my_fatal("pipex_open(): %s",win32_error());
 151     }
 152     hThread=CreateThread(NULL,         // default security
 153                          0,            // default stacksize
 154                          ThreadProc,   // worker function
 155                          pipex,        // tell worker about ourselves
 156                          0,            // run immediately
 157                          &dwThreadId   // dropped, but needed for the call to work in Win9x
 158                          );
 159     if(!hThread){
 160         my_fatal("pipex_open(): %s",win32_error());
 161     }
 162     pipex->dwWriteIndex=0;
 163     pipex_set_active(pipex);
 164 }
 165
 166
 167 // pipex_wait_event(pipex)
 168
 169 void pipex_wait_event(pipex_t *pipex[]){
 170     HANDLE hHandles[dwMaxHandles];
 171     DWORD dwHandleCount=0;
 172     pipex_t *p;
 173     while((p=pipex[dwHandleCount])!=NULL){
 174         ASSERT((p->hEvent)!=0);
 175         if(dwHandleCount>=dwMaxHandles){
 176             my_fatal("pipex_wait_event(): Too many objects to wait for");
 177         }
 178         hHandles[dwHandleCount++]=p->hEvent;
 179     }
 180     WaitForMultipleObjects(dwHandleCount,   // count
 181                            hHandles,        //
 182                            FALSE,           // return if one object is signaled
 183                            INFINITE         // no timeout
 184                            );
 185 }
 186
 187 // pipex_send_eof()
 188
 189 void pipex_send_eof(pipex_t *pipex)  {
 190     my_log("Adapter->%s: EOF\n",pipex->name);
 191     CloseHandle(pipex->hOutput);
 192 }
 193
 194 // pipex_exit()
 195
 196 void pipex_exit(pipex_t *pipex) {
 197     DWORD lpexit;
 198     CloseHandle(pipex->hInput);
 199     CloseHandle(pipex->hOutput);
 200     if(!pipex->quit_pending){
 201       // suppress further errors
 202       pipex->quit_pending=TRUE;
 203       my_fatal("pipex_exit(): %s: child exited unexpectedly.\n",pipex->command);
 204     }
 205     if(GetExitCodeProcess(pipex->hProcess,&lpexit)){
 206         if(lpexit==STILL_ACTIVE)
 207                 //must be java,hammer it down!
 208             TerminateProcess(pipex->hProcess,lpexit);
 209     }
 210         CloseHandle(pipex->hProcess);
 211 }
 212
 213 // pipex_eof_input()
 214
 215 static bool pipex_eof_input(pipex_t *pipex){
 216     int ret;
 217     EnterCriticalSection(&(pipex->CriticalSection));
 218     ret=(pipex->state)&PIPEX_EOF;
 219     LeaveCriticalSection(&(pipex->CriticalSection));
 220     return ret;
 221 }
 222
 223 // pipex_set_eof_input()
 224
 225 static void pipex_set_eof_input(pipex_t *pipex){
 226     EnterCriticalSection(&(pipex->CriticalSection));
 227     (pipex->state)|=PIPEX_EOF;
 228     LeaveCriticalSection(&(pipex->CriticalSection));
 229  }
 230
 231 // pipex_active()
 232
 233 /*
 234  * This function returns TRUE if and only if the pipes have succesfully
 235  * been created and the client has been started.
 236  *
 237  */
 238
 239 bool pipex_active(pipex_t *pipex){
 240     int ret;
 241     EnterCriticalSection(&(pipex->CriticalSection));
 242     ret=(pipex->state)&PIPEX_ACTIVE;
 243     LeaveCriticalSection(&(pipex->CriticalSection));
 244     return ret;
 245 }
 246
 247 // pipex_set_active()
 248
 249 static void pipex_set_active(pipex_t *pipex){
 250     EnterCriticalSection(&(pipex->CriticalSection));
 251     (pipex->state)|=PIPEX_ACTIVE;
 252     LeaveCriticalSection(&(pipex->CriticalSection));
 253 }
 254
 255 // pipex_read_data()
 256
 257 static int pipex_read_data(pipex_t *pipex){
 258     DWORD dwBytes;
 259     char * ret;
 260         // No protection. Access to nReadEnd is atomic.
 261         // It is not a problem that nReadEnd becomes smaller after the call.
 262         // This just means we have read less than we could have.
 263     ret=fgets(pipex->lpReadBuffer,
 264               LINE_INPUT_MAX_CHAR-(pipex->nReadEnd),
 265               pipex->fpInput);
 266     if(!ret){
 267         pipex_set_eof_input(pipex);
 268         (pipex->lpReadBuffer)[0]='\0';
 269         return 0;
 270     }
 271     dwBytes=strlen(pipex->lpReadBuffer);
 272     (pipex->lpReadBuffer)[dwBytes]='\0';
 273     return dwBytes;
 274 }
 275
 276 // pipex_read_input()
 277
 278 static void pipex_read_input(pipex_t *pipex) {
 279   int ret;
 280   BOOL bSetEvent=FALSE;
 281       // ReadData is outside the critical section otherwise everything
 282       // would block during the blocking read
 283   ret=pipex_read_data(pipex);
 284   EnterCriticalSection(&(pipex->CriticalSection));
 285   if(!pipex_eof_input(pipex)){
 286       if(ret+(pipex->nReadEnd)>=LINE_INPUT_MAX_CHAR){
 287           my_fatal("pipex_read_input(): Internal error: buffer overflow\n");
 288       }
 289       memcpy((pipex->lpBuffer)+(pipex->nReadEnd),(pipex->lpReadBuffer),ret+1);
 290       (pipex->nReadEnd) += ret;
 291       if(!(pipex->lpFeedEnd)){
 292           (pipex->lpFeedEnd) =
 293               (char *) memchr(pipex->lpBuffer,'\n',pipex->nReadEnd);
 294       }
 295       if(pipex->lpFeedEnd){
 296           bSetEvent=TRUE;
 297       }else if((pipex->nReadEnd)>=LINE_INPUT_MAX_CHAR-1){
 298           my_fatal("pipex_read_input(): LINE_INPUT_MAX_CHAR is equal to %d which is too small to contain a full line of engine output or GUI input.\n",LINE_INPUT_MAX_CHAR);
 299       }
 300   }
 301   LeaveCriticalSection(&(pipex->CriticalSection));
 302   if(pipex_eof_input(pipex) || bSetEvent){
 303       SetEvent(pipex->hEvent);
 304   }
 305 }
 306
 307 // pipex_eof()
 308
 309 /*
 310  * This function returns TRUE if and only if the input buffer does not
 311  * contain a full line of data and EOF was encountered by
 312  * the working thread.
 313  *
 314  */
 315
 316 bool pipex_eof(pipex_t *pipex){
 317   int ret;
 318   EnterCriticalSection(&(pipex->CriticalSection));
 319   if((pipex->lpFeedEnd) != NULL){
 320     ret=FALSE;
 321   }else if(pipex_eof_input(pipex)){
 322     ret=TRUE;
 323   }else{
 324     ret=FALSE;
 325   }
 326   LeaveCriticalSection(&(pipex->CriticalSection));
 327   return ret;
 328 }
 329
 330 // pipex_readln_nb()
 331
 332 /*
 333  * This function returns FALSE if and only if the asynchronously filled
 334  * input buffer does not contain a full line of data.
 335  * In other words it operates in non-blocking mode.
 336  *
 337  */
 338
 339 bool pipex_readln_nb(pipex_t *pipex, char *szLineStr) {
 340   int nFeedEnd;
 341   int ret;
 342   int src, dst;
 343   char c;
 344   EnterCriticalSection(&(pipex->CriticalSection));
 345   if ((pipex->lpFeedEnd) == NULL) {
 346     ret=FALSE;
 347   } else {
 348     nFeedEnd = pipex->lpFeedEnd - pipex->lpBuffer;
 349     memcpy(szLineStr, pipex->lpBuffer, nFeedEnd+1);
 350     szLineStr[nFeedEnd] = '\0';
 351
 352         // temp hack: stolen from util.c
 353         // remove CRs and LFs
 354     src = 0;
 355     dst = 0;
 356     while ((c=szLineStr[src++]) != '\0') {
 357         if (c != '\r' && c != '\n') szLineStr[dst++] = c;
 358     }
 359     szLineStr[dst] = '\0';
 360     ASSERT(strchr(szLineStr,'\n')==NULL)
 361     ASSERT(strchr(szLineStr,'\r')==NULL)
 362
 363     nFeedEnd ++;
 364     pipex->nReadEnd -= nFeedEnd;
 365     memcpy(pipex->lpBuffer, pipex->lpBuffer + nFeedEnd, pipex->nReadEnd+1);
 366     pipex->lpFeedEnd =
 367         (char *) memchr(pipex->lpBuffer, '\n', pipex->nReadEnd);
 368     ret=TRUE;
 369   }
 370   LeaveCriticalSection(&(pipex->CriticalSection));
 371   if(ret){
 372       my_log("%s->Adapter: %s\n",pipex->name,szLineStr);
 373   }
 374   return ret;
 375 }
 376
 377 // pipex_readln()
 378
 379 /*
 380  * This function returns FALSE if and only if EOF has been encountered by
 381  * the working thread and no full line of data is present in the input buffer.
 382  *
 383  * If there is a full line of data present in the input buffer it returns
 384  * TRUE.
 385  *
 386  * If none of these conditions is satisfied it blocks.
 387  *
 388  * As the name say this function is strictly for line input.
 389  * An incomplete line of data (i.e. not ending with \n) is lost when EOF
 390  * is encountered.
 391  *
 392  */
 393
 394 bool pipex_readln(pipex_t *pipex, char *szLineStr) {
 395   while(!pipex_eof(pipex)){
 396       if (pipex_readln_nb(pipex,szLineStr)) {
 397           return TRUE;
 398       }else{
 399           WaitForSingleObject(pipex->hEvent,INFINITE);
 400       }
 401   }
 402   my_log("%s->Adapter: EOF\n",pipex->name);
 403   szLineStr[0]='\0';
 404   return FALSE;
 405 }
 406
 407 //  GetWin32Priority()
 408
 409 static DWORD GetWin32Priority(int nice)
 410 {
 411 /*
 412 REALTIME_PRIORITY_CLASS     0x00000100
 413 HIGH_PRIORITY_CLASS         0x00000080
 414 ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
 415 NORMAL_PRIORITY_CLASS       0x00000020
 416 BELOW_NORMAL_PRIORITY_CLASS 0x00004000
 417 IDLE_PRIORITY_CLASS         0x00000040
 418 */
 419         if (nice < -15) return 0x00000080;
 420         if (nice < 0)   return 0x00008000;
 421         if (nice == 0)  return 0x00000020;
 422         if (nice < 15)  return 0x00004000;
 423         return 0x00000040;
 424 }
 425
 426 // pipex_set_priority()
 427
 428 void pipex_set_priority(pipex_t *pipex, int value){
 429     if(pipex->hProcess){
 430         if(!SetPriorityClass(pipex->hProcess,
 431                              GetWin32Priority(value))){
 432             my_log("POLYGLOT Unable to change priority\n");
 433         }
 434     }
 435 }
 436
 437 // pipex_set_affinit()
 438
 439 typedef void (WINAPI *SPAM)(HANDLE, int);
 440 void pipex_set_affinity(pipex_t *pipex, int value){
 441     SPAM pSPAM;
 442
 443     if(pipex->hProcess) return;
 444     if(value==-1) return;
 445
 446     pSPAM = (SPAM) GetProcAddress(
 447         GetModuleHandle(TEXT("kernel32.dll")),
 448         "SetProcessAffinityMask");
 449     if(NULL != pSPAM){
 450             // [HGM] avoid crash on Win95 by first checking if API call exists
 451         pSPAM(pipex->hProcess,value);
 452     }else{
 453         my_log("POLYGLOT API call \"SetProcessAffinityMask\" not available\n");
 454     }
 455 }
 456
 457 // pipex_write()
 458
 459 void pipex_write(pipex_t *pipex, const char *szLineStr) {
 460     int size,written;
 461     size=sizeof(pipex->szWriteBuffer)-pipex->dwWriteIndex;
 462     written=snprintf(pipex->szWriteBuffer + pipex->dwWriteIndex,
 463                      size,
 464                      "%s",
 465                      szLineStr);
 466         // snprintf returns how many bytes should have been written
 467         // (not including the trailing zero)
 468         // old versions of glibc and msvcrt return -1 in
 469         // case of truncated output.
 470     if(written>=size || written<0){
 471         my_fatal("engine_send(): write_buffer overflow\n");
 472     }
 473     pipex->dwWriteIndex+=written;
 474
 475 }
 476
 477
 478 // pipex_writeln()
 479
 480 void pipex_writeln(pipex_t *pipex, const char *szLineStr) {
 481   DWORD dwBytes;
 482   DWORD dwLengthWriteBuffer;
 483   pipex_write(pipex, szLineStr);
 484   my_log("Adapter->%s: %s\n",pipex->name,pipex->szWriteBuffer);
 485   if(pipex->bPipe){
 486       dwLengthWriteBuffer = strlen(pipex->szWriteBuffer);
 487       if(dwLengthWriteBuffer>=sizeof(pipex->szWriteBuffer)-3){
 488           my_fatal("pipex_writeln(): write buffer overflow\n");
 489       }
 490       pipex->szWriteBuffer[dwLengthWriteBuffer] = '\r';
 491       pipex->szWriteBuffer[dwLengthWriteBuffer + 1] = '\n';
 492           // for easy debugging
 493       pipex->szWriteBuffer[dwLengthWriteBuffer + 2] = '\0';
 494       WriteFile(pipex->hOutput, pipex->szWriteBuffer,
 495                 dwLengthWriteBuffer + 2,
 496                 &dwBytes, NULL);
 497   }else{
 498       printf("%s\n",pipex->szWriteBuffer);
 499       fflush(stdout);
 500   }
 501   pipex->dwWriteIndex = 0;
 502 }
 503 #endif