| 1 | /*++ |
| 2 | |
| 3 | Copyright (c) Microsoft. All rights reserved. |
| 4 | |
| 5 | Module Name: |
| 6 | |
| 7 | hcs_schema.h |
| 8 | |
| 9 | Abstract: |
| 10 | |
| 11 | This file contains the host networking service schema definitions. |
| 12 | |
| 13 | --*/ |
| 14 | |
| 15 | #pragma once |
| 16 | #include <variant> |
| 17 | #include "JsonUtils.h" |
| 18 | |
| 19 | namespace wsl::shared::hns { |
| 20 | |
| 21 | enum NetworkFlags |
| 22 | { |
| 23 | None = 0, |
| 24 | EnableDns = 1, |
| 25 | EnableDhcp = 2, |
| 26 | EnableMirroring = 4, |
| 27 | EnableNonPersistent = 8, |
| 28 | EnablePersistent = 16, |
| 29 | IsolateVSwitch = 32, |
| 30 | EnableFlowSteering = 64, |
| 31 | DisableSharing = 128, |
| 32 | EnableFirewall = 256, |
| 33 | SuppressMediaDisconnect = 512, |
| 34 | DisableHostPort = 1024, |
| 35 | WeakHostReceiveAdapter = 2048, |
| 36 | WeakHostSendAdapter = 4096, |
| 37 | EnableIov = 8192, |
| 38 | }; |
| 39 | |
| 40 | DEFINE_ENUM_FLAG_OPERATORS(NetworkFlags); |
| 41 | |
| 42 | struct HostComputeQuery |
| 43 | { |
| 44 | std::uint64_t Flags{}; |
| 45 | std::string Filter{}; |
| 46 | |
| 47 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(HostComputeQuery, Flags, Filter); |
| 48 | }; |
| 49 | |
| 50 | struct Version |
| 51 | { |
| 52 | uint32_t Major{}; |
| 53 | uint32_t Minor{}; |
| 54 | |
| 55 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Version, Major, Minor); |
| 56 | }; |
| 57 | |
| 58 | enum class EndpointPolicyType |
| 59 | { |
| 60 | PortName = 9, |
| 61 | Firewall = 18 |
| 62 | }; |
| 63 | |
| 64 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 65 | EndpointPolicyType, |
| 66 | { |
| 67 | {EndpointPolicyType::PortName, "PortName"}, |
| 68 | {EndpointPolicyType::Firewall, "Firewall"}, |
| 69 | }) |
| 70 | |
| 71 | struct PortnameEndpointPolicySetting |
| 72 | { |
| 73 | std::wstring Name; |
| 74 | |
| 75 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(PortnameEndpointPolicySetting, Name); |
| 76 | }; |
| 77 | |
| 78 | enum class FirewallPolicyFlags |
| 79 | { |
| 80 | None = 0, |
| 81 | ConstrainedInterface = 1 |
| 82 | }; |
| 83 | |
| 84 | struct FirewallPolicySetting |
| 85 | { |
| 86 | GUID VmCreatorId{}; |
| 87 | FirewallPolicyFlags PolicyFlags{}; |
| 88 | |
| 89 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(FirewallPolicySetting, VmCreatorId, PolicyFlags); |
| 90 | }; |
| 91 | |
| 92 | template <typename T> |
| 93 | struct EndpointPolicy |
| 94 | { |
| 95 | EndpointPolicyType Type{}; |
| 96 | T Settings{}; |
| 97 | }; |
| 98 | |
| 99 | template <typename T> |
| 100 | inline void to_json(nlohmann::json& j, const EndpointPolicy<T>& policy) |
| 101 | { |
| 102 | j = nlohmann::json{{"Type", policy.Type}, {"Settings", policy.Settings}}; |
| 103 | } |
| 104 | |
| 105 | struct IpConfig |
| 106 | { |
| 107 | std::wstring IpAddress; |
| 108 | |
| 109 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(IpConfig, IpAddress); |
| 110 | }; |
| 111 | |
| 112 | template <typename... Args> |
| 113 | inline void to_json(nlohmann::json& j, const std::variant<Args...>& variant) |
| 114 | { |
| 115 | std::visit<void>([&j](auto e) { to_json(j, e); }, variant); |
| 116 | } |
| 117 | |
| 118 | struct HostComputeEndpoint |
| 119 | { |
| 120 | std::vector<std::variant<EndpointPolicy<PortnameEndpointPolicySetting>, EndpointPolicy<FirewallPolicySetting>>> Policies; |
| 121 | std::vector<IpConfig> IpConfigurations; |
| 122 | Version SchemaVersion{}; |
| 123 | GUID HostComputeNetwork{}; |
| 124 | |
| 125 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(HostComputeEndpoint, Policies, IpConfigurations, SchemaVersion, HostComputeNetwork); |
| 126 | }; |
| 127 | |
| 128 | struct InterfaceConstraint |
| 129 | { |
| 130 | GUID InterfaceGuid{}; |
| 131 | uint32_t InterfaceIndex{}; |
| 132 | uint32_t InterfaceMediaType{}; |
| 133 | std::wstring InterfaceAlias{}; |
| 134 | |
| 135 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(InterfaceConstraint, InterfaceGuid, InterfaceIndex, InterfaceMediaType, InterfaceAlias); |
| 136 | }; |
| 137 | |
| 138 | struct HNSEndpoint |
| 139 | { |
| 140 | std::wstring IPAddress; |
| 141 | std::wstring MacAddress; |
| 142 | std::wstring GatewayAddress; |
| 143 | std::wstring PortFriendlyName; |
| 144 | GUID VirtualNetwork{}; |
| 145 | std::wstring VirtualNetworkName; |
| 146 | std::wstring Name; |
| 147 | GUID ID{}; |
| 148 | uint8_t PrefixLength{}; |
| 149 | InterfaceConstraint InterfaceConstraint{}; |
| 150 | std::wstring DNSServerList; |
| 151 | |
| 152 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT( |
| 153 | HNSEndpoint, IPAddress, MacAddress, GatewayAddress, PortFriendlyName, VirtualNetwork, VirtualNetworkName, Name, ID, PrefixLength, InterfaceConstraint, DNSServerList); |
| 154 | }; |
| 155 | |
| 156 | struct Route |
| 157 | { |
| 158 | std::wstring NextHop; |
| 159 | std::wstring DestinationPrefix; |
| 160 | uint8_t SitePrefixLength{}; |
| 161 | uint32_t Metric{}; |
| 162 | uint16_t Family{}; |
| 163 | |
| 164 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Route, NextHop, DestinationPrefix, SitePrefixLength, Metric, Family); |
| 165 | }; |
| 166 | |
| 167 | enum class ModifyRequestType |
| 168 | { |
| 169 | Add = 0, |
| 170 | Remove = 1, |
| 171 | Update = 2, |
| 172 | Refresh = 3, |
| 173 | Reset = 4, |
| 174 | }; |
| 175 | |
| 176 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 177 | ModifyRequestType, |
| 178 | { |
| 179 | {ModifyRequestType::Add, "Add"}, |
| 180 | {ModifyRequestType::Remove, "Remove"}, |
| 181 | {ModifyRequestType::Update, "Update"}, |
| 182 | {ModifyRequestType::Refresh, "Refresh"}, |
| 183 | {ModifyRequestType::Reset, "Reset"}, |
| 184 | }) |
| 185 | |
| 186 | enum class GuestEndpointResourceType |
| 187 | { |
| 188 | Interface = 0, |
| 189 | Route = 1, |
| 190 | IPAddress = 2, |
| 191 | DNS = 3, |
| 192 | MacAddress = 6, |
| 193 | Neighbor = 10, |
| 194 | Port = 15 |
| 195 | }; |
| 196 | |
| 197 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 198 | GuestEndpointResourceType, |
| 199 | { |
| 200 | {GuestEndpointResourceType::Interface, "Interface"}, |
| 201 | {GuestEndpointResourceType::Route, "Route"}, |
| 202 | {GuestEndpointResourceType::IPAddress, "IPAddress"}, |
| 203 | {GuestEndpointResourceType::DNS, "DNS"}, |
| 204 | {GuestEndpointResourceType::MacAddress, "MacAddress"}, |
| 205 | {GuestEndpointResourceType::Neighbor, "Neighbor"}, |
| 206 | {GuestEndpointResourceType::Port, "Port"}, |
| 207 | }) |
| 208 | |
| 209 | struct DNS |
| 210 | { |
| 211 | std::wstring Domain; |
| 212 | std::wstring Search; |
| 213 | std::wstring ServerList; |
| 214 | std::wstring Options; |
| 215 | |
| 216 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(DNS, Domain, Search, ServerList, Options); |
| 217 | }; |
| 218 | |
| 219 | struct IPAddress |
| 220 | { |
| 221 | std::wstring Address; |
| 222 | uint16_t Family{}; |
| 223 | uint8_t OnLinkPrefixLength{}; |
| 224 | uint8_t PrefixOrigin{}; |
| 225 | uint8_t SuffixOrigin{}; |
| 226 | uint32_t PreferredLifetime{}; |
| 227 | |
| 228 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(IPAddress, Address, Family, OnLinkPrefixLength, PrefixOrigin, SuffixOrigin, PreferredLifetime); |
| 229 | }; |
| 230 | |
| 231 | enum class OperationType |
| 232 | { |
| 233 | Create, |
| 234 | Update, |
| 235 | Remove |
| 236 | }; |
| 237 | |
| 238 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 239 | OperationType, {{OperationType::Create, "Create"}, {OperationType::Update, "Update"}, {OperationType::Remove, "Remove"}}) |
| 240 | |
| 241 | struct LoopbackRoutesRequest |
| 242 | { |
| 243 | std::wstring targetDeviceName; |
| 244 | OperationType operation{}; |
| 245 | uint32_t family{}; |
| 246 | std::wstring ipAddress; |
| 247 | |
| 248 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(LoopbackRoutesRequest, operation, targetDeviceName, family, ipAddress); |
| 249 | }; |
| 250 | |
| 251 | struct NetworkInterface |
| 252 | { |
| 253 | bool Connected{}; |
| 254 | uint32_t NlMtu{}; |
| 255 | uint32_t Metric{}; |
| 256 | |
| 257 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(NetworkInterface, Connected, NlMtu, Metric); |
| 258 | }; |
| 259 | |
| 260 | enum class InitialIpConfigurationNotificationFlags |
| 261 | { |
| 262 | None = 0x0, |
| 263 | SkipPrimaryRoutingTableUpdate = 0x1, |
| 264 | SkipLoopbackRouteReset = 0x2 |
| 265 | }; |
| 266 | |
| 267 | DEFINE_ENUM_FLAG_OPERATORS(InitialIpConfigurationNotificationFlags); |
| 268 | |
| 269 | struct InitialIpConfigurationNotification |
| 270 | { |
| 271 | std::wstring targetDeviceName; |
| 272 | InitialIpConfigurationNotificationFlags flags{}; |
| 273 | |
| 274 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(InitialIpConfigurationNotification, targetDeviceName, flags); |
| 275 | }; |
| 276 | |
| 277 | struct VmNicCreatedNotification |
| 278 | { |
| 279 | GUID adapterId{}; |
| 280 | |
| 281 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(VmNicCreatedNotification, adapterId); |
| 282 | }; |
| 283 | |
| 284 | enum class DeviceType |
| 285 | { |
| 286 | Bond, |
| 287 | Loopback, |
| 288 | VirtualWifi, |
| 289 | VirtualTunnel, |
| 290 | VirtualCellular |
| 291 | }; |
| 292 | |
| 293 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 294 | DeviceType, |
| 295 | { |
| 296 | {DeviceType::Bond, "Bond"}, |
| 297 | {DeviceType::Loopback, "Loopback"}, |
| 298 | {DeviceType::VirtualWifi, "VirtualWifi"}, |
| 299 | {DeviceType::VirtualTunnel, "VirtualTunnel"}, |
| 300 | {DeviceType::VirtualCellular, "VirtualCellular"}, |
| 301 | }) |
| 302 | |
| 303 | enum class CreateDeviceFlags |
| 304 | { |
| 305 | None = 0, |
| 306 | DisableDAD = 1 |
| 307 | }; |
| 308 | |
| 309 | DEFINE_ENUM_FLAG_OPERATORS(CreateDeviceFlags); |
| 310 | |
| 311 | struct CreateDeviceRequest |
| 312 | { |
| 313 | DeviceType type{}; |
| 314 | std::wstring deviceName; |
| 315 | std::optional<GUID> lowerEdgeAdapterId; |
| 316 | std::optional<std::wstring> lowerEdgeDeviceName; |
| 317 | CreateDeviceFlags flags{CreateDeviceFlags::None}; |
| 318 | }; |
| 319 | |
| 320 | NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_FROM_ONLY(CreateDeviceRequest, type, deviceName, lowerEdgeAdapterId, lowerEdgeDeviceName, flags); |
| 321 | |
| 322 | inline void to_json(nlohmann::json& j, const CreateDeviceRequest& request) |
| 323 | { |
| 324 | j = nlohmann::json{{"type", request.type}, {"deviceName", request.deviceName}, {"flags", request.flags}}; |
| 325 | |
| 326 | if (request.lowerEdgeAdapterId.has_value()) |
| 327 | { |
| 328 | j["lowerEdgeAdapterId"] = request.lowerEdgeAdapterId.value(); |
| 329 | } |
| 330 | |
| 331 | if (request.lowerEdgeDeviceName.has_value()) |
| 332 | { |
| 333 | j["lowerEdgeDeviceName"] = request.lowerEdgeDeviceName.value(); |
| 334 | } |
| 335 | } |
| 336 | |
| 337 | struct ModifyGuestDeviceSettingRequest |
| 338 | { |
| 339 | std::wstring targetDeviceName; |
| 340 | |
| 341 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(ModifyGuestDeviceSettingRequest, targetDeviceName); |
| 342 | }; |
| 343 | |
| 344 | struct InterfaceNetFilterRequest |
| 345 | { |
| 346 | std::wstring targetDeviceName; |
| 347 | OperationType operation{}; |
| 348 | uint16_t ephemeralPortRangeStart{}; |
| 349 | uint16_t ephemeralPortRangeEnd{}; |
| 350 | |
| 351 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(InterfaceNetFilterRequest, targetDeviceName, operation, ephemeralPortRangeStart, ephemeralPortRangeEnd); |
| 352 | }; |
| 353 | |
| 354 | struct MacAddress |
| 355 | { |
| 356 | std::string PhysicalAddress; |
| 357 | |
| 358 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(MacAddress, PhysicalAddress); |
| 359 | }; |
| 360 | |
| 361 | template <typename T> |
| 362 | struct ModifyGuestEndpointSettingRequest |
| 363 | { |
| 364 | ModifyRequestType RequestType{}; |
| 365 | GuestEndpointResourceType ResourceType{}; |
| 366 | T Settings{}; |
| 367 | |
| 368 | std::optional<std::wstring> targetDeviceName; |
| 369 | }; |
| 370 | |
| 371 | NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_FROM_ONLY( |
| 372 | ModifyGuestEndpointSettingRequest<NetworkInterface>, RequestType, ResourceType, targetDeviceName, Settings); |
| 373 | |
| 374 | template <> |
| 375 | struct ModifyGuestEndpointSettingRequest<void> |
| 376 | { |
| 377 | ModifyRequestType RequestType{}; |
| 378 | GuestEndpointResourceType ResourceType{}; |
| 379 | std::optional<std::wstring> targetDeviceName; |
| 380 | }; |
| 381 | |
| 382 | NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_FROM_ONLY(ModifyGuestEndpointSettingRequest<void>, RequestType, ResourceType, targetDeviceName); |
| 383 | |
| 384 | template <typename T> |
| 385 | inline void to_json(nlohmann::json& j, const ModifyGuestEndpointSettingRequest<T>& request) |
| 386 | { |
| 387 | j = nlohmann::json{{"ResourceType", request.ResourceType}, {"RequestType", request.RequestType}}; |
| 388 | |
| 389 | if (request.targetDeviceName.has_value()) |
| 390 | { |
| 391 | j["targetDeviceName"] = request.targetDeviceName.value(); |
| 392 | } |
| 393 | |
| 394 | if constexpr (!std::is_same_v<T, void>) |
| 395 | { |
| 396 | j["Settings"] = request.Settings; |
| 397 | } |
| 398 | } |
| 399 | |
| 400 | struct IpSubnet |
| 401 | { |
| 402 | std::wstring IpAddressPrefix; |
| 403 | |
| 404 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(IpSubnet, IpAddressPrefix); |
| 405 | }; |
| 406 | |
| 407 | struct Subnet |
| 408 | { |
| 409 | std::wstring GatewayAddress; |
| 410 | std::wstring AddressPrefix; |
| 411 | std::vector<IpSubnet> IpSubnets; |
| 412 | |
| 413 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Subnet, GatewayAddress, AddressPrefix, IpSubnets); |
| 414 | }; |
| 415 | |
| 416 | struct HNSNetwork |
| 417 | { |
| 418 | std::wstring ID; |
| 419 | std::wstring Name; |
| 420 | std::wstring SourceMac; |
| 421 | std::wstring DNSSuffix; |
| 422 | std::wstring DNSServerList; |
| 423 | std::wstring DNSDomain; |
| 424 | std::vector<Subnet> Subnets; |
| 425 | NetworkFlags Flags{}; |
| 426 | InterfaceConstraint InterfaceConstraint{}; |
| 427 | |
| 428 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(HNSNetwork, ID, Name, SourceMac, DNSSuffix, DNSServerList, DNSDomain, Subnets, Flags, InterfaceConstraint); |
| 429 | }; |
| 430 | |
| 431 | enum class NetworkMode |
| 432 | { |
| 433 | NAT, |
| 434 | ICS, |
| 435 | ConstrainedICS |
| 436 | }; |
| 437 | |
| 438 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 439 | NetworkMode, |
| 440 | { |
| 441 | {NetworkMode::NAT, "NAT"}, |
| 442 | {NetworkMode::ICS, "ICS"}, |
| 443 | {NetworkMode::ConstrainedICS, "ConstrainedICS"}, |
| 444 | }) |
| 445 | |
| 446 | struct Network |
| 447 | { |
| 448 | std::wstring Name; |
| 449 | NetworkMode Type{}; |
| 450 | bool IsolateSwitch{}; |
| 451 | NetworkFlags Flags{}; |
| 452 | std::vector<Subnet> Subnets; |
| 453 | InterfaceConstraint InterfaceConstraint{}; |
| 454 | |
| 455 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Network, Name, Type, IsolateSwitch, Subnets, Flags, InterfaceConstraint); |
| 456 | }; |
| 457 | |
| 458 | struct NotificationBase |
| 459 | { |
| 460 | GUID ID{}; |
| 461 | uint32_t Flags{}; |
| 462 | |
| 463 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(NotificationBase, ID, Flags); |
| 464 | }; |
| 465 | |
| 466 | enum class RpcEndpointType |
| 467 | { |
| 468 | LRpc |
| 469 | }; |
| 470 | |
| 471 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 472 | RpcEndpointType, |
| 473 | { |
| 474 | {RpcEndpointType::LRpc, "LRpc"}, |
| 475 | }) |
| 476 | |
| 477 | struct RpcConnectionInformation |
| 478 | { |
| 479 | RpcEndpointType EndpointType{}; |
| 480 | GUID ObjectUuid{}; |
| 481 | |
| 482 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(RpcConnectionInformation, EndpointType, ObjectUuid); |
| 483 | }; |
| 484 | |
| 485 | enum class GuestNetworkServiceFlags |
| 486 | { |
| 487 | IsFlowsteered = 1, |
| 488 | IsFlowsteeredSelfManaged = 2, |
| 489 | }; |
| 490 | |
| 491 | DEFINE_ENUM_FLAG_OPERATORS(GuestNetworkServiceFlags); |
| 492 | |
| 493 | struct GuestNetworkService |
| 494 | { |
| 495 | GUID VirtualMachineId{}; |
| 496 | bool MirrorHostNetworking{}; |
| 497 | Version SchemaVersion{}; |
| 498 | RpcConnectionInformation GnsRpcServerInformation{}; |
| 499 | GuestNetworkServiceFlags Flags{}; |
| 500 | |
| 501 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(GuestNetworkService, VirtualMachineId, MirrorHostNetworking, SchemaVersion, GnsRpcServerInformation, Flags); |
| 502 | }; |
| 503 | |
| 504 | enum class GuestNetworkServiceState |
| 505 | { |
| 506 | None, |
| 507 | Created, |
| 508 | Bootstrapping, |
| 509 | Synchronized, |
| 510 | Paused, |
| 511 | Desynchronized, |
| 512 | Rehydrating, |
| 513 | Degraded, |
| 514 | Destroyed, |
| 515 | }; |
| 516 | |
| 517 | NLOHMANN_JSON_SERIALIZE_ENUM( |
| 518 | GuestNetworkServiceState, |
| 519 | { |
| 520 | {GuestNetworkServiceState::None, "None"}, |
| 521 | {GuestNetworkServiceState::Created, "Created"}, |
| 522 | {GuestNetworkServiceState::Bootstrapping, "Bootstrapping"}, |
| 523 | {GuestNetworkServiceState::Synchronized, "Synchronized"}, |
| 524 | {GuestNetworkServiceState::Paused, "Paused"}, |
| 525 | {GuestNetworkServiceState::Desynchronized, "Desynchronized"}, |
| 526 | {GuestNetworkServiceState::Rehydrating, "Rehydrating"}, |
| 527 | {GuestNetworkServiceState::Degraded, "Degraded"}, |
| 528 | {GuestNetworkServiceState::Destroyed, "Destroyed"}, |
| 529 | }) |
| 530 | |
| 531 | struct GuestNetworkServiceStateRequest |
| 532 | { |
| 533 | GuestNetworkServiceState State{}; |
| 534 | |
| 535 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(GuestNetworkServiceStateRequest, State); |
| 536 | }; |
| 537 | |
| 538 | enum GuestNetworkServiceResourceType |
| 539 | { |
| 540 | State |
| 541 | }; |
| 542 | |
| 543 | NLOHMANN_JSON_SERIALIZE_ENUM(GuestNetworkServiceResourceType, {{GuestNetworkServiceResourceType::State, "State"}}) |
| 544 | |
| 545 | struct ModifyGuestNetworkServiceSettingRequest |
| 546 | { |
| 547 | GuestNetworkServiceResourceType ResourceType{}; |
| 548 | GuestNetworkServiceStateRequest Settings{}; |
| 549 | ModifyRequestType RequestType{}; |
| 550 | |
| 551 | NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(ModifyGuestNetworkServiceSettingRequest, ResourceType, RequestType, Settings); |
| 552 | }; |
| 553 | |
| 554 | } // namespace wsl::shared::hns |