Pass POST data to PHP request.

cscott · cscott · commit 2139b790f5f3 · 2015-10-29T20:26:13.000-04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,5 @@
 # php-embed x.x.x (not yet released)
+* Support passing cookies and POST data to PHP request.
 
 # php-embed 0.5.0 (2015-10-28)
 * Support server variables, headers, and query string
diff --git a/lib/index.js b/lib/index.js
@@ -31,22 +31,27 @@ exports.PhpObject = bindings.PhpObject;
 // the passed-in stream and do a little bit of bookkeeping to
 // ensure this always works right.
 // While we're at it, we'll do some hand-holding of the
-// HTTP header API as well.
+// HTTP header API as well, as well as support reading
+// POST data from an input stream.
 // NOTE that this is not actually a node.js "WritableStream" any more;
 // this is just an internal interface we can pass over to the PHP side.
-var StreamWrapper = function(stream) {
-  this.stream = stream;
+var StreamWrapper = function(inStream, outStream) {
+  this._initWrite(outStream);
+  this._initHeader(outStream);
+  this._initRead(inStream);
+
+};
+
+// WRITE interface
+StreamWrapper.prototype._initWrite = function(outStream) {
+  this.stream = outStream;
   this.flushed = true;
   this.error = null;
   this.callbacks = [];
-  this.supportsHeaders = (
-    typeof (stream.getHeader) === 'function' &&
-    typeof (stream.setHeader) === 'function'
-  );
-  stream.on('drain', this.onDrain.bind(this));
-  stream.on('error', this.onError.bind(this));
-  stream.on('close', this.onClose.bind(this));
-  stream.on('finish', this.onFinish.bind(this));
+  this.stream.on('drain', this._onDrain.bind(this));
+  this.stream.on('error', this._onError.bind(this));
+  this.stream.on('close', this._onClose.bind(this));
+  this.stream.on('finish', this._onFinish.bind(this));
 };
 StreamWrapper.prototype.write = function(buffer, cb) {
   if (this.error) {
@@ -64,39 +69,50 @@ StreamWrapper.prototype.write = function(buffer, cb) {
   }
   return notBuffered;
 };
-StreamWrapper.prototype.onDrain = function() {
+StreamWrapper.prototype._onDrain = function() {
   this.flushed = true;
   this.callbacks.forEach(function(f) { setImmediate(f); });
   this.callbacks.length = 0;
 };
-StreamWrapper.prototype.onError = function(e) {
+StreamWrapper.prototype._onError = function(e) {
   this.error = e;
-  this.onDrain();
+  this._onDrain();
+};
+StreamWrapper.prototype._onClose = function() {
+  this._onError(new Error('stream closed'));
 };
-StreamWrapper.prototype.onClose = function() {
-  this.onError(new Error('stream closed'));
+StreamWrapper.prototype._onFinish = function() {
+  this._onError(new Error('stream finished'));
 };
-StreamWrapper.prototype.onFinish = function() {
-  this.onError(new Error('stream finished'));
+
+// HEADER interface
+StreamWrapper.prototype._initHeader = function(outStream) {
+  this.supportsHeaders = (
+    typeof (this.stream.getHeader) === 'function' &&
+    typeof (this.stream.setHeader) === 'function'
+  );
 };
 StreamWrapper.prototype.sendHeader = function(headerBuf) {
   if (!this.supportsHeaders) { return; }
   if (headerBuf === null) { return; }  // This indicates the "last header".
   var header;
   try {
-    // Headers are sent from PHP to JS to avoid re-encoding, but
-    // technically they are ISO-8859-1 encoded, with a strong
-    // recommendation to only use ASCII.
+    // Headers are sent as Buffer from PHP to JS to avoid re-encoding
+    // in transit.  But node.js wants strings, so we need to do
+    // some decoding.  Technically headers are ISO-8859-1 encoded,
+    // with a strong recommendation to only use ASCII.
     // See RFC 2616, https://tools.ietf.org/html/rfc7230#section-3.2.4
     header = headerBuf.toString('ascii');
   } catch (e) {
     console.error('BAD HEADER ENCODING, SKIPPING:', headerBuf);
     return;
   }
-  var m = /^HTTP\/(\d+\.\d+) (\d+) (.*)$/.exec(header);
+  var m = /^HTTP\/(\d+\.\d+) (\d+)( (.*))?$/.exec(header);
   if (m) {
     this.stream.statusCode = parseInt(m[2], 10);
-    this.stream.statusMessage = m[3];
+    if (m[4]) {
+      this.stream.statusMessage = m[4];
+    }
     return;
   }
   m = /^([^: ]+): (.*)$/.exec(header);
@@ -116,13 +132,98 @@ StreamWrapper.prototype.sendHeader = function(headerBuf) {
   console.error('UNEXPECTED HEADER, SKIPPING:', header);
 };
 
+// READ interface
+StreamWrapper.prototype._initRead = function(inStream) {
+  this.inputStream = inStream;
+  this.inputSize = 0;
+  this.inputResult = null;
+  this.inputComplete = null;
+  this.inputLeftover = null;
+  this.inputCallbacks = []; // Future read requests.
+  this.inputError = null;
+  this.inputEnd = false;
+
+  if (!this.inputStream) {
+    this.inputEnd = true;
+  } else {
+    this.inputStream.on('data', this._onInputData.bind(this, false));
+    this.inputStream.on('end', this._onInputEnd.bind(this));
+    this.inputStream.on('error', this._onInputError.bind(this));
+    this.inputStream.pause();
+  }
+};
+StreamWrapper.prototype.read = function(size, cb) {
+  var self = this;
+  var error = this.inputError;
+  if (this.inputResult !== null) {
+    // Read already in progress, queue for later.
+    this.inputCallbacks.push(function() { self.read(size, cb); });
+    return;
+  }
+  if (this.inputEnd || error) {
+    if (cb) { setImmediate(function() { cb(error, new Buffer(0)); }); }
+    return;
+  }
+  this.inputResult = new Buffer(size);
+  this.inputSize = 0;
+  this.inputComplete = cb;
+  if (this.inputLeftover || size === 0) {
+    this._onInputData(false, this.inputLeftover || new Buffer(0));
+  } else {
+    // Enable data events.
+    this.inputStream.resume();
+  }
+};
+StreamWrapper.prototype._onInputData = function(isEnd, buffer) {
+  this.inputStream.pause();
+  var remaining = (this.inputResult.length - this.inputSize);
+  var amt = Math.min(buffer.length, remaining);
+  buffer.copy(this.inputResult, this.inputSize, 0, amt);
+  this.inputSize += amt;
+  // Are we done with this input request?
+  if (this.inputSize === this.inputResult.length || isEnd) {
+    var cb = this.inputComplete;  // Capture this for callback
+    var err = this.inputError;    // Capture this for callback
+    var result = this.inputResult.slice(0, this.inputSize);
+    setImmediate(function() { cb(err, result); });  // Queue callback
+    this.inputResult = this.inputComplete = null;
+    this.inputEnd = isEnd;
+    // Are we done with this buffer?
+    this.inputLeftover = (amt < buffer.length) ? buffer.slice(amt) : null;
+    // Were there any more reads waiting?
+    if (this.inputCallbacks.length > 0) {
+      setImmediate(this.inputCallbacks.shift());
+    }
+  } else {
+    // Need more chunks!
+    this.inputLeftover = null;
+    this.inputStream.resume();
+  }
+};
+StreamWrapper.prototype._onInputEnd = function() {
+  if (this.inputResult) {
+    this._onInputData(true, new Buffer(0));
+  } else {
+    this.inputEnd = true;
+  }
+  while (this.inputCallbacks.length > 0) {
+    setImmediate(this.inputCallbacks.shift());
+  }
+};
+StreamWrapper.prototype._onInputError = function(e) {
+  this.inputError = e;
+  this._onInputEnd();
+};
+
+
 exports.request = function(options, cb) {
   options = options || {};
   var source = options.source;
   if (options.file) {
     source = 'require ' + addslashes(options.file) + ';';
   }
-  var stream = new StreamWrapper(options.stream || process.stdout);
+  var stream = new StreamWrapper(options.request,
+                                 options.stream || process.stdout);
   var buildServerVars = function() {
     var server = Object.create(null);
     server.CONTEXT = options.context;
@@ -134,6 +235,10 @@ exports.request = function(options, cb) {
       var headers = options.request.headers || {};
       Object.keys(headers).forEach(function(h) {
         var hh = 'HTTP_' + h.toUpperCase().replace(/[^A-Z]/g, '_');
+        // The array case is very unusual here: it should basically
+        // only occur for Set-Cookie, which isn't going to be sent
+        // *to* PHP.  But make sure we don't crash if it is.
+        if (Array.isArray(headers[h])) { return; }
         server[hh] = headers[h];
       });
       server.PATH = process.env.PATH;
diff --git a/package.json b/package.json
@@ -57,6 +57,7 @@
     "mocha": "~2.3.3",
     "readable-stream": "~2.0.2",
     "segfault-handler": "git+https://github.com/cscott/node-segfault-handler#any-signal",
-    "should": "~7.1.0"
+    "should": "~7.1.0",
+    "should-http": "0.0.4"
   }
 }
diff --git a/src/node_php_embed.cc b/src/node_php_embed.cc
@@ -31,6 +31,8 @@ using node_php_embed::OwnershipType;
 using node_php_embed::PhpRequestWorker;
 using node_php_embed::Value;
 using node_php_embed::ZVal;
+using node_php_embed::node_php_jsbuffer;
+using node_php_embed::node_php_jsobject_call_method;
 
 static void node_php_embed_ensure_init(void);
 
@@ -139,6 +141,46 @@ static void node_php_embed_send_header(sapi_header_struct *sapi_header,
   TRACE("<");
 }
 
+static int node_php_embed_read_post(char *buffer, uint count_bytes TSRMLS_DC) {
+  // Invoke stream.read with a PHP "JsWait" callback, which causes PHP
+  // to block until the callback is handled.
+  TRACE(">");
+  // Fetch the MapperChannel for this thread.
+  PhpRequestWorker *worker = NODE_PHP_EMBED_G(worker);
+  MapperChannel *channel = NODE_PHP_EMBED_G(channel);
+  if (!worker) { return 0; /* we're in module shutdown, no request any more */ }
+  ZVal stream{ZEND_FILE_LINE_C}, retval{ZEND_FILE_LINE_C};
+  worker->GetStream().ToPhp(channel, stream TSRMLS_CC);
+  // Use plain zval to avoid allocating copy of method name.
+  zval method; ZVAL_STRINGL(&method, "read", 4, 0);
+  zval size; ZVAL_LONG(&size, count_bytes);
+  // Create the special JsWait object.
+  zval wait; INIT_ZVAL(wait);
+  node_php_embed::node_php_jswait_create(&wait TSRMLS_CC);
+  zval *args[] = { &size, &wait };
+  // We can't use call_user_function yet because the PHP function caches
+  // are not properly set up.  Use the backdoor.
+  node_php_jsobject_call_method(stream.Ptr(), &method, 2, args,
+                                retval.Ptr(), retval.PtrPtr() TSRMLS_CC);
+  if (EG(exception)) {
+    NPE_ERROR("- exception caught (ignoring)");
+    zend_clear_exception(TSRMLS_C);
+    return 0;
+  }
+  zval_dtor(&wait);
+  // Transfer the data from the retval to the buffer
+  if (!(retval.IsObject() && Z_OBJCE_P(retval.Ptr()) == php_ce_jsbuffer)) {
+    NPE_ERROR("Return value was not buffer :(");
+    return 0;
+  }
+  node_php_jsbuffer *b = reinterpret_cast<node_php_jsbuffer *>
+    (zend_object_store_get_object(retval.Ptr() TSRMLS_CC));
+  assert(b->length <= count_bytes);
+  memcpy(buffer, b->data, b->length);
+  TRACEX("< (read %lu)", b->length);
+  return static_cast<int>(b->length);
+}
+
 static char * node_php_embed_read_cookies(TSRMLS_D) {
   // This is a hack to prevent the SAPI from overwriting the
   // cookie data we set up in the PhpRequestWorker constructor.
@@ -298,6 +340,7 @@ NAN_MODULE_INIT(ModuleInit) {
   php_embed_module.ub_write = node_php_embed_ub_write;
   php_embed_module.flush = node_php_embed_flush;
   php_embed_module.send_header = node_php_embed_send_header;
+  php_embed_module.read_post = node_php_embed_read_post;
   php_embed_module.read_cookies = node_php_embed_read_cookies;
   php_embed_module.register_server_variables =
     node_php_embed_register_server_variables;
diff --git a/src/node_php_jsobject_class.cc b/src/node_php_jsobject_class.cc
@@ -471,6 +471,21 @@ PHP_METHOD(JsObject, __invoke) {
   TRACE("<");
 }
 
+/* Backdoor invocation, for use in node_php_embed before the request has
+ * been started. */
+void node_php_embed::node_php_jsobject_call_method(
+    zval *object, zval *member, ulong argc, zval **argv,
+    zval *return_value, zval **return_value_ptr TSRMLS_DC) {
+  assert(Z_TYPE_P(object) == IS_OBJECT && Z_OBJCE_P(object) == php_ce_jsobject);
+  FETCH_OBJ("node_php_embed_call_method", object);
+  JsInvokeMsg msg(obj->channel, nullptr, true,  // Sync call
+                  obj->id, member, argc, argv TSRMLS_CC);
+  obj->channel->SendToJs(&msg, MessageFlags::SYNC TSRMLS_CC);
+  THROW_IF_EXCEPTION("JS exception thrown during node_php_embed_call_method"
+                     "of \"%*s\"", Z_STRLEN_P(member), Z_STRVAL_P(member));
+  msg.retval().ToPhp(obj->channel, return_value, return_value_ptr TSRMLS_CC);
+}
+
 ZEND_BEGIN_ARG_INFO_EX(node_php_jsobject_toString_args, 0, 0, 0)
 ZEND_END_ARG_INFO()
 
diff --git a/src/node_php_jsobject_class.h b/src/node_php_jsobject_class.h
@@ -32,6 +32,14 @@ void node_php_jsobject_create(zval *res, MapperChannel *channel,
  * reference. */
 void node_php_jsobject_maybe_neuter(zval *o TSRMLS_DC);
 
+/* Export a method call backdoor to work around the fact that we want
+ * to call JS to get POST data before the request's function
+ * caches are properly set up. */
+void node_php_jsobject_call_method(zval *object, zval *member,
+                                   ulong argc, zval **argv,
+                                   zval *return_value, zval **return_value_ptr
+                                   TSRMLS_DC);
+
 }  // namespace node_php_embed
 
 extern zend_class_entry *php_ce_jsobject;
diff --git a/src/phprequestworker.cc b/src/phprequestworker.cc
@@ -88,21 +88,41 @@ void PhpRequestWorker::Execute(MapperChannel *channel TSRMLS_DC) {
     NPE_ERROR("OOPS! " #requestvar " is set!");                         \
     SG(request_info).requestvar = nullptr;                              \
   }
+  if (argc_ == 0) {
+    SG(sapi_headers).http_response_code = 200;
+  }
   SET_REQUEST_INFO("REQUEST_METHOD", request_method);
   SET_REQUEST_INFO("QUERY_STRING", query_string);
   SET_REQUEST_INFO("PATH_TRANSLATED", path_translated);
   SET_REQUEST_INFO("REQUEST_URI", request_uri);
   SET_REQUEST_INFO("HTTP_COOKIE", cookie_data);
-  // xxx set proto_num ?
-  // xxx set cookie_data ?
-  server_vars_.clear();  // We don't need to keep this around any more.
-
+  SET_REQUEST_INFO("HTTP_CONTENT_TYPE", content_type);
+  SG(request_info).content_length =
+    server_vars_.count("HTTP_CONTENT_LENGTH") ?
+    atol(server_vars_["HTTP_CONTENT_LENGTH"].c_str()) : 0;
+  // Unlike the other settings, proto_num needs to be set *after* we
+  // activate the new request.  Go figure.
+  int proto_num = 1000;
+  if (server_vars_.count("SERVER_PROTOCOL")) {
+    const char *sline = server_vars_["SERVER_PROTOCOL"].c_str();
+    if (strlen(sline) > 7 && strncmp(sline, "HTTP/1.", 7) == 0) {
+      proto_num = 1000 + (sline[7] - '0');
+    }
+  }
+  server_vars_.clear();  // We don't need to keep these around any more.
+  // SG(server_context) needs to be non-zero.  Believe it or not,
+  // this is what the php-cgi binary does:
+  SG(server_context) = reinterpret_cast<void*>(1);  // Sigh.
+  // The read_post callback gets executed by php_request_startup, and it
+  // will need access to the worker and channel, so set them up now.
+  NODE_PHP_EMBED_G(worker) = this;
+  NODE_PHP_EMBED_G(channel) = channel;
+  // Ok, *now* we can startup the request.
   if (php_request_startup(TSRMLS_C) == FAILURE) {
     Nan::ThrowError("can't create request");
     return;
   }
-  NODE_PHP_EMBED_G(worker) = this;
-  NODE_PHP_EMBED_G(channel) = channel;
+  SG(request_info).proto_num = proto_num;
   {
     ZVal source{ZEND_FILE_LINE_C}, result{ZEND_FILE_LINE_C};
     zend_first_try {
@@ -155,6 +175,7 @@ void PhpRequestWorker::AfterExecute(TSRMLS_D) {
   FREE_REQUEST_INFO(path_translated);
   FREE_REQUEST_INFO(request_uri);
   FREE_REQUEST_INFO(cookie_data);
+  FREE_REQUEST_INFO(content_type);
   php_request_shutdown(nullptr);
   TRACE("< PhpRequestWorker");
 }
@@ -164,6 +185,7 @@ void PhpRequestWorker::CheckRequestInfo(TSRMLS_D) {
   CHECK_REQUEST_INFO(path_translated);
   CHECK_REQUEST_INFO(request_uri);
   CHECK_REQUEST_INFO(cookie_data);
+  CHECK_REQUEST_INFO(content_type);
 }
 
 // Executed when the async work is complete.
diff --git a/test/post.js b/test/post.js

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`# php-embed x.x.x (not yet released)`
	`2`	`+* Support passing cookies and POST data to PHP request.`
`2`	`3`
`3`	`4`	`# php-embed 0.5.0 (2015-10-28)`
`4`	`5`	`* Support server variables, headers, and query string`
Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,7 @@`
`57`	`57`	`"mocha": "~2.3.3",`
`58`	`58`	`"readable-stream": "~2.0.2",`
`59`	`59`	`"segfault-handler": "git+https://github.com/cscott/node-segfault-handler#any-signal",`
`60`		`- "should": "~7.1.0"`
	`60`	`+ "should": "~7.1.0",`
	`61`	`+ "should-http": "0.0.4"`
`61`	`62`	`}`
`62`	`63`	`}`