ache.c

Linux 上的socket嗅探器

/*------------------------------------------------------------------------------------
 *
 * Copyright(c), 2002-....
 *    All rights reserved
 *
 *    FILENAME    : ache.c/cpp
 *    CONTENTS    : implementation file for the acher
 * DATE        : 2003/02/1
 * LANGUAGE    : C/C++
 * VERSION     : 1.0
 * AUTHOR : Xiangbin Lee(Honeycombs)
 * AUTHOR's EMail:
 *             [e-mail]
 *                 [e-mail]
 *-------------------------------------------------------------------------------------
 * If this code works, it was written by Xiangbin Lee(Honeycombs).
 * If not, I don't know who wrote it.
 *-------------------------------------------------------------------------------------
 * RECORD:
 * DATE         VERSION   AUTHOR       CONTENTS
 * 2003/02/01   1.0       Honeycombs   Create file
 * 2003/03/15   1.1       Honeycombs   flee bugs
 *------------------------------------------------------------------------------------*/

#include "ache.h"

#include <string.h>
#include <stdlib.h>

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


void SetBuf22(unsigned char *buf, unsigned short data)
{
    unsigned char *lpbuf;
    unsigned char *lpdata;
    lpbuf=buf;
    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpbuf++=lpdata[0];
    *lpbuf++=lpdata[1];
#else
    *lpbuf++=lpdata[1];
    *lpbuf++=lpdata[0];
#endif
}

unsigned short GetBuf22(unsigned char *buf)
{
    unsigned short data;
    unsigned char *lpbuf;
    unsigned char *lpdata;
    lpbuf=buf;
    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpdata++=lpbuf[0];
    *lpdata++=lpbuf[1];
#else
    *lpdata++=lpbuf[1];
    *lpdata++=lpbuf[0];
#endif
    return data;
}

void SetBuf44(unsigned char *buf, unsigned long data)
{
    unsigned char *lpbuf;
    unsigned char *lpdata;
    lpbuf=buf;
    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpbuf++=lpdata[0];
    *lpbuf++=lpdata[1];
    *lpbuf++=lpdata[2];
    *lpbuf++=lpdata[3];
#else
    *lpbuf++=lpdata[3];
    *lpbuf++=lpdata[2];
    *lpbuf++=lpdata[1];
    *lpbuf++=lpdata[0];
#endif
}

unsigned long GetBuf44(unsigned char *buf)
{
    unsigned long data ;
    unsigned char *lpbuf;
    unsigned char *lpdata;
    lpbuf=buf;
    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpdata++=lpbuf[0];
    *lpdata++=lpbuf[1];
    *lpdata++=lpbuf[2];
    *lpdata++=lpbuf[3];
#else
    *lpdata++=lpbuf[3];
    *lpdata++=lpbuf[2];


    *lpdata++=lpbuf[1];
    *lpdata++=lpbuf[0];
#endif
    return data ;
}

void SetBuf43(unsigned char *buf, unsigned long data)
{
    unsigned char *lpbuf;
    unsigned char *lpdata;
    lpbuf=buf;

    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpbuf++=lpdata[1];
    *lpbuf++=lpdata[2];
    *lpbuf++=lpdata[3];
#else
    *lpbuf++=lpdata[2];
    *lpbuf++=lpdata[1];
    *lpbuf++=lpdata[0];
#endif
}


unsigned long GetBuf43(unsigned char *buf)
{
    unsigned long data;
    unsigned char *lpbuf;
    unsigned char *lpdata;

    lpbuf=buf;
    lpdata=(unsigned char *)(&data);
#ifdef _SYS_UNIXOS
    *lpdata++=0;
    *lpdata++=lpbuf[0];
    *lpdata++=lpbuf[1];
    *lpdata++=lpbuf[2];
#else
    *lpdata++=lpbuf[2];
    *lpdata++=lpbuf[1];
    *lpdata++=lpbuf[0];
    *lpdata++=0;
#endif
    return data ;
}


int ResetAchStatus(
    ACHSTATUS *sta,
    unsigned char *dest,
    unsigned long maxbuflen,
    unsigned char fhead,
    unsigned char ftail,
    unsigned char fperbyte)
{
    if(sta == 0||dest == 0||maxbuflen<1024)
        return 0;
    sta->ACHCOUNT=0;
    sta->windex=0;
    sta->rindex=0;
    sta->ACHBuffer=(unsigned char *)dest;
    sta->MaxBufLen =maxbuflen;
    sta->head=fhead;
    sta->tail=ftail;
    sta->perbyte=fperbyte;
    sta->state=ACHE_USESIGNE;
    return 1;
}
/*
* Read Character from buffer
*/

int ReaderAche( ACHSTATUS *achSta, unsigned char * buffer)
{
    int freei, ret=0, tailfound=-1, headfound=-1;
    int fcurrent,fcount;
    if(achSta == 0||buffer == 0||achSta->ACHBuffer == 0)
        return 0;
    if(achSta->state!=ACHE_USESIGNE)
        return 0;
    fcurrent=achSta->rindex;
    fcount = achSta->ACHCOUNT;
    if(fcount<2)
        return 0;
    for(freei=0;freei<fcount;freei++)
    {
        ret=freei+fcurrent;
        ret%=achSta->MaxBufLen;
        if((achSta->ACHBuffer[ret]) == (achSta->head))
            headfound = freei;
        if((achSta->ACHBuffer[ret]) == (achSta->tail))
        {
            tailfound=freei;
            freei++;
            break;
        }
    }

    if(headfound<0&&tailfound<0)
        return 0;
    else if(headfound>=0&&tailfound<0)
        return 0;
    else if(headfound<0&&tailfound>=0)
    {
        achSta->ACHCOUNT -= (tailfound+1);
        achSta->rindex+=(tailfound+1);
        achSta->rindex%=achSta->MaxBufLen;
        return 0;
    }

    achSta->rindex+=headfound;
    achSta->rindex%=(achSta->MaxBufLen);

    if(achSta->readtype == ACHERW_NOTRANS)
    {
        for(ret=0;ret<tailfound-headfound+1;ret++)
        {
            buffer[ret]=(achSta->ACHBuffer[achSta->rindex])&(achSta->perbyte);
            achSta->ACHBuffer[achSta->rindex]=0;
            achSta->rindex++;
            achSta->rindex%=(achSta->MaxBufLen);
        }
        ret=tailfound-headfound+1;
        if(ret<0)ret=0;
    }
    else
    {
        achSta->readtype=ACHERW_TRANS;
        achSta->ACHBuffer[achSta->rindex]=0;
        achSta->rindex++;

        achSta->rindex%=(achSta->MaxBufLen);
        for(ret=0;ret<tailfound-headfound-1;ret++)
        {
            buffer[ret]=(achSta->ACHBuffer[achSta->rindex])&(achSta->perbyte);
            achSta->ACHBuffer[achSta->rindex]=0;
            achSta->rindex++;
            achSta->rindex%=(achSta->MaxBufLen);
        }
        achSta->ACHBuffer[achSta->rindex]=0;
        achSta->rindex++;
        achSta->rindex%=(achSta->MaxBufLen);
        ret=tailfound-headfound-1;
        if(ret<0)ret=0;
    }

    buffer[ret]=0;

    if(ret>(int)achSta->ACHCOUNT)
        achSta->ACHCOUNT=0;
    else
        achSta->ACHCOUNT-=ret;

    return ret;
}

/*
* Write Character to buffer
*/

int WriterAche( ACHSTATUS *achSta, unsigned char * buffer, int length)
{
    int i;
    if(achSta == 0||buffer == 0||achSta->ACHBuffer == 0)
        return 0;
    if(achSta->state!=ACHE_USESIGNE)
        return 0;

    switch(achSta->achemode)
    {
    case ACHE_AS_STACK:
        {
            if(achSta->writetype == ACHERW_TRANS)
            {
                achSta->rindex--;
                achSta->rindex%=(achSta->MaxBufLen);
                achSta->ACHBuffer[achSta->rindex]=(achSta->tail);
            }
            else
            {
                achSta->writetype=ACHERW_NOTRANS;
            }

            for ( i=length-1 ; i>=0 ; i--)
            {
                achSta->rindex--;
                achSta->rindex%=(achSta->MaxBufLen);
                achSta->ACHBuffer[achSta->rindex]=buffer[i]&(achSta->perbyte);
            }

            if(achSta->writetype == ACHERW_TRANS)
            {
                achSta->rindex--;
                achSta->rindex%=(achSta->MaxBufLen);
                achSta->ACHBuffer[achSta->rindex]=(achSta->head);
            }
            else
            {
                achSta->writetype=ACHERW_NOTRANS;
            }

        }break;
    default :
        {
            achSta->achemode=ACHE_AS_QUEUE;

            if(achSta->writetype == ACHERW_TRANS)
            {
                achSta->ACHBuffer[achSta->windex]=(achSta->head);
                achSta->windex++;
                achSta->windex%=(achSta->MaxBufLen);
            }
            else
            {
                achSta->writetype=ACHERW_NOTRANS;
            }

            for ( i=0 ; i< length ; i++)
            {
                achSta->ACHBuffer[achSta->windex]=buffer[i]&(achSta->perbyte);
                achSta->windex++;
                achSta->windex%=(achSta->MaxBufLen);
            }

            if(achSta->writetype == ACHERW_TRANS)
            {
                achSta->ACHBuffer[achSta->windex]=(achSta->tail);
                achSta->windex++;
                achSta->windex%=(achSta->MaxBufLen);
            }
            else
            {
                achSta->writetype=ACHERW_NOTRANS;
            }

            achSta->ACHBuffer[achSta->windex]=0;
        };
    }; //switch(achSta->achemode)
    achSta->ACHCOUNT+=length;
    if(achSta->writetype == ACHERW_TRANS)
        achSta->ACHCOUNT+=2;

    return length ;
}

ACHE_MODE SetAcheMode( ACHSTATUS *achSta, ACHE_MODE amode, int rtype, int wtype )
{
    ACHE_MODE ret=achSta->achemode;
    achSta->achemode=amode;

    if(rtype == ACHERW_NOTRANS)
        achSta->readtype=ACHERW_NOTRANS;
    else
        achSta->readtype=ACHERW_TRANS;

    if(wtype == ACHERW_NOTRANS)
        achSta->writetype=ACHERW_NOTRANS;
    else
        achSta->writetype=ACHERW_TRANS;

    return ret;
}

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

int ResetCircleAche(CIRCLEACHESTATUS *lpsta)
{
    if(lpsta == 0)
        return 0;

    if(lpsta->ifinit == ACHE_REGSIGNE)
    {
        unsigned freei;
        CIRCLEACHE *circleache=lpsta->head;
        CIRCLEACHE *next=0;
        for(freei=0;freei<lpsta->pocount;freei++)
        {
            if(circleache!=0)
            {
                next=circleache->next;
                free(circleache);
                circleache=next;
                if(circleache == lpsta->head)
                    break;
            }
            else
                break;
        }
    }

    lpsta->head=0;
    lpsta->rid=0;
    lpsta->wid=0;
    lpsta->pocount=0;
    lpsta->ifinit=0;
    return 1;
}

void *GetCurCircleAche( CIRCLEACHESTATUS *lpsta)
{
    void *ret=0;
    
    if(lpsta == 0)
        return 0;

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

    if(lpsta->rid == 0)
        return 0;


    ret = lpsta->rid->lppoint;
    lpsta->rid=lpsta->rid->next;

    return ret;
}

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

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

    circleache=lpsta->head;
    for(freei=0;freei<(int)(lpsta->pocount);freei++)
    {
        if(circleache&&circleache->id == nWitch)
        {
            ret=circleache->lppoint;
            found=1;
            break;
        }
        circleache=circleache->next;