libfcgi/fcgi_stdio.c

   1 /*
   2  * fcgi_stdio.c --
   3  *
   4  *      FastCGI-stdio compatibility package
   5  *
   6  *
   7  * Copyright (c) 1996 Open Market, Inc.
   8  *
   9  * See the file "LICENSE.TERMS" for information on usage and redistribution
  10  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  11  *
  12  */
  13
  14 #ifndef lint
  15 static const char rcsid[] = "$Id: fcgi_stdio.c,v 1.1 1997/09/16 15:36:33 stanleyg Exp $";
  16 #endif /* not lint */
  17
  18 #ifdef _WIN32
  19 #define DLLAPI  __declspec(dllexport)
  20 #endif
  21
  22 #define NO_FCGI_DEFINES
  23 #include "fcgi_stdio.h"
  24 #undef NO_FCGI_DEFINES
  25
  26 #ifdef _WIN32
  27 #include <windows.h>
  28 #endif
  29 #include <errno.h>
  30     /* for errno */
  31 #include <stdarg.h>
  32     /* for va_arg */
  33 #include <stdlib.h>
  34     /* for malloc */
  35 #include <string.h>
  36     /* for strerror */
  37 #ifdef HAVE_UNISTD_H
  38 #include <unistd.h>
  39 #endif
  40
  41 #include "fcgiapp.h"
  42 #include "fcgios.h"
  43
  44 #ifndef FALSE
  45 #define FALSE (0)
  46 #endif
  47 #ifndef TRUE
  48 #define TRUE  (1)
  49 #endif
  50
  51 #ifdef _WIN32
  52 FCGI_FILE _fcgi_sF[3];
  53 #else
  54 FCGI_FILE _fcgi_sF[3] = {{stdin, NULL}, {stdout, NULL}, {stderr, NULL}};
  55 #endif
  56
  57 #ifdef _WIN32
  58 #define popen _popen
  59 #endif
  60 \f
  61 /*
  62  *----------------------------------------------------------------------
  63  *
  64  * FCGI_Accept --
  65  *
  66  *      Accepts a new request from the HTTP server and creates
  67  *      a conventional execution environment for the request.
  68  *
  69  *      If the application was invoked as a FastCGI server,
  70  *      the first call to FCGI_Accept indicates that the application
  71  *      has completed its initialization and is ready to accept
  72  *      a request.  Subsequent calls to FCGI_Accept indicate that
  73  *      the application has completed its processing of the
  74  *      current request and is ready to accept a new request.
  75  *
  76  *      If the application was invoked as a CGI program, the first
  77  *      call to FCGI_Accept is essentially a no-op and the second
  78  *      call returns EOF (-1).
  79  *
  80  * Results:
  81  *    0 for successful call, -1 for error (application should exit).
  82  *
  83  * Side effects:
  84  *      If the application was invoked as a FastCGI server,
  85  *      and this is not the first call to this procedure,
  86  *      FCGI_Accept first performs the equivalent of FCGI_Finish.
  87  *
  88  *      On every call, FCGI_Accept accepts the new request and
  89  *      reads the FCGI_PARAMS stream into an environment array,
  90  *      i.e. a NULL-terminated array of strings of the form
  91  *      ``name=value''.  It assigns a pointer to this array
  92  *      to the global variable environ, used by the standard
  93  *      library function getenv.  It creates new FCGI_FILE *s
  94  *      representing input from the HTTP server, output to the HTTP
  95  *      server, and error output to the HTTP server, and assigns these
  96  *      new files to stdin, stdout, and stderr respectively.
  97  *
  98  *      DO NOT mutate or retain pointers to environ or any values
  99  *      contained in it (e.g. to the result of calling getenv(3)),
 100  *      since these are freed by the next call to FCGI_Finish or
 101  *      FCGI_Accept.  In particular do not use setenv(3) or putenv(3)
 102  *      in conjunction with FCGI_Accept.
 103  *
 104  *----------------------------------------------------------------------
 105  */
 106 static int acceptCalled = FALSE;
 107 static int isCGI = FALSE;
 108 #ifndef _WIN32
 109 extern char **environ;
 110 #endif
 111
 112 int FCGI_Accept(void)
 113 {
 114     if(!acceptCalled) {
 115         /*
 116          * First call to FCGI_Accept.  Is application running
 117          * as FastCGI or as CGI?
 118          */
 119         isCGI = FCGX_IsCGI();
 120         acceptCalled = TRUE;
 121     } else if(isCGI) {
 122         /*
 123          * Not first call to FCGI_Accept and running as CGI means
 124          * application is done.
 125          */
 126         return(EOF);
 127     }
 128     if(isCGI) {
 129         FCGI_stdin->stdio_stream = stdin;
 130         FCGI_stdin->fcgx_stream = NULL;
 131         FCGI_stdout->stdio_stream = stdout;
 132         FCGI_stdout->fcgx_stream = NULL;
 133         FCGI_stderr->stdio_stream = stderr;
 134         FCGI_stderr->fcgx_stream = NULL;
 135     } else {
 136         FCGX_Stream *in, *out, *error;
 137         FCGX_ParamArray envp;
 138         int acceptResult = FCGX_Accept(&in, &out, &error, &envp);
 139         if(acceptResult < 0) {
 140             return acceptResult;
 141         }
 142         FCGI_stdin->stdio_stream = NULL;
 143         FCGI_stdin->fcgx_stream = in;
 144         FCGI_stdout->stdio_stream = NULL;
 145         FCGI_stdout->fcgx_stream = out;
 146         FCGI_stderr->stdio_stream = NULL;
 147         FCGI_stderr->fcgx_stream = error;
 148         environ = envp;
 149     }
 150     return 0;
 151 }
 152 \f
 153 /*
 154  *----------------------------------------------------------------------
 155  *
 156  * FCGI_Finish --
 157  *
 158  *      Finishes the current request from the HTTP server.
 159  *
 160  * Side effects:
 161  *
 162  *      Flushes any buffered output to the HTTP server.  Then frees
 163  *      all storage allocated by the previous call, including all
 164  *      storage reachable from the value of environ set by the previous
 165  *      call to FCGI_Accept.
 166  *
 167  *      DO NOT use stdin, stdout, stderr, or environ between calling
 168  *      FCGI_Finish and calling FCGI_Accept.
 169  *
 170  *      DO NOT mutate or retain pointers to environ or any values
 171  *      contained in it (e.g. to the result of calling getenv(3)),
 172  *      since these are freed by the next call to FCGI_Finish or
 173  *      FCGI_Accept.  In particular do not use setenv(3) or putenv(3)
 174  *      in conjunction with FCGI_Accept.
 175  *
 176  *----------------------------------------------------------------------
 177  */
 178 void FCGI_Finish(void)
 179 {
 180     if(!acceptCalled || isCGI) {
 181         return;
 182     }
 183     FCGX_Finish();
 184     FCGI_stdin->fcgx_stream = NULL;
 185     FCGI_stdout->fcgx_stream = NULL;
 186     FCGI_stderr->fcgx_stream = NULL;
 187     environ = NULL;
 188 }
 189 \f
 190 /*
 191  *----------------------------------------------------------------------
 192  *
 193  * FCGI_StartFilterData --
 194  *
 195  *
 196  *      The current request is for the filter role, and stdin is
 197  *      positioned at EOF of FCGI_STDIN.  The call repositions
 198  *      stdin to the start of FCGI_DATA.
 199  *      If the preconditions are not met (e.g. FCGI_STDIN has not
 200  *      been read to EOF), the call sets the stream error code to
 201  *      FCGX_CALL_SEQ_ERROR.
 202  *
 203  * Results:
 204  *      0 for a normal return, < 0 for error
 205  *
 206  *----------------------------------------------------------------------
 207  */
 208
 209 int FCGI_StartFilterData(void)
 210 {
 211     if(FCGI_stdin->stdio_stream) {
 212         return -1;
 213     } else {
 214         return FCGX_StartFilterData(FCGI_stdin->fcgx_stream);
 215     }
 216 }
 217 \f
 218 /*
 219  *----------------------------------------------------------------------
 220  *
 221  * FCGI_SetExitStatus --
 222  *
 223  *      Sets the exit status for the current request. The exit status
 224  *      is the status code the request would have exited with, had
 225  *      the request been run as a CGI program.  You can call
 226  *      FCGI_SetExitStatus several times during a request; the last call
 227  *      before the request ends (by calling FCGI_Accept) determines the
 228  *      value.
 229  *
 230  *----------------------------------------------------------------------
 231  */
 232
 233 void FCGI_SetExitStatus(int status)
 234 {
 235     if(FCGI_stdin->fcgx_stream) {
 236         FCGX_SetExitStatus(status, FCGI_stdin->fcgx_stream);
 237     }
 238 }
 239 \f
 240 /*
 241  *----------------------------------------------------------------------
 242  *
 243  * FCGI_perror --
 244  *
 245  *       Wrapper for function defined in H&S Section 11.2
 246  *
 247  *----------------------------------------------------------------------
 248  */
 249
 250 void FCGI_perror(const char *str)
 251 {
 252     FCGI_fputs(str, FCGI_stderr);
 253     FCGI_fputs(": ", FCGI_stderr);
 254     FCGI_fputs(strerror(OS_Errno), FCGI_stderr);
 255     return;
 256 }
 257 \f
 258 /*
 259  *----------------------------------------------------------------------
 260  *
 261  * FCGI_OpenFromFILE --
 262  *
 263  *      Constructs a new FCGI_FILE * from the FILE *stream.
 264  *
 265  * Results:
 266  *      NULL if stream == NULL or storage could not be allocated,
 267  *      otherwise the new FCGI_FILE *.
 268  *
 269  *----------------------------------------------------------------------
 270  */
 271
 272 static FCGI_FILE *FCGI_OpenFromFILE(FILE *stream)
 273 {
 274     FCGI_FILE *fp;
 275     if(stream == NULL)
 276         return NULL;
 277     fp = malloc(sizeof(FCGI_FILE));
 278     if(fp == NULL)
 279         return NULL;
 280     fp->stdio_stream = stream;
 281     fp->fcgx_stream = NULL;
 282     return fp;
 283 }
 284 \f
 285 /*
 286  *----------------------------------------------------------------------
 287  *
 288  * FCGI_fopen, FCGI_fclose, FCGI_fflush, FCGI_freopen --
 289  *
 290  *       Wrappers for functions defined in H&S Section 15.2
 291  *
 292  *----------------------------------------------------------------------
 293  */
 294
 295 FCGI_FILE *FCGI_fopen(const char *path, const char *mode)
 296 {
 297     return FCGI_OpenFromFILE(fopen(path, mode));
 298 }
 299
 300 int FCGI_fclose(FCGI_FILE *fp)
 301 {
 302     int n = EOF;
 303     if(fp->stdio_stream) {
 304         n = fclose(fp->stdio_stream);
 305         fp->stdio_stream = NULL;
 306     } else if(fp->fcgx_stream) {
 307         n = FCGX_FClose(fp->fcgx_stream);
 308         fp->fcgx_stream = NULL;
 309     }
 310     if((fp != FCGI_stdin) && (fp != FCGI_stdout) && (fp != FCGI_stderr)) {
 311         free(fp);
 312     }
 313     return n;
 314 }
 315
 316 int FCGI_fflush(FCGI_FILE *fp)
 317 {
 318     if(fp->stdio_stream)
 319         return fflush(fp->stdio_stream);
 320     else if(fp->fcgx_stream)
 321         return FCGX_FFlush(fp->fcgx_stream);
 322     return EOF;
 323 }
 324
 325 FCGI_FILE *FCGI_freopen(const char *path, const char *mode,
 326                         FCGI_FILE *fp)
 327 {
 328     if(fp->stdio_stream) {
 329         if(freopen(path, mode, fp->stdio_stream) == NULL)
 330             return NULL;
 331         else
 332             return fp;
 333     } else if(fp->fcgx_stream) {
 334         (void) FCGX_FClose(fp->fcgx_stream);
 335         fp->stdio_stream = fopen(path, mode);
 336         if(fp->stdio_stream == NULL)
 337             return NULL;
 338         else {
 339             fp->fcgx_stream = NULL;
 340             return fp;
 341         }
 342     }
 343     return NULL;
 344 }
 345 \f
 346 /*
 347  *----------------------------------------------------------------------
 348  *
 349  * FCGI_setvbuf, FCGI_setbuf --
 350  *
 351  *       Wrappers for functions defined in H&S Section 15.3
 352  *
 353  *----------------------------------------------------------------------
 354  */
 355 int FCGI_setvbuf(FCGI_FILE *fp, char *buf, int bufmode, size_t size)
 356 {
 357     if(fp->stdio_stream)
 358         return setvbuf(fp->stdio_stream, buf, bufmode, size);
 359     else {
 360         return -1;
 361     }
 362 }
 363
 364 void FCGI_setbuf(FCGI_FILE *fp, char *buf)
 365 {
 366     if(fp->stdio_stream)
 367         setbuf(fp->stdio_stream, buf);
 368 }
 369 \f
 370 /*
 371  *----------------------------------------------------------------------
 372  *
 373  * FCGI_fseek, FCGI_ftell, FCGI_rewind, FCGI_fgetpos, FCGI_fsetpos --
 374  *
 375  *       Wrappers for functions defined in H&S Section 15.5
 376  *
 377  *----------------------------------------------------------------------
 378  */
 379
 380 int FCGI_fseek(FCGI_FILE *fp, long offset, int whence)
 381 {
 382     if(fp->stdio_stream)
 383         return fseek(fp->stdio_stream, offset, whence);
 384     else {
 385         OS_SetErrno(ESPIPE);
 386         return -1;
 387     }
 388 }
 389
 390 int FCGI_ftell(FCGI_FILE *fp)
 391 {
 392     if(fp->stdio_stream)
 393         return ftell(fp->stdio_stream);
 394     else {
 395         OS_SetErrno(ESPIPE);
 396         return -1;
 397     }
 398 }
 399
 400 void FCGI_rewind(FCGI_FILE *fp)
 401 {
 402     if(fp->stdio_stream)
 403         rewind(fp->stdio_stream);
 404     else
 405         OS_SetErrno(ESPIPE);
 406 }
 407
 408 #ifdef HAVE_FPOS
 409 int FCGI_fgetpos(FCGI_FILE *fp, fpos_t *pos)
 410 {
 411     if(fp->stdio_stream)
 412         return fgetpos(fp->stdio_stream, pos);
 413     else {
 414         OS_SetErrno(ESPIPE);
 415         return -1;
 416     }
 417 }
 418
 419 int FCGI_fsetpos(FCGI_FILE *fp, const fpos_t *pos)
 420 {
 421     if(fp->stdio_stream)
 422         return fsetpos(fp->stdio_stream, pos);
 423     else {
 424         OS_SetErrno(ESPIPE);
 425         return -1;
 426     }
 427 }
 428 #endif
 429 \f
 430 /*
 431  *----------------------------------------------------------------------
 432  *
 433  * FCGI_fgetc, FCGI_getchar, FCGI_ungetc --
 434  *
 435  *       Wrappers for functions defined in H&S Section 15.6
 436  *
 437  *       XXX: getc and getchar are generally defined as macros
 438  *            for performance reasons
 439  *
 440  *----------------------------------------------------------------------
 441  */
 442
 443 int FCGI_fgetc(FCGI_FILE *fp)
 444 {
 445     if(fp->stdio_stream)
 446         return fgetc(fp->stdio_stream);
 447     else if(fp->fcgx_stream)
 448         return FCGX_GetChar(fp->fcgx_stream);
 449     return EOF;
 450 }
 451
 452 int FCGI_getchar(void)
 453 {
 454     return FCGI_fgetc(FCGI_stdin);
 455 }
 456
 457 int FCGI_ungetc(int c, FCGI_FILE *fp)
 458 {
 459     if(fp->stdio_stream)
 460         return ungetc(c, fp->stdio_stream);
 461     else if(fp->fcgx_stream)
 462         return FCGX_UnGetChar(c, fp->fcgx_stream);
 463     return EOF;
 464 }
 465 \f
 466 /*
 467  *----------------------------------------------------------------------
 468  *
 469  * FCGI_fgets, FCGI_gets --
 470  *
 471  *       Wrappers for functions defined in H&S Section 15.7
 472  *
 473  *----------------------------------------------------------------------
 474  */
 475
 476 char *FCGI_fgets(char *str, int size, FCGI_FILE *fp)
 477 {
 478     if(fp->stdio_stream)
 479         return fgets(str, size, fp->stdio_stream);
 480     else if(fp->fcgx_stream)
 481         return FCGX_GetLine(str, size, fp->fcgx_stream);
 482     return NULL;
 483 }
 484
 485 /*
 486  * There is no standard equivalent of gets that takes an explicit
 487  * FILE * argument, so the following "wrapper" implements
 488  * gets for both FILE * and FCGX_Stream * in terms of FCGI_getchar.
 489  */
 490
 491 char *FCGI_gets(char *str)
 492 {
 493     char *s;
 494     int c;
 495     for (s = str; ((c = FCGI_getchar()) != '\n');) {
 496         if(c == EOF) {
 497             if(s == str)
 498                 return NULL;
 499             else
 500                 break;
 501         } else
 502             *s++ = c;
 503     }
 504     *s = 0;
 505     return str;
 506 }
 507 \f
 508 /*
 509  *----------------------------------------------------------------------
 510  *
 511  * --
 512  *
 513  *       Wrappers for functions defined in H&S Section 15.8
 514  *
 515  *       XXX: missing: fscanf, scanf
 516  *
 517  *----------------------------------------------------------------------
 518  */
 519
 520 \f
 521 /*
 522  *----------------------------------------------------------------------
 523  *
 524  * FCGI_fputc, FCGI_putchar --
 525  *
 526  *       Wrappers for functions defined in H&S Section 15.9
 527  *
 528  *       XXX: putc and putchar are generally defined as macros
 529  *            for performance reasons
 530  *
 531  *----------------------------------------------------------------------
 532  */
 533
 534 int FCGI_fputc(int c, FCGI_FILE *fp)
 535 {
 536     if(fp->stdio_stream)
 537         return fputc(c, fp->stdio_stream);
 538     else if(fp->fcgx_stream)
 539         return FCGX_PutChar(c, fp->fcgx_stream);
 540     else return EOF;
 541 }
 542
 543 int FCGI_putchar(int c)
 544 {
 545     return FCGI_fputc(c, FCGI_stdout);
 546 }
 547 \f
 548 /*
 549  *----------------------------------------------------------------------
 550  *
 551  * FCGI_fputs, FCGI_puts
 552  *
 553  *       Wrappers for functions defined in H&S Section 15.10
 554  *
 555  *----------------------------------------------------------------------
 556  */
 557
 558 int FCGI_fputs(const char *str, FCGI_FILE *fp)
 559 {
 560     if(fp->stdio_stream)
 561         return fputs(str, fp->stdio_stream);
 562     else if(fp->fcgx_stream)
 563         return FCGX_PutS(str, fp->fcgx_stream);
 564     return EOF;
 565 }
 566
 567 int FCGI_puts(const char *str)
 568 {
 569     int n;
 570     if(FCGI_stdout->stdio_stream) {
 571         n = fputs(str, FCGI_stdout->stdio_stream);
 572         if(n < 0)
 573             return n;
 574         else
 575             return fputc('\n', FCGI_stdout->stdio_stream);
 576     } else if(FCGI_stdout->fcgx_stream) {
 577         n = FCGX_PutS(str, FCGI_stdout->fcgx_stream);
 578         if(n < 0)
 579             return n;
 580         else
 581             return FCGX_PutChar('\n', FCGI_stdout->fcgx_stream);
 582     }
 583     return EOF;
 584 }
 585 \f
 586 /*
 587  *----------------------------------------------------------------------
 588  *
 589  * FCGI_fprintf, FCGI_printf --
 590  *
 591  *       Wrappers for functions defined in H&S Section 15.11
 592  *
 593  *----------------------------------------------------------------------
 594  */
 595
 596 int FCGI_fprintf(FCGI_FILE *fp, const char *format, ...)
 597 {
 598     va_list ap;
 599     int n = 0;
 600     va_start(ap, format);
 601     if(fp->stdio_stream)
 602         n = vfprintf(fp->stdio_stream, format, ap);
 603     else if(fp->fcgx_stream)
 604         n = FCGX_VFPrintF(fp->fcgx_stream, format, ap);
 605     va_end(ap);
 606     return n;
 607 }
 608
 609 int FCGI_printf(const char *format, ...)
 610 {
 611     va_list ap;
 612     int n;
 613     va_start(ap, format);
 614     n = FCGI_vfprintf(FCGI_stdout, format, ap);
 615     va_end(ap);
 616     return n;
 617 }
 618 \f
 619 /*
 620  *----------------------------------------------------------------------
 621  *
 622  * FCGI_vfprintf, FCGI_vprintf --
 623  *
 624  *       Wrappers for functions defined in H&S Section 15.12
 625  *
 626  *----------------------------------------------------------------------
 627  */
 628
 629 int FCGI_vfprintf(FCGI_FILE *fp, const char *format, va_list ap)
 630 {
 631     if(fp->stdio_stream)
 632         return vfprintf(fp->stdio_stream, format, ap);
 633     else if(fp->fcgx_stream)
 634         return FCGX_VFPrintF(fp->fcgx_stream, format, ap);
 635     return EOF;
 636 }
 637
 638 int FCGI_vprintf(const char *format, va_list ap)
 639 {
 640     if(FCGI_stdout->stdio_stream)
 641         return vfprintf(FCGI_stdout->stdio_stream, format, ap);
 642     else if(FCGI_stdout->fcgx_stream)
 643         return FCGX_VFPrintF(FCGI_stdout->fcgx_stream, format, ap);
 644     return EOF;
 645 }
 646 \f
 647 /*
 648  *----------------------------------------------------------------------
 649  *
 650  * FCGI_fread, FCGI_fwrite --
 651  *
 652  *       Wrappers for functions defined in H&S Section 15.13
 653  *
 654  *----------------------------------------------------------------------
 655  */
 656
 657 size_t FCGI_fread(void *ptr, size_t size, size_t nmemb, FCGI_FILE *fp)
 658 {
 659     int n;
 660     if(fp->stdio_stream)
 661         return fread(ptr, size, nmemb, fp->stdio_stream);
 662     else if(fp->fcgx_stream) {
 663         if((size * nmemb) == 0) {
 664             return 0;
 665         }
 666         n = FCGX_GetStr((char *) ptr, size * nmemb, fp->fcgx_stream);
 667         return (n/size);
 668     }
 669     return (size_t)EOF;
 670 }
 671
 672 size_t FCGI_fwrite(void *ptr, size_t size, size_t nmemb, FCGI_FILE *fp)
 673 {
 674     int n;
 675     if(fp->stdio_stream)
 676         return fwrite(ptr, size, nmemb, fp->stdio_stream);
 677     else if(fp->fcgx_stream) {
 678         if((size * nmemb) == 0) {
 679             return 0;
 680         }
 681         n = FCGX_PutStr((char *) ptr, size * nmemb, fp->fcgx_stream);
 682         return (n/size);
 683     }
 684     return (size_t)EOF;
 685 }
 686 \f
 687 /*
 688  *----------------------------------------------------------------------
 689  *
 690  * FCGI_feof, FCGI_ferror, FCGI_clearerr --
 691  *
 692  *       Wrappers for functions defined in H&S Section 15.14
 693  *
 694  *----------------------------------------------------------------------
 695  */
 696 int FCGI_feof(FCGI_FILE *fp)
 697 {
 698     if(fp->stdio_stream) {
 699         return feof(fp->stdio_stream);
 700     } else if (fp->fcgx_stream){
 701         return FCGX_HasSeenEOF(fp->fcgx_stream);
 702     }
 703     return -1;
 704
 705 }
 706
 707 int FCGI_ferror(FCGI_FILE *fp)
 708 {
 709     if(fp->stdio_stream) {
 710         return ferror(fp->stdio_stream);
 711     } else if(fp->fcgx_stream) {
 712         return FCGX_GetError(fp->fcgx_stream);
 713     }
 714     return -1;
 715 }
 716
 717 void FCGI_clearerr(FCGI_FILE *fp)
 718 {
 719     if(fp->stdio_stream) {
 720         clearerr(fp->stdio_stream);
 721     } else if(fp->fcgx_stream) {
 722         FCGX_ClearError(fp->fcgx_stream);
 723     }
 724     return;
 725 }
 726 \f
 727 /*
 728  *----------------------------------------------------------------------
 729  *
 730  * FCGI_fileno, FCGI_fdopen, FCGI_popen, FCGI_pclose --
 731  *
 732  *       Wrappers for POSIX, X/OPEN functions not in ISO C
 733  *
 734  *----------------------------------------------------------------------
 735  */
 736
 737 /*
 738  * These definitions should be supplied by stdio.h but for some
 739  * reason they get lost on certain platforms.
 740  */
 741 /*
 742  * XXX: Need to find the right way to handle this for NT
 743  */
 744 #ifndef _WIN32
 745 #ifndef fileno
 746 extern int fileno(FILE *stream);
 747 #endif
 748 extern FILE *fdopen(int fildes, const char *type);
 749 extern FILE *popen(const char *command, const char *type);
 750 extern int pclose(FILE *stream);
 751 #endif
 752
 753 int FCGI_fileno(FCGI_FILE *fp)
 754 {
 755     if(fp->stdio_stream)
 756         return fileno(fp->stdio_stream);
 757     else
 758         return -1;
 759 }
 760
 761 FCGI_FILE *FCGI_fdopen(int fd, const char *mode)
 762 {
 763 #ifndef _WIN32
 764     return FCGI_OpenFromFILE(fdopen(fd, mode));
 765 #else
 766     return NULL;
 767 #endif
 768 }
 769
 770 FCGI_FILE *FCGI_popen(const char *cmd, const char *type)
 771 {
 772     return FCGI_OpenFromFILE(popen(cmd, type));
 773 }
 774
 775 int FCGI_pclose(FCGI_FILE *fp)
 776 {
 777     int n = EOF;
 778     if(fp->stdio_stream) {
 779 #ifndef _WIN32
 780         n = pclose(fp->stdio_stream);
 781 #endif
 782         fp->stdio_stream = NULL;
 783     } else if(fp->fcgx_stream) {
 784         /*
 785          * The caller is deeply confused; don't free the storage.
 786          */
 787         return EOF;
 788     }
 789     if((fp != FCGI_stdin) && (fp != FCGI_stdout) && (fp != FCGI_stderr)) {
 790         free(fp);
 791     }
 792     return n;
 793 }
 794
 795 /*
 796  *----------------------------------------------------------------------
 797  */