ipcp2.cpp

一个ppp协议实现

#include <stdafx.h>
#include <stdio.h>
struct packet
{
unsigned char data[1000];
unsigned int packetsize;
};


void abcstr(char *p)
{
	FILE *fp;
	fp=fopen("c:\\z.txt","a+");
	fprintf(fp,"%s\n",p);
	fclose(fp);
}
void abcchar(unsigned char c)
{
	FILE *fp;
	fp=fopen("c:\\z.txt","a+");
	fprintf(fp,"%c..%x..%d\n",c,c,c);
	fclose(fp);
}
void processpacket();
void uescapepacket(struct packet *,struct packet *);
void removeframe(struct packet *,struct packet *);
long _stdcall zzz(HWND ,unsigned int ,unsigned int ,long );
void lcppacket(struct packet *);
unsigned int calcchksum(unsigned char *,int );
void escapepacket(struct packet *);
void addsevene(struct packet *);
void sendpacket(struct packet *);
void sendconfack(struct packet *);
unsigned int addffthree(struct packet *);
void sendconfreq();
void ipcppacket(struct packet * );
void sendipcpack(struct packet *);
void sendipcpreq(unsigned char ipadd[]);
void sendechoreply(struct packet *);

unsigned char ipaddress[4]={0,0,0,0};

HDC  hdc ;
HANDLE  handle ;
HWND  hwnd ;

struct packet recdpacket;
int  column, row, xwidth, yheight ,cnt=0, ctr=0;
unsigned long threadid, bytesrecd,byteswritten;
DCB dcb;
WNDCLASS wndclass;
MSG msg;
unsigned char writestr[200],ctemp;


static unsigned short fcstab[256] = {
    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
    0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
    0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
    0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
    0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
    0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
    0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
    0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
    0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
    0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
    0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
    0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
    0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
    0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
    0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
    0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
    0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
    0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
    0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
    0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
    0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
    0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
    0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
    0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
    0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
    0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
    0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
    0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
    0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
    0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
    0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
#define PPPINITFCS16 0xffff
#define PPPGOODFCS16 0xf0b8

unsigned long _stdcall  commcallback()
{
 unsigned char readstr[2] ; 
 while (1)
 { 	  
	ReadFile(handle,readstr,1,&bytesrecd,0);
	if (readstr[0] == 0x7e )
	{
	  if(ctr == 0)
	  {
		  cnt=0;	
		  ctr=1;
	  }
	  else if (ctr == 1)
	  { 
		  	ctr++;
			
	  }
  	  else if (ctr == 2)
	  { 
		  	ctr = 1;
			recdpacket.data[cnt]=readstr[0];
			cnt++;
			recdpacket.packetsize=cnt;
			cnt=0;
			processpacket();
	  }
    }	 
	if (ctr ==2 )
	{	  
		recdpacket.data[cnt]=readstr[0];
		cnt++;
	}
    if (readstr[0] == 13 )
		column = 0 ;
    if (readstr[0] == 10)
		row++;
    if (readstr[0] == 0x08)
	    column -- ;
	if (readstr[0] != 0x0a && readstr[0] != 0x0d)
	{
		TextOut(hdc,column*xwidth,row*yheight,(const char*)readstr,1);
		if (column < 79)
				column++ ;
		else
		{
			column = 0;
			row++;
		}
	}
 }
 return 1 ;
}


int _stdcall WinMain( HINSTANCE hinstance, HINSTANCE hprevinstance,LPSTR lpszcmdline, int ncmdshow )
{
wndclass.lpfnWndProc=zzz;
wndclass.hInstance=hinstance;
wndclass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH) ;
wndclass.lpszClassName="wclass";
RegisterClass(&wndclass);
hwnd=CreateWindow("wclass","hi",WS_OVERLAPPEDWINDOW,0,0,0,0,0,0,hinstance,0);
xwidth = 8;
yheight = 19;
ShowWindow( hwnd, 3 ) ;
hdc=GetDC(hwnd);

handle= CreateFile( "COM1", GENERIC_READ | GENERIC_WRITE,1,NULL,	
	OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL );

dcb.DCBlength = sizeof( DCB ) ;
GetCommState( handle, &dcb ) ;
dcb.BaudRate = 14400 ;
SetCommState( handle, &dcb ) ;
CreateThread(0,0,(LPTHREAD_START_ROUTINE) commcallback,0,0, &threadid );
strcpy((char*)writestr,"atdt2659385\r");
WriteFile(handle,writestr,strlen((const char*)writestr),&byteswritten,0) ;
while (GetMessage( &msg, 0, 0, 0 ))
   {
       TranslateMessage( &msg ) ;
       DispatchMessage( &msg ) ;
   }
   return 0 ;
}


long _stdcall zzz(HWND wnd,unsigned int umsg,unsigned int wparam,long lparam)
{
   if(umsg == WM_CHAR)
   {
         ctemp = wparam;
         WriteFile(handle,&ctemp,1,&byteswritten,0) ;
   }
    if(umsg == WM_DESTROY)
	{
		 ReleaseDC(wnd,hdc);
         PostQuitMessage( 0 ) ;
	}
         return( DefWindowProc( wnd, umsg, wparam, lparam ) ) ;
}  


void processpacket()
{
	struct packet unescpacket,finalpacket;
	unsigned int i;
       
	sprintf((char*)writestr,"Recd Packet packetsize=%d",recdpacket.packetsize);
	abcstr((char*)writestr);
	uescapepacket(&recdpacket,&unescpacket);
	for(i=0; i<unescpacket.packetsize;i++)
		abcchar(unescpacket.data[i]);
	
	removeframe(&unescpacket,&finalpacket);
	
	if(finalpacket.data[0] == 0xc0 && finalpacket.data[1] == 0x21)
		lcppacket(&finalpacket);
	if(finalpacket.data[0] == 0x80 && finalpacket.data[1] == 0x21)
		ipcppacket(&finalpacket);
}
void ipcppacket(struct packet * f)
{
if (f->data[2]== 1)
{
	abcstr("ipcpReq Sent....");
	sendipcpack(f);
	sendipcpreq(ipaddress);
	
}

if (f->data[2]== 2)
{
	abcstr("IPCP Ack Received");
	MessageBox(0,"IPCP Ack Received","IPCP Ack Received",0);
}

if (f->data[2]== 3)
{
	abcstr("ipcp NAck received");
	ipaddress[0]=f->data[8];
	ipaddress[1]=f->data[9];
	ipaddress[2]=f->data[10];
	ipaddress[3]=f->data[11];
	sendipcpreq(ipaddress);
}

if (f->data[2]== 4)
{
	abcstr("IPCP Reject received");
}

}

void sendipcpack(struct packet *aipcp)
{
aipcp->data[2]=2;
aipcp->packetsize=addffthree(aipcp);
aipcp->packetsize=calcchksum(aipcp->data,aipcp->packetsize);
escapepacket(aipcp);
addsevene(aipcp);
sendpacket(aipcp);

}


void sendipcpreq(unsigned char ipadd[])
{
struct packet ipcpreq;
ipcpreq.data[0]=0x80;
ipcpreq.data[1]=0x21;
ipcpreq.data[2]=0x01;
ipcpreq.data[3]=0x1;
ipcpreq.data[4]=0x00;
ipcpreq.data[5]=0xa;
ipcpreq.data[6]=0x3;
ipcpreq.data[7]=0x6;
ipcpreq.data[8]=ipadd[0];
ipcpreq.data[9]=ipadd[1];
ipcpreq.data[10]=ipadd[2];
ipcpreq.data[11]=ipadd[3];
ipcpreq.packetsize=12;
ipcpreq.packetsize=addffthree(&ipcpreq);
ipcpreq.packetsize=calcchksum(ipcpreq.data,ipcpreq.packetsize);
escapepacket(&ipcpreq);
addsevene(&ipcpreq);
sendpacket(&ipcpreq);
}



void uescapepacket(struct packet *r, struct packet *u)
{	
	unsigned int i,j;
	for(j=0,i=0;i<r->packetsize;i++,j++)
	{
		if (r->data[i]==0x7d)
		{
			i++;
			u->data[j]=r->data[i]^0x20;
		}
		else
		{
		u->data[j]=r->data[i];
		}
	}
	u->packetsize=j;
}



void removeframe(struct packet *u,struct packet *f)
{
	unsigned int i,j;
	for(i=0,j=3;j<u->packetsize-3;i++,j++)
	{
	f->data[i]=u->data[j];
	}
	f->packetsize=i;
}

void lcppacket(struct packet *lcp)
{
if (lcp->data[2]== 1)
{
	sendconfack(lcp);
	sendconfreq();
	abcstr("Configure Ack and Req");
}
if (lcp->data[2]== 2)
{
	abcstr("Configure Ack Received");
}
if (lcp->data[2]== 9)
{
	sendechoreply(lcp);
	abcstr("Sent Echo Reply ");
}

}

void sendechoreply(struct packet * alcp)
{
alcp->data[2]=10;
alcp->packetsize=addffthree(alcp);
alcp->packetsize=calcchksum(alcp->data,alcp->packetsize);
escapepacket(alcp);
addsevene(alcp);
sendpacket(alcp);

}


void sendconfreq()
{
	
struct packet lcpreq;
lcpreq.data[0]=0xc0;
lcpreq.data[1]=0x21;
lcpreq.data[2]=0x01;
lcpreq.data[3]=1;
lcpreq.data[4]=0x00;
lcpreq.data[5]=0x04;
lcpreq.packetsize=6;
lcpreq.packetsize=addffthree(&lcpreq);
lcpreq.packetsize=calcchksum(lcpreq.data,lcpreq.packetsize);
escapepacket(&lcpreq);
addsevene(&lcpreq);
sendpacket(&lcpreq);


}



void sendconfack(struct packet *alcp)
{

alcp->data[2]=2;
alcp->packetsize=addffthree(alcp);
alcp->packetsize=calcchksum(alcp->data,alcp->packetsize);
escapepacket(alcp);
addsevene(alcp);
sendpacket(alcp);

}


unsigned short pppfcs16(register unsigned short fcs,register unsigned char *cp,register int len)
 
{
while ( len -- )
fcs = ( fcs>>8 ) ^ fcstab[ (fcs^*cp++) & 0xff];
return fcs;
}

unsigned int calcchksum(register unsigned char *cp,register int len)
{
unsigned short trialfcs;
trialfcs = pppfcs16(PPPINITFCS16,cp,len);
trialfcs ^= 0xffff;
cp[len] = (trialfcs & 0x00ff);
cp[len+1] = ((trialfcs >> 8 ) & 0x00ff);
return len+2;
}

unsigned int addffthree(struct packet *flcp)
{
	struct packet dummy;
	unsigned int i,j=0;
	dummy.data[j]=0xff;
	j++;
	dummy.data[j]=0x03;
	j++;
	for(i=0; i< flcp->packetsize;i++,j++)
	{
		dummy.data[j]=flcp->data[i];
	}
	dummy.packetsize=j;
	for(i=0;i<dummy.packetsize;i++)
	{
		flcp->data[i]=dummy.data[i];
	}
	flcp->packetsize=dummy.packetsize;
	
	
	return flcp->packetsize;
	}


void escapepacket(struct packet * epacket)
{
	struct packet dummy;
	unsigned int i,j;
	for(i=0; i< epacket->packetsize;i++)
	abcchar(epacket->data[i]);

	for(i=0;i<epacket->packetsize;i++)
	{
		dummy.data[i]=epacket->data[i];
	}
	dummy.packetsize=epacket->packetsize;
     
	for(j=0,i=0;i<dummy.packetsize;i++,j++)
	{
		if (dummy.data[i] <= 31 || dummy.data[i] == 0x7e || dummy.data[i]== 0x7d)
		{
			epacket->data[j]=0x7d;
			j++;
			epacket->data[j]=dummy.data[i]^0x20;
		}
		else
			epacket->data[j]=dummy.data[i];
	}
	epacket->packetsize=j;
	
}

void addsevene(struct packet * apacket)
{
	struct packet dummy;
	unsigned int i,j;
	for(i=0;i<apacket->packetsize;i++)
	{
		dummy.data[i]=apacket->data[i];
	}
	dummy.packetsize=i;
	apacket->data[0]=0x7e;
	for(i=0,j=1;i<dummy.packetsize;i++,j++)
	{
		apacket->data[j]=dummy.data[i];
	}

	apacket->data[j]=0x7e;
	j++;
	apacket->packetsize=j;
}

void sendpacket(struct packet * spacket)
{

WriteFile(handle,spacket->data,spacket->packetsize,&byteswritten,0) ;
sprintf((char*)writestr,"WriteFile...spacket->packetsize=%d...byteswritten=%d",
		spacket->packetsize,byteswritten);
abcstr((char*)writestr);

}