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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
PACKET32.C
资源名称：packet32.zip　[点击查看]
上传用户：d748196
上传日期：2007-01-07
资源大小：42k
文件大小：18k
源码类别：

网络截获/分析

开发平台：

WINDOWS

PACKET32.C：源码内容
  1. // packet32.c - PacketInit PacketOpenAdapter PacketCloseAdapter
  2. //              PacketAllocatePacket PacketFreePacket PacketInitPacket
  3. //              PacketSendPacket PacketReceivePacket PacketWaitPacket
  4. //              PacketResetAdapter PacketRequest PacketSetFilter
  5. //              PacketGetAddr StartPacketDriver PacketGetAdapterNames
  6. //              PacketGetName
  7. // 
  8. // Author: Christopher Chlap chrisc@fir.canberra.edu.au 28. November, 1997
  9. //
  11. // #define UNICODE 1
  13. #include <windows.h>
  14. #include <windowsx.h>
  16. #include "packet32.h"
  18. //------------------------------------------------------------------------
  19. //
  20. //  Globals
  21. //
  22. //------------------------------------------------------------------------
  24. TCHAR   szWindowTitle[] = TEXT("PACKET32.DLL");
  26. //------------------------------------------------------------------------
  27. //
  28. //  Prototypes
  29. //
  30. //------------------------------------------------------------------------
  32. #if DBG
  34. #define ODS(_x) OutputDebugString(TEXT(_x))
  36. #else
  38. #define ODS(_x)
  40. #endif
  42. BOOLEAN StartPacketDriver(LPTSTR ServiceName);
  44. //------------------------------------------------------------------------
  45. //
  46. //  PacketInit - Start the Packet Driver
  47. //
  48. //      Args:   DllHandle   - not used
  49. //              Option      - attach or detach
  50. //              Context     - not used
  51. //
  52. //------------------------------------------------------------------------
  54. BOOLEAN PacketInit(
  55.     IN PVOID DllHandle,
  56.     IN ULONG Option,
  57.     IN PCONTEXT Context OPTIONAL)
  59. {
  60.     BOOLEAN     Status;
  62.     ODS("Packet32: DllEntryn");
  65.     switch (Option) {
  67.         case DLL_PROCESS_ATTACH:
  69.             Status = StartPacketDriver(TEXT("PACKET"));
  71.         case DLL_PROCESS_DETACH:
  73.         default:
  75.             break;
  76.     }
  77.     return Status;
  78. }
  80. //------------------------------------------------------------------------
  81. //
  82. //  PacketOpenAdapter - Open the named adapter
  83. //
  84. //      Args:   AdapterName - the UNICODE registry name of the adapter
  85. //
  86. //   Returns:   pointer to an Adapter or NULL
  87. // 
  88. //------------------------------------------------------------------------
  90. PVOID PacketOpenAdapter(LPTSTR AdapterName)
  91. {
  92.     LPADAPTER  lpAdapter;
  93.     BOOLEAN    Result;
  95.     ODS("Packet32: PacketOpenAdaptern");
  97.     lpAdapter = (LPADAPTER)GlobalAllocPtr(
  98.                     GMEM_MOVEABLE | GMEM_ZEROINIT,
  99.                     sizeof(ADAPTER));
  102.     if (lpAdapter == NULL) {
  104.         ODS("Packet32: PacketOpenAdapter GlobalAlloc Failedn");
  105.         return NULL;
  106.     }
  108.     wsprintf(
  109.         lpAdapter->SymbolicLink,
  110.         TEXT("\\.\%s%s"),
  111.         DOSNAMEPREFIX,
  112.         &AdapterName[8]);
  114.     Result = DefineDosDevice(
  115.         DDD_RAW_TARGET_PATH,
  116.         &lpAdapter->SymbolicLink[4],
  117.         AdapterName);
  119.     if (Result) {
  121.         lpAdapter->hFile = CreateFile(lpAdapter->SymbolicLink,
  122.                                 GENERIC_WRITE | GENERIC_READ,
  123.                                 0,
  124.                                 NULL,
  125.                                 CREATE_ALWAYS,
  126.                                 FILE_FLAG_OVERLAPPED,
  127.                                 0);
  129.         if (lpAdapter->hFile != INVALID_HANDLE_VALUE)
  131.             return lpAdapter;
  132.     }
  134.     ODS("Packet32: PacketOpenAdapter Could not open adaptern");
  136.     GlobalFreePtr(lpAdapter);
  138.     return NULL;
  140. }
  142. //------------------------------------------------------------------------
  143. //
  144. //  PacketCloseAdapter - Close the specified adapter
  145. //
  146. //      Args:   lpAdapter - pointer to an adapter object
  147. //
  148. //   Returns:   
  149. // 
  150. //------------------------------------------------------------------------
  152. VOID PacketCloseAdapter(LPADAPTER lpAdapter)
  154. {
  155.     ODS("Packet32: PacketCloseAdaptern");
  157.     CloseHandle(lpAdapter->hFile);
  159.     GlobalFreePtr(lpAdapter);
  161. }
  163. //------------------------------------------------------------------------
  164. //
  165. //  PacketAllocatePacket - allocate a Packet for send and receive
  166. //
  167. //      Args:   none
  168. //
  169. //   Returns:   pointer to a Packet or NULL   
  170. // 
  171. //------------------------------------------------------------------------
  173. PVOID PacketAllocatePacket()
  175. {
  176.     LPPACKET    lpPacket;
  178.     lpPacket = (LPPACKET)GlobalAllocPtr(
  179.                              GMEM_MOVEABLE | GMEM_ZEROINIT,
  180.                              sizeof(PACKET));
  182.     if (lpPacket == NULL) {
  184.         ODS("Packet32: PacketAllocateSendPacket: GlobalAlloc Failedn");
  185.         return NULL;
  186.     }
  188.     lpPacket->OverLapped.hEvent=CreateEvent(NULL, FALSE, FALSE, NULL);
  190.     if (lpPacket->OverLapped.hEvent == NULL) {
  192.         ODS("Packet32: PacketAllocateSendPacket: CreateEvent Failedn");
  194.         GlobalFreePtr(lpPacket);
  196.         return NULL;
  197.     }
  198.     return lpPacket;
  199. }
  201. //------------------------------------------------------------------------
  202. //
  203. //  PacketFreePacket - release a Packet
  204. //
  205. //      Args:   lpPacket - pointer to a Packet
  206. //
  207. //   Returns:
  208. // 
  209. //------------------------------------------------------------------------
  211. VOID PacketFreePacket(LPPACKET lpPacket)
  213. {
  214.     CloseHandle(lpPacket->OverLapped.hEvent);
  216.     GlobalFreePtr(lpPacket);
  217. }
  219. //------------------------------------------------------------------------
  220. //
  221. //  PacketInitPacket - initialize an allocated Packet
  222. //
  223. //      Args:   lpPacket - pointer to a Packet
  224. //              Buffer   - buffer pointer
  225. //              Length   - length of buffer
  226. //
  227. //   Returns:
  228. // 
  229. //------------------------------------------------------------------------
  231. VOID PacketInitPacket(LPPACKET lpPacket, PVOID Buffer, UINT Length)
  232. {
  233.     lpPacket->Buffer = Buffer;
  234.     lpPacket->Length = Length;
  235. }
  237. //------------------------------------------------------------------------
  238. //
  239. //  PacketSendPacket - send a Packet
  240. //
  241. //      Args:   lpAdapter - pointer to an Adapter
  242. //              lpPacket  - pointer to a Packet
  243. //              Sync      - synchronous or asynchronous I/O
  244. //
  245. //   Returns:   TRUE - synchronous operation completed or
  246. //                     asynchronous operation is pending
  247. // 
  248. //------------------------------------------------------------------------
  250. BOOLEAN PacketSendPacket(LPADAPTER lpAdapter,
  251.                          LPPACKET lpPacket,
  252.                          BOOLEAN Sync)
  253. {
  254.     BOOLEAN Result;
  256.     DWORD   BytesTransfered;
  258.     lpPacket->OverLapped.Offset = 0;
  259.     lpPacket->OverLapped.OffsetHigh = 0;
  261.     if (!ResetEvent(lpPacket->OverLapped.hEvent)) return FALSE;
  263.     Result=WriteFile(lpAdapter->hFile,
  264.                      lpPacket->Buffer,
  265.                      lpPacket->Length,
  266.                      &BytesTransfered,
  267.                      &lpPacket->OverLapped);
  269.     if (Sync) Result = GetOverlappedResult(lpAdapter->hFile,
  270.                                            &lpPacket->OverLapped,
  271.                                            &BytesTransfered,
  272.                                            TRUE);
  273.     else 
  274.     
  275.         Result = TRUE;
  277.     return Result;
  278. }
  280. //------------------------------------------------------------------------
  281. //
  282. //  PacketReceivePacket - receive a Packet
  283. //
  284. //      Args:   lpAdapter   - pointer to an Adapter
  285. //              lpPacket    - pointer to a Packet
  286. //              Sync        - synchronous or asynchronous I/O
  287. //              BytesReveived   - pointer to number of bytes received
  288. //
  289. //   Returns:   TRUE  - synchronous operation completed or
  290. //                      asynchronous operation is pending
  291. // 
  292. //------------------------------------------------------------------------
  294. BOOLEAN PacketReceivePacket(LPADAPTER lpAdapter,
  295.                             LPPACKET  lpPacket,
  296.                             BOOLEAN   Sync,
  297.                             PULONG    BytesReceived)
  298. {
  299.     BOOLEAN Result;
  301.     lpPacket->OverLapped.Offset = 0;
  302.     lpPacket->OverLapped.OffsetHigh = 0;
  304.     if (!ResetEvent(lpPacket->OverLapped.hEvent)) return FALSE;
  306.     Result = ReadFile(lpAdapter->hFile,
  307.                       lpPacket->Buffer,
  308.                       lpPacket->Length,
  309.                       BytesReceived,
  310.                       &lpPacket->OverLapped);
  312.     if (Sync) Result = GetOverlappedResult(lpAdapter->hFile,
  313.                                            &lpPacket->OverLapped,
  314.                                            BytesReceived,
  315.                                            TRUE);
  316.     else 
  317.         
  318.         Result = TRUE;
  320.     return Result;
  322. }
  324. //------------------------------------------------------------------------
  325. //
  326. //  PacketWaitPacket - wait for an asynchronous operation to complete
  327. //
  328. //      Args:   lpAdapter     - pointer to an Adapter object
  329. //              lpPacket      - pointer to a Packet
  330. //              BytesReceived - pointer to a bytes received ULONG
  331. //
  332. //   Returns:   result of asynchronous operation
  333. // 
  334. //------------------------------------------------------------------------
  336. BOOLEAN PacketWaitPacket(LPADAPTER lpAdapter,
  337.                          LPPACKET  lpPacket,
  338.                          PULONG    BytesReceived)
  339. {
  340.     return GetOverlappedResult(lpAdapter->hFile,
  341.                                &lpPacket->OverLapped,
  342.                                BytesReceived,
  343.                                TRUE);
  344. }
  346. //------------------------------------------------------------------------
  347. //
  348. //  PacketResetAdapter - reset adapter, completing all pending operations
  349. //
  350. //      Args:   lpAdapter - pointer to an Adapter
  351. //
  352. //   Returns:   TRUE
  353. // 
  354. //------------------------------------------------------------------------
  356. BOOLEAN PacketResetAdapter(LPADAPTER lpAdapter)
  357. {
  358.     UINT    BytesReturned;
  360.     DeviceIoControl(lpAdapter,
  361.                     (DWORD)IOCTL_PROTOCOL_RESET,
  362.                     NULL,
  363.                     0,
  364.                     NULL,
  365.                     0,
  366.                     &BytesReturned,
  367.                     NULL);
  369.     return TRUE;
  370. }
  372. //------------------------------------------------------------------------
  373. //
  374. //  PacketRequest - issue a request to an adapter
  375. //
  376. //      Args:   lpAdapter - pointer to an Adapter
  377. //              Set       - set OID if TRUE else get OID
  378. //              OidData - pointer to OID data
  379. //
  380. //   Returns:   Number of bytes returned   
  381. // 
  382. //------------------------------------------------------------------------
  384. ULONG PacketRequest(LPADAPTER lpAdapter,
  385.                     BOOLEAN   Set,
  386.                     PPACKET_OID_DATA OidData)
  387. {
  388.     UINT       BytesReturned = 0;
  389.     UINT       Result;
  391.     Result = DeviceIoControl(lpAdapter->hFile,
  392.     (DWORD) Set ? IOCTL_PROTOCOL_SET_OID : IOCTL_PROTOCOL_QUERY_OID, OidData,
  393.                              sizeof(PACKET_OID_DATA)-1+OidData->Length,
  394.                              OidData,
  395.                              sizeof(PACKET_OID_DATA)-1+OidData->Length,
  396.                              &BytesReturned,
  397.                              NULL);
  398.     return BytesReturned;
  399. }
  401. //------------------------------------------------------------------------
  402. //
  403. //  PacketSetFilter - issue a set filter request to an adapter
  404. //
  405. //      Args:   lpAdapter  - pointer to an Adapter
  406. //              Filter     - filter to set
  407. //
  408. //   Returns:   
  409. // 
  410. //------------------------------------------------------------------------
  412. BOOLEAN PacketSetFilter(LPADAPTER lpAdapter, ULONG Filter)
  414. {
  416.     BOOLEAN Status;
  418.     ULONG   IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+sizeof(ULONG)-1);
  420.     PPACKET_OID_DATA OidData;
  422.     OidData = GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT, IoCtlBufferLength);
  424.     if (OidData == NULL) return FALSE;
  426.     OidData->Oid = OID_GEN_CURRENT_PACKET_FILTER;
  427.     OidData->Length = sizeof(ULONG);
  428.     *((PULONG)OidData->Data) = Filter;
  430.     Status = PacketRequest(lpAdapter, TRUE, OidData);
  432.     GlobalFreePtr(OidData);
  434.     return Status;
  435. }
  437. //------------------------------------------------------------------------
  438. //
  439. //  PacketGetAddress - issue a get address request to an adapter
  440. //
  441. //      Args:   lpAdapter     - pointer to an Adapter
  442. //              AddressBuffer - buffer to hold the address
  443. //
  444. //   Returns:   number of bytes copied to address buffer   
  445. // 
  446. //------------------------------------------------------------------------
  448. ULONG PacketGetAddress(LPADAPTER lpAdapter, PUCHAR AddressBuffer)
  449.                              
  450. {
  452.     ULONG   Result;
  453.     
  454.     BYTE iBuf[sizeof(PACKET_OID_DATA) + 128];
  456.     PPACKET_OID_DATA pOidData = (PPACKET_OID_DATA) iBuf;
  458.     pOidData->Oid = OID_802_3_CURRENT_ADDRESS;
  459.     pOidData->Length = 6;
  460.     pOidData->Data[0] = 0;
  462.     Result = PacketRequest(lpAdapter, 0, pOidData);
  464.     if (Result > 0) {
  465.         memcpy(AddressBuffer, &iBuf[8], 6);
  466.         Result = 6;
  467.     }
  468.     else
  469.         Result = 0;
  470.         
  471.     return Result;
  472. }
  474. //------------------------------------------------------------------------
  475. //
  476. //  StartPacketDriver - starts the kernel mode packet driver
  477. //
  478. //      Args:   ServiceName - name of service to start
  479. //
  480. //   Returns:   
  481. // 
  482. //------------------------------------------------------------------------
  484. BOOLEAN StartPacketDriver(LPTSTR ServiceName)
  486. {
  487.     BOOLEAN  Status;
  489.     SC_HANDLE  SCManagerHandle;
  490.     SC_HANDLE  SCServiceHandle;
  492.     // Open a handle to the SC Manager database.
  494.     SCManagerHandle = OpenSCManager(NULL,       // local machine
  495.                                     NULL,       // ServicesActive database
  496.                                     SC_MANAGER_ALL_ACCESS);
  498.     if (SCManagerHandle==NULL) {
  500.         MessageBox(NULL,TEXT("Could not open SC"), szWindowTitle, MB_OK);
  502.         return FALSE;
  504.     } else {
  506.         SCServiceHandle = OpenService(SCManagerHandle,
  507.                                       ServiceName,
  508.                                       SERVICE_START);
  510.         if (SCServiceHandle == NULL)
  512.             MessageBox(NULL,TEXT("Could not open service"),szWindowTitle,MB_OK);
  514.         Status = StartService(SCServiceHandle, 0, NULL);
  516.         if (!Status) {
  518.             if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING) {
  520.                 ODS("Packet32: Packet service already startedn");
  522.                 return TRUE;
  523.             }
  524.         }
  525.         return Status;
  526.     }
  527. }
  529. //------------------------------------------------------------------------
  530. //
  531. //  PacketGetAdapterNames - returns the names of all available adapters
  532. //
  533. //      Args:   pStr   - pointer to buffer for UNICODE names
  534. //              pSize  - address of ulong containing string length
  535. //
  536. //   Returns:   
  537. // 
  538. //------------------------------------------------------------------------
  540. ULONG PacketGetAdapterNames(PTSTR pStr, PULONG pSize)
  542. {
  544.     HKEY    SystemKey;
  545.     HKEY    ControlSetKey;
  546.     HKEY    ServicesKey;
  547.     HKEY    NdisPerfKey;
  548.     HKEY    LinkageKey;
  549.     LONG    Status;
  551.     DWORD   RegType;
  553.     Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  554.                           TEXT("SYSTEM"),
  555.                           0,
  556.                           KEY_READ,
  557.                           &SystemKey);
  559.     if (Status == ERROR_SUCCESS) {
  561.         Status = RegOpenKeyEx(SystemKey,
  562.                               TEXT("CurrentControlSet"),
  563.                               0,
  564.                               KEY_READ,
  565.                               &ControlSetKey);
  567.         if (Status == ERROR_SUCCESS) {
  569.             Status = RegOpenKeyEx(ControlSetKey,
  570.                                   TEXT("Services"),
  571.                                   0,
  572.                                   KEY_READ,
  573.                                   &ServicesKey);
  575.             if (Status == ERROR_SUCCESS) {
  577.                 Status = RegOpenKeyEx(ServicesKey,
  578.                                       TEXT("Packet"),
  579.                                       0,
  580.                                       KEY_READ,
  581.                                       &NdisPerfKey);
  583.                 if (Status == ERROR_SUCCESS) {
  585.                     Status = RegOpenKeyEx(NdisPerfKey,
  586.                                           TEXT("Linkage"),
  587.                                           0,
  588.                                           KEY_READ,
  589.                                           &LinkageKey);
  591.                     if (Status == ERROR_SUCCESS) {
  593.                         Status = RegQueryValueEx(LinkageKey,
  594.                                                  TEXT("Export"),
  595.                                                  NULL,
  596.                                                  &RegType,
  597.                                                  (LPBYTE)pStr,
  598.                                                  pSize);
  600.                         RegCloseKey(LinkageKey);
  601.                     }
  603.                     RegCloseKey(NdisPerfKey);
  604.                 }
  606.                 RegCloseKey(ServicesKey);
  607.             }
  609.             RegCloseKey(ControlSetKey);
  610.         }
  612.         RegCloseKey(SystemKey);
  613.     }
  614.     return Status;
  615. }
  617. //------------------------------------------------------------------------
  618. //
  619. //  PacketGetName - returns the name of a specified adapter
  620. //
  621. //      Args:   pStr - pointer to buffer for a UNICODE name
  622. //              n    - which name to return
  623. //
  624. //   Returns:   TRUE  if the n'th name was found
  625. //              FALSE if the n'th name does not exist   
  626. // 
  627. //------------------------------------------------------------------------
  629. ULONG PacketGetName(PTSTR pStr, ULONG n)
  630. {
  631.     TCHAR   buf[256];
  632.     TCHAR   *Name;
  633.     ULONG   NameLength = 256;
  635.     Name = buf;
  636.         
  637.     PacketGetAdapterNames(Name, &NameLength);
  639.     switch (n) {
  640.         case 3: Name = &Name[strlen(Name)+1];
  641.                 if (!strlen(Name))
  642.                     break;
  643.         case 2: Name = (char *) &Name[strlen(Name)+1];
  644.                 if (!strlen(Name))
  645.                     break;
  646.         case 1: Name = (char *) &Name[strlen(Name)+1];
  647.                 if (!strlen(Name))
  648.                     break;
  649.         case 0: break;
  650.     }
  651.     
  652.     if (strlen(Name) != 0) {
  653.         strcpy(pStr, Name);
  654.         return TRUE;
  655.         }
  656.     else
  657.         return FALSE;
  658. }