src/firmware/gigaboot/src/tcp.c - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #define DEBUG_LOGGING 0

 #include "tcp.h"

 #include <log.h>
 #include <stdio.h>
 #include <string.h>
 #include <xefi.h>

 #include <efi/boot-services.h>

 #include "compiler.h"
 #include "inet6.h"

 static efi_guid kTcp6ServiceBindingProtocolGuid = EFI_TCP6_SERVICE_BINDING_PROTOCOL_GUID;
 static efi_guid kTcp6ProtocolGuid = EFI_TCP6_PROTOCOL_GUID;

 // Dumps the TCP state for debugging purposes.
 static void __UNUSED dump_state(efi_tcp6_protocol* protocol) {
   efi_tcp6_connection_state connection_state;
   efi_tcp6_option option = {};
   efi_tcp6_config_data config_data = {.ControlOption = &option};
   efi_ip6_mode_data mode_data = {};
   efi_managed_network_config_data managed_network_config_data = {};
   efi_simple_network_mode simple_network_mode = {};
   efi_status status = protocol->GetModeData(protocol, &connection_state, &config_data, &mode_data,
                                             &managed_network_config_data, &simple_network_mode);
   if (status != EFI_SUCCESS) {
     ELOG_S(status, "Failed to fetch TCP6 mode data");
     return;
   }

   char ip_buffer[IP6TOAMAX];
   LOG("Connection state: %d", connection_state);
   LOG("Config data:");
   LOG("  TrafficClass: %u", config_data.TrafficClass);
   LOG("  HopLimit: %u", config_data.HopLimit);
   LOG("  AccessPoint:");
   LOG("    StationAddress: %s", ip6toa(ip_buffer, &config_data.AccessPoint.StationAddress));
   LOG("    StationPort: %d", config_data.AccessPoint.StationPort);
   LOG("    RemoteAddress: %s", ip6toa(ip_buffer, &config_data.AccessPoint.RemoteAddress));
   LOG("    RemotePort: %d", config_data.AccessPoint.RemotePort);
   LOG("    ActiveFlag: %d", config_data.AccessPoint.ActiveFlag);
   LOG("  ControlOption:");
   LOG("    ReceiveBufferSize: %u", config_data.ControlOption->ReceiveBufferSize);
   LOG("    SendBufferSize: %u", config_data.ControlOption->SendBufferSize);
   LOG("    MaxSynBackLog: %u", config_data.ControlOption->MaxSynBackLog);
   LOG("    ConnectionTimeout: %u", config_data.ControlOption->ConnectionTimeout);
   LOG("    DataRetries: %u", config_data.ControlOption->DataRetries);
   LOG("    FinTimeout: %u", config_data.ControlOption->FinTimeout);
   LOG("    TimeWaitTimeout: %u", config_data.ControlOption->TimeWaitTimeout);
   LOG("    KeepAliveProbes: %u", config_data.ControlOption->KeepAliveProbes);
   LOG("    KeepAliveTime: %u", config_data.ControlOption->KeepAliveTime);
   LOG("    KeepAliveInterval: %u", config_data.ControlOption->KeepAliveInterval);
   LOG("    EnableNagle: %d", config_data.ControlOption->EnableNagle);
   LOG("    EnableTimeStamp: %d", config_data.ControlOption->EnableTimeStamp);
   LOG("    EnableWindowScaling: %d", config_data.ControlOption->EnableWindowScaling);
   LOG("    EnableSelectiveAck: %d", config_data.ControlOption->EnableSelectiveAck);
   LOG("    EnablePathMtuDiscovery: %d", config_data.ControlOption->EnablePathMtuDiscovery);
   // We could dump the rest of the structs here as well if useful, but for now
   // this contains most of the relevant info.
 }

 // Converts the given efi_status to the more generic TCP6_RESULT code.
 static tcp6_result status_to_tcp6_result(efi_status status) {
   switch (status) {
     case EFI_SUCCESS:
       return TCP6_RESULT_SUCCESS;
     case EFI_NOT_READY:
       return TCP6_RESULT_PENDING;
     case EFI_CONNECTION_FIN:
       FALLTHROUGH;
     case EFI_CONNECTION_RESET:
       DLOG_S(status, "TCP6 client has disconnected");
       return TCP6_RESULT_DISCONNECTED;
     default:
       ELOG_S(status, "TCP6 error");
       return TCP6_RESULT_ERROR;
   }
 }

 // Closes the token's event and resets the state.
 static void reset_token(efi_boot_services* boot_services, efi_tcp6_completion_token* token) {
   if (token->Event) {
     efi_status status = boot_services->CloseEvent(token->Event);
     if (status != EFI_SUCCESS) {
       // Log a warning, but keep going. Failure to close essentially means
       // whatever we were trying to close is already gone.
       WLOG_S(status, "Failed to close TCP event");
     }
     token->Event = NULL;
   }
   token->Status = EFI_SUCCESS;
 }

 // Checks if the completion token is done.
 //
 // On success or error, resets the token and returns the resulting status.
 // If the event is still pending, returns TCP6_RESULT_PENDING.
 static tcp6_result check_token(efi_boot_services* boot_services, efi_tcp6_completion_token* token) {
   efi_status status = boot_services->CheckEvent(token->Event);

   // If the event completed, return the final token status.
   // Do this first so we don't lose the token status when we reset it.
   if (status == EFI_SUCCESS) {
     status = token->Status;
   }

   // Anything except pending, reset the event since we're done with it.
   if (status != EFI_NOT_READY) {
     reset_token(boot_services, token);
   }

   return status_to_tcp6_result(status);
 }

 tcp6_result tcp6_open(tcp6_socket* socket, efi_boot_services* boot_services,
                       const efi_ipv6_addr* address, uint16_t port) {
   memset(socket, 0, sizeof(*socket));

   socket->boot_services = boot_services;

   // TCP uses the service binding protocol mechanism, so we have to open the
   // binding protocol first then open the actual protocol child.
   DLOG("Locating TCP6 binding handle");
   efi_handle* handles;
   size_t num_handles = 0;
   efi_status status = boot_services->LocateHandleBuffer(
       ByProtocol, &kTcp6ServiceBindingProtocolGuid, NULL, &num_handles, &handles);
   if (status != EFI_SUCCESS) {
     ELOG_S(status, "Failed to locate any TCP handles");
     return TCP6_RESULT_ERROR;
   }

   if (num_handles == 0) {
     ELOG("No TCP service handles found");
     boot_services->FreePool(handles);
     return TCP6_RESULT_ERROR;
   } else if (num_handles > 1) {
     // To keep things simple for now, just always take the first handle. We'll
     // probably want to improve this in the future.
     WLOG("Found %zu TCP service handles, but only using the first", num_handles);
   }
   socket->binding_handle = handles[0];
   boot_services->FreePool(handles);

   DLOG("Opening TCP6 binding protocol");
   status = boot_services->OpenProtocol(socket->binding_handle, &kTcp6ServiceBindingProtocolGuid,
                                        (void**)&socket->binding_protocol, gImg, NULL,
                                        EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
   if (status != EFI_SUCCESS) {
     ELOG_S(status, "Failed to open TCP binding protocol");
     return TCP6_RESULT_ERROR;
   }

   DLOG("Creating TCP6 server handle");
   status = socket->binding_protocol->CreateChild(socket->binding_protocol, &socket->server_handle);
   if (status != EFI_SUCCESS) {
     ELOG_S(status, "Failed to create TCP child handle");
     tcp6_close(socket);
     return TCP6_RESULT_ERROR;
   }

   DLOG("Opening TCP6 server protocol");
   status = boot_services->OpenProtocol(socket->server_handle, &kTcp6ProtocolGuid,
                                        (void**)&socket->server_protocol, gImg, NULL,
                                        EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
   if (status != EFI_SUCCESS) {
     ELOG_S(status, "Failed to open TCP protocol");
     tcp6_close(socket);
     return TCP6_RESULT_ERROR;
   }

   efi_tcp6_config_data config_data = {
       .TrafficClass = 0,  // Default forwarding, no congestion notification.
       .HopLimit = 0xFF,   // Maximum hop limit.
       .AccessPoint = {.StationAddress = *address,
                       .StationPort = port,
                       .RemoteAddress = {},
                       .RemotePort = 0,
                       .ActiveFlag = false},
       .ControlOption = NULL  // Use defaults.
   };

   char ip_buffer[IP6TOAMAX] __UNUSED;
   DLOG("Configuring TCP6 server for [%s]:%d",
        ip6toa(ip_buffer, &config_data.AccessPoint.StationAddress), port);
   status = socket->server_protocol->Configure(socket->server_protocol, &config_data);
   if (status != EFI_SUCCESS) {
     // Configure() will sometimes return EFI_INVALID_PARAMETER early on but
     // then succeed with the same parameters later, I think because any given
     // IP address will be invalid until the link is fully up. This is pretty
     // normal, so only debug log in this case to avoid spamming the console.
     if (status == EFI_INVALID_PARAMETER) {
       DLOG_S(status, "TCP configure failed - link not up yet?");
     } else {
       ELOG_S(status, "Failed to configure TCP protocol");
     }
     tcp6_close(socket);
     return TCP6_RESULT_ERROR;
   }

 #if DEBUG_LOGGING
   DLOG("== TCP6 server state ==");
   dump_state(socket->server_protocol);
 #endif  // DEBUG_LOGGING

   DLOG("TCP6 open success");
   return TCP6_RESULT_SUCCESS;
 }

 tcp6_result tcp6_accept(tcp6_socket* socket) {
   // Currently for simplicity we only support a single TCP client at a time.
   if (socket->client_protocol != NULL) {
     ELOG("A TCP client is already connected");
     return TCP6_RESULT_ERROR;
   }

   // If we don't have a server_event yet, start listening on this socket.
   if (socket->server_accept_token.CompletionToken.Event == NULL) {
     DLOG("Creating TCP6 listen event");
     efi_status status = socket->boot_services->CreateEvent(
         0, 0, NULL, NULL, &socket->server_accept_token.CompletionToken.Event);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "Failed to create TCP6 listen event");
       return TCP6_RESULT_ERROR;
     }

     DLOG("Accepting incoming TCP6 connections");
     status = socket->server_protocol->Accept(socket->server_protocol, &socket->server_accept_token);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "TCP accept failed");
       reset_token(socket->boot_services, &socket->server_accept_token.CompletionToken);
       return TCP6_RESULT_ERROR;
     }
   }

   tcp6_result result =
       check_token(socket->boot_services, &socket->server_accept_token.CompletionToken);
   if (result == TCP6_RESULT_SUCCESS) {
     DLOG("TCP6 client is ready");
     socket->client_handle = socket->server_accept_token.NewChildHandle;
     efi_status status = socket->boot_services->OpenProtocol(
         socket->client_handle, &kTcp6ProtocolGuid, (void**)&socket->client_protocol, gImg, NULL,
         EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "Failed to open TCP client protocol");
       return TCP6_RESULT_ERROR;
     }

     // Lookup and print the client IP if we're debug logging.
     if (DEBUG_LOGGING) {
       efi_tcp6_config_data config_data = {};
       status = socket->client_protocol->GetModeData(socket->client_protocol, NULL, &config_data,
                                                     NULL, NULL, NULL);
       if (status != EFI_SUCCESS) {
         WLOG_S(status, "Failed to fetch new client IP");
       } else {
         char ip_buffer[IP6TOAMAX];
         LOG("New TCP client: %s", ip6toa(ip_buffer, &config_data.AccessPoint.RemoteAddress));
       }
     }
   }
   return result;
 }

 tcp6_result tcp6_read(tcp6_socket* socket, void* data, uint32_t size) {
   if (socket->client_protocol == NULL) {
     ELOG("No TCP client to read from");
     return TCP6_RESULT_ERROR;
   }

   // If there isn't a read in progress, start a new one.
   if (socket->read_token.CompletionToken.Event == NULL) {
     DLOG("Creating TCP6 read event");
     efi_status status = socket->boot_services->CreateEvent(
         0, 0, NULL, NULL, &socket->read_token.CompletionToken.Event);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "Failed to create TCP6 read event");
       return TCP6_RESULT_ERROR;
     }

     // Store the original read end so that we can internally handle partial
     // reads. The EFI documentation isn't clear whether drivers can give us
     // partial reads or not, so assume that they will.
     socket->read_end = (uint8_t*)data + size;
     socket->read_data.UrgentFlag = false;
     socket->read_data.DataLength = size;
     socket->read_data.FragmentCount = 1;
     socket->read_data.FragmentTable[0].FragmentBuffer = data;
     socket->read_data.FragmentTable[0].FragmentLength = size;
     socket->read_token.Packet.RxData = &socket->read_data;

     status = socket->client_protocol->Receive(socket->client_protocol, &socket->read_token);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "TCP read failed to start");
       reset_token(socket->boot_services, &socket->read_token.CompletionToken);
       return TCP6_RESULT_ERROR;
     }
   }

   // The interrupt rate can be pretty slow (10-20ms) which really hurts
   // performance on larger transfers, so manually poll whenever we're waiting
   // for a read.
   socket->client_protocol->Poll(socket->client_protocol);

   tcp6_result result = check_token(socket->boot_services, &socket->read_token.CompletionToken);
   if (result == TCP6_RESULT_SUCCESS) {
     DLOG("TCP6 read: %u bytes\n", socket->read_token.Packet.RxData->DataLength);

     // Check if we're done with the read.
     uint8_t* end = (uint8_t*)socket->read_token.Packet.RxData->FragmentTable[0].FragmentBuffer +
                    socket->read_token.Packet.RxData->FragmentTable[0].FragmentLength;
     if (end > socket->read_end) {
       // Only possible if the driver is misbehaving and gives us more data than
       // we asked for.
       ELOG("TCP driver returned more data than expected");
       return TCP6_RESULT_ERROR;
     }
     if (end < socket->read_end) {
       // Partial read - advance the buffers and read again.

       // 32-bit cast is safe because we calculated read_end by adding a 32-bit
       // size in the first place, so the difference must be < 32 bits.
       uint32_t remaining = (uint32_t)(socket->read_end - end);
       DLOG("TCP6 partial read; starting again on the next %u bytes", remaining);
       return tcp6_read(socket, end, remaining);
     }
   }
   return result;
 }

 tcp6_result tcp6_write(tcp6_socket* socket, const void* data, uint32_t size) {
   if (socket->client_protocol == NULL) {
     ELOG("No TCP client to write to");
     return TCP6_RESULT_ERROR;
   }

   // If there isn't a write in progress, start a new one.
   if (socket->write_token.CompletionToken.Event == NULL) {
     DLOG("Creating TCP6 write event");
     efi_status status = socket->boot_services->CreateEvent(
         0, 0, NULL, NULL, &socket->write_token.CompletionToken.Event);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "Failed to create TCP6 write event");
       return TCP6_RESULT_ERROR;
     }

     // For our usage, we nearly always want to send data out right away since
     // fastboot is a pretty sequential protocol, so just always push for now.
     socket->write_data.Push = true;
     socket->write_data.Urgent = false;
     socket->write_data.DataLength = size;
     socket->write_data.FragmentCount = 1;
     socket->write_data.FragmentTable[0].FragmentBuffer = (void*)data;
     socket->write_data.FragmentTable[0].FragmentLength = size;
     socket->write_token.Packet.TxData = &socket->write_data;

     status = socket->client_protocol->Transmit(socket->client_protocol, &socket->write_token);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "TCP write failed to start");
       reset_token(socket->boot_services, &socket->write_token.CompletionToken);
       return status_to_tcp6_result(status);
     }
   }

   // Manually poll to improve performance for large transfers.
   socket->client_protocol->Poll(socket->client_protocol);

   tcp6_result result = check_token(socket->boot_services, &socket->write_token.CompletionToken);
   if (result == TCP6_RESULT_SUCCESS) {
     DLOG("TCP6 write: %u bytes", socket->write_token.Packet.TxData->DataLength);

     // The EFI documentation indicates that writes do not update the TxData
     // struct, which means it must not support partial writes (since it would
     // be impossible to know how much data was written). Double-check here
     // so that we are alerted if this assumption ever fails.
     if (socket->write_token.Packet.TxData->DataLength != size) {
       ELOG("TCP6 write expected %u bytes, but only sent %u", size,
            socket->write_token.Packet.TxData->DataLength);
       return TCP6_RESULT_ERROR;
     }
   }
   return result;
 }

 static tcp6_result close_protocol(efi_boot_services* boot_services, efi_tcp6_protocol* protocol,
                                   efi_handle handle, efi_tcp6_close_token* close_token) {
   // No-op if we don't currently have a connected protocol.
   if (protocol == NULL) {
     return EFI_SUCCESS;
   }

   // If we don't have a close event yet, start the close.
   if (close_token->CompletionToken.Event == NULL) {
     DLOG("Creating TCP6 close event");
     efi_status status =
         boot_services->CreateEvent(0, 0, NULL, NULL, &close_token->CompletionToken.Event);
     if (status != EFI_SUCCESS) {
       ELOG_S(status, "Failed to create close event");
       return TCP6_RESULT_ERROR;
     }

     DLOG("Starting TCP6 close");
     status = protocol->Close(protocol, close_token);
     if (status != EFI_SUCCESS) {
       reset_token(boot_services, &close_token->CompletionToken);
       if (status == EFI_NOT_STARTED) {
         // NOT_STARTED is OK, means the protocol is already closed.
         return TCP6_RESULT_SUCCESS;
       }
       ELOG_S(status, "TCP Close() failed");
       return TCP6_RESULT_ERROR;
     }
   }

   tcp6_result result = check_token(boot_services, &close_token->CompletionToken);
   if (result == TCP6_RESULT_SUCCESS) {
     DLOG("TCP6 close finished");
     efi_status status = boot_services->CloseProtocol(handle, &kTcp6ProtocolGuid, gImg, NULL);
     if (status != EFI_SUCCESS) {
       // Warn but keep going, we'll just leak a protocol.
       WLOG_S(status, "Failed to close TCP6 protocol");
     }
   }
   return result;
 }

 tcp6_result tcp6_disconnect(tcp6_socket* socket) {
   DLOG("Closing TCP6 client protocol");
   tcp6_result result = close_protocol(socket->boot_services, socket->client_protocol,
                                       socket->client_handle, &socket->client_close_token);
   if (result == TCP6_RESULT_SUCCESS) {
     DLOG("TCP6 client disconnect complete");
     // We shouldn't need to do anything else to close the client_handle, once an
     // EFI handle has no open protocols it closes automatically.
     socket->client_handle = NULL;
     socket->client_protocol = NULL;
   }
   return result;
 }

 tcp6_result tcp6_close(tcp6_socket* socket) {
   // Close any connected client first, and wait until it's fully closed before
   // continuing on to tearing down the rest of the socket.
   //
   // We could probably close the server socket concurrently, but it's simpler
   // this way and works just as well for our purposes.
   tcp6_result result = tcp6_disconnect(socket);
   if (result != TCP6_RESULT_SUCCESS) {
     return result;
   }

   DLOG("Closing TCP6 server protocol");
   result = close_protocol(socket->boot_services, socket->server_protocol, socket->server_handle,
                           &socket->server_close_token);
   if (result != TCP6_RESULT_SUCCESS) {
     return result;
   }
   socket->server_protocol = NULL;

   DLOG("Closing TCP6 binding protocol and handles");
   if (socket->binding_protocol != NULL) {
     if (socket->server_handle != NULL) {
       efi_status status =
           socket->binding_protocol->DestroyChild(socket->binding_protocol, socket->server_handle);
       if (status != EFI_SUCCESS) {
         // Warn but keep going, we'll just leak a handle.
         WLOG_S(status, "Failed to destroy TCP6 server handle");
       }
       socket->server_handle = NULL;
     }

     efi_status status = socket->boot_services->CloseProtocol(
         socket->binding_handle, &kTcp6ServiceBindingProtocolGuid, gImg, NULL);
     if (status != EFI_SUCCESS) {
       // Warn but keep going, we'll just leak a protocol.
       WLOG_S(status, "Failed to close TCP6 binding protocol");
     }
     socket->binding_protocol = NULL;
   }
   socket->binding_handle = NULL;

   return TCP6_RESULT_SUCCESS;
 }
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#define DEBUG_LOGGING 0

	#include "tcp.h"

	#include <log.h>
	#include <stdio.h>
	#include <string.h>
	#include <xefi.h>

	#include <efi/boot-services.h>

	#include "compiler.h"
	#include "inet6.h"

	static efi_guid kTcp6ServiceBindingProtocolGuid = EFI_TCP6_SERVICE_BINDING_PROTOCOL_GUID;
	static efi_guid kTcp6ProtocolGuid = EFI_TCP6_PROTOCOL_GUID;

	// Dumps the TCP state for debugging purposes.
	static void __UNUSED dump_state(efi_tcp6_protocol* protocol) {
	efi_tcp6_connection_state connection_state;
	efi_tcp6_option option = {};
	efi_tcp6_config_data config_data = {.ControlOption = &option};
	efi_ip6_mode_data mode_data = {};
	efi_managed_network_config_data managed_network_config_data = {};
	efi_simple_network_mode simple_network_mode = {};
	efi_status status = protocol->GetModeData(protocol, &connection_state, &config_data, &mode_data,
	&managed_network_config_data, &simple_network_mode);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to fetch TCP6 mode data");
	return;
	}

	char ip_buffer[IP6TOAMAX];
	LOG("Connection state: %d", connection_state);
	LOG("Config data:");
	LOG(" TrafficClass: %u", config_data.TrafficClass);
	LOG(" HopLimit: %u", config_data.HopLimit);
	LOG(" AccessPoint:");
	LOG(" StationAddress: %s", ip6toa(ip_buffer, &config_data.AccessPoint.StationAddress));
	LOG(" StationPort: %d", config_data.AccessPoint.StationPort);
	LOG(" RemoteAddress: %s", ip6toa(ip_buffer, &config_data.AccessPoint.RemoteAddress));
	LOG(" RemotePort: %d", config_data.AccessPoint.RemotePort);
	LOG(" ActiveFlag: %d", config_data.AccessPoint.ActiveFlag);
	LOG(" ControlOption:");
	LOG(" ReceiveBufferSize: %u", config_data.ControlOption->ReceiveBufferSize);
	LOG(" SendBufferSize: %u", config_data.ControlOption->SendBufferSize);
	LOG(" MaxSynBackLog: %u", config_data.ControlOption->MaxSynBackLog);
	LOG(" ConnectionTimeout: %u", config_data.ControlOption->ConnectionTimeout);
	LOG(" DataRetries: %u", config_data.ControlOption->DataRetries);
	LOG(" FinTimeout: %u", config_data.ControlOption->FinTimeout);
	LOG(" TimeWaitTimeout: %u", config_data.ControlOption->TimeWaitTimeout);
	LOG(" KeepAliveProbes: %u", config_data.ControlOption->KeepAliveProbes);
	LOG(" KeepAliveTime: %u", config_data.ControlOption->KeepAliveTime);
	LOG(" KeepAliveInterval: %u", config_data.ControlOption->KeepAliveInterval);
	LOG(" EnableNagle: %d", config_data.ControlOption->EnableNagle);
	LOG(" EnableTimeStamp: %d", config_data.ControlOption->EnableTimeStamp);
	LOG(" EnableWindowScaling: %d", config_data.ControlOption->EnableWindowScaling);
	LOG(" EnableSelectiveAck: %d", config_data.ControlOption->EnableSelectiveAck);
	LOG(" EnablePathMtuDiscovery: %d", config_data.ControlOption->EnablePathMtuDiscovery);
	// We could dump the rest of the structs here as well if useful, but for now
	// this contains most of the relevant info.
	}

	// Converts the given efi_status to the more generic TCP6_RESULT code.
	static tcp6_result status_to_tcp6_result(efi_status status) {
	switch (status) {
	case EFI_SUCCESS:
	return TCP6_RESULT_SUCCESS;
	case EFI_NOT_READY:
	return TCP6_RESULT_PENDING;
	case EFI_CONNECTION_FIN:
	FALLTHROUGH;
	case EFI_CONNECTION_RESET:
	DLOG_S(status, "TCP6 client has disconnected");
	return TCP6_RESULT_DISCONNECTED;
	default:
	ELOG_S(status, "TCP6 error");
	return TCP6_RESULT_ERROR;
	}
	}

	// Closes the token's event and resets the state.
	static void reset_token(efi_boot_services* boot_services, efi_tcp6_completion_token* token) {
	if (token->Event) {
	efi_status status = boot_services->CloseEvent(token->Event);
	if (status != EFI_SUCCESS) {
	// Log a warning, but keep going. Failure to close essentially means
	// whatever we were trying to close is already gone.
	WLOG_S(status, "Failed to close TCP event");
	}
	token->Event = NULL;
	}
	token->Status = EFI_SUCCESS;
	}

	// Checks if the completion token is done.
	//
	// On success or error, resets the token and returns the resulting status.
	// If the event is still pending, returns TCP6_RESULT_PENDING.
	static tcp6_result check_token(efi_boot_services* boot_services, efi_tcp6_completion_token* token) {
	efi_status status = boot_services->CheckEvent(token->Event);

	// If the event completed, return the final token status.
	// Do this first so we don't lose the token status when we reset it.
	if (status == EFI_SUCCESS) {
	status = token->Status;
	}

	// Anything except pending, reset the event since we're done with it.
	if (status != EFI_NOT_READY) {
	reset_token(boot_services, token);
	}

	return status_to_tcp6_result(status);
	}

	tcp6_result tcp6_open(tcp6_socket* socket, efi_boot_services* boot_services,
	const efi_ipv6_addr* address, uint16_t port) {
	memset(socket, 0, sizeof(*socket));

	socket->boot_services = boot_services;

	// TCP uses the service binding protocol mechanism, so we have to open the
	// binding protocol first then open the actual protocol child.
	DLOG("Locating TCP6 binding handle");
	efi_handle* handles;
	size_t num_handles = 0;
	efi_status status = boot_services->LocateHandleBuffer(
	ByProtocol, &kTcp6ServiceBindingProtocolGuid, NULL, &num_handles, &handles);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to locate any TCP handles");
	return TCP6_RESULT_ERROR;
	}

	if (num_handles == 0) {
	ELOG("No TCP service handles found");
	boot_services->FreePool(handles);
	return TCP6_RESULT_ERROR;
	} else if (num_handles > 1) {
	// To keep things simple for now, just always take the first handle. We'll
	// probably want to improve this in the future.
	WLOG("Found %zu TCP service handles, but only using the first", num_handles);
	}
	socket->binding_handle = handles[0];
	boot_services->FreePool(handles);

	DLOG("Opening TCP6 binding protocol");
	status = boot_services->OpenProtocol(socket->binding_handle, &kTcp6ServiceBindingProtocolGuid,
	(void**)&socket->binding_protocol, gImg, NULL,
	EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to open TCP binding protocol");
	return TCP6_RESULT_ERROR;
	}

	DLOG("Creating TCP6 server handle");
	status = socket->binding_protocol->CreateChild(socket->binding_protocol, &socket->server_handle);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to create TCP child handle");
	tcp6_close(socket);
	return TCP6_RESULT_ERROR;
	}

	DLOG("Opening TCP6 server protocol");
	status = boot_services->OpenProtocol(socket->server_handle, &kTcp6ProtocolGuid,
	(void**)&socket->server_protocol, gImg, NULL,
	EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to open TCP protocol");
	tcp6_close(socket);
	return TCP6_RESULT_ERROR;
	}

	efi_tcp6_config_data config_data = {
	.TrafficClass = 0, // Default forwarding, no congestion notification.
	.HopLimit = 0xFF, // Maximum hop limit.
	.AccessPoint = {.StationAddress = *address,
	.StationPort = port,
	.RemoteAddress = {},
	.RemotePort = 0,
	.ActiveFlag = false},
	.ControlOption = NULL // Use defaults.
	};

	char ip_buffer[IP6TOAMAX] __UNUSED;
	DLOG("Configuring TCP6 server for [%s]:%d",
	ip6toa(ip_buffer, &config_data.AccessPoint.StationAddress), port);
	status = socket->server_protocol->Configure(socket->server_protocol, &config_data);
	if (status != EFI_SUCCESS) {
	// Configure() will sometimes return EFI_INVALID_PARAMETER early on but
	// then succeed with the same parameters later, I think because any given
	// IP address will be invalid until the link is fully up. This is pretty
	// normal, so only debug log in this case to avoid spamming the console.
	if (status == EFI_INVALID_PARAMETER) {
	DLOG_S(status, "TCP configure failed - link not up yet?");
	} else {
	ELOG_S(status, "Failed to configure TCP protocol");
	}
	tcp6_close(socket);
	return TCP6_RESULT_ERROR;
	}

	#if DEBUG_LOGGING
	DLOG("== TCP6 server state ==");
	dump_state(socket->server_protocol);
	#endif // DEBUG_LOGGING

	DLOG("TCP6 open success");
	return TCP6_RESULT_SUCCESS;
	}

	tcp6_result tcp6_accept(tcp6_socket* socket) {
	// Currently for simplicity we only support a single TCP client at a time.
	if (socket->client_protocol != NULL) {
	ELOG("A TCP client is already connected");
	return TCP6_RESULT_ERROR;
	}

	// If we don't have a server_event yet, start listening on this socket.
	if (socket->server_accept_token.CompletionToken.Event == NULL) {
	DLOG("Creating TCP6 listen event");
	efi_status status = socket->boot_services->CreateEvent(
	0, 0, NULL, NULL, &socket->server_accept_token.CompletionToken.Event);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to create TCP6 listen event");
	return TCP6_RESULT_ERROR;
	}

	DLOG("Accepting incoming TCP6 connections");
	status = socket->server_protocol->Accept(socket->server_protocol, &socket->server_accept_token);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "TCP accept failed");
	reset_token(socket->boot_services, &socket->server_accept_token.CompletionToken);
	return TCP6_RESULT_ERROR;
	}
	}

	tcp6_result result =
	check_token(socket->boot_services, &socket->server_accept_token.CompletionToken);
	if (result == TCP6_RESULT_SUCCESS) {
	DLOG("TCP6 client is ready");
	socket->client_handle = socket->server_accept_token.NewChildHandle;
	efi_status status = socket->boot_services->OpenProtocol(
	socket->client_handle, &kTcp6ProtocolGuid, (void**)&socket->client_protocol, gImg, NULL,
	EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to open TCP client protocol");
	return TCP6_RESULT_ERROR;
	}

	// Lookup and print the client IP if we're debug logging.
	if (DEBUG_LOGGING) {
	efi_tcp6_config_data config_data = {};
	status = socket->client_protocol->GetModeData(socket->client_protocol, NULL, &config_data,
	NULL, NULL, NULL);
	if (status != EFI_SUCCESS) {
	WLOG_S(status, "Failed to fetch new client IP");
	} else {
	char ip_buffer[IP6TOAMAX];
	LOG("New TCP client: %s", ip6toa(ip_buffer, &config_data.AccessPoint.RemoteAddress));
	}
	}
	}
	return result;
	}

	tcp6_result tcp6_read(tcp6_socket* socket, void* data, uint32_t size) {
	if (socket->client_protocol == NULL) {
	ELOG("No TCP client to read from");
	return TCP6_RESULT_ERROR;
	}

	// If there isn't a read in progress, start a new one.
	if (socket->read_token.CompletionToken.Event == NULL) {
	DLOG("Creating TCP6 read event");
	efi_status status = socket->boot_services->CreateEvent(
	0, 0, NULL, NULL, &socket->read_token.CompletionToken.Event);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to create TCP6 read event");
	return TCP6_RESULT_ERROR;
	}

	// Store the original read end so that we can internally handle partial
	// reads. The EFI documentation isn't clear whether drivers can give us
	// partial reads or not, so assume that they will.
	socket->read_end = (uint8_t*)data + size;
	socket->read_data.UrgentFlag = false;
	socket->read_data.DataLength = size;
	socket->read_data.FragmentCount = 1;
	socket->read_data.FragmentTable[0].FragmentBuffer = data;
	socket->read_data.FragmentTable[0].FragmentLength = size;
	socket->read_token.Packet.RxData = &socket->read_data;

	status = socket->client_protocol->Receive(socket->client_protocol, &socket->read_token);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "TCP read failed to start");
	reset_token(socket->boot_services, &socket->read_token.CompletionToken);
	return TCP6_RESULT_ERROR;
	}
	}

	// The interrupt rate can be pretty slow (10-20ms) which really hurts
	// performance on larger transfers, so manually poll whenever we're waiting
	// for a read.
	socket->client_protocol->Poll(socket->client_protocol);

	tcp6_result result = check_token(socket->boot_services, &socket->read_token.CompletionToken);
	if (result == TCP6_RESULT_SUCCESS) {
	DLOG("TCP6 read: %u bytes\n", socket->read_token.Packet.RxData->DataLength);

	// Check if we're done with the read.
	uint8_t* end = (uint8_t*)socket->read_token.Packet.RxData->FragmentTable[0].FragmentBuffer +
	socket->read_token.Packet.RxData->FragmentTable[0].FragmentLength;
	if (end > socket->read_end) {
	// Only possible if the driver is misbehaving and gives us more data than
	// we asked for.
	ELOG("TCP driver returned more data than expected");
	return TCP6_RESULT_ERROR;
	}
	if (end < socket->read_end) {
	// Partial read - advance the buffers and read again.

	// 32-bit cast is safe because we calculated read_end by adding a 32-bit
	// size in the first place, so the difference must be < 32 bits.
	uint32_t remaining = (uint32_t)(socket->read_end - end);
	DLOG("TCP6 partial read; starting again on the next %u bytes", remaining);
	return tcp6_read(socket, end, remaining);
	}
	}
	return result;
	}

	tcp6_result tcp6_write(tcp6_socket* socket, const void* data, uint32_t size) {
	if (socket->client_protocol == NULL) {
	ELOG("No TCP client to write to");
	return TCP6_RESULT_ERROR;
	}

	// If there isn't a write in progress, start a new one.
	if (socket->write_token.CompletionToken.Event == NULL) {
	DLOG("Creating TCP6 write event");
	efi_status status = socket->boot_services->CreateEvent(
	0, 0, NULL, NULL, &socket->write_token.CompletionToken.Event);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to create TCP6 write event");
	return TCP6_RESULT_ERROR;
	}

	// For our usage, we nearly always want to send data out right away since
	// fastboot is a pretty sequential protocol, so just always push for now.
	socket->write_data.Push = true;
	socket->write_data.Urgent = false;
	socket->write_data.DataLength = size;
	socket->write_data.FragmentCount = 1;
	socket->write_data.FragmentTable[0].FragmentBuffer = (void*)data;
	socket->write_data.FragmentTable[0].FragmentLength = size;
	socket->write_token.Packet.TxData = &socket->write_data;

	status = socket->client_protocol->Transmit(socket->client_protocol, &socket->write_token);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "TCP write failed to start");
	reset_token(socket->boot_services, &socket->write_token.CompletionToken);
	return status_to_tcp6_result(status);
	}
	}

	// Manually poll to improve performance for large transfers.
	socket->client_protocol->Poll(socket->client_protocol);

	tcp6_result result = check_token(socket->boot_services, &socket->write_token.CompletionToken);
	if (result == TCP6_RESULT_SUCCESS) {
	DLOG("TCP6 write: %u bytes", socket->write_token.Packet.TxData->DataLength);

	// The EFI documentation indicates that writes do not update the TxData
	// struct, which means it must not support partial writes (since it would
	// be impossible to know how much data was written). Double-check here
	// so that we are alerted if this assumption ever fails.
	if (socket->write_token.Packet.TxData->DataLength != size) {
	ELOG("TCP6 write expected %u bytes, but only sent %u", size,
	socket->write_token.Packet.TxData->DataLength);
	return TCP6_RESULT_ERROR;
	}
	}
	return result;
	}

	static tcp6_result close_protocol(efi_boot_services* boot_services, efi_tcp6_protocol* protocol,
	efi_handle handle, efi_tcp6_close_token* close_token) {
	// No-op if we don't currently have a connected protocol.
	if (protocol == NULL) {
	return EFI_SUCCESS;
	}

	// If we don't have a close event yet, start the close.
	if (close_token->CompletionToken.Event == NULL) {
	DLOG("Creating TCP6 close event");
	efi_status status =
	boot_services->CreateEvent(0, 0, NULL, NULL, &close_token->CompletionToken.Event);
	if (status != EFI_SUCCESS) {
	ELOG_S(status, "Failed to create close event");
	return TCP6_RESULT_ERROR;
	}

	DLOG("Starting TCP6 close");
	status = protocol->Close(protocol, close_token);
	if (status != EFI_SUCCESS) {
	reset_token(boot_services, &close_token->CompletionToken);
	if (status == EFI_NOT_STARTED) {
	// NOT_STARTED is OK, means the protocol is already closed.
	return TCP6_RESULT_SUCCESS;
	}
	ELOG_S(status, "TCP Close() failed");
	return TCP6_RESULT_ERROR;
	}
	}

	tcp6_result result = check_token(boot_services, &close_token->CompletionToken);
	if (result == TCP6_RESULT_SUCCESS) {
	DLOG("TCP6 close finished");
	efi_status status = boot_services->CloseProtocol(handle, &kTcp6ProtocolGuid, gImg, NULL);
	if (status != EFI_SUCCESS) {
	// Warn but keep going, we'll just leak a protocol.
	WLOG_S(status, "Failed to close TCP6 protocol");
	}
	}
	return result;
	}

	tcp6_result tcp6_disconnect(tcp6_socket* socket) {
	DLOG("Closing TCP6 client protocol");
	tcp6_result result = close_protocol(socket->boot_services, socket->client_protocol,
	socket->client_handle, &socket->client_close_token);
	if (result == TCP6_RESULT_SUCCESS) {
	DLOG("TCP6 client disconnect complete");
	// We shouldn't need to do anything else to close the client_handle, once an
	// EFI handle has no open protocols it closes automatically.
	socket->client_handle = NULL;
	socket->client_protocol = NULL;
	}
	return result;
	}

	tcp6_result tcp6_close(tcp6_socket* socket) {
	// Close any connected client first, and wait until it's fully closed before
	// continuing on to tearing down the rest of the socket.
	//
	// We could probably close the server socket concurrently, but it's simpler
	// this way and works just as well for our purposes.
	tcp6_result result = tcp6_disconnect(socket);
	if (result != TCP6_RESULT_SUCCESS) {
	return result;
	}

	DLOG("Closing TCP6 server protocol");
	result = close_protocol(socket->boot_services, socket->server_protocol, socket->server_handle,
	&socket->server_close_token);
	if (result != TCP6_RESULT_SUCCESS) {
	return result;
	}
	socket->server_protocol = NULL;

	DLOG("Closing TCP6 binding protocol and handles");
	if (socket->binding_protocol != NULL) {
	if (socket->server_handle != NULL) {
	efi_status status =
	socket->binding_protocol->DestroyChild(socket->binding_protocol, socket->server_handle);
	if (status != EFI_SUCCESS) {
	// Warn but keep going, we'll just leak a handle.
	WLOG_S(status, "Failed to destroy TCP6 server handle");
	}
	socket->server_handle = NULL;
	}

	efi_status status = socket->boot_services->CloseProtocol(
	socket->binding_handle, &kTcp6ServiceBindingProtocolGuid, gImg, NULL);
	if (status != EFI_SUCCESS) {
	// Warn but keep going, we'll just leak a protocol.
	WLOG_S(status, "Failed to close TCP6 binding protocol");
	}
	socket->binding_protocol = NULL;
	}
	socket->binding_handle = NULL;

	return TCP6_RESULT_SUCCESS;
	}