Fix OBSERVED_ADDRESS frame codepoints and make address discovery opt-in (#43)

Two commits against the address discovery extension.

1. Use draft codepoints for OBSERVED_ADDRESS frame types
QUIC_FRAME_OBSERVED_ADDRESS_V4/_V6 in src/core/frame.h were 0x9f81/0x9f82, with the draft-ietf-quic-address-discovery codepoints (0x9f81a6/0x9f81a7) left only as a trailing comment.

The transport parameter ID (QUIC_TP_ID_OBSERVED_ADDRESS = 0x9f81a176) already matches the draft, so the extension negotiates successfully with other implementations — and only then do the frames themselves fail to parse. Reproduced against noq 1.0.1 (quinn-based, draft codepoints) over loopback:

quicsample: Connected -> Shut down by transport, 0x5   (QUIC_STATUS_INTERNAL_ERROR)
noq server: aborted by peer: received a frame that was badly formatted
src/plugins/dbg/quictypes.h already carried the correct draft values, so the two enums were out of sync.

src/core/unittest/SpinFrame.cpp widens FrameType to uint32_t so the case labels stay within the switch operand's range (-Werror=switch-outside-range otherwise fails the build). The fuzzed value is still drawn from the 16-bit space, exactly as before.

2. Add opt-in settings for observed address reports
The extension was unconditionally enabled: msquic always advertised the transport parameter, always sent it with a hardcoded value of 2 ("both"), discarded the peer's value (the TODO - Pass value? in crypto_tls.c), and always accepted OBSERVED_ADDRESS frames. An app had no way to turn any of it off.

Two new settings, mirroring the noq/quinn API:

Setting	Default	Meaning
SendObservedAddressReports	FALSE	Report the peer's observed address to it
ReceiveObservedAddressReports	FALSE	Ask the peer to report ours
The extension is now opt-in. Previously it was always on; both settings default to FALSE.
The transport parameter is sent only when at least one direction is enabled, and its value now states which — SEND_ONLY (0) / RECEIVE_ONLY (1) / BOTH (2), per the draft.
The peer's value is kept in QUIC_TRANSPORT_PARAMETERS::ObservedAddressRole and honored: frames are sent only when this endpoint enabled sending and the peer asked to receive.
An OBSERVED_ADDRESS frame arriving when we never asked to receive one is now a PROTOCOL_VIOLATION instead of being silently accepted.
quicsample gains -observed_address_send / -observed_address_recv on both client and server.
Plumbed through the usual places: msquic.h (IsSet + Flags bits), msquic.hpp setters, settings.h/settings.c (defaults, copy, apply, registry load, both dumps, to/from-internal), quicdef.h defaults and registry names, docs/Settings.md, SettingsTest SET+GET entries. Clog headers and clog.sidecar were regenerated with the clog tool from submodules/clog.

Verification
Loopback against noq-mp-sample (unmodified; noq enables both directions), with the rebuilt quicsample:

Frame codepoints — before commit 1:

Scenario	Result
quicsample -client -> noq server	❌ Shut down by transport, 0x5
quicsample -client -multipath -> noq server	❌ same
noq client -> quicsample -server	✅ (noq client never advertises the TP)
After both commits:

quicsample client flags	Observed Address reports	Data exchange
none (defaults off)	0	✅
-observed_address_recv	1	✅
-observed_address_send	0 (noq honors send-only)	✅
both	1	✅
-multipath -observed_address_recv	2 (one per path)	✅
msquic-to-msquic behaves the same: a server started with -observed_address_send reports only to a client that passed -observed_address_recv.

msquiccoretest: 540 passed, 0 failed (3 pre-existing skips are the Linux-unsupported storage tests). TransportParamTest.ObservedAddress was extended to round-trip all three role values.

Notes
Because the frame codepoints no longer fit in 16 bits, SpinFrame can no longer generate them, so its OBSERVED_ADDRESS cases become unreachable — the same situation as the existing ADD_ADDRESS/PUNCH_ME_NOW cases. Fuzzing those would need the loop to draw from a table of known frame types rather than rejection-sample a 16-bit space; left out of this change.
Rust bindings are updated: src/rs/settings.rs gains the two setters, and linux_bindings.rs was regenerated with cargo build --features overwrite. win_bindings.rs cannot be regenerated on Linux, so the identical hunks were applied by hand — the diffs of the two files match line for line and both parse, but it has not been compiled for a Windows target. Verified with cargo test --features preview-api (13 passed).
The C# bindings were not updated; they need their generator re-run. Note they are already missing MultipathEnabled.
Only the Linux clog artifacts were regenerated; Windows builds regenerate theirs as part of the build.
🤖 Generated with Claude Code

Author: masa-koz

docs/Settings.md

@@ -70,6 +70,8 @@ The following settings are available via registry as well as via [QUIC_SETTINGS]
 | Server Initiated Migration         | uint8_t    | ServerMigrationEnabled      |         0 (FALSE) | Enable Server Initiated Migration. |
 | ADD_ADDRESS handling mode          | uint8_t    | AddAddressMode              |         0 (AUTO)  | Control handling of ADD_ADDRESS Frame |
 | IgnoreUnreachable                  | uint8_t    | IgnoreUnreachable           |         0 (FALSE) | Ignore Unreachable during the Handshake |
+| SendObservedAddressReports         | uint8_t    | SendObservedAddressReports  |         0 (FALSE) | Report the peer's observed address to it via OBSERVED_ADDRESS frames. Frames are only sent if the peer also asked to receive them. |
+| ReceiveObservedAddressReports      | uint8_t    | ReceiveObservedAddressReports |       0 (FALSE) | Ask the peer to report this endpoint's observed address. Reports arrive as `QUIC_CONNECTION_EVENT_NOTIFY_OBSERVED_ADDRESS`. |
 
 The types map to registry types as follows:
   - `uint64_t` is a `REG_QWORD`.

src/core/connection.c

@@ -2110,9 +2110,23 @@ QuicConnGenerateLocalTransportParameters(
         QUIC_TP_FLAG_MAX_ACK_DELAY |
         QUIC_TP_FLAG_MIN_ACK_DELAY |
         QUIC_TP_FLAG_ACTIVE_CONNECTION_ID_LIMIT |
-        QUIC_TP_FLAG_OBSERVED_ADDRESS |
         QUIC_TP_FLAG_NAT_TRAVERSE;
 
+    //
+    // The observed_address transport parameter is only sent when at least one
+    // direction of the extension is enabled; its value states which.
+    //
+    if (Connection->Settings.SendObservedAddressReports ||
+        Connection->Settings.ReceiveObservedAddressReports) {
+        LocalTP->Flags |= QUIC_TP_FLAG_OBSERVED_ADDRESS;
+        LocalTP->ObservedAddressRole =
+            Connection->Settings.SendObservedAddressReports ?
+                (Connection->Settings.ReceiveObservedAddressReports ?
+                    QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH :
+                    QUIC_TP_OBSERVED_ADDRESS_ROLE_SEND_ONLY) :
+                QUIC_TP_OBSERVED_ADDRESS_ROLE_RECEIVE_ONLY;
+    }
+
     if (Connection->Settings.IdleTimeoutMs != 0) {
         LocalTP->Flags |= QUIC_TP_FLAG_IDLE_TIMEOUT;
         LocalTP->IdleTimeout = Connection->Settings.IdleTimeoutMs;
@@ -2769,7 +2783,7 @@ QuicConnProcessPeerTransportParameters(
             UINT32_MAX);
     }
 
-    if (Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_OBSERVED_ADDRESS) {
+    if (QuicConnPeerWantsObservedAddressReports(Connection)) {
         Connection->State.ObservedAddressNegotiated = TRUE;
         QuicSendSetSendFlag(
             &Connection->Send,
@@ -5533,7 +5547,21 @@ QuicConnRecvFrames(
         }
 
         case QUIC_FRAME_OBSERVED_ADDRESS_V4:
-        case QUIC_FRAME_OBSERVED_ADDRESS_V6: { // Always accept the frame, because we always enable support.
+        case QUIC_FRAME_OBSERVED_ADDRESS_V6: {
+            if (!Connection->Settings.ReceiveObservedAddressReports) {
+                //
+                // We never asked to receive these reports, so the peer isn't
+                // allowed to send them.
+                //
+                QuicTraceEvent(
+                    ConnError,
+                    "[conn][%p] ERROR, %s.",
+                    Connection,
+                    "Received OBSERVED_ADDRESS frame when not negotiated");
+                QuicConnTransportError(Connection, QUIC_ERROR_PROTOCOL_VIOLATION);
+                return FALSE;
+            }
+
             QUIC_OBSERVED_ADDRESS_EX Frame;
             if (!QuicObservedAddressFrameDecode(FrameType, PayloadLength, Payload, &Offset, &Frame)) {
                 QuicTraceEvent(
@@ -9542,7 +9570,7 @@ QuicConnApplyNewSettings(
             QuicConnIndicateEvent(Connection, &Event);
         }
 
-        if (QuicConnIsServer(Connection) && Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_OBSERVED_ADDRESS) {
+        if (QuicConnIsServer(Connection) && QuicConnPeerWantsObservedAddressReports(Connection)) {
             Connection->State.ObservedAddressNegotiated = TRUE;
             QuicSendSetSendFlag(
                 &Connection->Send,

src/core/connection.h

@@ -792,6 +792,23 @@ QuicConnIsServer(
     return ((QUIC_HANDLE*)Connection)->Type == QUIC_HANDLE_TYPE_CONNECTION_SERVER;
 }
 
+//
+// Helper to determine if observed address reports should be sent to the peer:
+// this endpoint must be willing to send them, and the peer must have asked to
+// receive them.
+//
+QUIC_INLINE
+BOOLEAN
+QuicConnPeerWantsObservedAddressReports(
+    _In_ const QUIC_CONNECTION * const Connection
+    )
+{
+    return
+        Connection->Settings.SendObservedAddressReports &&
+        (Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_OBSERVED_ADDRESS) &&
+        QUIC_TP_OBSERVED_ADDRESS_ROLE_RECEIVES(Connection->PeerTransportParams.ObservedAddressRole);
+}
+
 //
 // Helper to determine if a connection is client side.
 //

src/core/crypto_tls.c

@@ -912,7 +912,7 @@ QuicCryptoTlsEncodeTransportParameters(
         RequiredTPLen +=
             TlsTransportParamLength(
                 QUIC_TP_ID_OBSERVED_ADDRESS,
-                QuicVarIntSize(2)); // Hardcode for now
+                QuicVarIntSize(TransportParams->ObservedAddressRole));
     }
     if (TransportParams->Flags & QUIC_TP_FLAG_NAT_TRAVERSE) {
         if (IsServerTP) {
@@ -1285,13 +1285,13 @@ QuicCryptoTlsEncodeTransportParameters(
         TPBuf =
             TlsWriteTransportParamVarInt(
                 QUIC_TP_ID_OBSERVED_ADDRESS,
-                2,
+                TransportParams->ObservedAddressRole,
                 TPBuf);
         QuicTraceLogConnVerbose(
             EncodeTPObservedAddress,
             Connection,
             "TP: Observed Address (%u)",
-            2);
+            (uint32_t)TransportParams->ObservedAddressRole);
     }
     if (TransportParams->Flags & QUIC_TP_FLAG_NAT_TRAVERSE) {
         if (IsServerTP) {
@@ -2095,7 +2095,7 @@ QuicCryptoTlsDecodeTransportParameters( // NOLINT(readability-function-size, goo
                     "Invalid length of QUIC_TP_ID_OBSERVED_ADDRESS");
                 goto Exit;
             }
-            if (value > 2) {
+            if (value > QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH) {
                 QuicTraceEvent(
                     ConnError,
                     "[conn][%p] ERROR, %s.",
@@ -2108,7 +2108,8 @@ QuicCryptoTlsDecodeTransportParameters( // NOLINT(readability-function-size, goo
                 Connection,
                 "TP: Observed Address (%u)",
                 (uint32_t)value);
-            TransportParams->Flags |= QUIC_TP_FLAG_OBSERVED_ADDRESS; // TODO - Pass value?
+            TransportParams->Flags |= QUIC_TP_FLAG_OBSERVED_ADDRESS;
+            TransportParams->ObservedAddressRole = value;
             break;
         }
 

src/core/frame.h

@@ -159,9 +159,9 @@ typedef enum QUIC_FRAME_TYPE {
     QUIC_FRAME_IMMEDIATE_ACK        = 0x1fULL,
     /* 0xaf to 0x2f4 are unused currently */
     QUIC_FRAME_TIMESTAMP            = 0x2f5ULL,
-    /* 0x2f6 to 0x9f80 are unused currently */
-    QUIC_FRAME_OBSERVED_ADDRESS_V4  = 0x9f81ULL, // 0x9f81a6ULL,
-    QUIC_FRAME_OBSERVED_ADDRESS_V6  = 0x9f82ULL, // 0x9f81a7ULL,
+    /* 0x2f6 to 0x9f81a5 are unused currently */
+    QUIC_FRAME_OBSERVED_ADDRESS_V4  = 0x9f81a6ULL,
+    QUIC_FRAME_OBSERVED_ADDRESS_V6  = 0x9f81a7ULL,
 
     QUIC_FRAME_ADD_ADDRESS_V4       = 0x3d7e90LL,
     QUIC_FRAME_ADD_ADDRESS_V6       = 0x3d7e91LL,

src/core/quicdef.h

@@ -620,6 +620,13 @@ CXPLAT_STATIC_ASSERT(
 //
 #define QUIC_DEFAULT_MULTIPATH_ENABLED               FALSE
 
+//
+// The default settings for the address discovery extension. Both directions
+// are off by default; the app opts in per direction.
+//
+#define QUIC_DEFAULT_SEND_OBSERVED_ADDRESS_REPORTS      FALSE
+#define QUIC_DEFAULT_RECEIVE_OBSERVED_ADDRESS_REPORTS   FALSE
+
 //
 // The number of rounds in Cubic Slow Start to sample RTT.
 //
@@ -709,6 +716,21 @@ CXPLAT_STATIC_ASSERT(
 //
 #define QUIC_TP_MAX_PATH_ID_MAX                             ((1ULL << 32) - 1)
 
+//
+// Values of the observed_address transport parameter, per
+// draft-ietf-quic-address-discovery. The value states which directions of the
+// extension the endpoint is willing to take part in.
+//
+#define QUIC_TP_OBSERVED_ADDRESS_ROLE_SEND_ONLY             0
+#define QUIC_TP_OBSERVED_ADDRESS_ROLE_RECEIVE_ONLY          1
+#define QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH                  2
+
+#define QUIC_TP_OBSERVED_ADDRESS_ROLE_SENDS(Role) \
+    ((Role) == QUIC_TP_OBSERVED_ADDRESS_ROLE_SEND_ONLY || (Role) == QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH)
+
+#define QUIC_TP_OBSERVED_ADDRESS_ROLE_RECEIVES(Role) \
+    ((Role) == QUIC_TP_OBSERVED_ADDRESS_ROLE_RECEIVE_ONLY || (Role) == QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH)
+
 /*************************************************************
                   PERSISTENT SETTINGS
 *************************************************************/
@@ -743,6 +765,8 @@ CXPLAT_STATIC_ASSERT(
 #define QUIC_SETTING_ADD_ADDRESS_MODE               "AddAddressMode"
 #define QUIC_SETTING_IGNORE_UNREACHABLE             "IgnoreUnreachable"
 #define QUIC_SETTING_MULTIPATH_ENABLED              "MultipathEnabled"
+#define QUIC_SETTING_SEND_OBSERVED_ADDRESS_REPORTS    "SendObservedAddressReports"
+#define QUIC_SETTING_RECEIVE_OBSERVED_ADDRESS_REPORTS "ReceiveObservedAddressReports"
 
 
 #define QUIC_SETTING_INITIAL_WINDOW_PACKETS         "InitialWindowPackets"

src/core/settings.c

@@ -191,6 +191,12 @@ QuicSettingsSetDefault(
     if (!Settings->IsSet.MultipathEnabled) {
         Settings->MultipathEnabled = QUIC_DEFAULT_MULTIPATH_ENABLED;
     }
+    if (!Settings->IsSet.SendObservedAddressReports) {
+        Settings->SendObservedAddressReports = QUIC_DEFAULT_SEND_OBSERVED_ADDRESS_REPORTS;
+    }
+    if (!Settings->IsSet.ReceiveObservedAddressReports) {
+        Settings->ReceiveObservedAddressReports = QUIC_DEFAULT_RECEIVE_OBSERVED_ADDRESS_REPORTS;
+    }
 }
 
 _IRQL_requires_max_(PASSIVE_LEVEL)
@@ -382,6 +388,12 @@ QuicSettingsCopy(
     if (!Destination->IsSet.MultipathEnabled) {
         Destination->MultipathEnabled = Source->MultipathEnabled;
     }
+    if (!Destination->IsSet.SendObservedAddressReports) {
+        Destination->SendObservedAddressReports = Source->SendObservedAddressReports;
+    }
+    if (!Destination->IsSet.ReceiveObservedAddressReports) {
+        Destination->ReceiveObservedAddressReports = Source->ReceiveObservedAddressReports;
+    }
 }
 
 _IRQL_requires_max_(PASSIVE_LEVEL)
@@ -811,6 +823,16 @@ QuicSettingApply(
         Destination->IsSet.MultipathEnabled = TRUE;
     }
 
+    if (Source->IsSet.SendObservedAddressReports && (!Destination->IsSet.SendObservedAddressReports || OverWrite)) {
+        Destination->SendObservedAddressReports = Source->SendObservedAddressReports;
+        Destination->IsSet.SendObservedAddressReports = TRUE;
+    }
+
+    if (Source->IsSet.ReceiveObservedAddressReports && (!Destination->IsSet.ReceiveObservedAddressReports || OverWrite)) {
+        Destination->ReceiveObservedAddressReports = Source->ReceiveObservedAddressReports;
+        Destination->IsSet.ReceiveObservedAddressReports = TRUE;
+    }
+
     return TRUE;
 }
 
@@ -1551,6 +1573,26 @@ QuicSettingsLoad(
             &ValueLen);
         Settings->MultipathEnabled = !!Value;
     }
+    if (!Settings->IsSet.SendObservedAddressReports) {
+        Value = QUIC_DEFAULT_SEND_OBSERVED_ADDRESS_REPORTS;
+        ValueLen = sizeof(Value);
+        CxPlatStorageReadValue(
+            Storage,
+            QUIC_SETTING_SEND_OBSERVED_ADDRESS_REPORTS,
+            (uint8_t*)&Value,
+            &ValueLen);
+        Settings->SendObservedAddressReports = !!Value;
+    }
+    if (!Settings->IsSet.ReceiveObservedAddressReports) {
+        Value = QUIC_DEFAULT_RECEIVE_OBSERVED_ADDRESS_REPORTS;
+        ValueLen = sizeof(Value);
+        CxPlatStorageReadValue(
+            Storage,
+            QUIC_SETTING_RECEIVE_OBSERVED_ADDRESS_REPORTS,
+            (uint8_t*)&Value,
+            &ValueLen);
+        Settings->ReceiveObservedAddressReports = !!Value;
+    }
 }
 
 _IRQL_requires_max_(PASSIVE_LEVEL)
@@ -1625,6 +1667,8 @@ QuicSettingsDump(
     QuicTraceLogVerbose(SettingAddAddress,                  "[sett] AddAddressMode         = %hhu", Settings->AddAddressMode);
     QuicTraceLogVerbose(SettingIgnoreUnreachable,           "[sett] IgnoreUnreachable      = %hhu", Settings->IgnoreUnreachable);
     QuicTraceLogVerbose(SettingMultipathEnabled,            "[sett] MultipathEnabled       = %hhu", Settings->MultipathEnabled);
+    QuicTraceLogVerbose(SettingSendObservedAddressReports,  "[sett] SendObservedAddrRpts   = %hhu", Settings->SendObservedAddressReports);
+    QuicTraceLogVerbose(SettingRecvObservedAddressReports,  "[sett] RecvObservedAddrRpts   = %hhu", Settings->ReceiveObservedAddressReports);
 }
 
 _IRQL_requires_max_(PASSIVE_LEVEL)
@@ -1812,6 +1856,12 @@ QuicSettingsDumpNew(
     if (Settings->IsSet.MultipathEnabled) {
         QuicTraceLogVerbose(SettingMultipathEnabled,                "[sett] MultipathEnabled           = %hhu", Settings->MultipathEnabled);
     }
+    if (Settings->IsSet.SendObservedAddressReports) {
+        QuicTraceLogVerbose(SettingSendObservedAddressReports,      "[sett] SendObservedAddrRpts       = %hhu", Settings->SendObservedAddressReports);
+    }
+    if (Settings->IsSet.ReceiveObservedAddressReports) {
+        QuicTraceLogVerbose(SettingRecvObservedAddressReports,      "[sett] RecvObservedAddrRpts       = %hhu", Settings->ReceiveObservedAddressReports);
+    }
 }
 
 #define SETTING_COPY_TO_INTERNAL(Field, Settings, InternalSettings) \
@@ -2117,6 +2167,22 @@ QuicSettingsSettingsToInternal(
         SettingsSize,
         InternalSettings);
 
+    SETTING_COPY_FLAG_TO_INTERNAL_SIZED(
+        Flags,
+        SendObservedAddressReports,
+        QUIC_SETTINGS,
+        Settings,
+        SettingsSize,
+        InternalSettings);
+
+    SETTING_COPY_FLAG_TO_INTERNAL_SIZED(
+        Flags,
+        ReceiveObservedAddressReports,
+        QUIC_SETTINGS,
+        Settings,
+        SettingsSize,
+        InternalSettings);
+
     return QUIC_STATUS_SUCCESS;
 }
 
@@ -2334,6 +2400,22 @@ QuicSettingsGetSettings(
         *SettingsLength,
         InternalSettings);
 
+    SETTING_COPY_FLAG_FROM_INTERNAL_SIZED(
+        Flags,
+        SendObservedAddressReports,
+        QUIC_SETTINGS,
+        Settings,
+        *SettingsLength,
+        InternalSettings);
+
+    SETTING_COPY_FLAG_FROM_INTERNAL_SIZED(
+        Flags,
+        ReceiveObservedAddressReports,
+        QUIC_SETTINGS,
+        Settings,
+        *SettingsLength,
+        InternalSettings);
+
     *SettingsLength = CXPLAT_MIN(*SettingsLength, sizeof(QUIC_SETTINGS));
 
     return QUIC_STATUS_SUCCESS;

src/core/settings.h

@@ -69,7 +69,9 @@ typedef struct QUIC_SETTINGS_INTERNAL {
             uint64_t AddAddressMode                         : 1;
             uint64_t IgnoreUnreachable                      : 1;
             uint64_t MultipathEnabled                       : 1;
-            uint64_t RESERVED                               : 9;
+            uint64_t SendObservedAddressReports             : 1;
+            uint64_t ReceiveObservedAddressReports          : 1;
+            uint64_t RESERVED                               : 7;
         } IsSet;
     };
 
@@ -127,6 +129,8 @@ typedef struct QUIC_SETTINGS_INTERNAL {
     uint8_t AddAddressMode                  : 2;    // QUIC_ADD_ADDRESS_MODE
     uint8_t IgnoreUnreachable               : 1;
     uint8_t MultipathEnabled                : 1;
+    uint8_t SendObservedAddressReports      : 1;
+    uint8_t ReceiveObservedAddressReports   : 1;
     uint8_t MtuDiscoveryMissingProbeCount;
 } QUIC_SETTINGS_INTERNAL;
 

src/core/transport_params.h

@@ -160,6 +160,13 @@ typedef struct QUIC_TRANSPORT_PARAMETERS {
     _Field_range_(0, QUIC_TP_MAX_PATH_ID_MAX)
     QUIC_VAR_INT InitialMaxPathId;
 
+    //
+    // The role advertised by the observed_address transport parameter. Only
+    // meaningful when QUIC_TP_FLAG_OBSERVED_ADDRESS is set.
+    //
+    _Field_range_(0, QUIC_TP_OBSERVED_ADDRESS_ROLE_BOTH)
+    QUIC_VAR_INT ObservedAddressRole;
+
 } QUIC_TRANSPORT_PARAMETERS;
 
 //

src/core/unittest/SettingsTest.cpp

@@ -133,6 +133,8 @@ TEST(SettingsTest, TestAllSettingsFieldsSet)
     SETTINGS_FEATURE_SET_TEST(AddAddressMode, QuicSettingsSettingsToInternal);
     SETTINGS_FEATURE_SET_TEST(IgnoreUnreachable, QuicSettingsSettingsToInternal);
     SETTINGS_FEATURE_SET_TEST(MultipathEnabled, QuicSettingsSettingsToInternal);
+    SETTINGS_FEATURE_SET_TEST(SendObservedAddressReports, QuicSettingsSettingsToInternal);
+    SETTINGS_FEATURE_SET_TEST(ReceiveObservedAddressReports, QuicSettingsSettingsToInternal);
 
     // Bias field count on behalf of erstwhile ReservedRioEnabled
     FieldCount++;
@@ -228,6 +230,8 @@ TEST(SettingsTest, TestAllSettingsFieldsGet)
     SETTINGS_FEATURE_GET_TEST(AddAddressMode, QuicSettingsGetSettings);
     SETTINGS_FEATURE_GET_TEST(IgnoreUnreachable, QuicSettingsGetSettings);
     SETTINGS_FEATURE_GET_TEST(MultipathEnabled, QuicSettingsGetSettings);
+    SETTINGS_FEATURE_GET_TEST(SendObservedAddressReports, QuicSettingsGetSettings);
+    SETTINGS_FEATURE_GET_TEST(ReceiveObservedAddressReports, QuicSettingsGetSettings);
 
     // Bias field count on behalf of erstwhile ReservedRioEnabled
     FieldCount++;