Provide all environment variables to kreq

Prior to this change, only HTTP_ variables were available to the kreq
structure, and these were formatted back into HTTP normal form.  Other
environment variables (even those referenced in the CGI and FastCGI
specs) were discarded.

This introduces new variables to kreq, "envs" and "envsz", that has all
unmodified variables.  This allows callers to access all possible
variables and not just those deemed worthy by kcgi(3).

Fixes #50

Author: kristapsdz

Makefile

@@ -218,6 +218,7 @@ REGRESS		 = regress/test-abort-validator \
 		   regress/test-digest \
 		   regress/test-digest-auth-int \
 		   regress/test-digest-auth-int-bad \
+		   regress/test-environment \
 		   regress/test-epoch2datetime \
 		   regress/test-epoch2str \
 		   regress/test-epoch2tm \

child.c

@@ -1060,17 +1060,23 @@ kworker_child_env(const struct env *env, int fd, size_t envsz)
 	char		 c;
 	const char	*cp;
 
-	for (reqs = i = 0; i < envsz; i++)
+	/* Serialise all environment variables and count HTTPs. */
+
+	fullwrite(fd, &envsz, sizeof(size_t));
+
+	for (reqs = i = 0; i < envsz; i++) {
+		fullwrite(fd, &env[i].keysz, sizeof(size_t));
+		fullwrite(fd, env[i].key, env[i].keysz);
+		fullwrite(fd, &env[i].valsz, sizeof(size_t));
+		fullwrite(fd, env[i].val, env[i].valsz);
 		if (strncmp(env[i].key, "HTTP_", 5) == 0 &&
 		    env[i].key[5] != '\0')
 			reqs++;
+	}
 
-	fullwrite(fd, &reqs, sizeof(size_t));
+	/* Serialise known headers (starting with HTTP_). */
 
-	/*
-	 * Process known headers (starting with HTTP_).
-	 * We must have non-zero-length keys.
-	 */
+	fullwrite(fd, &reqs, sizeof(size_t));
 
 	for (i = 0; i < envsz; i++) {
 		if (strncmp(env[i].key, "HTTP_", 5) || 

kcgi.c

@@ -903,6 +903,11 @@ kreq_free(struct kreq *req)
 		free(req->reqs[i].val);
 	}
 
+	for (i = 0; i < req->envsz; i++) {
+		free(req->envs[i].key);
+		free(req->envs[i].val);
+	}
+
 	free(req->reqs);
 	kpair_free(req->cookies, req->cookiesz);
 	kpair_free(req->fields, req->fieldsz);

kcgi.h

@@ -455,6 +455,8 @@ struct	kreq {
 	struct khead		 *reqmap[KREQU__MAX];
 	struct khead		 *reqs;
 	size_t		 	  reqsz;
+	struct khead		 *envs;
+	size_t		 	  envsz;
 	enum kmethod		  method;
 	enum kauth		  auth;
 	struct khttpauth	  rawauth;

man/khttp_parse.3

@@ -466,22 +466,43 @@ header variable, or
 if that is not defined.
 The address format of the string is not checked.
 .It Vt "struct khead *" Ns Va reqmap Ns Bq Dv KREQU__MAX
-Mapping of
+Map of
 .Vt "enum krequ"
-enumeration values to
-.Va reqs
-parsed from the input stream.
+enumeration values to pairs in
+.Va reqs .
+If an enumerated request was not specified, it is
+.Dv NULL .
 .It Vt "struct khead *" Ns Va reqs
-List of all HTTP request headers, known via
-.Vt "enum krequ"
-and not known, parsed from the input stream, or
+List of all HTTP request headers or
 .Dv NULL
 if
 .Va reqsz
 is 0.
+The request headers are in HTTP syntax with all lowercase and
+underscores as hyphens, e.g., the CGI variable
+.Dv HTTP_ACCEPT_LANGUAGE
+is stored as
+.Dv http-accept-language .
+See
+.Va envs
+for unmodified environment variables.
 .It Vt size_t Va reqsz
 Number of request headers in
 .Va reqs .
+.It Vt "struct khead *" Ns Va envs
+List of all environment variables in the CGI or FastCGI context or
+.Dv NULL
+if
+.Va envsz
+is 0.
+See
+.Va reqs
+for parsed and formatted HTTP headers, defined as environment variables
+starting with
+.Dq HTTP_ .
+.It Vt size_t Va envsz
+Number of environment variables in
+.Va envs .
 .It Vt "enum kscheme" Va scheme
 The access scheme according to the
 .Ev HTTPS

parent.c

@@ -216,10 +216,36 @@ kworker_parent(int fd, struct kreq *r, int eofok, size_t mimesz)
 
 	memset(&kp, 0, sizeof(struct kpair));
 
+	/* Read all environment variables. */
+
+	if (fullread(fd, &r->envsz, sizeof(size_t), 0, &ke) < 0) {
+		kutil_warnx(NULL, NULL, "read environment size");
+		goto out;
+	}
+
+	if (r->envsz) {
+		r->envs = kxcalloc(r->envsz, sizeof(struct khead));
+		if (r->envs == NULL) {
+			ke = KCGI_ENOMEM;
+			goto out;
+		}
+	}
+
+	for (i = 0; i < r->envsz; i++) {
+		if ((ke = fullreadword(fd, &r->envs[i].key)) != KCGI_OK) {
+			kutil_warnx(NULL, NULL, "read environment key");
+			goto out;
+		}
+		if ((ke = fullreadword(fd, &r->envs[i].val)) != KCGI_OK) {
+			kutil_warnx(NULL, NULL, "read environment value");
+			goto out;
+		}
+	}
+
 	/*
-	 * First read all of our parsed parameters.
-	 * Each parsed parameter is handled a little differently.
-	 * This list will end with META__MAX.
+	 * Read all of parsed and formatted HTTP parameters.  If the
+	 * request value is not KREQU__MAX, assign the value to the
+	 * request map.  (The last parsed wins.)
 	 */
 
 	if (fullread(fd, &r->reqsz, sizeof(size_t), 0, &ke) < 0) {
@@ -252,6 +278,8 @@ kworker_parent(int fd, struct kreq *r, int eofok, size_t mimesz)
 			r->reqmap[requ] = &r->reqs[i];
 	}
 
+	/* Read remaining variables. */
+
 	if (fullread(fd, &r->method, sizeof(enum kmethod), 0, &ke) < 0) {
 		kutil_warnx(NULL, NULL, "failed read request method");
 		goto out;

regress/test-environment.c

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Kristaps Dzonsons <[email protected]>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#include "../config.h"
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <curl/curl.h>
+
+#include "../kcgi.h"
+#include "regress.h"
+
+static int
+parent(CURL *curl)
+{
+	struct curl_slist *slist = NULL;
+	int		   ret;
+
+	slist = curl_slist_append(slist, "Testing:123");
+	slist = curl_slist_append(slist, "Testing-Test:321");
+	curl_easy_setopt(curl, CURLOPT_URL, "http://localhost:17123/");
+	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
+	ret = curl_easy_perform(curl);
+	curl_slist_free_all(slist);
+	return ret == CURLE_OK;
+}
+
+static int
+child(void)
+{
+	struct kreq	 r;
+	const char 	*page = "index";
+	size_t		 i, found1 = 0, found2 = 0;
+
+	if (khttp_parse(&r, NULL, 0, &page, 1, 0) != KCGI_OK)
+		return 0;
+
+	for (i = 0; i < r.envsz; i++) {
+		if (strcmp(r.envs[i].key, "HTTP_TESTING") == 0)
+			found1 += strcmp(r.envs[i].val, "123") == 0;
+		else if (strcmp(r.envs[i].key, "HTTP_TESTING_TEST") == 0)
+			found2 += strcmp(r.envs[i].val, "321") == 0;
+	}
+
+	if (found1 != 1 || found2 != 1 ) 
+		return 0;
+
+	khttp_head(&r, kresps[KRESP_STATUS], 
+		"%s", khttps[KHTTP_200]);
+	khttp_head(&r, kresps[KRESP_CONTENT_TYPE], 
+		"%s", kmimetypes[KMIME_TEXT_HTML]);
+	khttp_body(&r);
+	khttp_free(&r);
+	return 1;
+}
+
+int
+main(int argc, char *argv[])
+{
+
+	return regress_cgi(parent, child) ? EXIT_SUCCESS : EXIT_FAILURE;
+}