feat: Add FetchEvent.server object which contains information about the server which received the incoming HTTP request from the client. (#855)

Co-authored-by: Guy Bedford <[email protected]>

Author: JakeChampion

documentation/docs/globals/FetchEvent/FetchEvent.mdx

@@ -29,6 +29,10 @@ It provides the [`event.respondWith()`](./prototype/respondWith.mdx) method, whi
         - : An ArrayBuffer containing the raw client certificate in the mutual TLS handshake message. It is in PEM format. Returns an empty ArrayBuffer if this is not mTLS or available.
     - `FetchEvent.client.tlsClientHello` _**readonly**_
         - : An ArrayBuffer containing the raw bytes sent by the client in the TLS ClientHello message.
+- `FetchEvent.server` _**readonly**_
+    - : Information about the server receiving the request for the Fastly Compute service.
+    - `FetchEvent.server.address` _**readonly**_
+        - : A string representation of the IPv4 or IPv6 address of the server which received the request.
 
 ## Instance methods
 

integration-tests/js-compute/fixtures/app/src/index.js

@@ -43,6 +43,7 @@ import "./response-json.js"
 import "./response-redirect.js"
 import "./response.js"
 import "./secret-store.js"
+import "./server.js"
 import "./tee.js"
 import "./timers.js"
 import "./transform-stream.js"

integration-tests/js-compute/fixtures/app/src/server.js

@@ -0,0 +1,14 @@
+import { pass, assert } from "./assertions.js";
+import { routes, isRunningLocally } from "./routes.js";
+
+let error;
+routes.set("/server/address", event => {
+    error = assert(typeof event.server.address, 'string', 'typeof event.server.address')
+    if (error) { return error }
+
+    if (isRunningLocally()) {
+        error = assert(event.server.address, '127.0.0.1', 'event.server.address')
+        if (error) { return error }
+    }
+    return pass('ok')
+});

integration-tests/js-compute/fixtures/app/tests.json

@@ -8219,5 +8219,16 @@
       "status": 200,
       "body": "ok"
     }
+  },
+  "GET /server/address": {
+    "environments": ["compute", "viceroy"],
+    "downstream_request": {
+      "method": "GET",
+      "pathname": "/server/address"
+    },
+    "downstream_response": {
+      "status": 200,
+      "body": "ok"
+    }
   }
 }

runtime/fastly/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.27)
 
 include("../StarlingMonkey/cmake/add_as_subproject.cmake")
 
-add_builtin(fastly::runtime SRC handler.cpp host-api/component/fastly_world_adapter.cpp)
+add_builtin(fastly::runtime SRC handler.cpp common/ip_octets_to_js_string.cpp host-api/component/fastly_world_adapter.cpp)
 add_builtin(fastly::cache_simple SRC builtins/cache-simple.cpp DEPENDENCIES OpenSSL)
 add_builtin(fastly::fastly SRC builtins/fastly.cpp)
 add_builtin(fastly::backend SRC builtins/backend.cpp)

runtime/fastly/builtins/fastly.cpp

@@ -11,6 +11,7 @@
 #include "js/Conversions.h"
 #include "js/JSON.h"
 #include "logger.h"
+#include <arpa/inet.h>
 
 using builtins::web::url::URL;
 using builtins::web::url::URLSearchParams;

runtime/fastly/builtins/fetch-event.cpp

@@ -2,6 +2,7 @@
 #include "../../StarlingMonkey/builtins/web/performance.h"
 #include "../../StarlingMonkey/builtins/web/url.h"
 #include "../../StarlingMonkey/builtins/web/worker-location.h"
+#include "../common/ip_octets_to_js_string.h"
 #include "../host-api/fastly.h"
 #include "../host-api/host_api_fastly.h"
 #include "./fetch/request-response.h"
@@ -10,7 +11,6 @@
 #include "host_api.h"
 #include "js/JSON.h"
 #include "openssl/evp.h"
-#include <arpa/inet.h>
 
 #include <iostream>
 #include <memory>
@@ -29,7 +29,7 @@ namespace fastly::fetch_event {
 
 namespace {
 
-JSString *address(JSObject *obj) {
+JSString *client_address(JSObject *obj) {
   JS::Value val = JS::GetReservedSlot(obj, static_cast<uint32_t>(ClientInfo::Slots::Address));
   return val.isString() ? val.toString() : nullptr;
 }
@@ -60,44 +60,16 @@ JSString *protocol(JSObject *obj) {
   return val.isString() ? val.toString() : nullptr;
 }
 
-static JSString *retrieve_address(JSContext *cx, JS::HandleObject self) {
+static JSString *retrieve_client_address(JSContext *cx, JS::HandleObject self) {
   auto res = host_api::HttpReq::downstream_client_ip_addr();
   if (auto *err = res.to_err()) {
     HANDLE_ERROR(cx, *err);
     return nullptr;
   }
 
-  auto octets = std::move(res.unwrap());
-  char address_chars[INET6_ADDRSTRLEN];
-  int addr_family = 0;
-  socklen_t size = 0;
-
-  switch (octets.len) {
-  case 0: {
-    // No address to be had, leave `address` as a nullptr.
-    break;
-  }
-  case 4: {
-    addr_family = AF_INET;
-    size = INET_ADDRSTRLEN;
-    break;
-  }
-  case 16: {
-    addr_family = AF_INET6;
-    size = INET6_ADDRSTRLEN;
-    break;
-  }
-  }
-
-  JS::RootedString address(cx);
-  if (octets.len > 0) {
-    // TODO: do we need to do error handling here, or can we depend on the
-    // host giving us a valid address?
-    inet_ntop(addr_family, octets.begin(), address_chars, size);
-    address = JS_NewStringCopyZ(cx, address_chars);
-    if (!address) {
-      return nullptr;
-    }
+  JS::RootedString address(cx, common::ip_octets_to_js_string(cx, std::move(res.unwrap())));
+  if (!address) {
+    return nullptr;
   }
 
   JS::SetReservedSlot(self, static_cast<uint32_t>(ClientInfo::Slots::Address),
@@ -106,9 +78,9 @@ static JSString *retrieve_address(JSContext *cx, JS::HandleObject self) {
 }
 
 JSString *retrieve_geo_info(JSContext *cx, JS::HandleObject self) {
-  JS::RootedString address_str(cx, address(self));
+  JS::RootedString address_str(cx, client_address(self));
   if (!address_str) {
-    address_str = retrieve_address(cx, self);
+    address_str = retrieve_client_address(cx, self);
     if (!address_str)
       return nullptr;
   }
@@ -127,9 +99,9 @@ JSString *retrieve_geo_info(JSContext *cx, JS::HandleObject self) {
 bool ClientInfo::address_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0);
 
-  JS::RootedString address_str(cx, address(self));
+  JS::RootedString address_str(cx, client_address(self));
   if (!address_str) {
-    address_str = retrieve_address(cx, self);
+    address_str = retrieve_client_address(cx, self);
     if (!address_str)
       return false;
   }
@@ -305,6 +277,67 @@ JSObject *ClientInfo::create(JSContext *cx) {
 
 namespace {
 
+JSString *server_address(JSObject *obj) {
+  JS::Value val = JS::GetReservedSlot(obj, static_cast<uint32_t>(ServerInfo::Slots::Address));
+  return val.isString() ? val.toString() : nullptr;
+}
+
+static JSString *retrieve_server_address(JSContext *cx, JS::HandleObject self) {
+  auto res = host_api::HttpReq::downstream_server_ip_addr();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
+    return nullptr;
+  }
+
+  JS::RootedString address(cx, common::ip_octets_to_js_string(cx, std::move(res.unwrap())));
+  if (!address) {
+    return nullptr;
+  }
+
+  JS::SetReservedSlot(self, static_cast<uint32_t>(ServerInfo::Slots::Address),
+                      JS::StringValue(address));
+  return address;
+}
+
+} // namespace
+
+bool ServerInfo::address_get(JSContext *cx, unsigned argc, JS::Value *vp) {
+  METHOD_HEADER(0);
+
+  JS::RootedString address_str(cx, server_address(self));
+  if (!address_str) {
+    address_str = retrieve_server_address(cx, self);
+    if (!address_str)
+      return false;
+  }
+
+  args.rval().setString(address_str);
+  return true;
+}
+
+const JSFunctionSpec ServerInfo::static_methods[] = {
+    JS_FS_END,
+};
+
+const JSPropertySpec ServerInfo::static_properties[] = {
+    JS_PS_END,
+};
+
+const JSFunctionSpec ServerInfo::methods[] = {
+    JS_FS_END,
+};
+
+const JSPropertySpec ServerInfo::properties[] = {
+    JS_PSG("address", address_get, JSPROP_ENUMERATE),
+    JS_PS_END,
+};
+
+JSObject *ServerInfo::create(JSContext *cx) {
+  return JS_NewObjectWithGivenProto(cx, &class_, proto_obj);
+}
+
+namespace {
+
 api::Engine *ENGINE;
 
 PersistentRooted<JSObject *> INSTANCE;
@@ -373,6 +406,25 @@ bool FetchEvent::client_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
+bool FetchEvent::server_get(JSContext *cx, unsigned argc, JS::Value *vp) {
+  METHOD_HEADER(0)
+
+  JS::RootedValue serverInfo(cx,
+                             JS::GetReservedSlot(self, static_cast<uint32_t>(Slots::ServerInfo)));
+
+  if (serverInfo.isUndefined()) {
+    JS::RootedObject obj(cx, ServerInfo::create(cx));
+    if (!obj) {
+      return false;
+    }
+    serverInfo.setObject(*obj);
+    JS::SetReservedSlot(self, static_cast<uint32_t>(Slots::ServerInfo), serverInfo);
+  }
+
+  args.rval().set(serverInfo);
+  return true;
+}
+
 void dispatch_fetch_event(HandleObject event, double *total_compute) {
   MOZ_ASSERT(FetchEvent::is_instance(event));
   auto pre_handler = system_clock::now();
@@ -729,6 +781,7 @@ const JSFunctionSpec FetchEvent::methods[] = {
 const JSPropertySpec FetchEvent::properties[] = {
     JS_PSG("client", client_get, JSPROP_ENUMERATE),
     JS_PSG("request", request_get, JSPROP_ENUMERATE),
+    JS_PSG("server", server_get, JSPROP_ENUMERATE),
     JS_PS_END,
 };
 
@@ -858,6 +911,10 @@ bool install(api::Engine *engine) {
     return false;
   }
 
+  if (!ServerInfo::init_class(engine->cx(), engine->global())) {
+    return false;
+  }
+
   return true;
 }
 

runtime/fastly/builtins/fetch-event.h

@@ -38,12 +38,31 @@ class ClientInfo final : public builtins::BuiltinNoConstructor<ClientInfo> {
   static JSObject *create(JSContext *cx);
 };
 
+class ServerInfo final : public builtins::BuiltinNoConstructor<ServerInfo> {
+  static bool address_get(JSContext *cx, unsigned argc, JS::Value *vp);
+
+public:
+  static constexpr const char *class_name = "ServerInfo";
+
+  enum class Slots {
+    Address,
+    Count,
+  };
+  static const JSFunctionSpec static_methods[];
+  static const JSPropertySpec static_properties[];
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+
+  static JSObject *create(JSContext *cx);
+};
+
 void dispatch_fetch_event(HandleObject event, double *total_compute);
 
 class FetchEvent final : public builtins::BuiltinNoConstructor<FetchEvent> {
   static bool respondWith(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool client_get(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool request_get(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool server_get(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool waitUntil(JSContext *cx, unsigned argc, JS::Value *vp);
 
 public:
@@ -64,6 +83,7 @@ class FetchEvent final : public builtins::BuiltinNoConstructor<FetchEvent> {
     PendingPromiseCount,
     DecPendingPromiseCountFunc,
     ClientInfo,
+    ServerInfo,
     Count
   };
 

runtime/fastly/builtins/fetch/request-response.cpp

@@ -6,6 +6,7 @@
 #include "../../../StarlingMonkey/builtins/web/url.h"
 #include "../../../StarlingMonkey/builtins/web/worker-location.h"
 #include "../../../StarlingMonkey/runtime/encode.h"
+#include "../../common/ip_octets_to_js_string.h"
 #include "../cache-core.h"
 #include "../cache-override.h"
 #include "../cache-simple.h"
@@ -22,7 +23,6 @@
 #include "js/Stream.h"
 #include "picosha2.h"
 #include <algorithm>
-#include <arpa/inet.h>
 #include <vector>
 
 #pragma clang diagnostic push
@@ -2535,26 +2535,13 @@ bool Response::ip_get(JSContext *cx, unsigned argc, JS::Value *vp) {
     args.rval().setUndefined();
     return true;
   }
-  if (ret->len == 4) {
-    char *out = (char *)malloc(INET_ADDRSTRLEN);
-    inet_ntop(AF_INET, ret->ptr.get(), out, 16);
-    JS::RootedString text(
-        cx, JS_NewStringCopyUTF8N(cx, JS::UTF8Chars(out, strnlen(out, INET_ADDRSTRLEN))));
-    if (!text) {
-      return false;
-    }
-    args.rval().setString(text);
-  } else {
-    MOZ_ASSERT(ret->len == 16);
-    char *out = (char *)malloc(INET6_ADDRSTRLEN);
-    inet_ntop(AF_INET6, ret->ptr.get(), out, 16);
-    JS::RootedString text(
-        cx, JS_NewStringCopyUTF8N(cx, JS::UTF8Chars(out, strnlen(out, INET6_ADDRSTRLEN))));
-    if (!text) {
-      return false;
-    }
-    args.rval().setString(text);
+
+  JS::RootedString address(cx, common::ip_octets_to_js_string(cx, std::move(*ret)));
+  if (!address) {
+    return false;
   }
+  args.rval().setString(address);
+
   return true;
 }