如何实现首先截获从internet上来的http数据流，进行处理以后，然后才转给浏览器进行解析？

我有vxd的例子，vc++的：DWORD QueryPacket(HANDLE hVxD,ULONG ioctl,BYTE* inBuffer,DWORD cbIn,
  BYTE* outBuffer,DWORD cbOut)
{
    HANDLE      hEvent = 0;
    DWORD       cbRet;
    OVERLAPPED  ovlp = {0,0,0,0,0};

    if (!(hEvent = CreateEvent(0, TRUE, 0, NULL)))
        ERROR_OUT("CreateEvent failed!\n")    ovlp.hEvent = hEvent;

    if (!DeviceIoControl(hVxD, ioctl, inBuffer, cbIn, outBuffer, cbOut, &cbRet, &ovlp)) {
        if (GetLastError() == ERROR_IO_PENDING)
            fprintf(stderr,"VxD correctly returned operation incomplete.\n" );
        else
            ERROR_OUT( "VxD does not support the requested API!!!\n" );
        if (!GetOverlappedResult(hVxD, &ovlp, &cbRet, FALSE)) {
            if (GetLastError() == ERROR_IO_INCOMPLETE)
                fprintf(stderr,"GetOverlappedResult returned expected value.\n");
            else
                ERROR_OUT("GetOverlappedResult returned unexpected error.\n");
        }
        GetOverlappedResult( hVxD, &ovlp, &cbRet, TRUE);
}
    return cbRet;
}BYTE* QueryOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength)
{
    DWORD               cbIn = sizeof(PACKET_OID_DATA) + ulLength;
    DWORD               cbRet;
PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA)InBuff;
    ULONG               ioctl;

    ioctl = (ulOid >= OID_802_3_PERMANENT_ADDRESS)

   ? IOCTL_PROTOCOL_QUERY_OID : IOCTL_PROTOCOL_STATISTICS;    memset(InBuff, 0, cbIn+1); pOidData->Oid    = ulOid;
pOidData->Length = ulLength; cbRet = QueryPacket( hVxD, ioctl, InBuff, cbIn, InBuff, cbIn );

if ( cbRet > 0 )
        return (InBuff+sizeof(PACKET_OID_DATA)-1); return 0;
}BYTE* SetOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength, ULONG data)
{
    DWORD               cbIn = sizeof(PACKET_OID_DATA) + ulLength;
    DWORD               cbRet;
PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA)InBuff;
    ULONG               ioctl;

    if (ulOid == OID_GEN_CURRENT_PACKET_FILTER)
        ioctl = (ULONG) IOCTL_PROTOCOL_SET_OID;    memset(InBuff, 0, cbIn+1);    pOidData->Oid     = ulOid;
    pOidData->Length  = ulLength;
    pOidData->Data[0] = (UCHAR) data;    cbRet = QueryPacket(hVxD, ioctl, InBuff, cbIn, InBuff, cbIn);

return 0;
}WORD RecvStart(HANDLE hVxD,struct PacketTable *packtab)
{
int result; packtab->Overlap.Internal=0;
packtab->Overlap.InternalHigh=0;
packtab->Overlap.Offset=0;
packtab->Overlap.OffsetHigh=0;
packtab->Overlap.hEvent=packtab->hEvent; result=DeviceIoControl(hVxD,
   IOCTL_PROTOCOL_READ,
   &packtab->Buffer,
   packtab->Size,
   &packtab->Buffer,
   packtab->Size,
   &packtab->Length,
   &packtab->Overlap); if(result) return SYSERR; return OK;
}WORD SendStart(HANDLE hVxD,struct PacketTable *packtab)
{
int result; packtab->Overlap.Internal=0;
packtab->Overlap.InternalHigh=0;
packtab->Overlap.Offset=0;
packtab->Overlap.OffsetHigh=0;
packtab->Overlap.hEvent=packtab->hEvent; result=DeviceIoControl(hVxD,
   IOCTL_PROTOCOL_WRITE,
   &packtab->Buffer,
   packtab->Size,
   &packtab->Buffer,
   packtab->Length,
   &packtab->Length,
   &packtab->Overlap); if(result) return SYSERR; return OK;
}WORD ListenStart(HANDLE hVxD)
{
return RecvPacket(hVxD,NULL);
}WORD RecvPacket(HANDLE hVxD,BYTE *pbuf)
{
static BOOL first=TRUE;
static struct PacketTable RecvTab[RECV_MAX];
static HANDLE EventTab[RECV_MAX];
HANDLE hEvent;
int i,j,k;
WORD len; if(first) {
for(i=0;i<RECV_MAX;i++) {
hEvent=CreateEvent(0, TRUE, 0, NULL);
if(!hEvent) {
fprintf(stderr,"Can not create event\n");
return SYSERR;
}
RecvTab[i].hEvent=hEvent;
memset(RecvTab[i].Buffer,0,BUFFER_SIZE);
RecvTab[i].Size=BUFFER_SIZE;
RecvTab[i].Active=TRUE;
RecvTab[i].Type=READ;
EventTab[i]=hEvent;
RecvStart(hVxD,&RecvTab[i]);
}
first=FALSE;
}
if(pbuf==NULL) return OK;
i=WaitForMultipleObjectsEx(RECV_MAX,EventTab,FALSE,INFINITE,FALSE);
if(i==WAIT_FAILED) return SYSERR;
for(j=0;j<RECV_MAX;j++)
if(EventTab[i]==RecvTab[j].hEvent) break;
k=j;
if(RecvTab[k].Type==READ&&RecvTab[k].Active==TRUE) { /* read complete */
GetOverlappedResult(hVxD,&RecvTab[k].Overlap,&RecvTab[k].Length,FALSE);
if(RecvTab[k].Length>BUFFER_SIZE) RecvTab[k].Length=BUFFER_SIZE;
memcpy((void *)pbuf,(void *)RecvTab[k].Buffer,RecvTab[k].Length);
len=RecvTab[k].Length;
CloseHandle(RecvTab[k].hEvent);
for(j=i;j<RECV_MAX-1;i++)
EventTab[i]=EventTab[++j];
hEvent=CreateEvent(0, TRUE, 0, NULL);
if(!hEvent) {
fprintf(stderr,"Can not create event\n");
return SYSERR;
}
RecvTab[k].hEvent=hEvent;
memset(RecvTab[k].Buffer,0,BUFFER_SIZE);
RecvTab[k].Size=BUFFER_SIZE;
RecvTab[k].Active=TRUE;
RecvTab[k].Type=READ;
EventTab[RECV_MAX-1]=hEvent;
RecvStart(hVxD,&RecvTab[k]);
return len;
}
else return SYSERR;
}WORD SendPacket(HANDLE hVxD,BYTE *pbuf,WORD len)
{
static struct PacketTable SendTab;
HANDLE hEvent; hEvent=CreateEvent(0, TRUE, 0, NULL);
if(!hEvent) {
fprintf(stderr,"Can not create event\n");
return SYSERR;
}
SendTab.hEvent=hEvent;
memcpy(SendTab.Buffer,(void *)pbuf,len);
SendTab.Size=len;
SendTab.Length=BUFFER_SIZE;
SendTab.Active=TRUE;
SendTab.Type=WRITE;
SendStart(hVxD,&SendTab); GetOverlappedResult(hVxD,&SendTab.Overlap,&SendTab.Length,TRUE);
return OK;
}WORD CheckSum(WORD *addr,WORD len)
{
DWORD lSum;
WORD wOddByte;
WORD wAnswer; lSum=0l; while(len>1) {
lSum+= *addr++;
len-=2;
} if(len==1) {
wOddByte=0;
*((unsigned char*)&wOddByte)=*(unsigned char*)addr;
lSum+=wOddByte;
} lSum=(lSum>>16)+(lSum&0xffff);
lSum+=(lSum>>16);
wAnswer=(unsigned int)~lSum; return wAnswer;
}WORD swaps(WORD net)
{
WORD lo,hi;
WORD host; lo=net&0xff;
hi=net&0xff00;
lo=lo<<8;
hi=hi>>8;
host=hi|lo; return host;
}DWORD swapl(DWORD net)
{
DWORD b1,b2,b3,b4;
DWORD host; b1=net&0xff;
b2=net&0xff00;
b3=net&0xff0000;
b4=net&0xff000000; b1=b1<<24;
b2=b2<<8;
b3=b3>>8;
b4=b4>>24; host=b1|b2|b3|b4; return host;
}
WORD GetOption(int argc,char *argv[],struct CommandLine *cmdline)
{
int i;
char *pbufh,*pbuft;
char c; cmdline->option=OPT_DO_NOTHING;
for(i=1;i<argc;i++) {
if((pbufh=strstr(argv[i],"-l"))!=NULL) { /* Listen */
if(strstr(argv[i],"-lini")!=NULL) cmdline->option|=OPT_LISTEN_INIT;
else cmdline->option|=OPT_LISTEN_ALL;
/*printf("listen\n");*/
}
else if(strstr(argv[i],"-?")!=NULL) {
cmdline->option|=OPT_HELP;
}
else if((pbufh=strstr(argv[i],"-ip:"))!=NULL&&
(cmdline->option&OPT_LISTEN_ALL)!=0) { /* IP address */
pbufh+=4;
if((pbuft=strstr(pbufh,":"))!=NULL) { /* Two IP */
pbuft++;
GetIPAddr(pbufh,&cmdline->queip[0]);
GetIPAddr(pbuft,&cmdline->queip[1]);
cmdline->option|=OPT_LISTEN_IP_2;
}
else { /* One IP */
GetIPAddr(pbufh,&cmdline->queip[0]);
cmdline->option|=OPT_LISTEN_IP_1;
}
}
else if((pbufh=strstr(argv[i],"-port:"))!=NULL&&
(cmdline->option&OPT_LISTEN_ALL)!=0) { /* Port */
pbufh+=6;
if((pbuft=strstr(pbufh,":"))!=NULL) { /* Two port */
pbuft++;
sscanf(pbufh,"%d",&cmdline->queport[0]);
sscanf(pbuft,"%d",&cmdline->queport[1]);
cmdline->option|=OPT_LISTEN_PORT_2;
}
else { /* One port */
sscanf(pbufh,"%d",&cmdline->queport[0]);
cmdline->option|=OPT_LISTEN_PORT_1;
}
}
else if((pbufh=strstr(argv[i],"-qeth:"))!=NULL) { /* Query ethernet address */
cmdline->option|=OPT_QUE_ETHER;
pbufh+=6;
GetIPAddr(pbufh,&cmdline->queip[0]);
}
else if((pbufh=strstr(argv[i],"-qip:"))!=NULL) { /* Query IP */
cmdline->option|=OPT_QUE_IP;
pbufh+=5;
GetEtherAddr(pbufh,&cmdline->queeth[0]);
}
else if((pbufh=strstr(argv[i],"-fout:"))!=NULL) { /* Output file */
cmdline->option|=OPT_OUTPUT_FILE;
pbufh+=6;
sscanf(pbufh,"%s",cmdline->outfile);
}
else if((pbufh=strstr(argv[i],"-fcmd:"))!=NULL) { /* Command file */
cmdline->option|=OPT_COMMAND_FILE;
pbufh+=6;
sscanf(pbufh,"%s",cmdline->cmdfile);
}
}
if(cmdline->option&OPT_LISTEN_SPEC) cmdline->option&=~OPT_LISTEN_ALL;
return OK;
}WORD GetInitial(FILE *pfini,struct InitialFile *inifile)
{
char Command[BUFFER_SIZE];
int i;
int out; out=2;
inifile->ipno=0;
inifile->portno=0;
inifile->timeout=INFINITE;
inifile->maxdatalen=MAX_DATA;
while(feof(pfini)==0) {
ReadCommand(pfini,Command);
switch (GetCommand(Command)) {
case INITIAL_MAX_DATA:
ReadCommand(pfini,Command);
sscanf(Command,"%d",&inifile->maxdatalen);
break;
case INITIAL_IP_ADDR:
ReadCommand(pfini,Command);
out--;
GetIPAddr(Command,&inifile->mipaddr);
break;
case INITIAL_NDIS:
out--;
ReadCommand(pfini,inifile->ndis);
break;
case INITIAL_QUERY_IP:
ReadCommand(pfini,Command);
i=0;
while(GetCommand(Command)!=INITIAL_END_SEGMENT) {
GetIPAddr(Command,&inifile->qip[i]);
i++;
if(i==MAX_QUERY) return SYSERR;
ReadCommand(pfini,Command);
}
inifile->ipno=i;
break;
case INITIAL_QUERY_PORT:
ReadCommand(pfini,Command);
i=0;
while(GetCommand(Command)!=INITIAL_END_SEGMENT) {
sscanf(Command,"%d",&inifile->qport[i]);
i++;
if(i==MAX_QUERY) return SYSERR;
ReadCommand(pfini,Command);
}
inifile->portno=i;
break;
case INITIAL_TIMEOUT:
ReadCommand(pfini,Command);
if(strstr(Command,INITIAL_INFINITE)==NULL)
sscanf(Command,"%d",&inifile->timeout);
else inifile->timeout=INFINITE;
break;
case COMMENT:
break;
case INITIAL_END_SEGMENT:
break;
default:
if(feof(pfini)==0) return SYSERR;
}
}
if(out>0) return SYSERR;
else return OK;
return OK;
}void PrintEtherAddr(FILE *pf,struct EtherAddr *pethaddr)
{
fprintf(pf,"%02x.%02x.%02x.%02x.%02x.%02x",pethaddr->AddrByte[0],
    pethaddr->AddrByte[1],
    pethaddr->AddrByte[2],
    pethaddr->AddrByte[3],
    pethaddr->AddrByte[4],
    pethaddr->AddrByte[5]);
}void PrintIPAddr(FILE *pf,struct IPAddr *pIPaddr)
{
fprintf(pf,"%d.%d.%d.%d",pIPaddr->AddrByte[0],
    pIPaddr->AddrByte[1],
    pIPaddr->AddrByte[2],
    pIPaddr->AddrByte[3]);
}
WORD SendARPPacket(HANDLE hVxD,
   struct EtherAddr *psourether,
   struct EtherAddr *pdestether,
   struct EtherAddr *psendether,
   struct EtherAddr *precvether,
   struct IPAddr *psendip,
   struct IPAddr *precvip,
   WORD oper)
{
char Buffer[BUFFER_SIZE];
struct EtherPacketHead *pEtherHead;
struct ARPPacket *pARPHead; memset(Buffer,0,BUFFER_SIZE);
pEtherHead=(struct EtherPacketHead *)Buffer;
pARPHead=(struct ARPPacket *)(Buffer+ETHER_HEAD_LEN);
memcpy((void *)&pEtherHead->SourEther,(void *)psourether,6);
memcpy((void *)&pEtherHead->DestEther,(void *)pdestether,6);
pEtherHead->ServType=swaps(ETHER_PROTO_ARP);
memset((void *)pARPHead,0,ARP_PACKET_LEN);
pARPHead->Type=swaps(ARP_HARD_TYPE);
pARPHead->Proto=swaps(ARP_PROTO_TYPE);
pARPHead->HardAddrLen=ARP_HARD_ADDR_LEN;
pARPHead->AddrLen=ARP_ADDR_LEN;
pARPHead->Oper=swaps(oper);
memcpy((void *)&pARPHead->SourEther,(void *)psendether,6);
memcpy((void *)&pARPHead->DestEther,(void *)precvether,6);
memcpy((void *)&pARPHead->SourIP,(void *)psendip,4);
memcpy((void *)&pARPHead->DestIP,(void *)precvip,4);
if(SendPacket(hVxD,Buffer,ETHER_HEAD_LEN+ARP_PACKET_LEN)==SYSERR) {
fprintf(stderr,"Can not send ARP packet.\n");
return SYSERR;
}
return OK;
}WORD SendTCPPacket(HANDLE hVxD,
   struct EtherAddr *psourether,
   struct EtherAddr *pdestether,
   struct IPAddr *psourip,
   struct IPAddr *pdestip,
   WORD sourport,
   WORD destport,
   WORD flag,
   DWORD seqno,
   DWORD ackno,
   char *pbuf,
   WORD len)
{
char Buffer[BUFFER_SIZE];
char HelpBuffer[BUFFER_SIZE];
char *pdata;
struct EtherPacketHead *pEtherHead;
struct IPPacketHead *pIPHead;
struct TCPPacketHead *pTCPHead,*pHelpTCPHead;
struct PseudoHead *pPseudoHead;
static WORD id=0;
WORD wlen; id++;
memset(Buffer,0,BUFFER_SIZE);
pEtherHead=(struct EtherPacketHead *)Buffer;
pIPHead=(struct IPPacketHead *)(Buffer+ETHER_HEAD_LEN);
pTCPHead=(struct TCPPacketHead *)(Buffer+ETHER_HEAD_LEN+IP_HEAD_BYTE_LEN);
pPseudoHead=(struct PseudoHead *)HelpBuffer;
pHelpTCPHead=(struct TCPPacketHead *)(HelpBuffer+PSEUDO_HEAD_LEN);
pdata=(char *)(Buffer+ETHER_HEAD_LEN+IP_HEAD_BYTE_LEN+TCP_HEAD_BYTE_LEN);
/* Set ether head */
memcpy((void *)&pEtherHead->SourEther,(void *)psourether,6);
memcpy((void *)&pEtherHead->DestEther,(void *)pdestether,6);
pEtherHead->ServType=swaps(ETHER_PROTO_IP);
/* Set IP head */
memcpy((void *)&pIPHead->SourIP,(void *)psourip,4);
memcpy((void *)&pIPHead->DestIP,(void *)pdestip,4);
pIPHead->VerHLen=(IP_VER<<4)|IP_HEAD_LEN;
pIPHead->Type=IP_SERV_TYPE;
wlen=len+TCP_HEAD_BYTE_LEN+IP_HEAD_BYTE_LEN;
pIPHead->TtlLen=swaps(wlen);
pIPHead->Id=swaps(id);
pIPHead->FlgOff=0;
pIPHead->TTL=69;
pIPHead->Proto=IP_PROTO_TCP;
pIPHead->ChkSum=0;
pIPHead->ChkSum=CheckSum((WORD *)pIPHead,IP_HEAD_BYTE_LEN);
/* Set TCP head */
pTCPHead->SourPort=swaps(sourport);
pTCPHead->DestPort=swaps(destport);
pTCPHead->SeqNo=swapl(seqno);
pTCPHead->AckNo=swapl(ackno);
pTCPHead->HLen=TCP_HEAD_LEN<<4;
pTCPHead->Flag=flag;
pTCPHead->WndSize=swaps(8192);
pTCPHead->ChkSum=0;
pTCPHead->UrgPtr=0;
/* Set TCP data */
memcpy((void *)pdata,(void *)pbuf,len);
/* Calculate TCP checksum */
memcpy((void *)&pPseudoHead->SourIP,(void *)psourip,4);
memcpy((void *)&pPseudoHead->DestIP,(void *)pdestip,4);
pPseudoHead->Pad=0;
pPseudoHead->Proto=IP_PROTO_TCP;
wlen=len+TCP_HEAD_BYTE_LEN;
pPseudoHead->Len=swaps(wlen);
memcpy((void *)pHelpTCPHead,(void *)pTCPHead,wlen);
wlen=len+TCP_HEAD_BYTE_LEN+PSEUDO_HEAD_LEN;
pTCPHead->ChkSum=CheckSum((WORD *)HelpBuffer,wlen);
wlen=len+TCP_HEAD_BYTE_LEN+IP_HEAD_BYTE_LEN+ETHER_HEAD_LEN;
if(SendPacket(hVxD,Buffer,wlen)==SYSERR) {
fprintf(stderr,"Can not send TCP packet.\n");
return SYSERR;
}
return OK;
}

调试易

如何实现首先截获从internet上来的http数据流，进行处理以后，然后才转给浏览器进行解析？

解决方案 »