You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
885 lines
20 KiB
885 lines
20 KiB
/*++
|
|
|
|
Copyright (c) 2001-2002 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
server.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the teredo server (and relay) implementation.
|
|
|
|
Author:
|
|
|
|
Mohit Talwar (mohitt) Fri Nov 02 14:55:38 2001
|
|
|
|
Environment:
|
|
|
|
User mode only.
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
TEREDO_SERVER_STATE TeredoServer;
|
|
|
|
|
|
TEREDO_PACKET_IO_COMPLETE TeredoServerReadComplete;
|
|
TEREDO_PACKET_IO_COMPLETE TeredoServerWriteComplete;
|
|
TEREDO_PACKET_IO_COMPLETE TeredoServerBounceComplete;
|
|
TEREDO_PACKET_IO_COMPLETE TeredoServerReceiveComplete;
|
|
TEREDO_PACKET_IO_COMPLETE TeredoServerTransmitComplete;
|
|
|
|
|
|
USHORT
|
|
__inline
|
|
TeredoChecksumDatagram(
|
|
IN CONST IN6_ADDR *Destination,
|
|
IN CONST IN6_ADDR *Source,
|
|
IN USHORT NextHeader,
|
|
IN UCHAR CONST *Buffer,
|
|
IN USHORT Bytes
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
16-bit one's complement of the one's complement sum of a 'Buffer'
|
|
of size 'Bytes'. NOTE: The sum is independent of the byte order!
|
|
|
|
Arguments:
|
|
|
|
Buffer - Supplies the buffer containing data to compute checksum for.
|
|
|
|
Bytes - Supplies the number of bytes to compute checksum for.
|
|
|
|
Return Value:
|
|
|
|
The checksum.
|
|
|
|
--*/
|
|
{
|
|
DWORD Sum, Words, i;
|
|
PUSHORT Start = (PUSHORT) Buffer;
|
|
|
|
//
|
|
// If 'Bytes' is odd, this has to be handled differently.
|
|
// That, however, is never the case for us, so we optimize.
|
|
// Also ensure that 'Buffer' is aligned on a 2 byte boundary.
|
|
//
|
|
ASSERT(((((DWORD_PTR) Buffer) % 2) == 0) && ((Bytes % 2) == 0));
|
|
Words = Bytes / 2;
|
|
|
|
//
|
|
// Start with the pseudo-header.
|
|
//
|
|
Sum = htons(Bytes) + (NextHeader << 8);
|
|
for (i = 0; i < 8; i++) {
|
|
Sum += Source->s6_words[i] + Destination->s6_words[i];
|
|
}
|
|
|
|
for (i = 0; i < Words; i++) {
|
|
Sum += Start[i];
|
|
}
|
|
|
|
Sum = (Sum & 0x0000ffff) + (Sum >> 16);
|
|
Sum += (Sum >> 16);
|
|
|
|
return LOWORD(~((DWORD_PTR) Sum));
|
|
}
|
|
|
|
|
|
VOID
|
|
CALLBACK
|
|
TeredoServerIoCompletionCallback(
|
|
IN DWORD ErrorCode,
|
|
IN DWORD Bytes,
|
|
IN LPOVERLAPPED Overlapped
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Callback routine for I/O completion on TUN interface device or UDP socket.
|
|
|
|
Arguments:
|
|
|
|
ErrorCode - Supplies the I/O completion status.
|
|
|
|
Bytes - Supplies the number of bytes transferred.
|
|
|
|
Overlapped - Supplies the completion context.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
static CONST PTEREDO_PACKET_IO_COMPLETE Callback[] =
|
|
{
|
|
TeredoServerReadComplete,
|
|
TeredoServerWriteComplete,
|
|
NULL, // No bubbling...
|
|
TeredoServerBounceComplete,
|
|
TeredoServerReceiveComplete,
|
|
TeredoServerTransmitComplete,
|
|
NULL, // No multicasting...
|
|
};
|
|
PTEREDO_PACKET Packet = Cast(
|
|
CONTAINING_RECORD(Overlapped, TEREDO_PACKET, Overlapped),
|
|
TEREDO_PACKET);
|
|
|
|
ASSERT((Packet->Type != TEREDO_PACKET_BUBBLE) &&
|
|
(Packet->Type != TEREDO_PACKET_MULTICAST));
|
|
|
|
//
|
|
// This completion function usually posts the packet for another I/O.
|
|
// Since we are called by a non-I/O worker thread, asynchronous I/O
|
|
// requests posted here might terminate when this thread does. This
|
|
// is rare enough that we don't special case it. Moreover, we only
|
|
// make best effort guarantees to the upper layer!
|
|
//
|
|
(*Callback[Packet->Type])(ErrorCode, Bytes, Packet);
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerAddressDeletionNotification(
|
|
IN IN_ADDR Address
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process an address deletion request.
|
|
|
|
Arguments:
|
|
|
|
Address - Supplies the address that was deleted.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Caller LOCK: API.
|
|
|
|
--*/
|
|
{
|
|
if (!IN4_ADDR_EQUAL(Address, TeredoServer.Io.SourceAddress.sin_addr)) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Refresh the socket state (the socket bound to SourceAddress).
|
|
//
|
|
if (TeredoRefreshSocket(&(TeredoServer.Io)) != NO_ERROR) {
|
|
//
|
|
// Online -> Offline.
|
|
//
|
|
TeredoStopServer();
|
|
return;
|
|
}
|
|
|
|
if (!IN4_ADDR_EQUAL(
|
|
TeredoServer.Io.SourceAddress.sin_addr,
|
|
TeredoServer.Io.ServerAddress.sin_addr)) {
|
|
//
|
|
// Online -> Offline.
|
|
//
|
|
TeredoStopServer();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoStartServer(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Attempt to start the teredo service at the server.
|
|
|
|
Events / Transitions
|
|
ServiceStart Offline -> Online.
|
|
ServiceEnable Offline -> Online.
|
|
AdapterArrival Offline -> Online.
|
|
AddressAddition Offline -> Online.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Caller LOCK: API.
|
|
|
|
--*/
|
|
{
|
|
TraceEnter("TeredoStartServer");
|
|
|
|
//
|
|
// Can't have both the client and server on the same node.
|
|
//
|
|
if (TeredoClient.State != TEREDO_STATE_OFFLINE) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Well, the service has already been started!
|
|
//
|
|
if (TeredoServer.State != TEREDO_STATE_OFFLINE) {
|
|
return;
|
|
}
|
|
|
|
TeredoServer.State = TEREDO_STATE_ONLINE;
|
|
|
|
//
|
|
// Start I/O processing.
|
|
//
|
|
if (TeredoStartIo(&(TeredoServer.Io)) != NO_ERROR) {
|
|
goto Bail;
|
|
}
|
|
|
|
if (!IN4_ADDR_EQUAL(
|
|
TeredoServer.Io.SourceAddress.sin_addr,
|
|
TeredoServer.Io.ServerAddress.sin_addr)) {
|
|
goto Bail;
|
|
}
|
|
|
|
return;
|
|
|
|
Bail:
|
|
TeredoServer.State = TEREDO_STATE_OFFLINE;
|
|
TeredoStopIo(&(TeredoServer.Io));
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoStopServer(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Stop the teredo service at the server.
|
|
|
|
Events / Transitions
|
|
ServiceStop Online -> Offline.
|
|
ServiceDisable Online -> Offline.
|
|
AdapterRemoval Online -> Offline.
|
|
AddressDeletion Online -> Offline.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Caller LOCK: API.
|
|
|
|
--*/
|
|
{
|
|
TraceEnter("TeredoStopServer");
|
|
|
|
//
|
|
// Well, the service was never started!
|
|
//
|
|
if (TeredoServer.State == TEREDO_STATE_OFFLINE) {
|
|
return;
|
|
}
|
|
|
|
TeredoServer.State = TEREDO_STATE_OFFLINE;
|
|
|
|
TeredoStopIo(&(TeredoServer.Io));
|
|
}
|
|
|
|
|
|
DWORD
|
|
TeredoInitializeServer(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes the server.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR or failure code.
|
|
|
|
--*/
|
|
{
|
|
DWORD Error;
|
|
IN_ADDR Group;
|
|
Group.s_addr = htonl(INADDR_ANY);
|
|
|
|
//
|
|
// Obtain a reference on the teredo server for initialization.
|
|
//
|
|
TeredoServer.ReferenceCount = 1;
|
|
|
|
Error = TeredoInitializeIo(
|
|
&(TeredoServer.Io),
|
|
Group,
|
|
TeredoReferenceServer,
|
|
TeredoDereferenceServer,
|
|
TeredoServerIoCompletionCallback);
|
|
if (Error != NO_ERROR) {
|
|
return Error;
|
|
}
|
|
|
|
TeredoServer.State = TEREDO_STATE_OFFLINE;
|
|
|
|
IncEventCount("TeredoInitializeServer");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoUninitializeServer(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Uninitializes the server. Typically invoked upon service stop.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
TeredoStopServer();
|
|
TeredoDereferenceServer();
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoCleanupServer(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Cleans up the server after the last reference to it has been released.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
TeredoCleanupIo(&(TeredoServer.Io));
|
|
DecEventCount("TeredoCleanupServer");
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoBuildRouterAdvertisementPacket(
|
|
OUT PTEREDO_PACKET Packet,
|
|
IN IN6_ADDR Destination,
|
|
IN IN_ADDR Address,
|
|
IN USHORT Port
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Construct an RA in response to the client's RS.
|
|
|
|
Arguments:
|
|
|
|
Packet - Returns the constructed RA in the caller supplied packet.
|
|
|
|
Destination - Supplies the destination address of the RA,
|
|
the client's random link-local address in the triggering RS.
|
|
Passed by value so this function may reuse the packet buffer.
|
|
|
|
Address - Supplies the client's address, used to source the RS.
|
|
|
|
Port - Supplies the client's port, used to source the RS.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PIP6_HDR Ipv6 = (PIP6_HDR) Packet->Buffer.buf;
|
|
ICMPv6Header *Icmpv6 = (ICMPv6Header *) (Ipv6 + 1);
|
|
NDRouterAdvertisement *Ra = (NDRouterAdvertisement *) (Icmpv6 + 1);
|
|
NDOptionPrefixInformation *Prefix = (NDOptionPrefixInformation *) (Ra + 1);
|
|
NDOptionMTU *Mtu = (NDOptionMTU *) (Prefix + 1);
|
|
PUCHAR End = (PUCHAR) (Mtu + 1);
|
|
|
|
Packet->Buffer.len = (ULONG) (End - (Packet->Buffer.buf));
|
|
ZeroMemory(Packet->Buffer.buf, Packet->Buffer.len);
|
|
|
|
//
|
|
// Construct the IPv6 Header...
|
|
//
|
|
Ipv6->ip6_plen = htons((USHORT) (Packet->Buffer.len - sizeof(IP6_HDR)));
|
|
Ipv6->ip6_nxt = IP_PROTOCOL_ICMPv6;
|
|
Ipv6->ip6_hlim = 255;
|
|
Ipv6->ip6_vfc = IPV6_VERSION;
|
|
|
|
//
|
|
// ...using the server's link local address: fe80:IPv4 Address:UDP Port::1
|
|
//
|
|
Ipv6->ip6_src.s6_words[0] = 0x80fe;
|
|
Ipv6->ip6_src.s6_words[1] =
|
|
((PUSHORT) &TeredoServer.Io.ServerAddress.sin_addr)[0];
|
|
Ipv6->ip6_src.s6_words[2] =
|
|
((PUSHORT) &TeredoServer.Io.ServerAddress.sin_addr)[1];
|
|
Ipv6->ip6_src.s6_words[3] =
|
|
TeredoServer.Io.ServerAddress.sin_port;
|
|
Ipv6->ip6_src.s6_words[7] = 0x0100;
|
|
Ipv6->ip6_dest = Destination;
|
|
|
|
//
|
|
// Construct ICMPv6 Header.
|
|
//
|
|
Icmpv6->Type = ICMPv6_ROUTER_ADVERT;
|
|
|
|
//
|
|
// Construct RouterAdvertisement Header.
|
|
//
|
|
Ra->RouterLifetime = htons(TEREDO_ROUTER_LIFETIME);
|
|
Ra->Flags = ROUTE_PREF_LOW;
|
|
|
|
//
|
|
// Construct Prefix Option.
|
|
//
|
|
Prefix->Type = ND_OPTION_PREFIX_INFORMATION;
|
|
Prefix->Length = sizeof(NDOptionPrefixInformation) / 8;
|
|
Prefix->PrefixLength = 64;
|
|
Prefix->Flags = ND_PREFIX_FLAG_AUTONOMOUS;
|
|
Prefix->ValidLifetime = Prefix->PreferredLifetime = IPV6_INFINITE_LIFETIME;
|
|
|
|
Prefix->Prefix.s6_words[0] = TeredoIpv6ServicePrefix.s6_words[0];
|
|
Prefix->Prefix.s6_words[1] = ((PUSHORT) &Address)[0];
|
|
Prefix->Prefix.s6_words[2] = ((PUSHORT) &Address)[1];
|
|
Prefix->Prefix.s6_words[3] = Port;
|
|
|
|
//
|
|
// Construct MTU Option.
|
|
//
|
|
Mtu->Type = ND_OPTION_MTU;
|
|
Mtu->Length = sizeof(NDOptionMTU) / 8;
|
|
Mtu->MTU = htonl(IPV6_TEREDOMTU);
|
|
|
|
//
|
|
// Checksum Packet!
|
|
//
|
|
Icmpv6->Checksum = TeredoChecksumDatagram(
|
|
&(Ipv6->ip6_dest),
|
|
&(Ipv6->ip6_src),
|
|
IP_PROTOCOL_ICMPv6,
|
|
(PUCHAR) Icmpv6,
|
|
(USHORT) (End - ((PUCHAR) Icmpv6)));
|
|
}
|
|
|
|
|
|
PTEREDO_PACKET
|
|
TeredoReceiveRouterSolicitation(
|
|
IN PTEREDO_PACKET Packet,
|
|
IN ULONG Bytes
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process the router solicitation packet received on the UDP socket.
|
|
|
|
Arguments:
|
|
|
|
Packet - Supplies the packet that was received.
|
|
|
|
Bytes - Supplies the length of the packet.
|
|
|
|
Return Value:
|
|
|
|
Returns the supplied packet if processing completed or failed;
|
|
NULL if the processing will complete asynchronously.
|
|
|
|
--*/
|
|
{
|
|
PUCHAR Buffer = Packet->Buffer.buf;
|
|
ICMPv6Header *Icmpv6;
|
|
ULONG Length;
|
|
PIP6_HDR Ipv6 = (PIP6_HDR) Packet->Buffer.buf;
|
|
|
|
Icmpv6 = TeredoParseIpv6Headers(Buffer, Bytes);
|
|
if (Icmpv6 == NULL) {
|
|
return Packet;
|
|
}
|
|
|
|
if ((Icmpv6->Type != ICMPv6_ROUTER_SOLICIT) || (Icmpv6->Code != 0)) {
|
|
return Packet;
|
|
}
|
|
Buffer = (PUCHAR) (Icmpv6 + 1);
|
|
Bytes -= (ULONG) (Buffer - Packet->Buffer.buf);
|
|
|
|
//
|
|
// Parse the rest of the router solicitation header.
|
|
//
|
|
if (Bytes < sizeof(ULONG)) {
|
|
return Packet;
|
|
}
|
|
Buffer += sizeof(ULONG);
|
|
Bytes -= sizeof(ULONG);
|
|
|
|
while (Bytes != 0) {
|
|
//
|
|
// Parse TLV options.
|
|
//
|
|
if (Bytes < 8) {
|
|
return Packet;
|
|
}
|
|
|
|
Length = (Buffer[1] * 8);
|
|
if ((Length == 0) || (Bytes < Length)) {
|
|
return Packet;
|
|
}
|
|
|
|
Buffer += Length;
|
|
Bytes -= Length;
|
|
}
|
|
|
|
//
|
|
// Checksum Packet!
|
|
//
|
|
if (TeredoChecksumDatagram(
|
|
&(Ipv6->ip6_dest),
|
|
&(Ipv6->ip6_src),
|
|
IP_PROTOCOL_ICMPv6,
|
|
(PUCHAR) Icmpv6,
|
|
(USHORT) (Buffer - ((PUCHAR) Icmpv6))) != 0) {
|
|
return Packet;
|
|
}
|
|
|
|
//
|
|
// We have a valid router solicitation, so tunnel an advertisement!
|
|
// Reuse the RS packet to bounce the RA.
|
|
//
|
|
TeredoBuildRouterAdvertisementPacket(
|
|
Packet,
|
|
Ipv6->ip6_src,
|
|
Packet->SocketAddress.sin_addr,
|
|
Packet->SocketAddress.sin_port);
|
|
Packet->Type = TEREDO_PACKET_BOUNCE;
|
|
return TeredoTransmitPacket(&(TeredoServer.Io), Packet);
|
|
}
|
|
|
|
|
|
PTEREDO_PACKET
|
|
TeredoServerReceiveData(
|
|
IN PTEREDO_PACKET Packet,
|
|
IN ULONG Bytes
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process the data packet received on the UDP socket.
|
|
|
|
Arguments:
|
|
|
|
Packet - Supplies the packet that was received.
|
|
|
|
Bytes - Supplies the length of the packet.
|
|
|
|
Return Value:
|
|
|
|
Returns the supplied packet if processing completed or failed;
|
|
NULL if the processing will complete asynchronously.
|
|
|
|
--*/
|
|
{
|
|
PIP6_HDR Ipv6 = (PIP6_HDR) Packet->Buffer.buf;
|
|
IN_ADDR Address;
|
|
USHORT Port;
|
|
|
|
//
|
|
// Validate source address.
|
|
//
|
|
if (!TeredoServicePrefix(&(Ipv6->ip6_src))) {
|
|
return Packet;
|
|
}
|
|
|
|
TeredoParseAddress(&(Ipv6->ip6_src), &Address, &Port);
|
|
if (!IN4_ADDR_EQUAL(Packet->SocketAddress.sin_addr, Address) ||
|
|
(Packet->SocketAddress.sin_port != Port)) {
|
|
//
|
|
// Should have been constructed by the *right* teredo peer.
|
|
//
|
|
return Packet;
|
|
}
|
|
//
|
|
// NOTE: Caller has previously verified that the source has global scope.
|
|
//
|
|
|
|
//
|
|
// Validate destination address.
|
|
//
|
|
if (TeredoServicePrefix(&(Ipv6->ip6_dest))) {
|
|
TeredoParseAddress(&(Ipv6->ip6_dest), &Address, &Port);
|
|
if (!TeredoIpv4GlobalAddress((PUCHAR) &Address)) {
|
|
//
|
|
// The IPv4 destination address should be global scope.
|
|
//
|
|
return Packet;
|
|
}
|
|
|
|
//
|
|
// Now tunnel it to the destination.
|
|
//
|
|
Packet->SocketAddress.sin_addr = Address;
|
|
Packet->SocketAddress.sin_port = Port;
|
|
Packet->Type = TEREDO_PACKET_BOUNCE;
|
|
Packet->Buffer.len = Bytes;
|
|
return TeredoTransmitPacket(&(TeredoServer.Io), Packet);
|
|
}
|
|
|
|
if (!TeredoIpv6GlobalAddress(&(Ipv6->ip6_dest))) {
|
|
//
|
|
// The IPv6 destination address should be global scope.
|
|
//
|
|
return Packet;
|
|
}
|
|
|
|
//
|
|
// Else forward it to the stack for forwarding.
|
|
//
|
|
Packet->Type = TEREDO_PACKET_WRITE;
|
|
Packet->Buffer.len = Bytes;
|
|
return TeredoWritePacket(&(TeredoServer.Io), Packet);
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerReadComplete(
|
|
IN DWORD Error,
|
|
IN ULONG Bytes,
|
|
IN PTEREDO_PACKET Packet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a read completion on the TUN device.
|
|
|
|
--*/
|
|
{
|
|
PIP6_HDR Ipv6 = (PIP6_HDR) Packet->Buffer.buf;
|
|
IN_ADDR Address;
|
|
USHORT Port;
|
|
|
|
if ((Error != NO_ERROR) || (Bytes < sizeof(IP6_HDR))) {
|
|
//
|
|
// Attempt to post the read again.
|
|
// If we are going offline, the packet is destroyed in the attempt.
|
|
//
|
|
TeredoPostRead(&(TeredoServer.Io), Packet);
|
|
return;
|
|
}
|
|
|
|
TraceEnter("TeredoServerReadComplete");
|
|
|
|
//
|
|
// Validate destination address.
|
|
//
|
|
if (!TeredoServicePrefix(&(Ipv6->ip6_dest))) {
|
|
TeredoPostRead(&(TeredoServer.Io), Packet);
|
|
return;
|
|
}
|
|
|
|
TeredoParseAddress(&(Ipv6->ip6_dest), &Address, &Port);
|
|
if (!TeredoIpv4GlobalAddress((PUCHAR) &Address)) {
|
|
//
|
|
// The IPv4 source address should be global scope.
|
|
//
|
|
TeredoPostRead(&(TeredoServer.Io), Packet);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Now tunnel it to the destination.
|
|
//
|
|
Packet->SocketAddress.sin_addr = Address;
|
|
Packet->SocketAddress.sin_port = Port;
|
|
Packet->Type = TEREDO_PACKET_TRANSMIT;
|
|
Packet->Buffer.len = Bytes;
|
|
if (TeredoTransmitPacket(&(TeredoServer.Io), Packet) == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We are done processing this packet.
|
|
//
|
|
TeredoServerTransmitComplete(NO_ERROR, Bytes, Packet);
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerWriteComplete(
|
|
IN DWORD Error,
|
|
IN ULONG Bytes,
|
|
IN PTEREDO_PACKET Packet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a write completion on the TUN device.
|
|
|
|
--*/
|
|
{
|
|
TraceEnter("TeredoServerWriteComplete");
|
|
|
|
//
|
|
// Attempt to post the receive again.
|
|
// If we are going offline, the packet is destroyed in the attempt.
|
|
//
|
|
Packet->Type = TEREDO_PACKET_RECEIVE;
|
|
Packet->Buffer.len = IPV6_TEREDOMTU;
|
|
TeredoPostReceives(&(TeredoServer.Io), Packet);
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerBounceComplete(
|
|
IN DWORD Error,
|
|
IN ULONG Bytes,
|
|
IN PTEREDO_PACKET Packet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a bounce completion on the UDP socket.
|
|
|
|
--*/
|
|
{
|
|
TraceEnter("TeredoServerBounceComplete");
|
|
|
|
//
|
|
// Attempt to post the receive again.
|
|
// If we are going offline, the packet is destroyed in the attempt.
|
|
//
|
|
Packet->Type = TEREDO_PACKET_RECEIVE;
|
|
Packet->Buffer.len = IPV6_TEREDOMTU;
|
|
TeredoPostReceives(&(TeredoServer.Io), Packet);
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerReceiveComplete(
|
|
IN DWORD Error,
|
|
IN ULONG Bytes,
|
|
IN PTEREDO_PACKET Packet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a receive completion on the UDP socket.
|
|
|
|
--*/
|
|
{
|
|
PIP6_HDR Ipv6 = (PIP6_HDR) Packet->Buffer.buf;
|
|
|
|
InterlockedDecrement(&(TeredoServer.Io.PostedReceives));
|
|
|
|
if ((Error != NO_ERROR) ||
|
|
(Bytes < sizeof(IP6_HDR)) ||
|
|
((Ipv6->ip6_vfc & IP_VER_MASK) != IPV6_VERSION) ||
|
|
(Bytes < (ntohs(Ipv6->ip6_plen) + sizeof(IP6_HDR))) ||
|
|
(!TeredoIpv4GlobalAddress(
|
|
(PUCHAR) &(Packet->SocketAddress.sin_addr)))) {
|
|
//
|
|
// Attempt to post the receive again.
|
|
// If we are going offline, the packet is destroyed in the attempt.
|
|
//
|
|
TeredoPostReceives(&(TeredoServer.Io), Packet);
|
|
return;
|
|
}
|
|
|
|
TraceEnter("TeredoServerReceiveComplete");
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&(Ipv6->ip6_src)) ||
|
|
IN6_IS_ADDR_UNSPECIFIED(&(Ipv6->ip6_src))) {
|
|
//
|
|
// This should be a valid router solicitation. Note that only router
|
|
// solicitation packets are accepted with a link-local source address.
|
|
//
|
|
Packet = TeredoReceiveRouterSolicitation(Packet, Bytes);
|
|
} else {
|
|
//
|
|
// This may be a packet of any other kind.
|
|
//
|
|
Packet = TeredoServerReceiveData(Packet, Bytes);
|
|
}
|
|
|
|
if (Packet != NULL) {
|
|
//
|
|
// We are done processing this packet.
|
|
//
|
|
TeredoServerWriteComplete(NO_ERROR, Bytes, Packet);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
TeredoServerTransmitComplete(
|
|
IN DWORD Error,
|
|
IN ULONG Bytes,
|
|
IN PTEREDO_PACKET Packet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a transmit completion on the UDP socket.
|
|
|
|
--*/
|
|
{
|
|
TraceEnter("TeredoServerTransmitComplete");
|
|
|
|
//
|
|
// Attempt to post the read again.
|
|
// If we are going offline, the packet is destroyed in the attempt.
|
|
//
|
|
Packet->Type = TEREDO_PACKET_READ;
|
|
Packet->Buffer.len = IPV6_TEREDOMTU;
|
|
TeredoPostRead(&(TeredoServer.Io), Packet);
|
|
}
|