decdirda.c

收集到的orion_ep93xx_wince_bsp_1-3-507红外收发驱动源码,未作测试

/* Copyright (c) 1999-2000 Microsoft Corporation.  All rights reserved. */
#include <windows.h>
#include <tchar.h>
#include <decdirda.h>

#ifdef DEBUG

int BaudBitMask = 0;

int vDispMode;

UINT vDecodeLayer;

int vSlotTable[] = { 1, 6, 8, 16 };

TCHAR *vLM_PDU_DscReason[] = 
{
    TEXT(""),
    TEXT("User Request"),
    TEXT("Unexpected IrLAP Disconnect"),
    TEXT("Failed to establish IrLAP connection"),
    TEXT("IrLAP reset"),
    TEXT("Link management initiated disconnect"),
    TEXT("data sent to disconnected LSAP"),
    TEXT("Non responsive LM-MUX client"),
    TEXT("No available LM-MUX client"),
    TEXT("Unspecified")
};

/*
** Negotiation Parameter Value (PV) tables
*/
TCHAR *vBaud[] =
{
    TEXT("2400"), TEXT("9600"), TEXT("19200"), TEXT("38400"), TEXT("57600"),
    TEXT("115200"), TEXT("reserved"), TEXT("reserved")
};

TCHAR *vMaxTAT[] = /* Turn Around Time */
{
    TEXT("500"), TEXT("250"), TEXT("100"), TEXT("50"), TEXT("25"), TEXT("10"),
    TEXT("5"), TEXT("reserved")
};

TCHAR *vMinTAT[] = 
{
    TEXT("10"), TEXT("5"), TEXT("1"), TEXT("0.5"), TEXT("0.1"), TEXT("0.05"),
    TEXT("0.01"), TEXT("0")
};

TCHAR *vDataSize[] =
{
    TEXT("64"), TEXT("128"), TEXT("256"), TEXT("512"), TEXT("1024"),
    TEXT("2048"), TEXT("reserved"), TEXT("reserved")
};

TCHAR *vWinSize[] =
{
    TEXT("1"), TEXT("2"), TEXT("3"), TEXT("4"), TEXT("5"), TEXT("6"),
    TEXT("7"), TEXT("reserved")
};

TCHAR *vNumBofs[] =
{
    TEXT("48"), TEXT("24"), TEXT("12"), TEXT("5"), TEXT("3"), TEXT("2"),
    TEXT("1"), TEXT("0")
};

TCHAR *vDiscThresh[] =
{
    TEXT("3"), TEXT("8"), TEXT("12"), TEXT("16"), TEXT("20"), TEXT("25"),
    TEXT("30"), TEXT("40")
};

/*---------------------------------------------------------------------------*/
void
RawDump(BYTE *pFrameBuf, BYTE *pEndBuf, TCHAR **ppOutStr)
{
    BOOL    First = TRUE;
    BYTE    *pBufPtr = pFrameBuf;

    if (vDispMode == DISP_ASCII || vDispMode == DISP_BOTH)
    {
        while (pBufPtr <= pEndBuf)
        {
            if (First)
            {
                First = FALSE;
                *(*ppOutStr)++ = TEXT('[');
            }
        
            *(*ppOutStr)++ = isprint(*pBufPtr) ? *pBufPtr : '.';
        
            pBufPtr++;
        }
        if (!First) /* meaning, close [ */
            *(*ppOutStr)++ = ']';
    } 

    First = TRUE;
    pBufPtr = pFrameBuf;
    
    if (vDispMode == DISP_HEX || vDispMode == DISP_BOTH)
    {        
        while (pBufPtr <= pEndBuf)
        {
            if (First)
            {
                First = FALSE;
                *(*ppOutStr)++ = TEXT('[');
            }
        
            *ppOutStr += wsprintf(*ppOutStr, TEXT("%02X "), *pBufPtr);
        
            pBufPtr++;

        }
        if (!First) /* meaning, close [ */
            *(*ppOutStr)++ = ']';
    }
}
/*---------------------------------------------------------------------------*/
TCHAR *
GetStatusStr(BYTE status)
{
    switch (status)
    {
        case LM_PDU_SUCCESS:
            return (TEXT("SUCCESS"));
        case LM_PDU_FAILURE:
            return (TEXT("FAILURE"));
        case LM_PDU_UNSUPPORTED:
            return (TEXT("UNSUPPORTED"));
        default:
            return (TEXT("BAD STATUS!"));
    }
}
/*---------------------------------------------------------------------------*/
void
DecodeIFrm(BYTE *pFrameBuf, BYTE *pEndBuf, TCHAR **ppOutStr)
{
    LM_HEADER *pLMHeader = (LM_HEADER *) pFrameBuf;
    LM_CNTL_FORMAT *pCFormat =
       (LM_CNTL_FORMAT *)(pFrameBuf + sizeof(LM_HEADER));
    BYTE *pLMParm1 = ((BYTE *) pCFormat + sizeof(LM_CNTL_FORMAT));
    BYTE *pLMParm2 = ((BYTE *) pCFormat + sizeof(LM_CNTL_FORMAT) + 1);
    TTP_CONN_HEADER *pTTPConnHeader = (TTP_CONN_HEADER *) pLMParm2;
    TTP_DATA_HEADER *pTTPDataHeader = (TTP_DATA_HEADER *)
                            (pFrameBuf + sizeof(LM_HEADER));
    TCHAR RCStr[] = TEXT("    ");
    
    if (2 == vDecodeLayer) // LAP only
    {
        RawDump(pFrameBuf, pEndBuf, ppOutStr);
        return;
    }

    // Ensure the LMP header is there
    if (((BYTE *)pLMHeader + sizeof(LM_HEADER) > pEndBuf+1))
    {
        *ppOutStr += wsprintf(*ppOutStr, TEXT("!-MISSING LMP HEADER-!"));
        return;
    }
    
    *ppOutStr += wsprintf(*ppOutStr, TEXT("sls:%02X dls:%02X "),
                         pLMHeader->SLSAP_SEL, pLMHeader->DLSAP_SEL);
    
    switch (pLMHeader->CntlBit)
    {
        case LM_PDU_CNTL_FRAME:
            _tcscpy(RCStr, pCFormat->ABit == LM_PDU_REQUEST ?
                   TEXT("req") : TEXT("conf"));

            if (((BYTE *)pCFormat + sizeof(LM_CNTL_FORMAT)) > pEndBuf+1)
            {
                *ppOutStr += wsprintf(*ppOutStr, 
                                      TEXT("!-MISSING LMP-CNTL HEADER-!"));
                return;
            }
            else
            {
                if (pLMParm1 > pEndBuf)
                {
                    pLMParm1 = NULL;
                    pLMParm2 = NULL;
                    pTTPConnHeader = NULL;
                }
                else
                {
                    if (pLMParm2 > pEndBuf)
                    {
                        pLMParm2 = NULL;
                        pTTPConnHeader = NULL;
                    }
                    else
                    {
                        if (((BYTE *)pTTPConnHeader+sizeof(TTP_CONN_HEADER)) >
                        pEndBuf+1)
                        {
                            pTTPConnHeader = NULL;
                        }
                    }
                }
            }
            
            switch (pCFormat->OpCode)
            {
                case LM_PDU_CONNECT:
                    *ppOutStr += wsprintf(*ppOutStr, TEXT("LM-Connect.%s "),
                                         RCStr);
                    if (pLMParm1 != NULL)
                    {
                        *ppOutStr += wsprintf(*ppOutStr, TEXT("rsvd:%02X "),
                                              *pLMParm1);
                    }
                    if (3 == vDecodeLayer) // LMP only
                    {
                        if (pLMParm2 != NULL) 
                        {
                            // This is user data
                            RawDump(pLMParm2, pEndBuf, ppOutStr);
                        }
                    }
                    else
                    {
                        // TTP
                        if (pTTPConnHeader == NULL)
                        {
                            *ppOutStr += wsprintf(*ppOutStr, 
                                     TEXT("!-MISSING TTP CONNECT HEADER-!"));
                        }
                        else
                        {
                            *ppOutStr += wsprintf(*ppOutStr,
                                  TEXT("pf:%d ic:%d "),
                                  pTTPConnHeader->ParmFlag,
                                       pTTPConnHeader->InitialCredit);
                            // This is user data
                            RawDump(((BYTE *) pTTPConnHeader + 
                                     sizeof(TTP_CONN_HEADER)), pEndBuf,
                                    ppOutStr);
                        }
                    }
                    break;
                    
                case LM_PDU_DISCONNECT:
                    *ppOutStr += wsprintf(*ppOutStr,
                                     TEXT("LM-Disconnect.%s"), RCStr); 
                    if (pLMParm1 == NULL)
                    {
                        *ppOutStr += wsprintf(*ppOutStr, 
                                        TEXT("!-MISSING REASON CODE-!"));
                        return;
                    }
                    else
                    {
                        if ((*pLMParm1 > LM_PDU_MAX_DSC_REASON || 
                             *pLMParm1 == 0) && *pLMParm1 != 0xFF)
                        { 
                            *ppOutStr += wsprintf(*ppOutStr,
                                          TEXT(" BAD REASON CODE:%02X "),
                                                  *pLMParm1);
                        }
                        else
                        {
                            if (*pLMParm1 == 0xFF)
                            {
                                *pLMParm1 = 0x09; // KLUDGE HERE !!
                            }
                            *ppOutStr += wsprintf(*ppOutStr,
                                           TEXT("(%02X:%s) "), *pLMParm1,
                                           vLM_PDU_DscReason[*pLMParm1]);
                        }
                        if (pLMParm2 != NULL)
                        {
                            RawDump(pLMParm2, pEndBuf, ppOutStr);
                        }
                    }

                    break;
                    
                case LM_PDU_ACCESSMODE:
                    *ppOutStr += wsprintf(*ppOutStr, TEXT("LM-AccessMode.%s "),
                                          RCStr);
                    if (pLMParm1 == NULL || pLMParm2 == NULL)
                    {
                        *ppOutStr += wsprintf(*ppOutStr, 
                                              TEXT("!-MISSING PARAMETER-!"));
                    }
                    else
                    {
                        if (pCFormat->ABit == LM_PDU_REQUEST)
                        {
                            *ppOutStr += wsprintf(*ppOutStr,
                                  TEXT("rsvd:%02X "), *pLMParm1);
                        }
                        else
                        {
                            *ppOutStr += wsprintf(*ppOutStr, 
                                 TEXT("status:%s "), GetStatusStr(*pLMParm1));
                        }
                        
                        *ppOutStr += wsprintf(*ppOutStr, TEXT("mode:%s "),
                                          *pLMParm2 == LM_PDU_EXCLUSIVE ?
                                          TEXT("Exclusive") :
                                              TEXT("Multiplexed"));
                    }
                    break;
                default:
                    *ppOutStr += wsprintf(*ppOutStr, TEXT("Bad opcode: "));
                    RawDump((BYTE *) pCFormat, pEndBuf, ppOutStr);
            }
            break;
                    
        case LM_PDU_DATA_FRAME:
            if (3 == vDecodeLayer)
            {
                RawDump((BYTE *) pCFormat, pEndBuf, ppOutStr);
            }
            else
            {
                // TTP
                if ((BYTE *) (pTTPDataHeader + 1) > pEndBuf + 1)
                {
                    *ppOutStr += wsprintf(*ppOutStr, 
                                 TEXT("!-MISSING TTP DATA HEADER-!"));
                }
                else
                {
                    *ppOutStr += wsprintf(*ppOutStr,
                               TEXT("mb:%d nc:%d "),
                                          pTTPDataHeader->MoreBit,
                                          pTTPDataHeader->AdditionalCredit);
                    // This is user data
                    RawDump(((BYTE *) pTTPDataHeader + 
                             sizeof(TTP_DATA_HEADER)), pEndBuf,
                            ppOutStr);                    
                }
                
            }
            break;

        default: