headers.h

Vitual Ring Routing 管你知不知道

extern void
MiniportResetStatistics(MiniportAdapter *VA);

extern void
MiniportRescheduleTimeout(MiniportAdapter *VA, Time Now, Time Timeout);

NDIS_STATUS
MiniportWriteMetricType(NDIS_HANDLE Config, MetricType MetricType);

NDIS_STATUS
MiniportReadMetricType(NDIS_HANDLE Config, MetricType *MetricType);

__inline void
MiniportAllocatePacket(
    MiniportAdapter *VA,
    NDIS_PACKET **pPacket,
    NDIS_STATUS *pStatus)
{
    NdisAllocatePacket(pStatus, pPacket, VA->PacketPool);
    if (*pStatus != NDIS_STATUS_SUCCESS)
        InterlockedIncrement((PLONG)&VA->CountPacketPoolFailure);
}

__inline NDIS_STATUS
MiniportClonePacket(
    MiniportAdapter *VA,
    NDIS_PACKET *OrigPacket,
    uint OrigHeaderLength, uint CloneHeaderLength,
    uint LookAhead,
    void **pOrigHeader,
    NDIS_PACKET **pClonePacket, void **pCloneHeader)
{
    NDIS_STATUS Status;

    Status = NdisClonePacket(OrigPacket, VA->PacketPool, VA->BufferPool,
                             OrigHeaderLength, CloneHeaderLength,
                             LookAhead, pOrigHeader,
                             pClonePacket, pCloneHeader);
    if (Status != NDIS_STATUS_SUCCESS)
        InterlockedIncrement((PLONG)&VA->CountPacketPoolFailure);
    return Status;
}

__inline NDIS_STATUS
MiniportMakeEmptyPacket(
    MiniportAdapter *VA, uint Size,
    NDIS_PACKET **pPacket, void **pData)
{
    NDIS_STATUS Status;

    Status = NdisMakeEmptyPacket(VA->PacketPool, VA->BufferPool,
                                 Size, pPacket, pData);
    if (Status != NDIS_STATUS_SUCCESS)
        InterlockedIncrement((PLONG)&VA->CountPacketPoolFailure);
    return Status;
}

//* IsJoiningOnHold
//
//  Returns TRUE iff VA->JoiningOnHold is TRUE.
//
__inline uint
IsJoiningOnHold(MiniportAdapter *VA)
{
    return InterlockedCompareExchange(&VA->JoiningOnHold,FALSE,FALSE);
}

//* IsDriverInitialized
//
//  Returns TRUE iff VA->DriverInitialized is TRUE.
//
__inline uint
IsDriverInitialized(MiniportAdapter *VA)
{
    return InterlockedCompareExchange(&VA->DriverInitialized,FALSE,FALSE);
}

//* IsDriverActive
//
//  Returns TRUE iff VA->DriverActive is TRUE.
//
__inline uint
IsDriverActive(MiniportAdapter *VA)
{
    return InterlockedCompareExchange(&VA->DriverActive,FALSE,FALSE);
}

//* IsPartitionRepairEnabled
//
//  Returns TRUE iff VA->PartitionRepairEnabled is TRUE.
//
__inline uint
IsPartitionRepairEnabled(MiniportAdapter *VA)
{
    return InterlockedCompareExchange(&VA->PartitionRepairEnabled,FALSE,FALSE);
}

extern boolint
MiniportIsInfinite(uint Metric);

extern uint
MiniportConvMetric(uint LinkMetric);

extern uint
MiniportPathMetric(MiniportAdapter *VA, Link **Hops, uint NumHops);

extern void 
MiniportInitLinkMetric(MiniportAdapter *VA, int SNode, Link *Link, Time Now);

extern NTSTATUS
MiniportPersistControl(MiniportAdapter *VA,
                       VRR_CONTROL_VIRTUAL_ADAPTER *Control);

extern void
MiniportReadControl(MiniportAdapter *VA,
                    VRR_CONTROL_VIRTUAL_ADAPTER *Control);

extern NTSTATUS
MiniportControl(MiniportAdapter *VA, VRR_CONTROL_VIRTUAL_ADAPTER *Control);


//
// Functionality in driver.c and io.c.
//

extern uint Version;

extern DEVICE_OBJECT *OurDeviceObject;

extern PDRIVER_DISPATCH IoMajorFunctions[IRP_MJ_MAXIMUM_FUNCTION + 1];

extern NTSTATUS
IoCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp);

extern NTSTATUS
IoCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp);
extern NTSTATUS
IoClose(PDEVICE_OBJECT DeviceObject, PIRP Irp);

extern NTSTATUS
IoControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);

//
// Functionality in random.c.
//
extern int
RandomInit(void);

extern void
GetRandom(uchar *Buffer, uint Length);

extern uint
GetRandomNumber(uint Max);

//
// Functionality in msripv6.c
//
extern void
SeedRandom(unsigned int Seed);

extern uint
RandomNumber(uint Min, uint Max);

extern ushort
ChecksumPacket(
    PNDIS_PACKET Packet,
    uint Offset,
    uchar *Data,
    uint Length,
    IPv6Addr *Source,
    IPv6Addr *Dest,
    uchar NextHeader);

//
// Functionality in ndishack.c
//
extern void
VrrNdisAllocateBuffer(
    OUT PNDIS_STATUS  Status,
    OUT PNDIS_BUFFER  *Buffer,
    IN NDIS_HANDLE  PoolHandle,
    IN PVOID  VirtualAddress,
    IN UINT  Length);

//
// Functionality in IPv6.c
//
extern void
SetVSetChanged (
    MiniportAdapter *VA);

extern boolint
IPv6TrapOutboundNS(
    MiniportAdapter *VA,
    NDIS_PACKET *Packet,
    EtherHeader *eth);

extern boolint
TestVSetChanged (
    MiniportAdapter *VA);

extern void
DHTDriverRequest (
    MiniportAdapter *VA,
    uchar MsgType,
    DHTHeader UNALIGNED *RequestDHT,
    ushort RequestLength,
    ushort Port);

extern boolint
IPv6TrapOutboundDHT(
    MiniportAdapter *VA,
    NDIS_PACKET *Packet,
    EtherHeader *Eth,
    SRPacket *SRP);

extern char *
AllocFlatBuffer(
    NDIS_PACKET *Packet,
    uint BytesRequired);

extern unsigned short
Cksum(
      unsigned char *c,
      unsigned int Length);


//
// Functionality in io.c
//
uchar
ExecCommand(
    MiniportAdapter *VA,
    uchar OpCode,
    uchar Arg);

//
// Functionality in IPv4.c
//
extern boolint
IPv4TrapOutboundARPRequest(
    MiniportAdapter *VA,
    NDIS_PACKET *Packet,
    EtherHeader *eth);

//
// Functionality in reg.c.
//

typedef enum {
    OpenRegKeyRead,
    OpenRegKeyCreate,
    OpenRegKeyDeleting
} OpenRegKeyAction;

extern NTSTATUS
OpenRegKey(PHANDLE HandlePtr, HANDLE Parent, const WCHAR *KeyName,
           OpenRegKeyAction Action);

extern NTSTATUS
GetRegDWORDValue(HANDLE KeyHandle, const WCHAR *ValueName, PULONG ValueData);

extern NTSTATUS
SetRegDWORDValue(HANDLE KeyHandle, const WCHAR *ValueName,
                 IN ULONG ValueData);

extern NTSTATUS
GetRegNetworkAddress(HANDLE KeyHandle, const WCHAR *ValueName,
                     OUT VirtualAddress Address);

extern NTSTATUS
SetRegNetworkAddress(HANDLE KeyHandle, const WCHAR *ValueName,
                     IN VirtualAddress Address);

extern NTSTATUS
GetRegGuid(HANDLE KeyHandle, const WCHAR *ValueName,
           OUT GUID *Guid);

extern NTSTATUS
GetRegBinaryValue(HANDLE KeyHandle, const WCHAR *ValueName,
                  OUT uchar *Buffer, uint Length);

extern NTSTATUS
SetRegBinaryValue(HANDLE KeyHandle, const WCHAR *ValueName,
                  IN uchar *Buffer, uint Length);

//
// Define missing interlocked functions.
//

__inline LONGLONG
InterlockedRead64(LONGLONG volatile *Target)
{
#if defined(_M_IA64) || defined(_M_AMD64)
    return *Target;
#else
    LONGLONG Value = 0;
    return InterlockedCompareExchange64(Target, Value, Value);
#endif
}

__inline void
InterlockedWrite64(LONGLONG volatile *Target, LONGLONG Value)
{
#if defined(_M_IA64) || defined(_M_AMD64)
    *Target = Value;
#else
    LONGLONG OldValue = InterlockedRead64(Target);
    (void) InterlockedCompareExchange64(Target, Value, OldValue);
#endif
}

__inline void
InterlockedIncrementHighWater(LONG volatile *Count, LONG volatile *HighWater)
{
    LONG NewValue = InterlockedIncrement(Count);
    LONG OldHighWater;
    while ((OldHighWater = *HighWater) < NewValue) {
        if (InterlockedCompareExchange(HighWater, NewValue, OldHighWater) == NewValue)
            break;
    }
}

#if DBG
//* VrrKdPrint
//
//  Handy formatter for dng messages.
//
__inline void
VrrKdPrint (
    char *msg,
    VirtualAddress s,
    VirtualAddress d)
{   //uchar *s = srp->ackreq->opt.Source;
    //uchar *d = srp->ackreq->opt.Dest;
    if (NULL != s && NULL != d)
        KdPrint(("VrrKdPrint: (%u) %s : s=%02x%02x%02x%02x%02x%02x d=%02x%02x%02x%02x%02x%02x\n",
                 TIMESTAMP, msg, s[0], s[1], s[2], s[3], s[4], s[5], d[0], d[1], d[2], d[3], d[4], d[5]));
    else if (d != NULL && NULL == s)         
        KdPrint(("VrrKdPrint: (%u) %s : d=%02x%02x%02x%02x%02x%02x\n",
                 TIMESTAMP, msg, d[0], d[1], d[2], d[3], d[4], d[5]));
    else if (s != NULL && NULL == d)
        KdPrint(("VrrKdPrint: (%u) %s : s=%02x%02x%02x%02x%02x%02x\n",
                 TIMESTAMP, msg, s[0], s[1], s[2], s[3], s[4], s[5]));
    else 
        KdPrint(("VrrKdPrint: (%u) %s \n", TIMESTAMP, msg));
                 
}
#else  // DBG
#define VrrKdPrint(a,b,c) ;
#endif // DBG

#if DBG
//* VrrTrace
//
//  Debug: writes semi-structured dbg msg for I/P to csv-friendly util.
//  usage e.g.: VrrTrace(VA,"TDtoPCache",SrcAddr,SenderOrNextHopAddr,DestAddr,"Str1",uint1,"Str2",uint2);
//
__inline void
VrrTrace (
    MiniportAdapter *VA,
    uint NoiseLevel,
    char *msg,
    VirtualAddress Src,
    VirtualAddress Addr,  // Sender on rx paths, NextHop on tx paths.
    VirtualAddress Dest,
    char *Str1,
    uint uint1,
    char *Str2,
    uint uint2)
{
    uint MsSinceMidnight = TIME_TO_MS(TimeSinceMidnight());

    if (Src == NULL) Src = NullAddress;
    if (Addr == NULL) Addr = NullAddress;
    if (Dest == NULL) Dest = NullAddress;
    if (Str1 == NULL) Str1 = "";
    if (Str2 == NULL) Str2 = "";
    if (NoiseLevel <= VA->VrrTraceNoiseLevel)

    KdPrint(("VrrTrace,%u,%02x%02x%02x%02x%02x%02x,%s,%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x,%s:0x%08x,%s:0x%08x\n",
                 MsSinceMidnight,
                 VA->Address[0], VA->Address[1], VA->Address[2], VA->Address[3], VA->Address[4], VA->Address[5],
                 msg, 
                 Src[0], Src[1], Src[2], Src[3], Src[4], Src[5],
                 Addr[0], Addr[1], Addr[2], Addr[3], Addr[4], Addr[5],
                 Dest[0], Dest[1], Dest[2], Dest[3], Dest[4], Dest[5],
                 Str1, uint1, Str2, uint2));
                 
}
#else  // DBG
#define VrrTrace(a,b,c,d,e,f,g,h,i,j) ;
#endif // DBG

#if DBG
//* VrrTraceVset
//
//  Debug: writes semi-structured dbg msg for I/P to csv-friendly util.
//  usage e.g.: VrrTrace(VA,"message",Addr1,Addr2,Addr3,Addr4,Addr5);
//
__inline void
VrrTraceVSet (
    MiniportAdapter *VA,
    char *msg,
    VirtualAddress Addr1,
    VirtualAddress Addr2,
    VirtualAddress Addr3,
    VirtualAddress Addr4,
    VirtualAddress Addr5)
{
    uint MsSinceMidnight = TIME_TO_MS(TimeSinceMidnight());

    if (Addr1 == NULL) Addr1 = NullAddress;
    if (Addr2 == NULL) Addr2 = NullAddress;
    if (Addr3 == NULL) Addr3 = NullAddress;
    if (Addr4 == NULL) Addr4 = NullAddress;
    if (Addr5 == NULL) Addr5 = NullAddress;

    KdPrint(("VrrTrace,%u,%02x%02x%02x%02x%02x%02x,%s,%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x,"
             "%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x,%02x%02x%02x%02x%02x%02x,\n",
                 MsSinceMidnight,
                 VA->Address[0], VA->Address[1], VA->Address[2], VA->Address[3], VA->Address[4], VA->Address[5],
                 msg, 
                 Addr1[0], Addr1[1], Addr1[2], Addr1[3], Addr1[4], Addr1[5],
                 Addr2[0], Addr2[1], Addr2[2], Addr2[3], Addr2[4], Addr2[5],
                 Addr3[0], Addr3[1], Addr3[2], Addr3[3], Addr3[4], Addr3[5],
                 Addr4[0], Addr4[1], Addr4[2], Addr4[3], Addr4[4], Addr4[5],
                 Addr5[0], Addr5[1], Addr5[2], Addr5[3], Addr5[4], Addr5[5]));
                 
}
#else  // DBG
#define VrrTraceVSet(a,b,c,d,e,f,g) ;
#endif // DBG

extern void PrintfNdisStatus(
    char *msg,
    NDIS_STATUS NdisStatus,
    boolint PrintSuccess);

__inline void
PrintRTE (
    RouteTableEntry *RTE)
{
    VrrKdPrint("RTE(a=s,b=d)",RTE->A.Address,RTE->B.Address);
    VrrKdPrint("   NextHops(a=s,b=d)",
             (NULL != RTE->A.Next) ? RTE->A.Next->VAddress : NULL,
             (NULL != RTE->B.Next) ? RTE->B.Next->VAddress : NULL);
}

// DHT: 
extern PhysicalAddress DHTMagicL2;