ache.c

Linux 上的socket嗅探器

    }
    return ret ;
}

unsigned long GetCurCircleAcheIndex( CIRCLEACHESTATUS *lpsta)
{
    unsigned long ret=0;
    if(lpsta == 0)
        return 0;
    if(lpsta->rid == 0)
        return 0;

    if(lpsta->ifinit!=ACHE_REGSIGNE)
    {
        ResetCircleAche(lpsta);
        return 0;
    }



    ret = lpsta->rid->id;
    return ret;
}

unsigned long GetCircleAcheCount( CIRCLEACHESTATUS *lpsta)
{
    unsigned long ret=0;
    if(lpsta == 0)
        return 0;
    if(lpsta->ifinit!=ACHE_REGSIGNE)
    {
        ResetCircleAche(lpsta);
        return 0;
    }
    ret = lpsta->pocount;
    return ret;
}

void CircleAcheResetRead(CIRCLEACHESTATUS *lpsta)
{
    if(lpsta == 0)
        return ;
    if(lpsta->ifinit!=ACHE_REGSIGNE)
        ResetCircleAche(lpsta);
    else
    {

        lpsta->rid=lpsta->head;
    }
}

void CircleAcheResetWrite(CIRCLEACHESTATUS *lpsta)
{
    if(lpsta == 0)
        return ;
    if(lpsta->ifinit!=ACHE_REGSIGNE)
        ResetCircleAche(lpsta);
    else
    {
        lpsta->wid=lpsta->head;
    }
}

unsigned long AddCircleAche( CIRCLEACHESTATUS *lpsta, void *lpoint)
{
    unsigned long ret=0;
    if(lpsta == 0)
        return 0;

    if(lpsta->ifinit!=ACHE_REGSIGNE)
    {
        ResetCircleAche(lpsta);
    }

    if(lpsta->pocount == 0)
    {
        CIRCLEACHE *circleache=(CIRCLEACHE*)malloc(sizeof(CIRCLEACHE));
        if(circleache == 0)
            return 0;


        circleache->id=1;
        circleache->lppoint=lpoint;
        circleache->next=circleache;
        circleache->prev=circleache;
        lpsta->head=circleache;
        lpsta->pocount=1;
        lpsta->rid=lpsta->head;
        lpsta->wid=lpsta->head;
        ret=lpsta->pocount;
    }
    else
    {
        unsigned long freei;
        CIRCLEACHE *circleache=lpsta->head;
        for(freei=0;freei<lpsta->pocount;freei++)
        {
            if(circleache!=0&&circleache->lppoint == lpoint)
                return circleache->id;
            circleache=circleache->next;
        }

        circleache=(CIRCLEACHE*)malloc(sizeof(CIRCLEACHE));
        if(circleache == 0)
            return 0;
        lpsta->pocount++;
        circleache->id=lpsta->pocount;
        circleache->lppoint=lpoint;


        circleache->next=lpsta->wid->next;

        lpsta->wid->next->prev=circleache;

        circleache->prev=lpsta->wid;
        lpsta->wid->next=circleache;

        lpsta->wid=circleache;
        ret= circleache->id;

    }

    lpsta->ifinit=ACHE_REGSIGNE;
    return ret ;
}


unsigned long DelCircleAche( CIRCLEACHESTATUS *lpsta, void *lpoint)
{
    unsigned long ret=0,freei=0;
    int found=0;
    CIRCLEACHE *circleache=0;
    if(lpsta == 0||lpsta->pocount<=0)
        return 0;

    if(lpsta->ifinit!=ACHE_REGSIGNE)
    {
        ResetCircleAche(lpsta);
        return 0;
    }

    if(lpsta->pocount == 1&&lpsta->head->lppoint == lpoint)
    {
        ResetCircleAche(lpsta);
        return 1;
    }

    circleache=lpsta->head;
    for(freei=0;freei<lpsta->pocount;freei++)
    {
        if(circleache!=0&&circleache->lppoint == lpoint)
        {
            ret= circleache->id;
            if(circleache == lpsta->head)
            {
                lpsta->head=lpsta->head->next;
            }

            if(circleache == lpsta->rid)
            {
                lpsta->rid=lpsta->rid->next;
            }

            if(circleache == lpsta->wid)
            {
                lpsta->wid=lpsta->wid->prev;
            }

            circleache->prev->next=circleache->next;
            circleache->next->prev=circleache->prev;

            free(circleache);

            lpsta->pocount--;
            found=1;
            break;
        }
        circleache=circleache->next;
    }

    if(found)
    {
        circleache=lpsta->head;
        for(freei=0;freei<lpsta->pocount;freei++)
        {
            if(circleache!=0&&circleache->id>ret)
                circleache->id--;
            circleache=circleache->next;
        }
    }

    return ret ;
}

/*----------------------------------------------------*/

void *MallocWinPro(WINPRO_ACHE *lpro,
        unsigned long wnd, unsigned long buflen)
{
    int curcount=0;
    int found=0,freei;
    void *lproret=0;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);
    SetBuf44((unsigned char*)(icx+4),wnd);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char*)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)
        {
            if(memcmp((void*)(lpbuf),(void*)icx,8) == 0)
            {
                found=1;
                break;

            }
        }
    }

    if(!found)
    {
        lpbuf = (unsigned char*)malloc(buflen+16);
        if(lpbuf == 0)
            return 0;
        memcpy((void*)(lpbuf),(void*)(icx),8);
        AddCircleAche(&(lpro->cir_ache), (void *)lpbuf);
    }

    lproret = (void*)(lpbuf+8);

    return (void*)(lproret);
}

int FreeWinPro(WINPRO_ACHE *lpro,
        unsigned long wnd)
{
    int curcount=0;
    int found=0,freei;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);
    SetBuf44((unsigned char*)(icx+4),wnd);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char*)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)
        {
            if(memcmp((void*)(lpbuf),(void*)icx,8) == 0)
            {
                found=1;
                DelCircleAche(&(lpro->cir_ache),(void*)lpbuf);
                free(lpbuf);
                break;
            }
        }
    }

    return found;
}

int FreeAllWinPro(WINPRO_ACHE *lpro)
{
    int curcount=0;
    int freei;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char*)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)
        {
            DelCircleAche(&(lpro->cir_ache),(void*)lpbuf);
            free(lpbuf);
        }
    }

    return curcount;
}

void *FindWinPro(WINPRO_ACHE *lpro,
        unsigned long wnd)
{
    int curcount=0;
    int found=0,freei;
    void *lproret=0;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);
    SetBuf44((unsigned char*)(icx+4),wnd);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char *)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)

        {
            if(memcmp((void*)(lpbuf),(void*)icx,8) == 0)
            {
                found=1;
                lproret=(void*)(lpbuf+8);
                break;
            }
        }
    }

    return lproret;
}


unsigned long CheckWinPro(WINPRO_ACHE *lpro, void *lprec)
{
    int curcount=0,freei;
    unsigned char *lpbuf;
    if(lprec==0)
        return 0;
    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char *)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0&&lprec==(void*)(lpbuf+8)) 
            return  GetBuf44((unsigned char*)(lpbuf+4));
    }

    return 0;
}

void *FirstWinPro(WINPRO_ACHE *lpro)
{
    int curcount=0;
    int found=0,freei;
    void *lproret=0;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));


    CircleAcheResetRead(&(lpro->cir_ache));

    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char *)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)
        {
            if(memcmp((void*)(lpbuf),(void*)icx,4) == 0)
            {
                found=1;
                lproret=(void*)(lpbuf+8);
                break;
            }
        }
    }

    return lproret;
}

void *NextWinPro(WINPRO_ACHE *lpro)
{

    int curcount=0;
    int found=0,freei;
    void *lproret=0;
    unsigned char icx[9];
    unsigned char *lpbuf=0;

    memcpy((void*)icx,(void*)(lpro->cir_sign),4);

    curcount=GetCircleAcheCount(&(lpro->cir_ache));
    for(freei=0;freei<curcount;freei++)
    {
        lpbuf=(unsigned char *)GetCurCircleAche(&(lpro->cir_ache));
        if(lpbuf!=0)
        {
            if(memcmp((void*)(lpbuf),(void*)icx,4) == 0)
            {
                found=1;
                lproret=(void*)(lpbuf+8);
                break;
            }
        }
    }

    return lproret;
}


int GetWinProCount(WINPRO_ACHE *lpro)
{
    return GetCircleAcheCount(&(lpro->cir_ache));
}


unsigned long ResetWinProIdent(WINPRO_ACHE *lpro, unsigned long wnd, unsigned long newnd)
{
    unsigned long ret=0;
    void *res=0;
    res=FindWinPro(lpro,wnd);
    if(res!=0)
    {
       ret=GetBuf44((unsigned char *)res-4);
       SetBuf44((unsigned char *)res-4,newnd);        
    }

    return ret;  
}

/*
 *
 *
 *
 *
 *
 */

/*
 * Init root tree
 */
int InitAcheTree(ACHETREE *lptree)
{
    if(lptree==0) /* 0 point to tree */
        return -1;

    lptree->type=ACHETRTEE_SINGLE;
    lptree->lpParent=0;
    lptree->lppre=0;
    lptree->lpnext=0;
    lptree->lpChild=0;
    lptree->curChildNum=0;
    lptree->index=0;
    lptree->ifinit=ACHE_REGSIGNE;

    lptree->lpData=0;