开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
IPMAN.C
资源名称：ipman.zip　[点击查看]
上传用户：zsjierui
上传日期：2007-01-05
资源大小：156k
文件大小：42k
源码类别：

网络编程

开发平台：

Visual C++

IPMAN.C：源码内容
  1. /* IPMan.C
  2. Console application to send and receive IP packet
  3.         Written by HiHint
  4.         Using vpacket.vxd */
  6. #include <stdio.h>
  7. #include <windows.h>
  8. #include <string.h>
  10. #include "ntddpack.h"
  11. #include "conpack.h"
  13. #include "ip.h"
  15. #define ERROR_OUT(str) { fprintf(stderr,str); CloseHandle(hEvent); return(0); }
  17. #define RECV_MAX 32
  18. #define SEND_MAX 32
  19. #define MAX_CONNECTION 64
  20. #define MAX_COMMAND 64
  21. #define MAX_DATA 64
  22. #define MAX_QUERY 64
  23. #define SYSERR -1
  24. #define OK 0
  26. #define OPT_DO_NOTHING 0x0 /* Do nothing, print local ethernet address */
  27. #define OPT_LISTEN_ALL 0x1 /* Listen all packet */
  28. #define OPT_LISTEN_SPEC 0x41e /* Listen specially */
  29. #define OPT_LISTEN 0x41f /* Listen */
  30. #define OPT_LISTEN_IP 0xa /* Listen IP packet carry special address */
  31. #define OPT_LISTEN_IP_1 0x2 /* Listen IP packet carry one special address */
  32. #define OPT_LISTEN_PORT 0x14 /* Listen IP packet carry special port */
  33. #define OPT_LISTEN_PORT_1 0x4 /* Listen IP packet carry one special port */
  34. #define OPT_LISTEN_IP_2 0x8 /* Listern IP packet between two address */
  35. #define OPT_LISTEN_PORT_2 0x10 /* Listen IP packet between two port */
  37. #define OPT_QUE_IP 0x20 /* Query ethernet address from IP address */
  38. #define OPT_QUE_ETHER 0x40 /* Query IP address from ethernet address */
  40. #define OPT_COMMAND_FILE 0x80 /* Work with command file */
  42. #define OPT_OUTPUT_FILE 0x100 /* Output to file */
  44. #define OPT_HELP 0x200 /* Print help message */
  46. #define COMMAND_SEND_ARP 0x1 /* Send ARP packet */
  47. #define COMMAND_SEND_TCP 0x2 /* Send TCP packet */
  48. #define COMMAND_RECV_TCP 0x4 /* Receive TCP packet */
  49. #define COMMAND_CONNECT_TCP 0x8 /* Connect TCP */
  50. #define COMMAND_CLOSE_TCP 0x10 /* Close TCP */
  52. #define COMMENT 0x8000 /* Comment line */
  54. #define COMMAND_UNKNOWN 0x0 /* Unknown command */
  56. #define OPT_LISTEN_INIT 0x400 /* Listen IP packet match INI file speciallity */
  57. #define INITIAL_FILE "ipman.ini" /* Initial file name */
  58. #define INITIAL_MAX_DATA 0x01 /* Initial file max data legth */
  59. #define INITIAL_IP_ADDR 0x02 /* Initial file my IP address */
  60. #define INITIAL_NDIS 0x04 /* Initial file NDIS */
  61. #define INITIAL_QUERY_IP 0x08 /* Initial file query ip array */
  62. #define INITIAL_QUERY_PORT 0x10 /* Initial file query port array */
  63. #define INITIAL_TIMEOUT 0x20 /* Initial file timeout */
  64. #define INITIAL_INFINITE "INFINITE" /* Initial file timeout infinite */
  65. #define INITIAL_END_SEGMENT 0x40 /* Initial file blank line as end of segment */
  67. struct CommandLine {
  68. DWORD option;
  69. char outfile[50];
  70. char cmdfile[50];
  71. struct IPAddr queip[2];
  72. struct EtherAddr queeth[2];
  73. WORD queport[2];
  74. };
  76. struct InitialFile {
  77. int maxdatalen;
  78. struct IPAddr mipaddr;
  79. char ndis[16];
  80. struct IPAddr qip[MAX_QUERY];
  81. int ipno;
  82. WORD qport[MAX_QUERY];
  83. int portno;
  84. DWORD timeout;
  85. };
  87. struct TCPConnection {
  88. struct EtherAddr sendeth,recveth;
  89. struct IPAddr sourip,destip;
  90. WORD sourport,destport;
  91. WORD id;
  92. DWORD ackno,seqno;
  93. BOOL inuse;
  94. };
  96. BYTE InBuff[ sizeof(PACKET_OID_DATA) + 128 ];
  98. DWORD Bind(HANDLE hVxD, BYTE* inBuffer);
  99. WORD  GetHardEtherAddr(HANDLE hVxD,struct EtherAddr *petheraddr);
  100. BYTE* SetOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength, ULONG data);
  101. DWORD QueryPacket(HANDLE hVxD,ULONG ioctl,BYTE* inBuffer,DWORD cbIn,
  102.   BYTE* outBuffer,DWORD cbOut);
  103. BYTE* QueryOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength);
  104. WORD RecvStart(HANDLE hVxD,struct PacketTable *packtab);
  105. WORD SendStart(HANDLE hVxD,struct PacketTable *packtab);
  106. WORD RecvPacket(HANDLE hVxD,BYTE *pbuf);
  107. WORD SendPacket(HANDLE hVxD,BYTE *pbuf,WORD len);
  108. WORD CheckSum(WORD *pbuf,WORD len);
  109. WORD ListenStart(HANDLE hVxD);
  111. WORD SendARPPacket(HANDLE hVxD,
  112.    struct EtherAddr *psourether,
  113.    struct EtherAddr *pdestether,
  114.    struct EtherAddr *psendether,
  115.    struct EtherAddr *precvether,
  116.    struct IPAddr *psendip,
  117.    struct IPAddr *precvip,
  118.    WORD oper);
  119. WORD SendTCPPacket(HANDLE hVxD,
  120.    struct EtherAddr *psourether,
  121.    struct EtherAddr *pdestether,
  122.    struct IPAddr *psourip,
  123.    struct IPAddr *pdestip,
  124.    WORD sourport,
  125.    WORD destport,
  126.    WORD flag,
  127.    DWORD seqno,
  128.    DWORD ackno,
  129.    char *pbuf,
  130.    WORD len);
  131. WORD RecvTCPPacket(HANDLE hVxD,
  132.    struct IPAddr *psourip,
  133.    struct IPAddr *pdestip,
  134.    WORD sourport,
  135.    WORD destport,
  136.    WORD *flag,
  137.    DWORD *seqno,
  138.    DWORD *ackno,
  139.    char *pbuf,
  140.    WORD *size);
  141. WORD swaps(WORD net);
  142. DWORD swapl(DWORD net);
  143. WORD GetOption(int argc,char *argv[],struct CommandLine *cmdline);
  144. WORD GetInitial(FILE *pfini,struct InitialFile *inifile);
  145. void ReadCommand(FILE *pf,char *pbuf);
  146. WORD GetCommand(char *pbuf);
  147. void GetSendARPArg(char *pbuf,
  148.        struct EtherAddr *psendeth,
  149.    struct EtherAddr *precveth,
  150.    struct EtherAddr *soureth,
  151.    struct EtherAddr *desteth,
  152.    struct IPAddr *sourip,
  153.    struct IPAddr *destip,
  154.    WORD *oper);
  155. void GetSendTCPArg(char *pbuf,WORD *id,char *pdata,WORD *size);
  156. void GetRecvTCPArg(char *pbuf,WORD *id);
  157. void GetConnectArg(char *pbuf,
  158.    struct EtherAddr *sendeth,
  159.    struct EtherAddr *recveth,
  160.    struct IPAddr *sourip,
  161.    struct IPAddr *destip,
  162.    WORD *sourport,
  163.    WORD *destport,
  164.    WORD *id);
  165. void GetCloseArg(char *pbuf,WORD *id);
  166. void GetDataArg(char *pbuf,char *pdata,WORD *size);
  167. void GetIPAddr(char *pbuf,struct IPAddr *pipaddr);
  168. void GetEtherAddr(char *pbuf,struct EtherAddr *pethaddr);
  169. void PrintEtherAddr(FILE *pf,struct EtherAddr *pethaddr);
  170. void PrintIPAddr(FILE *pf,struct IPAddr *pIPaddr);
  171. void PrintData(FILE *pf,BYTE *pdata,int size);
  172. void ToUpper(char *pbuf);
  174. static Max_Data_Len;
  176. int main(int argc,char *argv[])
  177. {
  178. HANDLE hVxD;
  179. DWORD dwErrorCode;
  180. struct EtherAddr m_EtherAddr;
  181. struct IPAddr m_IPAddr;
  182. HANDLE hEvent;
  183. BOOL Continue;
  184. int i,j,k;
  185. BYTE Buffer[BUFFER_SIZE];
  186. WORD DataLen;
  187. struct EtherPacketHead *pEtherHead;
  188. struct IPPacketHead *pIPHead;
  189. struct TCPPacketHead *pTCPHead;
  190. struct ARPPacket *pARPHead;
  191. struct ICMPPacketHead *pICMPHead;
  192. struct UDPPacketHead *pUDPHead;
  193. int headlen,totallen;
  194. struct IPAddr *psourip,*pdestip;
  195. struct EtherAddr *psoureth,*pdesteth;
  196. WORD sourport,destport;
  197. DWORD seqno,ackno;
  198. BYTE *pdata;
  199. WORD filter;
  200. BOOL flag;
  201. FILE *pfout=NULL,*pfcmd=NULL,*pfini=NULL;
  202. struct EtherAddr ethernull,etherbroad;
  203. struct IPAddr ipnull;
  204. struct CommandLine cmdline;
  205. struct InitialFile inifile;
  206. char Command[BUFFER_SIZE];
  207. char *pbufh,*pbuft;
  208. struct EtherAddr sendethaddr,recvethaddr,sourethaddr,destethaddr;
  209. struct IPAddr sipaddr,dipaddr;
  210. WORD arpoper,tcpid;
  211. struct TCPConnection TCP[MAX_CONNECTION];
  212. WORD maxconn=0;
  213. WORD TCPFlag;
  215. /* Set null ethernet address and broadcast ethernet address */
  216. memset((void*)&ethernull,0,6);
  217. memset((void*)&etherbroad,0xff,6);
  218. memset((void*)&ipnull,0,6);
  220. /* Get initial file property */
  221. if((pfini=fopen(INITIAL_FILE,"r"))==NULL) {
  222. fprintf(stderr,"Can not open %sn",INITIAL_FILE);
  223. return 0;
  224. }
  225. if(GetInitial(pfini,&inifile)!=OK) {
  226. fprintf(stderr,"Not valid initial file.n");
  227. return 0;
  228. }
  229. Max_Data_Len=inifile.maxdatalen;
  230. memcpy((void *)&m_IPAddr,(void *)&inifile.mipaddr,4);
  232. /* Get command line option */
  233. if(GetOption(argc,argv,&cmdline)!=OK||cmdline.option&OPT_HELP) {
  234.                 fprintf(stderr,"IPMan Version 0.5bn");
  235.                 fprintf(stderr,"Author: HiHintnEmail:HiHint@hotmail.comnn");
  236.                 fprintf(stderr,"Usage ipman [-?] [-l[ini] [-ip:sour_ip[:dest_ip]] [-port:sour_port[:dest_port]]] [-qeth:ip_addr] [-qip:eth_addr] [-fout:output_file] [-fcmd:command_file]n");
  237. return 0;
  238. }
  240. if((cmdline.option&OPT_LISTEN)!=0) filter=NDIS_PACKET_TYPE_PROMISCUOUS;
  241. else filter=NDIS_PACKET_TYPE_DIRECTED;
  243. /* Open device */
  244.     hVxD = CreateFile("\\.\VPACKET.VXD", 
  245.                       GENERIC_READ | GENERIC_WRITE,
  246.                       0,
  247.                       NULL,
  248.                       OPEN_EXISTING,
  249.                       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED |
  250.                       FILE_FLAG_DELETE_ON_CLOSE,
  251.                       NULL);
  253.     if (hVxD == INVALID_HANDLE_VALUE) {
  254.         dwErrorCode = GetLastError();
  255.         if (dwErrorCode == ERROR_NOT_SUPPORTED) {
  256.             fprintf(stderr,"Unable to open VxD,ndevice does not support DeviceIOCTLn");
  257.         }
  258.         else
  259.             fprintf(stderr,"Unable to open VxD, Error code: %lxn", dwErrorCode);
  260. return(0);
  261.     }
  263. /* Device opened successfully */
  264. /* Bind driver to NDIS3 adapter */
  266. Bind(hVxD,inifile.ndis);
  268. /* Get ethernet address and IP */
  269. if(GetHardEtherAddr(hVxD,&m_EtherAddr)!=OK) return 0;
  271. /* Set Filter */
  272. SetOid(hVxD, OID_GEN_CURRENT_PACKET_FILTER, 4, filter);
  274. if((cmdline.option&OPT_OUTPUT_FILE)!=0) { /* Open output file */
  275. if((pfout=fopen(cmdline.outfile,"w"))==NULL) {
  276. fprintf(stderr,"Can not open output file.n");
  277. goto ENDOFTASK;
  278. }
  279. }
  280. else pfout=stdout;
  282. if(cmdline.option==0) {
  283. fprintf(pfout,"Ether address:");
  284. PrintEtherAddr(pfout,&m_EtherAddr);
  285. goto ENDOFTASK;
  286. }
  288. if((cmdline.option&OPT_COMMAND_FILE)!=0) { /* Open command file */
  289. if((pfcmd=fopen(cmdline.cmdfile,"r"))==NULL) {
  290. fprintf(stderr,"Can not open command file.n");
  291. goto ENDOFTASK;
  292. }
  293. for(i=0;i<MAX_CONNECTION;i++) TCP[i].inuse=FALSE;
  294. }
  296. if((cmdline.option&OPT_LISTEN)!=0) {
  297. /* Do listen */
  298. Continue=TRUE;
  299. while(Continue) {
  300. DataLen=RecvPacket(hVxD,Buffer);
  301. if(DataLen==SYSERR) goto ENDOFTASK;
  302. /* Begin to process data */
  303. pEtherHead=(struct EtherPacketHead *)Buffer;
  304. switch (swaps(pEtherHead->ServType)) {
  305. case ETHER_PROTO_IP: /* IP packet */
  306. pIPHead=(struct IPPacketHead *)(Buffer+ETHER_HEAD_LEN);
  307. headlen=(pIPHead->VerHLen)&0xf;
  308. headlen*=4;
  309. totallen=swaps(pIPHead->TtlLen);
  310. psourip=&(pIPHead->SourIP);
  311. pdestip=&(pIPHead->DestIP);
  312. flag=TRUE;
  313. if(cmdline.option&OPT_LISTEN_IP) {
  314. flag=FALSE;
  315. if((cmdline.option&OPT_LISTEN_IP_1)&&
  316.    (memcmp((void *)&cmdline.queip[0],(void *)psourip,4)==0||
  317. memcmp((void *)&cmdline.queip[0],(void *)pdestip,4)==0))  
  318. flag=TRUE;
  319. else if((cmdline.option&OPT_LISTEN_IP_2)&&
  320. ((memcmp((void *)&cmdline.queip[0],(void *)psourip,4)==0&&
  321.   memcmp((void *)&cmdline.queip[1],(void *)pdestip,4))||
  322.  (memcmp((void *)&cmdline.queip[0],(void *)pdestip,4)==0&&
  323.   memcmp((void *)&cmdline.queip[1],(void *)psourip,4))))
  324. flag=TRUE;
  325. }
  326. else if(cmdline.option&OPT_LISTEN_INIT) {
  327. flag=FALSE;
  328. for(i=0;i<inifile.ipno;i++) 
  329. if(memcmp((void *)&inifile.qip[i],(void *)psourip,4)==0||
  330.    memcmp((void *)&inifile.qip[i],(void *)pdestip,4)==0) break;
  331. if(i<inifile.ipno) flag=TRUE;
  332. }
  333. if(flag) {
  334. switch (pIPHead->Proto) {
  335. case IP_PROTO_TCP: /* TCP packet */
  336. pTCPHead=(struct TCPPacketHead *)(Buffer+ETHER_HEAD_LEN+headlen);
  337. totallen-=headlen;
  338. sourport=swaps(pTCPHead->SourPort);
  339. destport=swaps(pTCPHead->DestPort);
  340. seqno=swapl(pTCPHead->SeqNo);
  341. ackno=swapl(pTCPHead->AckNo);
  342. headlen=(pTCPHead->HLen)>>4;
  343. headlen*=4;
  344. totallen-=headlen;
  345. pdata=((BYTE *)pTCPHead)+headlen;
  346. /* TODO */
  347. flag=TRUE;
  348. if(cmdline.option&OPT_LISTEN_PORT) {
  349. flag=FALSE;
  350. if((cmdline.option&OPT_LISTEN_PORT_1)&&
  351.    (cmdline.queport[0]==sourport||
  352.     cmdline.queport[0]==destport))
  353. flag=TRUE;
  354. else if((cmdline.option&OPT_LISTEN_PORT_2)&&
  355.      ((cmdline.queport[0]==sourport&&cmdline.queport[1]==destport)||
  356.   (cmdline.queport[0]==destport&&cmdline.queport[1]==sourport)))
  357. flag=TRUE;
  358. }
  359. else if(cmdline.option&OPT_LISTEN_INIT) {
  360. flag=FALSE;
  361. for(i=0;i<inifile.portno;i++) 
  362. if(sourport==inifile.qport[i]||
  363.    destport==inifile.qport[i]) break;
  364. if(i<inifile.portno) flag=TRUE;
  365. }
  366. if(flag) {
  367. PrintIPAddr(pfout,psourip);
  368. fprintf(pfout,":%d -> ",sourport);
  369. PrintIPAddr(pfout,pdestip);
  370. fprintf(pfout,":%dn",destport);
  371. fprintf(pfout,"%d Byte(s) TCP Message:",totallen);
  372. PrintData(pfout,pdata,totallen);
  373. fprintf(pfout,"n");
  374. }
  375. break;
  376. case IP_PROTO_UDP: /* UDP packet */
  377. pUDPHead=(struct UDPPacketHead *)(Buffer+ETHER_HEAD_LEN+headlen);
  378. totallen-=headlen;
  379. sourport=swaps(pUDPHead->SourPort);
  380. destport=swaps(pUDPHead->DestPort);
  381. pdata=((BYTE *)pUDPHead)+UDP_HEAD_LEN;
  382. /* TODO */
  383. totallen-=UDP_HEAD_LEN;
  384. flag=TRUE;
  385. if(cmdline.option&OPT_LISTEN_PORT) {
  386. flag=FALSE;
  387. if((cmdline.option&OPT_LISTEN_PORT_1)&&
  388.    (cmdline.queport[0]==sourport||
  389.     cmdline.queport[0]==destport))
  390. flag=TRUE;
  391. else if((cmdline.option&OPT_LISTEN_PORT_2)&&
  392.      ((cmdline.queport[0]==sourport&&cmdline.queport[1]==destport)||
  393.   (cmdline.queport[0]==destport&&cmdline.queport[1]==sourport)))
  394. flag=TRUE;
  395. }
  396. else if(cmdline.option&OPT_LISTEN_INIT) {
  397. flag=FALSE;
  398. for(i=0;i<inifile.portno;i++) 
  399. if(sourport==inifile.qport[i]||
  400.    destport==inifile.qport[i]) break;
  401. if(i<inifile.portno) flag=TRUE;
  402. }
  403. if(flag) {
  404. PrintIPAddr(pfout,psourip);
  405. fprintf(pfout,":%d -> ",sourport);
  406. PrintIPAddr(pfout,pdestip);
  407. fprintf(pfout,":%dn",destport);
  408. fprintf(pfout,"%d Byte(s) UDP Message:",totallen);
  409. PrintData(pfout,pdata,totallen);
  410. fprintf(pfout,"n");
  411. }
  412. break;
  413. case IP_PROTO_ICMP: /* ICMP packet */
  414. flag=TRUE;
  415. if(cmdline.option&OPT_LISTEN_PORT) 
  416.    flag=FALSE;
  417. if(flag) {
  418. pICMPHead=(struct ICMPPacketHead *)(Buffer+ETHER_HEAD_LEN+headlen);
  419. totallen-=headlen;
  420. pdata=((BYTE *)pICMPHead)+ICMP_HEAD_LEN;
  421. totallen-=ICMP_HEAD_LEN;
  422. /* TODO */
  423. PrintIPAddr(pfout,psourip);
  424. fprintf(pfout," -> ");
  425. PrintIPAddr(pfout,pdestip);
  426. fprintf(pfout,"n");
  427. fprintf(pfout,"%d Byte(s) ICMP Message:Type:%d Code:%dn",totallen,pICMPHead->Type,pICMPHead->Code);
  428. }
  429. break;
  430. default: /* Unknown packet */
  431. /*fprintf(stderr,"Unknown ip packet type.n");*/
  432. break;
  433. }
  434. }
  435. break;
  436. case ETHER_PROTO_ARP: /* ARP packet */
  437. if((cmdline.option&OPT_LISTEN_SPEC)==0) {
  438. pARPHead=(struct ARPPacket*)(Buffer+ETHER_HEAD_LEN);
  439. psourip=&(pARPHead->SourIP);
  440. pdestip=&(pARPHead->DestIP);
  441. psoureth=&(pARPHead->SourEther);
  442. pdesteth=&(pARPHead->DestEther);
  443. /* TODO */
  444. fprintf(pfout,"ARP Message:From:");
  445. PrintEtherAddr(pfout,psoureth);
  446. fprintf(pfout,":");
  447. PrintIPAddr(pfout,psourip);
  448. fprintf(pfout," To:");
  449. PrintEtherAddr(pfout,pdesteth);
  450. fprintf(pfout,":");
  451. PrintIPAddr(pfout,pdestip);
  452. fprintf(pfout," Operation:%dn",swaps(pARPHead->Oper));
  453. }
  454. break;
  455. default: /* Unknown packet */
  456. /*fprintf(stderr,"Unknown ethernet packet type.n");*/
  457. break;
  458. }
  459. }
  460. }
  461. else if((cmdline.option&OPT_QUE_ETHER)!=0) {
  462. /* Do query ethernet address form IP */
  463. ListenStart(hVxD);
  464. SendARPPacket(hVxD,
  465.   &m_EtherAddr,
  466.   &etherbroad,
  467.   &m_EtherAddr,
  468.   &ethernull,
  469.   &m_IPAddr,
  470.   &cmdline.queip[0],
  471.   ARP_OPER_ARP_REQ);
  472. Continue=TRUE;
  473. while(Continue) {
  474. if((DataLen=RecvPacket(hVxD,Buffer))==SYSERR) {
  475. fprintf(stderr,"Can not recv ARP packet.n");
  476. goto ENDOFTASK;
  477. }
  478. pEtherHead=(struct EtherPacketHead *)Buffer;
  479. if(swaps(pEtherHead->ServType)!=ETHER_PROTO_ARP) continue;
  480. pARPHead=(struct ARPPacket *)(Buffer+ETHER_HEAD_LEN);
  481. if(swaps(pARPHead->Oper)!=ARP_OPER_ARP_ANS) continue;
  482. if(memcmp((void *)&pARPHead->SourIP,(void *)&cmdline.queip[0],4)!=0) continue;
  483. /* Get ethernet address */
  484. fprintf(pfout,"Ethernet Address:");
  485. PrintEtherAddr(pfout,&pARPHead->SourEther);
  486. fprintf(pfout," of IP Address:");
  487. PrintIPAddr(pfout,&cmdline.queip[0]);
  488. fprintf(pfout,"n"); 
  489. Continue=FALSE;
  490. }
  491. }
  492. else if((cmdline.option&OPT_QUE_IP)!=0) {
  493. /* Do query IP from ethernet address */
  494. ListenStart(hVxD);
  495. SendARPPacket(hVxD,
  496.   &m_EtherAddr,
  497.   &etherbroad,
  498.   &m_EtherAddr,
  499.   &cmdline.queeth[0],
  500.   &m_IPAddr,
  501.   &ipnull,
  502.   ARP_OPER_RARP_REQ);
  503. Continue=TRUE;
  504. while(Continue) {
  505. if((DataLen=RecvPacket(hVxD,Buffer))==SYSERR) {
  506. fprintf(stderr,"Can not recv ARP packet.n");
  507. goto ENDOFTASK;
  508. }
  509. pEtherHead=(struct EtherPacketHead *)Buffer;
  510. if(swaps(pEtherHead->ServType)!=ETHER_PROTO_ARP) continue;
  511. pARPHead=(struct ARPPacket *)(Buffer+ETHER_HEAD_LEN);
  512. if(swaps(pARPHead->Oper)!=ARP_OPER_RARP_ANS) continue;
  513. if(memcmp((void *)&pARPHead->SourEther,(void *)&cmdline.queeth[0],6)!=0) continue;
  514. /* Get IP address */
  515. fprintf(pfout,"IP Address:");
  516. PrintIPAddr(pfout,&pARPHead->SourIP);
  517. fprintf(pfout," of Ethernet Address:");
  518. PrintEtherAddr(pfout,&cmdline.queeth[0]);
  519. fprintf(pfout,"n");
  520. Continue=FALSE;
  521. }
  522. }
  523. else if((cmdline.option&OPT_COMMAND_FILE)!=0) {
  524. /* Do command file */
  525. while(feof(pfcmd)==0) {
  526. ReadCommand(pfcmd,Command);
  527. switch (GetCommand(Command)) {
  528. case COMMAND_SEND_ARP:
  529. GetSendARPArg(Command,
  530.           &sendethaddr,
  531.   &recvethaddr,
  532.   &sourethaddr,
  533.   &destethaddr,
  534.   &sipaddr,
  535.   &dipaddr,
  536.   &arpoper);
  537. SendARPPacket(hVxD,
  538.           &sendethaddr,
  539.   &recvethaddr,
  540.   &sourethaddr,
  541.   &destethaddr,
  542.   &sipaddr,
  543.   &dipaddr,
  544.   arpoper);
  545. fprintf(pfout,"Send ARP.n");
  546. break;
  547. case COMMAND_SEND_TCP:
  548. GetSendTCPArg(Command,&tcpid,Buffer,&DataLen);
  549. if(TCP[tcpid].inuse==FALSE) 
  550. fprintf(stdout,"Connection %d invalid or already closed.n",tcpid);
  551. else {
  552. SendTCPPacket(hVxD,
  553.   &TCP[tcpid].sendeth,
  554.   &TCP[tcpid].recveth,
  555.   &TCP[tcpid].sourip,
  556.   &TCP[tcpid].destip,
  557.   TCP[tcpid].sourport,
  558.   TCP[tcpid].destport,
  559.   TCP_ACK|TCP_PSH,
  560.   TCP[tcpid].seqno,
  561.   TCP[tcpid].ackno,
  562.   Buffer,
  563.   DataLen);
  564. fprintf(pfout,"Send %d TCP:",tcpid);
  565. PrintData(pfout,Buffer,DataLen);
  566. fprintf(pfout,"n");
  567. }
  568. break;
  569. case COMMAND_RECV_TCP:
  570. GetRecvTCPArg(Command,&tcpid);
  571. RecvTCPPacket(hVxD,
  572.   &TCP[tcpid].destip,
  573.   &TCP[tcpid].sourip,
  574.   TCP[tcpid].destport,
  575.   TCP[tcpid].sourport,
  576.   &TCPFlag,
  577.   &TCP[tcpid].ackno,
  578.   &TCP[tcpid].seqno,
  579.   Buffer,
  580.   &DataLen);
  581. if(DataLen==0) TCP[tcpid].ackno++;
  582. else TCP[tcpid].ackno+=DataLen;
  583. fprintf(pfout,"Receive %d TCP %d byte(s):",tcpid,DataLen);
  584. PrintData(pfout,Buffer,DataLen);
  585. fprintf(pfout,"n");
  586. /*fprintf(pfout,"Flag:%xn",TCPFlag);*/
  587. if(TCPFlag&TCP_FIN||TCPFlag&TCP_RST) {
  588. TCP[tcpid].inuse=FALSE;
  589. fprintf(pfout,"Peer close connection %d.n",tcpid);
  590. }
  591. break;
  592. case COMMAND_CONNECT_TCP:
  593. ListenStart(hVxD);
  594. GetConnectArg(Command,
  595.   &sendethaddr,
  596.   &recvethaddr,
  597.   &sipaddr,
  598.   &dipaddr,
  599.   &sourport,
  600.   &destport,
  601.   &tcpid);
  602. memcpy((void *)&TCP[tcpid].sendeth,(void *)&sendethaddr,6);
  603. memcpy((void *)&TCP[tcpid].recveth,(void *)&recvethaddr,6);
  604. memcpy((void *)&TCP[tcpid].sourip,(void *)&sipaddr,4);
  605. memcpy((void *)&TCP[tcpid].destip,(void *)&dipaddr,4);
  606. TCP[tcpid].sourport=sourport;
  607. TCP[tcpid].destport=destport;
  608. TCP[tcpid].seqno=swapl(0x1234);
  609. TCP[tcpid].ackno=0;
  610. TCPFlag=TCP_SYN;
  611. SendTCPPacket(hVxD,
  612.   &TCP[tcpid].sendeth,
  613.   &TCP[tcpid].recveth,
  614.   &TCP[tcpid].sourip,
  615.   &TCP[tcpid].destip,
  616.   TCP[tcpid].sourport,
  617.   TCP[tcpid].destport,
  618.   TCPFlag,
  619.   TCP[tcpid].seqno,
  620.   TCP[tcpid].ackno,
  621.   Buffer,
  622.   0);
  623. /*fprintf(pfout,"First:Flag:%x Seq:%lu Ack:%lun",
  624.     TCPFlag,swapl(0x1234),ackno);*/
  625. RecvTCPPacket(hVxD,
  626.   &TCP[tcpid].destip,
  627.   &TCP[tcpid].sourip,
  628.   TCP[tcpid].destport,
  629.   TCP[tcpid].sourport,
  630.   &TCPFlag,
  631.   &TCP[tcpid].ackno,
  632.   &TCP[tcpid].seqno,
  633.   Buffer,
  634.   &DataLen);
  635. /*fprintf(pfout,"Second:Flag:%x Seq:%lu Ack:%lun",
  636.     TCPFlag,TCP[tcpid].ackno,TCP[tcpid].seqno);*/
  637. TCP[tcpid].ackno++;
  638. TCPFlag=TCP_ACK;
  639. SendTCPPacket(hVxD,
  640.   &TCP[tcpid].sendeth,
  641.   &TCP[tcpid].recveth,
  642.   &TCP[tcpid].sourip,
  643.   &TCP[tcpid].destip,
  644.   TCP[tcpid].sourport,
  645.   TCP[tcpid].destport,
  646.   TCPFlag,
  647.   TCP[tcpid].seqno,
  648.   TCP[tcpid].ackno,
  649.   Buffer,
  650.   0);
  651. /*fprintf(pfout,"Third:Flag:%x Seq:%lu Ack:%lun",
  652.     TCPFlag,TCP[tcpid].seqno,TCP[tcpid].ackno);*/
  653. fprintf(pfout,"TCP %d Connectedn",tcpid);
  654. TCP[tcpid].inuse=TRUE;
  655. break;
  656. case COMMAND_CLOSE_TCP:
  657. GetCloseArg(Command,&tcpid);
  658. TCPFlag=TCP_FIN|TCP_ACK;
  659. SendTCPPacket(hVxD,
  660.   &TCP[tcpid].sendeth,
  661.   &TCP[tcpid].recveth,
  662.   &TCP[tcpid].sourip,
  663.   &TCP[tcpid].destip,
  664.   TCP[tcpid].sourport,
  665.   TCP[tcpid].destport,
  666.   TCPFlag,
  667.   TCP[tcpid].seqno,
  668.   TCP[tcpid].ackno,
  669.   Buffer,
  670.   0);
  671. fprintf(pfout,"Closen");
  672. TCP[tcpid].inuse=FALSE;
  673. break;
  674. case COMMENT:
  675. break;
  676. case COMMAND_UNKNOWN:
  677. if(feof(pfcmd)==0) fprintf(stderr,"Command unknown.n");
  678. /*goto ENDOFTASK;*/
  679. }
  680. }
  681. }
  683. ENDOFTASK:
  684. CloseHandle(hVxD);
  685. if(pfout!=NULL) fclose(pfout);
  686. if(pfcmd!=NULL) fclose(pfcmd);
  687. return 0;
  688. }
  690. DWORD Bind(HANDLE hVxD, BYTE* inBuffer)
  691. {
  692.     HANDLE          hEvent  = 0;
  693.     DWORD           cbRet   = 0;
  694.     OVERLAPPED      ovlp    = {0,0,0,0,0};
  695.     int result;
  696.     int cbIn = 5;
  697.     
  698.     hEvent = CreateEvent(0, TRUE, 0, NULL);
  699. if(!hEvent) {
  700. fprintf(stderr,"Can not create eventn");
  701. return SYSERR;
  702. }
  704. ovlp.hEvent=hEvent;
  706.     result = DeviceIoControl(hVxD,
  707.  IOCTL_PROTOCOL_BIND, 
  708.  inBuffer, 
  709.  cbIn, 
  710.  inBuffer, 
  711.  cbIn, 
  712.  &cbRet, 
  713.  &ovlp);
  715.     if (!result)
  716.         GetOverlappedResult(hVxD, &ovlp, &cbRet, TRUE);
  718. CloseHandle(hEvent);
  719.     return OK;
  720. }
  722. WORD GetHardEtherAddr(HANDLE hVxD,struct EtherAddr *petheraddr)
  723. {
  724.     BYTE*   buffer = QueryOid(hVxD, OID_802_3_CURRENT_ADDRESS, 6);
  726.     if (buffer!=NULL) {
  727. memcpy((void *)petheraddr->AddrByte,(void*)buffer,6);
  728. return OK;
  729. }
  730. return SYSERR;
  731. }
  733. DWORD QueryPacket(HANDLE hVxD,ULONG ioctl,BYTE* inBuffer,DWORD cbIn,
  734.   BYTE* outBuffer,DWORD cbOut)
  735. {
  736.     HANDLE      hEvent = 0;
  737.     DWORD       cbRet;
  738.     OVERLAPPED  ovlp = {0,0,0,0,0};
  739.    
  740.     if (!(hEvent = CreateEvent(0, TRUE, 0, NULL)))
  741.         ERROR_OUT("CreateEvent failed!n")
  743.     ovlp.hEvent = hEvent;
  744.     
  745.     if (!DeviceIoControl(hVxD, ioctl, inBuffer, cbIn, outBuffer, cbOut, &cbRet, &ovlp)) {
  746.         if (GetLastError() == ERROR_IO_PENDING)                         
  747.             fprintf(stderr,"VxD correctly returned operation incomplete.n" );
  748.         else
  749.             ERROR_OUT( "VxD does not support the requested API!!!n" );
  750.         if (!GetOverlappedResult(hVxD, &ovlp, &cbRet, FALSE)) {
  751.             if (GetLastError() == ERROR_IO_INCOMPLETE)
  752.                 fprintf(stderr,"GetOverlappedResult returned expected value.n");
  753.             else
  754.                 ERROR_OUT("GetOverlappedResult returned unexpected error.n");
  755.         }
  756.         GetOverlappedResult( hVxD, &ovlp, &cbRet, TRUE);
  757. }
  758.     return cbRet;
  759. }
  761. BYTE* QueryOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength)
  762. {
  763.     DWORD               cbIn = sizeof(PACKET_OID_DATA) + ulLength;
  764.     DWORD               cbRet;
  765. PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA)InBuff;
  766.     ULONG               ioctl;
  768.     ioctl = (ulOid >= OID_802_3_PERMANENT_ADDRESS) 
  769.   
  770.    ? IOCTL_PROTOCOL_QUERY_OID : IOCTL_PROTOCOL_STATISTICS;
  772.     memset(InBuff, 0, cbIn+1);
  774. pOidData->Oid    = ulOid;
  775. pOidData->Length = ulLength;
  777. cbRet = QueryPacket( hVxD, ioctl, InBuff, cbIn, InBuff, cbIn );
  778.    
  779. if ( cbRet > 0 ) 
  780.         return (InBuff+sizeof(PACKET_OID_DATA)-1);
  782. return 0;
  783. }
  785. BYTE* SetOid(HANDLE hVxD, ULONG ulOid, ULONG ulLength, ULONG data)
  786. {
  787.     DWORD               cbIn = sizeof(PACKET_OID_DATA) + ulLength;
  788.     DWORD               cbRet;
  789. PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA)InBuff;
  790.     ULONG               ioctl;
  792.     if (ulOid == OID_GEN_CURRENT_PACKET_FILTER)
  793.         ioctl = (ULONG) IOCTL_PROTOCOL_SET_OID;
  795.     memset(InBuff, 0, cbIn+1);
  797.     pOidData->Oid     = ulOid;
  798.     pOidData->Length  = ulLength;
  799.     pOidData->Data[0] = (UCHAR) data;
  801.     cbRet = QueryPacket(hVxD, ioctl, InBuff, cbIn, InBuff, cbIn);
  802.    
  803. return 0;
  804. }
  806. WORD RecvStart(HANDLE hVxD,struct PacketTable *packtab)
  807. {
  808. int result;
  810. packtab->Overlap.Internal=0;
  811. packtab->Overlap.InternalHigh=0;
  812. packtab->Overlap.Offset=0;
  813. packtab->Overlap.OffsetHigh=0;
  814. packtab->Overlap.hEvent=packtab->hEvent;
  816. result=DeviceIoControl(hVxD,
  817.    IOCTL_PROTOCOL_READ,
  818.    &packtab->Buffer,
  819.    packtab->Size,
  820.    &packtab->Buffer,
  821.    packtab->Size,
  822.    &packtab->Length,
  823.    &packtab->Overlap);
  825. if(result) return SYSERR;
  827. return OK;
  828. }
  830. WORD SendStart(HANDLE hVxD,struct PacketTable *packtab)
  831. {
  832. int result;
  834. packtab->Overlap.Internal=0;
  835. packtab->Overlap.InternalHigh=0;
  836. packtab->Overlap.Offset=0;
  837. packtab->Overlap.OffsetHigh=0;
  838. packtab->Overlap.hEvent=packtab->hEvent;
  840. result=DeviceIoControl(hVxD,
  841.    IOCTL_PROTOCOL_WRITE,
  842.    &packtab->Buffer,
  843.    packtab->Size,
  844.    &packtab->Buffer,
  845.    packtab->Length,
  846.    &packtab->Length,
  847.    &packtab->Overlap);
  849. if(result) return SYSERR;
  851. return OK;
  852. }
  854. WORD ListenStart(HANDLE hVxD)
  855. {
  856. return RecvPacket(hVxD,NULL);
  857. }
  859. WORD RecvPacket(HANDLE hVxD,BYTE *pbuf)
  860. {
  861. static BOOL first=TRUE;
  862. static struct PacketTable RecvTab[RECV_MAX];
  863. static HANDLE EventTab[RECV_MAX];
  864. HANDLE hEvent;
  865. int i,j,k;
  866. WORD len;
  868. if(first) {
  869. for(i=0;i<RECV_MAX;i++) {
  870. hEvent=CreateEvent(0, TRUE, 0, NULL);
  871. if(!hEvent) {
  872. fprintf(stderr,"Can not create eventn");
  873. return SYSERR;
  874. }
  875. RecvTab[i].hEvent=hEvent;
  876. memset(RecvTab[i].Buffer,0,BUFFER_SIZE);
  877. RecvTab[i].Size=BUFFER_SIZE;
  878. RecvTab[i].Active=TRUE;
  879. RecvTab[i].Type=READ;
  880. EventTab[i]=hEvent;
  881. RecvStart(hVxD,&RecvTab[i]);
  882. }
  883. first=FALSE;
  884. }
  885. if(pbuf==NULL) return OK;
  886. i=WaitForMultipleObjectsEx(RECV_MAX,EventTab,FALSE,INFINITE,FALSE);
  887. if(i==WAIT_FAILED) return SYSERR;
  888. for(j=0;j<RECV_MAX;j++) 
  889. if(EventTab[i]==RecvTab[j].hEvent) break;
  890. k=j;
  891. if(RecvTab[k].Type==READ&&RecvTab[k].Active==TRUE) { /* read complete */
  892. GetOverlappedResult(hVxD,&RecvTab[k].Overlap,&RecvTab[k].Length,FALSE);
  893. if(RecvTab[k].Length>BUFFER_SIZE) RecvTab[k].Length=BUFFER_SIZE;
  894. memcpy((void *)pbuf,(void *)RecvTab[k].Buffer,RecvTab[k].Length);
  895. len=RecvTab[k].Length;
  896. CloseHandle(RecvTab[k].hEvent);
  897. for(j=i;j<RECV_MAX-1;i++) 
  898. EventTab[i]=EventTab[++j];
  899. hEvent=CreateEvent(0, TRUE, 0, NULL);
  900. if(!hEvent) {
  901. fprintf(stderr,"Can not create eventn");
  902. return SYSERR;
  903. }
  904. RecvTab[k].hEvent=hEvent;
  905. memset(RecvTab[k].Buffer,0,BUFFER_SIZE);
  906. RecvTab[k].Size=BUFFER_SIZE;
  907. RecvTab[k].Active=TRUE;
  908. RecvTab[k].Type=READ;
  909. EventTab[RECV_MAX-1]=hEvent;
  910. RecvStart(hVxD,&RecvTab[k]);
  911. return len;
  912. }
  913. else return SYSERR;
  914. }
  916. WORD SendPacket(HANDLE hVxD,BYTE *pbuf,WORD len)
  917. {
  918. static struct PacketTable SendTab;
  919. HANDLE hEvent;
  921. hEvent=CreateEvent(0, TRUE, 0, NULL);
  922. if(!hEvent) {
  923. fprintf(stderr,"Can not create eventn");
  924. return SYSERR;
  925. }
  926. SendTab.hEvent=hEvent;
  927. memcpy(SendTab.Buffer,(void *)pbuf,len);
  928. SendTab.Size=len;
  929. SendTab.Length=BUFFER_SIZE;
  930. SendTab.Active=TRUE;
  931. SendTab.Type=WRITE;
  932. SendStart(hVxD,&SendTab);
  934. GetOverlappedResult(hVxD,&SendTab.Overlap,&SendTab.Length,TRUE);
  935. return OK;
  936. }
  938. WORD CheckSum(WORD *addr,WORD len)
  939. {
  940. DWORD lSum;
  941. WORD wOddByte;
  942. WORD wAnswer; 
  944. lSum=0l;
  946. while(len>1) {
  947. lSum+= *addr++;
  948. len-=2;
  949. }
  951. if(len==1) {
  952. wOddByte=0;
  953. *((unsigned char*)&wOddByte)=*(unsigned char*)addr;
  954. lSum+=wOddByte;
  955. }
  957. lSum=(lSum>>16)+(lSum&0xffff);
  958. lSum+=(lSum>>16);
  959. wAnswer=(unsigned int)~lSum;
  961. return wAnswer;
  962. }
  964. WORD swaps(WORD net)
  965. {
  966. WORD lo,hi;
  967. WORD host;
  969. lo=net&0xff;
  970. hi=net&0xff00;
  971. lo=lo<<8;
  972. hi=hi>>8;
  973. host=hi|lo;
  975. return host;
  976. }
  978. DWORD swapl(DWORD net)
  979. {
  980. DWORD b1,b2,b3,b4;
  981. DWORD host;
  983. b1=net&0xff;
  984. b2=net&0xff00;
  985. b3=net&0xff0000;
  986. b4=net&0xff000000;
  988. b1=b1<<24;
  989. b2=b2<<8;
  990. b3=b3>>8;
  991. b4=b4>>24;
  993. host=b1|b2|b3|b4;
  995. return host;
  996. }
  998. WORD GetOption(int argc,char *argv[],struct CommandLine *cmdline)
  999. {
  1000. int i;
  1001. char *pbufh,*pbuft;
  1002. char c;
  1004. cmdline->option=OPT_DO_NOTHING;
  1005. for(i=1;i<argc;i++) {
  1006. if((pbufh=strstr(argv[i],"-l"))!=NULL) { /* Listen */
  1007. if(strstr(argv[i],"-lini")!=NULL) cmdline->option|=OPT_LISTEN_INIT;
  1008. else cmdline->option|=OPT_LISTEN_ALL;
  1009. /*printf("listenn");*/
  1010. }
  1011. else if(strstr(argv[i],"-?")!=NULL) {
  1012. cmdline->option|=OPT_HELP;
  1013. }
  1014. else if((pbufh=strstr(argv[i],"-ip:"))!=NULL&&
  1015. (cmdline->option&OPT_LISTEN_ALL)!=0) { /* IP address */
  1016. pbufh+=4;
  1017. if((pbuft=strstr(pbufh,":"))!=NULL) { /* Two IP */
  1018. pbuft++;
  1019. GetIPAddr(pbufh,&cmdline->queip[0]);
  1020. GetIPAddr(pbuft,&cmdline->queip[1]);
  1021. cmdline->option|=OPT_LISTEN_IP_2;
  1022. }
  1023. else { /* One IP */
  1024. GetIPAddr(pbufh,&cmdline->queip[0]);
  1025. cmdline->option|=OPT_LISTEN_IP_1;
  1026. }
  1027. }
  1028. else if((pbufh=strstr(argv[i],"-port:"))!=NULL&&
  1029. (cmdline->option&OPT_LISTEN_ALL)!=0) { /* Port */
  1030. pbufh+=6;
  1031. if((pbuft=strstr(pbufh,":"))!=NULL) { /* Two port */
  1032. pbuft++;
  1033. sscanf(pbufh,"%d",&cmdline->queport[0]);
  1034. sscanf(pbuft,"%d",&cmdline->queport[1]);
  1035. cmdline->option|=OPT_LISTEN_PORT_2;
  1036. }
  1037. else { /* One port */
  1038. sscanf(pbufh,"%d",&cmdline->queport[0]);
  1039. cmdline->option|=OPT_LISTEN_PORT_1;
  1040. }
  1041. }
  1042. else if((pbufh=strstr(argv[i],"-qeth:"))!=NULL) { /* Query ethernet address */
  1043. cmdline->option|=OPT_QUE_ETHER;
  1044. pbufh+=6;
  1045. GetIPAddr(pbufh,&cmdline->queip[0]);
  1046. }
  1047. else if((pbufh=strstr(argv[i],"-qip:"))!=NULL) { /* Query IP */
  1048. cmdline->option|=OPT_QUE_IP;
  1049. pbufh+=5;
  1050. GetEtherAddr(pbufh,&cmdline->queeth[0]);
  1051. }
  1052. else if((pbufh=strstr(argv[i],"-fout:"))!=NULL) { /* Output file */
  1053. cmdline->option|=OPT_OUTPUT_FILE;
  1054. pbufh+=6;
  1055. sscanf(pbufh,"%s",cmdline->outfile);
  1056. }
  1057. else if((pbufh=strstr(argv[i],"-fcmd:"))!=NULL) { /* Command file */
  1058. cmdline->option|=OPT_COMMAND_FILE;
  1059. pbufh+=6;
  1060. sscanf(pbufh,"%s",cmdline->cmdfile);
  1061. }
  1062. }
  1063. if(cmdline->option&OPT_LISTEN_SPEC) cmdline->option&=~OPT_LISTEN_ALL;
  1064. return OK;
  1065. }
  1067. WORD GetInitial(FILE *pfini,struct InitialFile *inifile)
  1068. {
  1069. char Command[BUFFER_SIZE];
  1070. int i;
  1071. int out;
  1073. out=2;
  1074. inifile->ipno=0;
  1075. inifile->portno=0;
  1076. inifile->timeout=INFINITE;
  1077. inifile->maxdatalen=MAX_DATA;
  1078. while(feof(pfini)==0) {
  1079. ReadCommand(pfini,Command);
  1080. switch (GetCommand(Command)) {
  1081. case INITIAL_MAX_DATA:
  1082. ReadCommand(pfini,Command);
  1083. sscanf(Command,"%d",&inifile->maxdatalen);
  1084. break;
  1085. case INITIAL_IP_ADDR:
  1086. ReadCommand(pfini,Command);
  1087. out--;
  1088. GetIPAddr(Command,&inifile->mipaddr);
  1089. break;
  1090. case INITIAL_NDIS:
  1091. out--;
  1092. ReadCommand(pfini,inifile->ndis);
  1093. break;
  1094. case INITIAL_QUERY_IP:
  1095. ReadCommand(pfini,Command);
  1096. i=0;
  1097. while(GetCommand(Command)!=INITIAL_END_SEGMENT) {
  1098. GetIPAddr(Command,&inifile->qip[i]);
  1099. i++;
  1100. if(i==MAX_QUERY) return SYSERR;
  1101. ReadCommand(pfini,Command);
  1102. }
  1103. inifile->ipno=i;
  1104. break;
  1105. case INITIAL_QUERY_PORT:
  1106. ReadCommand(pfini,Command);
  1107. i=0;
  1108. while(GetCommand(Command)!=INITIAL_END_SEGMENT) {
  1109. sscanf(Command,"%d",&inifile->qport[i]);
  1110. i++;
  1111. if(i==MAX_QUERY) return SYSERR;
  1112. ReadCommand(pfini,Command);
  1113. }
  1114. inifile->portno=i;
  1115. break;
  1116. case INITIAL_TIMEOUT:
  1117. ReadCommand(pfini,Command);
  1118. if(strstr(Command,INITIAL_INFINITE)==NULL) 
  1119. sscanf(Command,"%d",&inifile->timeout);
  1120. else inifile->timeout=INFINITE;
  1121. break;
  1122. case COMMENT:
  1123. break;
  1124. case INITIAL_END_SEGMENT:
  1125. break;
  1126. default:
  1127. if(feof(pfini)==0) return SYSERR;
  1128. }
  1129. }
  1130. if(out>0) return SYSERR;
  1131. else return OK;
  1132. return OK;
  1133. }
  1135. void PrintEtherAddr(FILE *pf,struct EtherAddr *pethaddr)
  1136. {
  1137. fprintf(pf,"%02x.%02x.%02x.%02x.%02x.%02x",pethaddr->AddrByte[0],
  1138.     pethaddr->AddrByte[1],
  1139.     pethaddr->AddrByte[2],
  1140.     pethaddr->AddrByte[3],
  1141.     pethaddr->AddrByte[4],
  1142.     pethaddr->AddrByte[5]);
  1143. }
  1145. void PrintIPAddr(FILE *pf,struct IPAddr *pIPaddr)
  1146. {
  1147. fprintf(pf,"%d.%d.%d.%d",pIPaddr->AddrByte[0],
  1148.     pIPaddr->AddrByte[1],
  1149.     pIPaddr->AddrByte[2],
  1150.     pIPaddr->AddrByte[3]);
  1151. }
  1153. WORD SendARPPacket(HANDLE hVxD,
  1154.    struct EtherAddr *psourether,
  1155.    struct EtherAddr *pdestether,
  1156.    struct EtherAddr *psendether,
  1157.    struct EtherAddr *precvether,
  1158.    struct IPAddr *psendip,
  1159.    struct IPAddr *precvip,
  1160.    WORD oper)
  1161. {
  1162. char Buffer[BUFFER_SIZE];
  1163. struct EtherPacketHead *pEtherHead;
  1164. struct ARPPacket *pARPHead;
  1166. memset(Buffer,0,BUFFER_SIZE);
  1167. pEtherHead=(struct EtherPacketHead *)Buffer;
  1168. pARPHead=(struct ARPPacket *)(Buffer+ETHER_HEAD_LEN);
  1169. memcpy((void *)&pEtherHead->SourEther,(void *)psourether,6);
  1170. memcpy((void *)&pEtherHead->DestEther,(void *)pdestether,6);
  1171. pEtherHead->ServType=swaps(ETHER_PROTO_ARP);
  1172. memset((void *)pARPHead,0,ARP_PACKET_LEN);
  1173. pARPHead->Type=swaps(ARP_HARD_TYPE);
  1174. pARPHead->Proto=swaps(ARP_PROTO_TYPE);
  1175. pARPHead->HardAddrLen=ARP_HARD_ADDR_LEN;
  1176. pARPHead->AddrLen=ARP_ADDR_LEN;
  1177. pARPHead->Oper=swaps(oper);
  1178. memcpy((void *)&pARPHead->SourEther,(void *)psendether,6);
  1179. memcpy((void *)&pARPHead->DestEther,(void *)precvether,6);
  1180. memcpy((void *)&pARPHead->SourIP,(void *)psendip,4);
  1181. memcpy((void *)&pARPHead->DestIP,(void *)precvip,4);
  1182. if(SendPacket(hVxD,Buffer,ETHER_HEAD_LEN+ARP_PACKET_LEN)==SYSERR) {
  1183. fprintf(stderr,"Can not send ARP packet.n");
  1184. return SYSERR;
  1185. }
  1186. return OK;
  1187. }
  1189. WORD SendTCPPacket(HANDLE hVxD,
  1190.    struct EtherAddr *psourether,
  1191.    struct EtherAddr *pdestether,
  1192.    struct IPAddr *psourip,
  1193.    struct IPAddr *pdestip,
  1194.    WORD sourport,
  1195.    WORD destport,
  1196.    WORD flag,
  1197.    DWORD seqno,
  1198.    DWORD ackno,
  1199.    char *pbuf,
  1200.    WORD len)
  1201. {
  1202. char Buffer[BUFFER_SIZE];
  1203. char HelpBuffer[BUFFER_SIZE];
  1204. char *pdata;
  1205. struct EtherPacketHead *pEtherHead;
  1206. struct IPPacketHead *pIPHead;
  1207. struct TCPPacketHead *pTCPHead,*pHelpTCPHead;
  1208. struct PseudoHead *pPseudoHead;
  1209. static WORD id=0;
  1210. WORD wlen;
  1212. id++;
  1213. memset(Buffer,0,BUFFER_SIZE);
  1214. pEtherHead=(struct EtherPacketHead *)Buffer;
  1215. pIPHead=(struct IPPacketHead *)(Buffer+ETHER_HEAD_LEN);
  1216. pTCPHead=(struct TCPPacketHead *)(Buffer+ETHER_HEAD_LEN+IP_HEAD_BYTE_LEN);
  1217. pPseudoHead=(struct PseudoHead *)HelpBuffer;
  1218. pHelpTCPHead=(struct TCPPacketHead *)(HelpBuffer+PSEUDO_HEAD_LEN);
  1219. pdata=(char *)(Buffer+ETHER_HEAD_LEN+IP_HEAD_BYTE_LEN+TCP_HEAD_BYTE_LEN);
  1220. /* Set ether head */
  1221. memcpy((void *)&pEtherHead->SourEther,(void *)psourether,6);
  1222. memcpy((void *)&pEtherHead->DestEther,(void *)pdestether,6);
  1223. pEtherHead->ServType=swaps(ETHER_PROTO_IP);
  1224. /* Set IP head */
  1225. memcpy((void *)&pIPHead->SourIP,(void *)psourip,4);
  1226. memcpy((void *)&pIPHead->DestIP,(void *)pdestip,4);
  1227. pIPHead->VerHLen=(IP_VER<<4)|IP_HEAD_LEN;
  1228. pIPHead->Type=IP_SERV_TYPE;
  1229. wlen=len+TCP_HEAD_BYTE_LEN+IP_HEAD_BYTE_LEN;
  1230. pIPHead->TtlLen=swaps(wlen);
  1231. pIPHead->Id=swaps(id);
  1232. pIPHead->FlgOff=0;
  1233. pIPHead->TTL=69;
  1234. pIPHead->Proto=IP_PROTO_TCP;
  1235. pIPHead->ChkSum=0;
  1236. pIPHead->ChkSum=CheckSum((WORD *)pIPHead,IP_HEAD_BYTE_LEN);
  1237. /* Set TCP head */
  1238. pTCPHead->SourPort=swaps(sourport);
  1239. pTCPHead->DestPort=swaps(destport);
  1240. pTCPHead->SeqNo=swapl(seqno);
  1241. pTCPHead->AckNo=swapl(ackno);
  1242. pTCPHead->HLen=TCP_HEAD_LEN<<4;
  1243. pTCPHead->Flag=flag;
  1244. pTCPHead->WndSize=swaps(8192);
  1245. pTCPHead->ChkSum=0;
  1246. pTCPHead->UrgPtr=0;
  1247. /* Set TCP data */
  1248. memcpy((void *)pdata,(void *)pbuf,len);
  1249. /* Calculate TCP checksum */
  1250. memcpy((void *)&pPseudoHead->SourIP,(void *)psourip,4);
  1251. memcpy((void *)&pPseudoHead->DestIP,(void *)pdestip,4);
  1252. pPseudoHead->Pad=0;
  1253. pPseudoHead->Proto=IP_PROTO_TCP;
  1254. wlen=len+TCP_HEAD_BYTE_LEN;
  1255. pPseudoHead->Len=swaps(wlen);
  1256. memcpy((void *)pHelpTCPHead,(void *)pTCPHead,wlen);
  1257. wlen=len+TCP_HEAD_BYTE_LEN+PSEUDO_HEAD_LEN;
  1258. pTCPHead->ChkSum=CheckSum((WORD *)HelpBuffer,wlen);
  1259. wlen=len+TCP_HEAD_BYTE_LEN+IP_HEAD_BYTE_LEN+ETHER_HEAD_LEN;
  1260. if(SendPacket(hVxD,Buffer,wlen)==SYSERR) {
  1261. fprintf(stderr,"Can not send TCP packet.n");
  1262. return SYSERR;
  1263. }
  1264. return OK;
  1265. }
  1267. WORD RecvTCPPacket(HANDLE hVxD,
  1268.    struct IPAddr *psourip,
  1269.    struct IPAddr *pdestip,
  1270.    WORD sourport,
  1271.    WORD destport,
  1272.    WORD *flag,
  1273.    DWORD *seqno,
  1274.    DWORD *ackno,
  1275.    char *pbuf,
  1276.    WORD *size)
  1277. {
  1278. BOOL Continue;
  1279. WORD DataLen;
  1280. char Buffer[BUFFER_SIZE];
  1281. struct EtherPacketHead *pEtherHead;
  1282. struct IPPacketHead *pIPHead;
  1283. struct TCPPacketHead *pTCPHead;
  1284. int headlen;
  1285. int totallen;
  1286. char *pdata;
  1289. struct IPAddr *mpsourip,*mpdestip;
  1290. WORD msourport,mdestport,i;
  1291. DWORD mackno,mseqno;
  1293. Continue=TRUE;
  1294. while(Continue) {
  1295. if((DataLen=RecvPacket(hVxD,Buffer))==SYSERR) {
  1296. fprintf(stderr,"Can not recv TCP packet.n");
  1297. return SYSERR;
  1298. }
  1299. pEtherHead=(struct EtherPacketHead *)Buffer;
  1300. if(swaps(pEtherHead->ServType)!=ETHER_PROTO_IP) continue;
  1301. pIPHead=(struct IPPacketHead *)(Buffer+ETHER_HEAD_LEN);
  1302. if(memcmp((void *)&pIPHead->SourIP,(void *)psourip,4)!=0) continue;
  1303. if(memcmp((void *)&pIPHead->DestIP,(void *)pdestip,4)!=0) continue;
  1304. headlen=(pIPHead->VerHLen)&0xf;
  1305. headlen*=4;
  1306. totallen=swaps(pIPHead->TtlLen);
  1307. pTCPHead=(struct TCPPacketHead *)(Buffer+ETHER_HEAD_LEN+headlen);
  1308. if(swaps(pTCPHead->SourPort)!=sourport) continue;
  1309. if(swaps(pTCPHead->DestPort)!=destport) continue;
  1310. /* Get TCP data */
  1311. totallen-=headlen;
  1312. headlen=pTCPHead->HLen>>4;
  1313. headlen*=4;
  1314. totallen-=headlen;
  1315. *flag=pTCPHead->Flag;
  1316. *seqno=swapl(pTCPHead->SeqNo);
  1317. *ackno=swapl(pTCPHead->AckNo);
  1318. *size=totallen;
  1319. pdata=((char *)pTCPHead)+headlen;
  1320. memcpy((void *)pbuf,(void *)pdata,totallen);
  1321. Continue=FALSE;
  1322. }
  1323. return OK;
  1324. }
  1326. void ReadCommand(FILE *pf,char *pbuf)
  1327. {
  1328. while(feof(pf)==0) {
  1329. *pbuf=fgetc(pf);
  1330. if(*pbuf=='n') break;
  1331. pbuf++;
  1332. }
  1333. *pbuf=0;
  1334. }
  1336. WORD GetCommand(char *pbuf)
  1337. {
  1338. char buf[MAX_COMMAND];
  1340. if(*pbuf==0) return INITIAL_END_SEGMENT;
  1341. sscanf(pbuf,"%s",buf);
  1342. ToUpper(buf);
  1343. if(strstr(buf,"SENDARP")!=NULL) return COMMAND_SEND_ARP;
  1344. else if(strstr(buf,"SENDTCP")!=NULL) return COMMAND_SEND_TCP;
  1345. else if(strstr(buf,"RECVTCP")!=NULL) return COMMAND_RECV_TCP;
  1346. else if(strstr(buf,"CONNECT")!=NULL) return COMMAND_CONNECT_TCP;
  1347. else if(strstr(buf,"CLOSE")!=NULL) return COMMAND_CLOSE_TCP;
  1348. else if(buf[0]=='#') return COMMENT;
  1349. else if(strstr(buf,"[IPADDR]")!=NULL) return INITIAL_IP_ADDR;
  1350. else if(strstr(buf,"[NDIS]")!=NULL) return INITIAL_NDIS;
  1351. else if(strstr(buf,"[MAXDATALEN]")!=NULL) return INITIAL_MAX_DATA;
  1352. else if(strstr(buf,"[QUERYIP]")!=NULL) return INITIAL_QUERY_IP;
  1353. else if(strstr(buf,"[QUERYPORT]")!=NULL) return INITIAL_QUERY_PORT;
  1354. else if(strstr(buf,"[TIMEOUT]")!=NULL) return INITIAL_TIMEOUT;
  1355. else return COMMAND_UNKNOWN;
  1356. }
  1358. void ToUpper(char *pbuf)
  1359. {
  1360. char c;
  1362. while(*pbuf) {
  1363. c=*pbuf;
  1364. if(c>='a'&&c<='z') *pbuf=c+'A'-'a';
  1365. pbuf++;
  1366. }
  1367. }
  1369. void GetSendARPArg(char *pbuf,
  1370.    struct EtherAddr *psendeth,
  1371.    struct EtherAddr *precveth,
  1372.    struct EtherAddr *soureth,
  1373.    struct EtherAddr *desteth,
  1374.    struct IPAddr *sourip,
  1375.    struct IPAddr *destip,
  1376.    WORD *oper)
  1377. {
  1378. char pcmd[20],pseth[20],preth[20],psoureth[20],pdesteth[20],psip[20],pdip[20],poper[20];
  1380. /* A line as "SENDARP sendeth recveth soureth sourip desteth destip oper" */
  1381. sscanf(pbuf,"%s %s %s %s %s %s %s %s",
  1382.    pcmd,pseth,preth,psoureth,psip,pdesteth,pdip,poper);
  1383. GetEtherAddr(pseth,psendeth);
  1384. GetEtherAddr(preth,precveth);
  1385. GetEtherAddr(psoureth,soureth);
  1386. GetEtherAddr(pdesteth,desteth);
  1387. GetIPAddr(psip,sourip);
  1388. GetIPAddr(pdip,destip);
  1389. sscanf(poper,"%d",oper);
  1390. }
  1392. void GetSendTCPArg(char *pbuf,WORD *id,char *pdata,WORD *size)
  1393. {
  1394. /* A line as "SENDTCP id data" */
  1395. char pcmd[20],pid[20],Buffer[BUFFER_SIZE];
  1397. sscanf(pbuf,"%s %s %s",pcmd,pid,Buffer);
  1398. sscanf(pid,"%d",id);
  1399. GetDataArg(Buffer,pdata,size);
  1400. }
  1402. void GetRecvTCPArg(char *pbuf,WORD *id)
  1403. {
  1404. /* A line as "RECVTCP id" */
  1405. char pcmd[20],pid[20];
  1407. sscanf(pbuf,"%s %s",pcmd,pid);
  1408. sscanf(pid,"%d",id);
  1409. }
  1411. void GetConnectArg(char *pbuf,
  1412.    struct EtherAddr *sendeth,
  1413.    struct EtherAddr *recveth,
  1414.    struct IPAddr *sourip,
  1415.    struct IPAddr *destip,
  1416.    WORD *sourport,
  1417.    WORD *destport,
  1418.    WORD *id)
  1419. {
  1420. /* A line as "CONNECT sendeth recveth sourip destip sourport destport id" */
  1421. char pcmd[20],psip[20],pdip[20],psport[20],pdport[20],pid[20],pseth[20],preth[20];
  1423. sscanf(pbuf,"%s %s %s %s %s %s %s %s",
  1424.    pcmd,pseth,preth,psip,pdip,psport,pdport,pid);
  1425. GetEtherAddr(pseth,sendeth);
  1426. GetEtherAddr(preth,recveth);
  1427. GetIPAddr(psip,sourip);
  1428. GetIPAddr(pdip,destip);
  1429. sscanf(psport,"%d",sourport);
  1430. sscanf(pdport,"%d",destport);
  1431. sscanf(pid,"%d",id);
  1432. }
  1434. void GetCloseArg(char *pbuf,WORD *id)
  1435. {
  1436. /* A line as "CLOSE id */
  1437. char pcmd[20],pid[20];
  1439. sscanf(pbuf,"%s %s",pcmd,pid);
  1440. sscanf(pid,"%d",id);
  1441. }
  1443. void GetIPAddr(char *pbuf,struct IPAddr *pipaddr)
  1444. {
  1445. char c;
  1447. sscanf(pbuf,"%d%c%d%c%d%c%d",&pipaddr->AddrByte[0],&c,
  1448.    &pipaddr->AddrByte[1],&c,
  1449.    &pipaddr->AddrByte[2],&c,
  1450.    &pipaddr->AddrByte[3]);
  1451. }
  1453. void GetEtherAddr(char *pbuf,struct EtherAddr *pethaddr)
  1454. {
  1455. char c;
  1457. sscanf(pbuf,"%x%c%x%c%x%c%x%c%x%c%x",&pethaddr->AddrByte[0],&c,
  1458.    &pethaddr->AddrByte[1],&c,
  1459.    &pethaddr->AddrByte[2],&c,
  1460.    &pethaddr->AddrByte[3],&c,
  1461.    &pethaddr->AddrByte[4],&c,
  1462.    &pethaddr->AddrByte[5]);
  1463. }
  1465. void GetDataArg(char *pbuf,char *pdata,WORD *size)
  1466. {
  1467. char buf[4];
  1469. (*size)=0;
  1470. while(*pbuf) {
  1471. if(*pbuf=='\') {
  1472. pbuf++;
  1473. memcpy(buf,pbuf,3);
  1474. buf[3]=0;
  1475. sscanf(buf,"%d",pdata);
  1476. pbuf+=2;
  1477. }
  1478. else *pdata=*pbuf;
  1479. pdata++;
  1480. pbuf++;
  1481. (*size)++;
  1482. }
  1483. }
  1485. void PrintData(FILE *pf,BYTE *pdata,int size)
  1486. {
  1487. int i;
  1489. if(size>Max_Data_Len) size=Max_Data_Len;
  1490. for(i=0;i<size;i++) {
  1491. if(pdata[i]<' ') fprintf(pf,"\%03d",pdata[i]);
  1492. else fprintf(pf,"%c",pdata[i]);
  1493. }
  1494. }