serverfun.c

Linux 上的socket嗅探器

/*
 *
 * Copyright (C) 2003 Xiangbin Lee <[e-mail]> <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation.
 */

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>

#include "serverfun.h"

/*----------------------------------------------------*/
WINPRO_ACHE SocketUser_CircleAche ={{'C','S','U',':'},} ;

void ResetSrvclientData(REQLIST *lpclient)
{
    if(lpclient!=NULL)
    {
        memset(lpclient->request,0,MAXRECLEN) ;
        lpclient->recvlen=lpclient->res=lpclient->error=0;
    }
}

REQLIST *MallocSocketUser(unsigned long wnd)
{
    return (REQLIST *)(MallocWinPro(&SocketUser_CircleAche,wnd,sizeof(REQLIST)));
}

int FreeSocketUser( unsigned long wnd)
{
    return FreeWinPro(&SocketUser_CircleAche,wnd);
}

int FreeAllSocketUser(void)
{
    return FreeAllWinPro(&SocketUser_CircleAche);
}

unsigned long GetSocketUsercount(void)
{
    unsigned long ret=0;
    ret = GetCircleAcheCount(&(SocketUser_CircleAche.cir_ache));
    return ret;
}

unsigned long CheckSocketUser(REQLIST *lpuser)
{
    return CheckWinPro(&SocketUser_CircleAche,(void*)lpuser);
}

REQLIST *GetSocketUser(unsigned long wnd)
{
    return (REQLIST *)FindWinPro(&SocketUser_CircleAche,wnd);
}


REQLIST *GetNextSocketUser(void)
{
    return (REQLIST *)NextWinPro(&SocketUser_CircleAche);
}


/* client data cache , functions list */

static WINPRO_ACHE LinkClientProAche={{'V','C','U',':'},};

LinkClientInfo *GetConnectClient(REQLIST *lpusr)
{
    LinkClientInfo *lpret=NULL;
    if(lpusr==NULL)
        return NULL;
    lpret=(LinkClientInfo *)MallocWinPro(&LinkClientProAche,(unsigned long)lpusr,sizeof(LinkClientInfo));

    if(lpret==NULL)
        return NULL;
    else
    {
        memset((void*)lpret,0,sizeof(LinkClientInfo));
        memcpy(lpret->DataAche.cir_sign,"VCC:",4);
        lpret->lpuser=lpusr;
    }

    return lpret;
}

LinkClientInfo *CheckConnectClient(REQLIST *lpusr)
{
    LinkClientInfo *lpret=NULL;
    if(lpusr==NULL)
        return 0;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);

    return lpret;
}

int GetDisconnectClient(REQLIST *lpusr)
{
    LinkClientInfo *lpret=NULL;
    if(lpusr==NULL)
        return 0;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);
    if(lpret==NULL)
        return 0;
    FreeAllWinPro(&(lpret->DataAche));
    return FreeWinPro(&LinkClientProAche,(unsigned long)lpusr);
}

static unsigned long InsertDataToClien_nid=0;
ClientDataInfo *InsertDataToClient(REQLIST *lpusr, unsigned char *dest, unsigned short lenth)
{
    LinkClientInfo *lpret=NULL;
    ClientDataInfo *lpdata=NULL;

    if(lpusr==NULL)
        return NULL;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);
    if(lpret==NULL)
        return NULL;

    InsertDataToClien_nid++;
    lpdata=(ClientDataInfo *)MallocWinPro(&(lpret->DataAche),InsertDataToClien_nid,sizeof(ClientDataInfo)+lenth+8);
    if(lpdata==NULL)
        return NULL;
    else
    {
        lpdata->nID=InsertDataToClien_nid;
        lpdata->dtime=time(0);
        lpdata->length=lenth;
        memcpy(lpdata->data,dest,lenth);
    }

    return lpdata;
}

int GetClientDataCount(REQLIST *lpusr)
{
    LinkClientInfo *lpret=NULL;
    if(lpusr==NULL)
        return 0;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);
    if(lpret==NULL)
        return 0;
    return GetWinProCount(&(lpret->DataAche));
}

ClientDataInfo *GetClientFirstData(REQLIST *lpusr)
{
    LinkClientInfo *lpret=NULL;
    ClientDataInfo *lpdata=NULL;

    if(lpusr==NULL)
        return NULL;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);
    if(lpret==NULL)
        return NULL;

    lpdata=(ClientDataInfo *)FirstWinPro(&(lpret->DataAche));

    return lpdata;
}

ClientDataInfo *GetClientNextData(REQLIST *lpusr)
{

    LinkClientInfo *lpret=NULL;
    ClientDataInfo *lpdata=NULL;

    if(lpusr==NULL)
        return NULL;
    lpret=(LinkClientInfo *)FindWinPro(&LinkClientProAche,(unsigned long)lpusr);
    if(lpret==NULL)
        return NULL;

    lpdata=(ClientDataInfo *)NextWinPro(&(lpret->DataAche));

    return lpdata;
}


/* **********************************************************************
 * Globle Veriable for ACCEPT THREADs for server
 * **********************************************************************/

typedef struct _SockServer_Param
{
    char server_pszHost[64] ;
    char server_pszHostname[128] ;
    SOCKET sd_listen;
    unsigned short iPort;
    int ifprocessrun;
#ifdef GTK_INCLUDE
    pthread_t server_AcceptPid;
#else
    int server_AcceptPid;        /* Socket Thread Handle */
#endif
}SockServer_Param;

SockServer_Param Servparam=
{"","",0,80,0,
#ifndef GTK_INCLUDE
 0,
#endif
};


char *Server_GetHost(void)
{
    return (char*)Servparam.server_pszHost;
}

char *Server_GetHostname(void)
{
    return (char*)Servparam.server_pszHostname;
}


/********************************************************************
 *
 *
 ********************************************************************/
#include <stdarg.h>
void Server_OnDebugMessage_Default(char *pszMsg, ...)
{
    char pszErr[ 1024 ];
    va_list args;
    va_start( args, pszMsg );
    vsprintf( pszErr, pszMsg, args );  pszErr[ 1023 ] = '\0';
    va_end( args );
    printf("\nDBG: %s",pszErr);
}
int Server_OnClientConnected_Default(REQLIST *lpuser)
{
    return 1;
}

int Server_OnClientDisconnected_Default(REQLIST *lpuser)
{
    return 1;
}

int Server_OnRequestPro_Default(REQLIST *accinfo,unsigned char *lpbuf,int recvlen)
{
    return 1;
}
int Server_OnClientSend_Default(REQLIST *accinfo,unsigned char *lpbuf,int recvlen)
{
    return 1;

}

void (*Server_OnDebugMessage)( char *pszMsg, ... ) =Server_OnDebugMessage_Default;
int (*Server_OnClientConnected)(REQLIST *) =Server_OnClientConnected_Default;
int (*Server_OnClientDisconnected)(REQLIST *) =Server_OnClientDisconnected_Default;
int (*Server_OnRequestPro)(REQLIST *,unsigned char *,int) =Server_OnRequestPro_Default;
int (*Server_OnClientSend)(REQLIST *,unsigned char *,int) =Server_OnClientSend_Default;

void Server_SetClientPro(
    void (*OnDebugMessage)( char *, ... ),
    int (*OnClientConnected)(REQLIST *),
    int (*OnClientDisconnected)(REQLIST *),
    int (*OnRequestPro)(REQLIST *,unsigned char *,int),
    int (*OnClientSend)(REQLIST *,unsigned char *,int)
    )
{
    Server_OnDebugMessage =OnDebugMessage;
    Server_OnClientConnected =OnClientConnected;
    Server_OnClientDisconnected =OnClientDisconnected;
    Server_OnRequestPro  =OnRequestPro;
    Server_OnClientSend =OnClientSend;
}


void *Server_AcceptProc(LPVOID);

void Server_SetPort(unsigned short port)
{                          
    Servparam.iPort=port;   
}

unsigned short Server_GetPort(void)
{
   return  Servparam.iPort;
}

int Server_Open(void)
{
    int err;  
    struct sockaddr_in addr_srv; 
    if(Server_OnDebugMessage!=NULL)
        Server_OnDebugMessage("Server is opening..");  
    FreeAllSocketUser();    
    Servparam.sd_listen = socket(AF_INET, SOCK_STREAM, 0); 
    if (Servparam.sd_listen == INVALID_SOCKET)
    {
        Servparam.sd_listen=0;
        if(Server_OnDebugMessage!=NULL)
            Server_OnDebugMessage("Error %d, socket isn't ready !", WSAGetLastError());
        return 0;
    }
    
    if(Server_OnDebugMessage!=NULL)
        Server_OnDebugMessage("config local host ...");
         
    memset((void*)(&addr_srv),0,sizeof(addr_srv));
    addr_srv.sin_family = AF_INET;
    addr_srv.sin_addr.s_addr = htonl(INADDR_ANY);
    addr_srv.sin_port = htons(Servparam.iPort);

    err = bind(Servparam.sd_listen, (const struct sockaddr *) &addr_srv,sizeof(addr_srv));
    if (err == INVALID_SOCKET)
    {
        fd_set allset;
        FD_ZERO(&allset);
        FD_SET(Servparam.sd_listen,&allset);
        closesocket(Servparam.sd_listen);
        Servparam.sd_listen=0;
        if(Server_OnDebugMessage!=NULL)
            Server_OnDebugMessage("Error %d, socket isn't ready for bind !",WSAGetLastError());
        return 0;
    }

    err = listen(Servparam.sd_listen, SOMAXCONN);
    if(err == INVALID_SOCKET)
    {
        fd_set allset;
        FD_ZERO(&allset);
        FD_SET(Servparam.sd_listen,&allset);
        closesocket(Servparam.sd_listen);
        Servparam.sd_listen=0;
        if(Server_OnDebugMessage!=NULL)
            Server_OnDebugMessage("Error %d, socket isn't ready for listen !", WSAGetLastError());
        return 0;
    }
    Servparam.ifprocessrun=1;   
#ifdef GTK_INCLUDE
    pthread_create( &(Servparam.server_AcceptPid), NULL, Server_AcceptProc,&Servparam);
#else
    if ((Servparam.server_AcceptPid=fork())!=0)
    {
    }
    else if(Servparam.server_AcceptPid<0)
    {
        fd_set allset;
        FD_ZERO(&allset);
        FD_SET(Servparam.sd_listen,&allset);
        closesocket(Servparam.sd_listen);
        Servparam.sd_listen=0;
        Servparam.ifprocessrun=0; 
        if(Server_OnDebugMessage!=NULL)
            Server_OnDebugMessage("Error, cann't create server thread !");
        return 0;
    }
    else
    {
        /* I am child process */
        Server_AcceptProc(&Servparam); 
        exit(1);
    }