From c0ea79151d25c2e2e486cbc86cbdf9f375c13e34 Mon Sep 17 00:00:00 2001
From: Boris Ranto <branto@redhat.com>
Date: Tue, 21 Feb 2017 13:46:59 +0100
Subject: [PATCH] Add fake fcgiapp.h for rgw
- do not link against fcgi
Signed-off-by: Boris Ranto <branto@redhat.com>
---
src/rgw/Makefile.am | 1 -
src/rgw/fcgiapp.h | 622 ++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 622 insertions(+), 1 deletion(-)
create mode 100644 src/rgw/fcgiapp.h
diff --git a/src/rgw/Makefile.am b/src/rgw/Makefile.am
index a94e4e2..d4c5ad8 100644
--- a/src/rgw/Makefile.am
+++ b/src/rgw/Makefile.am
@@ -93,7 +93,6 @@ LIBRGW_DEPS += \
-lcurl \
-lexpat \
-lm \
- -lfcgi \
-ldl
librgw_la_LIBADD = $(LIBRGW_DEPS) \
diff --git a/src/rgw/fcgiapp.h b/src/rgw/fcgiapp.h
new file mode 100644
index 0000000..41852f9
--- /dev/null
+++ b/src/rgw/fcgiapp.h
@@ -0,0 +1,622 @@
+/*
+ * fcgiapp.h --
+ *
+ * Definitions for FastCGI application server programs
+ *
+ *
+ * Copyright (c) 1996 Open Market, Inc.
+ *
+ * See the file "LICENSE.TERMS" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * $Id: fcgiapp.h,v 1.12 2001/11/21 21:10:11 robs Exp $
+ */
+
+#ifndef _FCGIAPP_H
+#define _FCGIAPP_H
+
+/* Hack to see if we are building TCL - TCL needs varargs not stdarg */
+#ifndef TCL_LIBRARY
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#ifndef DLLAPI
+#ifdef _WIN32
+#define DLLAPI __declspec(dllimport)
+#else
+#define DLLAPI
+#endif
+#endif
+
+#if defined (c_plusplus) || defined (__cplusplus)
+extern "C" {
+#endif
+
+/*
+ * Error codes. Assigned to avoid conflict with EOF and errno(2).
+ */
+#define FCGX_UNSUPPORTED_VERSION -2
+#define FCGX_PROTOCOL_ERROR -3
+#define FCGX_PARAMS_ERROR -4
+#define FCGX_CALL_SEQ_ERROR -5
+
+/*
+ * This structure defines the state of a FastCGI stream.
+ * Streams are modeled after the FILE type defined in stdio.h.
+ * (We wouldn't need our own if platform vendors provided a
+ * standard way to subclass theirs.)
+ * The state of a stream is private and should only be accessed
+ * by the procedures defined below.
+ */
+typedef struct FCGX_Stream {
+ unsigned char *rdNext; /* reader: first valid byte
+ * writer: equals stop */
+ unsigned char *wrNext; /* writer: first free byte
+ * reader: equals stop */
+ unsigned char *stop; /* reader: last valid byte + 1
+ * writer: last free byte + 1 */
+ unsigned char *stopUnget; /* reader: first byte of current buffer
+ * fragment, for ungetc
+ * writer: undefined */
+ int isReader;
+ int isClosed;
+ int wasFCloseCalled;
+ int FCGI_errno; /* error status */
+ void (*fillBuffProc) (struct FCGX_Stream *stream);
+ void (*emptyBuffProc) (struct FCGX_Stream *stream, int doClose);
+ void *data;
+} FCGX_Stream;
+
+/*
+ * An environment (as defined by environ(7)): A NULL-terminated array
+ * of strings, each string having the form name=value.
+ */
+typedef char **FCGX_ParamArray;
+
+/*
+ * FCGX_Request Flags
+ *
+ * Setting FCGI_FAIL_ACCEPT_ON_INTR prevents FCGX_Accept() from
+ * restarting upon being interrupted.
+ */
+#define FCGI_FAIL_ACCEPT_ON_INTR 1
+
+/*
+ * FCGX_Request -- State associated with a request.
+ *
+ * Its exposed for API simplicity, I expect parts of it to change!
+ */
+typedef struct FCGX_Request {
+ int requestId; /* valid if isBeginProcessed */
+ int role;
+ FCGX_Stream *in;
+ FCGX_Stream *out;
+ FCGX_Stream *err;
+ char **envp;
+
+ /* Don't use anything below here */
+
+ struct Params *paramsPtr;
+ int ipcFd; /* < 0 means no connection */
+ int isBeginProcessed; /* FCGI_BEGIN_REQUEST seen */
+ int keepConnection; /* don't close ipcFd at end of request */
+ int appStatus;
+ int nWriters; /* number of open writers (0..2) */
+ int flags;
+ int listen_sock;
+} FCGX_Request;
+
+
+/*
+ *======================================================================
+ * Control
+ *======================================================================
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_IsCGI --
+ *
+ * Returns TRUE iff this process appears to be a CGI process
+ * rather than a FastCGI process.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_IsCGI(void) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Init --
+ *
+ * Initialize the FCGX library. Call in multi-threaded apps
+ * before calling FCGX_Accept_r().
+ *
+ * Returns 0 upon success.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_Init(void) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_OpenSocket --
+ *
+ * Create a FastCGI listen socket.
+ *
+ * path is the Unix domain socket (named pipe for WinNT), or a colon
+ * followed by a port number. e.g. "/tmp/fastcgi/mysocket", ":5000"
+ *
+ * backlog is the listen queue depth used in the listen() call.
+ *
+ * Returns the socket's file descriptor or -1 on error.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_OpenSocket(const char *path, int backlog) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_InitRequest --
+ *
+ * Initialize a FCGX_Request for use with FCGX_Accept_r().
+ *
+ * sock is a file descriptor returned by FCGX_OpenSocket() or 0 (default).
+ * The only supported flag at this time is FCGI_FAIL_ON_INTR.
+ *
+ * Returns 0 upon success.
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_InitRequest(FCGX_Request *request, int sock, int flags) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Accept_r --
+ *
+ * Accept a new request (multi-thread safe). Be sure to call
+ * FCGX_Init() first.
+ *
+ * Results:
+ * 0 for successful call, -1 for error.
+ *
+ * Side effects:
+ *
+ * Finishes the request accepted by (and frees any
+ * storage allocated by) the previous call to FCGX_Accept.
+ * Creates input, output, and error streams and
+ * assigns them to *in, *out, and *err respectively.
+ * Creates a parameters data structure to be accessed
+ * via getenv(3) (if assigned to environ) or by FCGX_GetParam
+ * and assigns it to *envp.
+ *
+ * DO NOT retain pointers to the envp array or any strings
+ * contained in it (e.g. to the result of calling FCGX_GetParam),
+ * since these will be freed by the next call to FCGX_Finish
+ * or FCGX_Accept.
+ *
+ * DON'T use the FCGX_Request, its structure WILL change.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_Accept_r(FCGX_Request *request) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Finish_r --
+ *
+ * Finish the request (multi-thread safe).
+ *
+ * Side effects:
+ *
+ * Finishes the request accepted by (and frees any
+ * storage allocated by) the previous call to FCGX_Accept.
+ *
+ * DO NOT retain pointers to the envp array or any strings
+ * contained in it (e.g. to the result of calling FCGX_GetParam),
+ * since these will be freed by the next call to FCGX_Finish
+ * or FCGX_Accept.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_Finish_r(FCGX_Request *request) {};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Free --
+ *
+ * Free the memory and, if close is true,
+ * IPC FD associated with the request (multi-thread safe).
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_Free(FCGX_Request * request, int close) {};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Accept --
+ *
+ * Accept a new request (NOT multi-thread safe).
+ *
+ * Results:
+ * 0 for successful call, -1 for error.
+ *
+ * Side effects:
+ *
+ * Finishes the request accepted by (and frees any
+ * storage allocated by) the previous call to FCGX_Accept.
+ * Creates input, output, and error streams and
+ * assigns them to *in, *out, and *err respectively.
+ * Creates a parameters data structure to be accessed
+ * via getenv(3) (if assigned to environ) or by FCGX_GetParam
+ * and assigns it to *envp.
+ *
+ * DO NOT retain pointers to the envp array or any strings
+ * contained in it (e.g. to the result of calling FCGX_GetParam),
+ * since these will be freed by the next call to FCGX_Finish
+ * or FCGX_Accept.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_Accept(
+ FCGX_Stream **in,
+ FCGX_Stream **out,
+ FCGX_Stream **err,
+ FCGX_ParamArray *envp) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_Finish --
+ *
+ * Finish the current request (NOT multi-thread safe).
+ *
+ * Side effects:
+ *
+ * Finishes the request accepted by (and frees any
+ * storage allocated by) the previous call to FCGX_Accept.
+ *
+ * DO NOT retain pointers to the envp array or any strings
+ * contained in it (e.g. to the result of calling FCGX_GetParam),
+ * since these will be freed by the next call to FCGX_Finish
+ * or FCGX_Accept.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_Finish(void) {};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_StartFilterData --
+ *
+ * stream is an input stream for a FCGI_FILTER request.
+ * stream is positioned at EOF on FCGI_STDIN.
+ * Repositions stream to the start of FCGI_DATA.
+ * If the preconditions are not met (e.g. FCGI_STDIN has not
+ * been read to EOF) sets the stream error code to
+ * FCGX_CALL_SEQ_ERROR.
+ *
+ * Results:
+ * 0 for a normal return, < 0 for error
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_StartFilterData(FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_SetExitStatus --
+ *
+ * Sets the exit status for stream's request. The exit status
+ * is the status code the request would have exited with, had
+ * the request been run as a CGI program. You can call
+ * SetExitStatus several times during a request; the last call
+ * before the request ends determines the value.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_SetExitStatus(int status, FCGX_Stream *stream) {};
+
+/*
+ *======================================================================
+ * Parameters
+ *======================================================================
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_GetParam -- obtain value of FCGI parameter in environment
+ *
+ *
+ * Results:
+ * Value bound to name, NULL if name not present in the
+ * environment envp. Caller must not mutate the result
+ * or retain it past the end of this request.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI char *FCGX_GetParam(const char *name, FCGX_ParamArray envp) {return 0;};
+
+/*
+ *======================================================================
+ * Readers
+ *======================================================================
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_GetChar --
+ *
+ * Reads a byte from the input stream and returns it.
+ *
+ * Results:
+ * The byte, or EOF (-1) if the end of input has been reached.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_GetChar(FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_UnGetChar --
+ *
+ * Pushes back the character c onto the input stream. One
+ * character of pushback is guaranteed once a character
+ * has been read. No pushback is possible for EOF.
+ *
+ * Results:
+ * Returns c if the pushback succeeded, EOF if not.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_UnGetChar(int c, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_GetStr --
+ *
+ * Reads up to n consecutive bytes from the input stream
+ * into the character array str. Performs no interpretation
+ * of the input bytes.
+ *
+ * Results:
+ * Number of bytes read. If result is smaller than n,
+ * the end of input has been reached.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_GetStr(char *str, int n, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_GetLine --
+ *
+ * Reads up to n-1 consecutive bytes from the input stream
+ * into the character array str. Stops before n-1 bytes
+ * have been read if '\n' or EOF is read. The terminating '\n'
+ * is copied to str. After copying the last byte into str,
+ * stores a '\0' terminator.
+ *
+ * Results:
+ * NULL if EOF is the first thing read from the input stream,
+ * str otherwise.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI char *FCGX_GetLine(char *str, int n, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_HasSeenEOF --
+ *
+ * Returns EOF if end-of-file has been detected while reading
+ * from stream; otherwise returns 0.
+ *
+ * Note that FCGX_HasSeenEOF(s) may return 0, yet an immediately
+ * following FCGX_GetChar(s) may return EOF. This function, like
+ * the standard C stdio function feof, does not provide the
+ * ability to peek ahead.
+ *
+ * Results:
+ * EOF if end-of-file has been detected, 0 if not.
+ *
+ *----------------------------------------------------------------------
+ */
+
+DLLAPI int FCGX_HasSeenEOF(FCGX_Stream *stream) {return 0;};
+
+/*
+ *======================================================================
+ * Writers
+ *======================================================================
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_PutChar --
+ *
+ * Writes a byte to the output stream.
+ *
+ * Results:
+ * The byte, or EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_PutChar(int c, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_PutStr --
+ *
+ * Writes n consecutive bytes from the character array str
+ * into the output stream. Performs no interpretation
+ * of the output bytes.
+ *
+ * Results:
+ * Number of bytes written (n) for normal return,
+ * EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_PutStr(const char *str, int n, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_PutS --
+ *
+ * Writes a null-terminated character string to the output stream.
+ *
+ * Results:
+ * number of bytes written for normal return,
+ * EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_PutS(const char *str, FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_FPrintF, FCGX_VFPrintF --
+ *
+ * Performs printf-style output formatting and writes the results
+ * to the output stream.
+ *
+ * Results:
+ * number of bytes written for normal return,
+ * EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_FPrintF(FCGX_Stream *stream, const char *format, ...) {return 0;};
+
+DLLAPI int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_FFlush --
+ *
+ * Flushes any buffered output.
+ *
+ * Server-push is a legitimate application of FCGX_FFlush.
+ * Otherwise, FCGX_FFlush is not very useful, since FCGX_Accept
+ * does it implicitly. Calling FCGX_FFlush in non-push applications
+ * results in extra writes and therefore reduces performance.
+ *
+ * Results:
+ * EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_FFlush(FCGX_Stream *stream) {return 0;};
+
+/*
+ *======================================================================
+ * Both Readers and Writers
+ *======================================================================
+ */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_FClose --
+ *
+ * Closes the stream. For writers, flushes any buffered
+ * output.
+ *
+ * Close is not a very useful operation since FCGX_Accept
+ * does it implicitly. Closing the out stream before the
+ * err stream results in an extra write if there's nothing
+ * in the err stream, and therefore reduces performance.
+ *
+ * Results:
+ * EOF (-1) if an error occurred.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_FClose(FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_GetError --
+ *
+ * Return the stream error code. 0 means no error, > 0
+ * is an errno(2) error, < 0 is an FastCGI error.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI int FCGX_GetError(FCGX_Stream *stream) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_ClearError --
+ *
+ * Clear the stream error code and end-of-file indication.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_ClearError(FCGX_Stream *stream) {};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_CreateWriter --
+ *
+ * Create a FCGX_Stream (used by cgi-fcgi). This shouldn't
+ * be needed by a FastCGI applictaion.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI FCGX_Stream *FCGX_CreateWriter(
+ int socket,
+ int requestId,
+ int bufflen,
+ int streamType) {return 0;};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FCGX_FreeStream --
+ *
+ * Free a FCGX_Stream (used by cgi-fcgi). This shouldn't
+ * be needed by a FastCGI applictaion.
+ *
+ *----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_FreeStream(FCGX_Stream **stream) {};
+
+/* ----------------------------------------------------------------------
+ *
+ * Prevent the lib from accepting any new requests. Signal handler safe.
+ *
+ * ----------------------------------------------------------------------
+ */
+DLLAPI void FCGX_ShutdownPending(void) {};
+
+#if defined (__cplusplus) || defined (c_plusplus)
+} /* terminate extern "C" { */
+#endif
+
+#endif /* _FCGIAPP_H */
--
2.9.3