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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
ethsock.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：44k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

ethsock.cxx：源码内容
  1. /*
  2.  * ethsock.cxx
  3.  *
  4.  * Direct Ethernet socket implementation.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: ethsock.cxx,v $
  30.  * Revision 1.21  2000/03/06 03:59:22  robertj
  31.  * Fixed warning about handle types, thanks Steve Bennett
  32.  *
  33.  * Revision 1.20  1999/10/29 03:34:19  robertj
  34.  * Fixed possible crash accessing IP addresses from SNMP tables.
  35.  *
  36.  * Revision 1.19  1999/10/14 01:34:55  robertj
  37.  * Fixed backward compatibility problem with old SNMP header file.
  38.  *
  39.  * Revision 1.18  1999/09/10 04:35:42  robertj
  40.  * Added Windows version of PIPSocket::GetInterfaceTable() function.
  41.  *
  42.  * Revision 1.17  1999/04/18 12:58:39  robertj
  43.  * MSVC 5 backward compatibility
  44.  *
  45.  * Revision 1.16  1999/02/16 08:08:06  robertj
  46.  * MSVC 6.0 compatibility changes.
  47.  *
  48.  * Revision 1.15  1998/11/30 04:48:38  robertj
  49.  * New directory structure
  50.  *
  51.  * Revision 1.14  1998/11/22 11:30:10  robertj
  52.  * Check route table function to get a list
  53.  *
  54.  * Revision 1.13  1998/11/20 03:17:43  robertj
  55.  * Split rad and write buffers to separate pools.
  56.  *
  57.  * Revision 1.12  1998/11/19 05:18:48  robertj
  58.  * Added route table manipulation functions to PIPSocket class.
  59.  *
  60.  * Revision 1.11  1998/11/14 06:31:41  robertj
  61.  * Changed semantics of os_sendto to return TRUE if ANY bytes are sent.
  62.  * Added support for MSDUN1.3 DHCP registry entries.
  63.  *
  64.  * Revision 1.10  1998/10/23 04:09:08  robertj
  65.  * Fixes for NT support.
  66.  * Allowed both old and new driver by compilation option.
  67.  *
  68.  * Revision 1.9  1998/10/15 05:41:48  robertj
  69.  * New memory leak check code.
  70.  *
  71.  * Revision 1.8  1998/10/12 09:34:42  robertj
  72.  * New method for getting IP addresses of interfaces.
  73.  *
  74.  * Revision 1.7  1998/10/06 10:24:41  robertj
  75.  * Fixed hang when using reset command, removed the command!
  76.  *
  77.  * Revision 1.6  1998/09/24 03:30:45  robertj
  78.  * Added open software license.
  79.  *
  80.  * Revision 1.5  1998/09/15 08:25:36  robertj
  81.  * Fixed a number of warnings at maximum optimisation.
  82.  *
  83.  * Revision 1.4  1998/09/08 15:14:36  robertj
  84.  * Fixed packet type based filtering in Read() function.
  85.  *
  86.  * Revision 1.3  1998/08/25 11:03:15  robertj
  87.  * Fixed proble with NT get of OID.
  88.  * Fixed bug with not setting channel name when interface opened.
  89.  *
  90.  * Revision 1.2  1998/08/21 05:27:13  robertj
  91.  * Fine tuning of interface.
  92.  *
  93.  * Revision 1.1  1998/08/20 06:04:52  robertj
  94.  * Initial revision
  95.  *
  96.  */
  98. #include <ptlib.h>
  99. #include <ptlib/sockets.h>
  100. #include <snmp.h>
  103. ///////////////////////////////////////////////////////////////////////////////
  104. // Stuff from snmp.h
  106. #ifndef RFC1157VarBindList
  107. typedef RFC1157VarBind SnmpVarBind;
  108. typedef RFC1157VarBindList SnmpVarBindList;
  109. typedef LONG AsnInteger32;
  110. #define SNMP_PDU_GET ASN_RFC1157_GETREQUEST
  111. #define SNMP_PDU_GETNEXT ASN_RFC1157_GETNEXTREQUEST
  112. #define ASN_IPADDRESS    ASN_RFC1155_IPADDRESS // Prevents GetInterfaceTable failure
  113. #pragma message("Later version of snmp.h required!")
  114. #endif
  116. ///////////////////////////////////////////////////////////////////////////////
  117. // Stuff from ndis.h
  119. #define OID_802_3_PERMANENT_ADDRESS         0x01010101
  120. #define OID_802_3_CURRENT_ADDRESS           0x01010102
  122. #define OID_GEN_DRIVER_VERSION              0x00010110
  123. #define OID_GEN_CURRENT_PACKET_FILTER       0x0001010E
  124. #define OID_GEN_MEDIA_SUPPORTED             0x00010103
  126. #define NDIS_PACKET_TYPE_DIRECTED           0x0001
  127. #define NDIS_PACKET_TYPE_MULTICAST          0x0002
  128. #define NDIS_PACKET_TYPE_ALL_MULTICAST      0x0004
  129. #define NDIS_PACKET_TYPE_BROADCAST          0x0008
  130. #define NDIS_PACKET_TYPE_PROMISCUOUS        0x0020
  132. typedef enum _NDIS_MEDIUM {
  133.     NdisMedium802_3,
  134.     NdisMedium802_5,
  135.     NdisMediumFddi,
  136.     NdisMediumWan,
  137.     NdisMediumLocalTalk,
  138.     NdisMediumDix,              // defined for convenience, not a real medium
  139.     NdisMediumArcnetRaw,
  140.     NdisMediumArcnet878_2
  141. } NDIS_MEDIUM, *PNDIS_MEDIUM;                    
  143. ///////////////////////////////////////////////////////////////////////////////
  146. #define USE_VPACKET
  147. #include <ptlib/epacket.h>
  150. #ifdef USE_VPACKET
  151. #define PACKET_SERVICE_NAME "Packet"
  152. #define PACKET_VXD_NAME     "VPacket"
  153. #else
  154. #define PACKET_SERVICE_NAME "EPacket"
  155. #define PACKET_VXD_NAME     "EPacket"
  156. #define GetQueryOidCommand(oid) IOCTL_EPACKET_QUERY_OID
  157. #endif
  159. #define SERVICES_REGISTRY_KEY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\"
  162. ///////////////////////////////////////////////////////////////////////////////
  164. class PWin32AsnAny : public AsnAny
  165. {
  166.   public:
  167.     PWin32AsnAny();
  168.     PWin32AsnAny(const AsnAny & any)  { memcpy(this, &any, sizeof(*this)); }
  169.     ~PWin32AsnAny();
  170.     BOOL GetInteger(AsnInteger & i);
  171.     BOOL GetIpAddress(PIPSocket::Address & addr);
  172. };
  175. ///////////////////////////////////////////////////////////////////////////////
  177. class PWin32AsnOid : public AsnObjectIdentifier
  178. {
  179.   public:
  180.     PWin32AsnOid();
  181.     PWin32AsnOid(const char * str);
  182.     PWin32AsnOid(const AsnObjectIdentifier & oid);
  183.     PWin32AsnOid(const PWin32AsnOid & oid)              { SnmpUtilOidCpy(this, (AsnObjectIdentifier *)&oid); }
  184.     void Free()                                         { SnmpUtilOidFree(this); }
  185.     PWin32AsnOid & operator=(const AsnObjectIdentifier&);
  186.     PWin32AsnOid & operator=(const PWin32AsnOid & oid)  { SnmpUtilOidCpy(this, (AsnObjectIdentifier *)&oid); return *this; }
  187.     PWin32AsnOid & operator+=(const PWin32AsnOid & oid) { SnmpUtilOidAppend(this, (AsnObjectIdentifier *)&oid); return *this; }
  188.     UINT & operator[](int idx)                          { return ids[idx]; }
  189.     UINT   operator[](int idx) const                    { return ids[idx]; }
  190.     bool operator==(const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) == 0; }
  191.     bool operator!=(const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) != 0; }
  192.     bool operator< (const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) <  0; }
  193.     bool operator<=(const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) <= 0; }
  194.     bool operator> (const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) >  0; }
  195.     bool operator>=(const PWin32AsnOid & oid)           { return SnmpUtilOidCmp(this, (AsnObjectIdentifier *)&oid) >= 0; }
  196.     bool operator*=(const PWin32AsnOid & oid)           { return SnmpUtilOidNCmp(this, (AsnObjectIdentifier *)&oid, idLength) == 0; }
  197. };
  200. /////////////////////////////////////////////////////////////////////////////
  202. class PWin32SnmpLibrary : public PDynaLink
  203. {
  204.   PCLASSINFO(PWin32SnmpLibrary, PDynaLink)
  205.   public:
  206.     PWin32SnmpLibrary();
  208.     BOOL GetOid(AsnObjectIdentifier & oid, AsnInteger & value);
  209.     BOOL GetOid(AsnObjectIdentifier & oid, PIPSocket::Address & ip_address);
  210.     BOOL GetOid(AsnObjectIdentifier & oid, void * value, UINT valSize, UINT * len = NULL);
  211.     BOOL GetOid(AsnObjectIdentifier & oid, AsnAny & value);
  213.     BOOL GetNextOid(AsnObjectIdentifier & oid, AsnAny & value);
  215.     PString GetInterfaceName(int ifNum);
  216.     PString GetInterfaceName(PIPSocket::Address ipAddr);
  218.   private:
  219.     BOOL (WINAPI *Init)(DWORD,HANDLE*,AsnObjectIdentifier*);
  220.     BOOL (WINAPI *Query)(BYTE,SnmpVarBindList*,AsnInteger32*,AsnInteger32*);
  222.     HANDLE hEvent;
  223.     AsnObjectIdentifier baseOid;
  224. };
  227. ///////////////////////////////////////////////////////////////////////////////
  229. class PWin32OidBuffer
  230. {
  231.   public:
  232.     PWin32OidBuffer(UINT oid, UINT len, const BYTE * data = NULL);
  233.     ~PWin32OidBuffer() { delete buffer; }
  235.     operator void *()         { return buffer; }
  236.     operator DWORD ()         { return size; }
  237.     DWORD operator [](int i)  { return buffer[i]; }
  239.     void Move(BYTE * data, DWORD received);
  241.   private:
  242.     DWORD * buffer;
  243.     UINT size;
  244. };
  247. ///////////////////////////////////////////////////////////////////////////////
  249. class PWin32PacketDriver
  250. {
  251.   public:
  252.     static PWin32PacketDriver * Create();
  254.     virtual ~PWin32PacketDriver();
  256.     BOOL IsOpen() const;
  257.     void Close();
  258.     DWORD GetLastError() const;
  260.     virtual BOOL EnumInterfaces(PINDEX idx, PString & name) = 0;
  261.     virtual BOOL BindInterface(const PString & interfaceName) = 0;
  263.     virtual BOOL EnumIpAddress(PINDEX idx, PIPSocket::Address & addr, PIPSocket::Address & net_mask) = 0;
  265.     virtual BOOL BeginRead(void * buf, DWORD size, DWORD & received, PWin32Overlapped & overlap) = 0;
  266.     virtual BOOL BeginWrite(const void * buf, DWORD len, PWin32Overlapped & overlap) = 0;
  267.     BOOL CompleteIO(DWORD & received, PWin32Overlapped & overlap);
  269.     BOOL IoControl(UINT func,
  270.                    const void * input, DWORD inSize,
  271.                    void * output, DWORD outSize,
  272.                    DWORD & received);
  274.     BOOL QueryOid(UINT oid, DWORD & data);
  275.     BOOL QueryOid(UINT oid, UINT len, BYTE * data);
  276.     BOOL SetOid(UINT oid, DWORD data);
  277.     BOOL SetOid(UINT oid, UINT len, const BYTE * data);
  278. #ifdef USE_VPACKET
  279.     virtual UINT GetQueryOidCommand(DWORD oid) const = 0;
  280. #endif
  282.   protected:
  283.     PWin32PacketDriver();
  285.     DWORD dwError;
  286.     HANDLE hDriver;
  287. };
  290. ///////////////////////////////////////////////////////////////////////////////
  292. class PWin32PacketVxD : public PWin32PacketDriver
  293. {
  294.   public:
  295.     virtual BOOL EnumInterfaces(PINDEX idx, PString & name);
  296.     virtual BOOL BindInterface(const PString & interfaceName);
  298.     virtual BOOL EnumIpAddress(PINDEX idx, PIPSocket::Address & addr, PIPSocket::Address & net_mask);
  300.     virtual BOOL BeginRead(void * buf, DWORD size, DWORD & received, PWin32Overlapped & overlap);
  301.     virtual BOOL BeginWrite(const void * buf, DWORD len, PWin32Overlapped & overlap);
  303. #ifdef USE_VPACKET
  304.     virtual UINT GetQueryOidCommand(DWORD oid) const
  305.       { return oid >= OID_802_3_PERMANENT_ADDRESS ? IOCTL_EPACKET_QUERY_OID : IOCTL_EPACKET_STATISTICS; }
  306. #endif
  308.   protected:
  309.     PStringList transportBinding;
  310. };
  313. ///////////////////////////////////////////////////////////////////////////////
  315. class PWin32PacketSYS : public PWin32PacketDriver
  316. {
  317.   public:
  318.     PWin32PacketSYS();
  320.     virtual BOOL EnumInterfaces(PINDEX idx, PString & name);
  321.     virtual BOOL BindInterface(const PString & interfaceName);
  323.     virtual BOOL EnumIpAddress(PINDEX idx, PIPSocket::Address & addr, PIPSocket::Address & net_mask);
  325.     virtual BOOL BeginRead(void * buf, DWORD size, DWORD & received, PWin32Overlapped & overlap);
  326.     virtual BOOL BeginWrite(const void * buf, DWORD len, PWin32Overlapped & overlap);
  328. #ifdef USE_VPACKET
  329.     virtual UINT GetQueryOidCommand(DWORD) const
  330.       { return IOCTL_EPACKET_QUERY_OID; }
  331. #endif
  333.   protected:
  334.     PString registryKey;
  335. };
  338. /////////////////////////////////////////////////////////////////////////////
  340. class PWin32PacketBuffer : public PBYTEArray
  341. {
  342.   PCLASSINFO(PWin32PacketBuffer, PBYTEArray)
  343.   public:
  344.     enum Statuses {
  345.       Uninitialised,
  346.       Progressing,
  347.       Completed
  348.     };
  350.     PWin32PacketBuffer(PINDEX sz);
  352.     PINDEX GetData(void * buf, PINDEX size);
  353.     PINDEX PutData(const void * buf, PINDEX length);
  354.     HANDLE GetEvent() const { return overlap.hEvent; }
  356.     BOOL ReadAsync(PWin32PacketDriver & pkt);
  357.     BOOL ReadComplete(PWin32PacketDriver & pkt);
  358.     BOOL WriteAsync(PWin32PacketDriver & pkt);
  359.     BOOL WriteComplete(PWin32PacketDriver & pkt);
  361.     BOOL InProgress() const { return status == Progressing; }
  362.     BOOL IsCompleted() const { return status == Completed; }
  363.     BOOL IsType(WORD type) const;
  365.   protected:
  366.     Statuses         status;
  367.     PWin32Overlapped overlap;
  368.     DWORD            count;
  369. };
  372. #define new PNEW
  375. /////////////////////////////////////////////////////////////////////////////
  377. PWin32AsnAny::PWin32AsnAny()
  378. {
  379.   asnType = ASN_INTEGER;
  380.   asnValue.number = 0;
  381. }
  384. PWin32AsnAny::~PWin32AsnAny()
  385. {
  386.   switch (asnType) {
  387.     case ASN_OCTETSTRING :
  388.       SnmpUtilMemFree(asnValue.string.stream);
  389.       break;
  390. #ifdef ASN_BITS
  391.     case ASN_BITS :
  392.       SnmpUtilMemFree(asnValue.bits.stream);
  393.       break;
  394. #endif
  395.     case ASN_OBJECTIDENTIFIER :
  396.       SnmpUtilMemFree(asnValue.object.ids);
  397.       break;
  398.     case ASN_SEQUENCE :
  399.       SnmpUtilMemFree(asnValue.sequence.stream);
  400.       break;
  401.     case ASN_IPADDRESS :
  402.       SnmpUtilMemFree(asnValue.address.stream);
  403.       break;
  404. #ifdef ASN_OPAQUE
  405.     case ASN_OPAQUE :
  406.       SnmpUtilMemFree(asnValue.arbitrary.stream);
  407.       break;
  408. #endif
  409.   }
  410. }
  413. BOOL PWin32AsnAny::GetInteger(AsnInteger & i)
  414. {
  415.   if (asnType != ASN_INTEGER)
  416.     return FALSE;
  418.   i = asnValue.number;
  419.   return TRUE;
  420. }
  423. BOOL PWin32AsnAny::GetIpAddress(PIPSocket::Address & addr)
  424. {
  425.   if (asnType != ASN_IPADDRESS ||
  426.       asnValue.address.stream == NULL ||
  427.       asnValue.address.length < sizeof(addr))
  428.     return FALSE;
  430.   memcpy(&addr, asnValue.address.stream, sizeof(addr));
  431.   return TRUE;
  432. }
  435. ///////////////////////////////////////////////////////////////////////////////
  437. PWin32AsnOid::PWin32AsnOid()
  438. {
  439.   ids = NULL;
  440.   idLength = 0;
  441. }
  444. PWin32AsnOid::PWin32AsnOid(const AsnObjectIdentifier & oid)
  445. {
  446.   ids = oid.ids;
  447.   idLength = oid.idLength;
  448. }
  451. PWin32AsnOid::PWin32AsnOid(const char * str)
  452. {
  453.   idLength = 0;
  454.   ids = NULL;
  456.   AsnObjectIdentifier oid;
  457.   oid.idLength = 0;
  458.   const char * dot = strchr(str, '.');
  459.   while (dot != NULL) {
  460.     oid.idLength++;
  461.     dot = strchr(dot+1, '.');
  462.   }
  464.   if (oid.idLength > 0) {
  465.     oid.ids = new UINT[++oid.idLength];
  466.     char * next = (char *)str;
  467.     for (UINT i = 0; i < oid.idLength; i++) {
  468.       oid.ids[i] = strtoul(next, &next, 10);
  469.       if (*next != '.')
  470.         break;
  471.       next++;
  472.     }
  474.     if (*next == '')
  475.       SnmpUtilOidCpy(this, &oid);
  477.     delete [] oid.ids;
  478.   }
  479. }
  482. PWin32AsnOid & PWin32AsnOid::operator=(const AsnObjectIdentifier & oid)
  483. {
  484.   ids = oid.ids;
  485.   idLength = oid.idLength;
  486.   return *this;
  487. }
  490. ///////////////////////////////////////////////////////////////////////////////
  492. PWin32SnmpLibrary::PWin32SnmpLibrary()
  493.   : PDynaLink("inetmib1.dll")
  494. {
  495.   if (!GetFunction("SnmpExtensionInit", (Function &)Init) ||
  496.       !GetFunction("SnmpExtensionQuery", (Function &)Query) ||
  497.       !Init(0, &hEvent, &baseOid))
  498.     Close();
  499. }
  502. BOOL PWin32SnmpLibrary::GetOid(AsnObjectIdentifier & oid, AsnInteger & value)
  503. {
  504.   if (!IsLoaded())
  505.     return FALSE;
  507.   PWin32AsnAny any;
  508.   if (!GetOid(oid, any))
  509.     return FALSE;
  511.   return any.GetInteger(value);
  512. }
  515. BOOL PWin32SnmpLibrary::GetOid(AsnObjectIdentifier & oid, PIPSocket::Address & value)
  516. {
  517.   if (!IsLoaded())
  518.     return FALSE;
  520.   PWin32AsnAny any;
  521.   if (!GetOid(oid, any))
  522.     return FALSE;
  524.   return any.GetIpAddress(value);
  525. }
  528. BOOL PWin32SnmpLibrary::GetOid(AsnObjectIdentifier & oid, void * value, UINT valSize, UINT * len)
  529. {
  530.   if (!IsLoaded())
  531.     return FALSE;
  533.   PWin32AsnAny any;
  534.   if (!GetOid(oid, any))
  535.     return FALSE;
  537.   if (any.asnType != ASN_OCTETSTRING)
  538.     return FALSE;
  540.   if (len != NULL)
  541.     *len = any.asnValue.string.length;
  543.   if (any.asnValue.string.length > valSize)
  544.     return FALSE;
  546.   memcpy(value, any.asnValue.string.stream, any.asnValue.string.length);
  547.   if (valSize > any.asnValue.string.length)
  548.     ((char *)value)[any.asnValue.string.length] = '';
  549.   return TRUE;
  550. }
  553. BOOL PWin32SnmpLibrary::GetOid(AsnObjectIdentifier & oid, AsnAny & value)
  554. {
  555.   if (!IsLoaded())
  556.     return FALSE;
  558.   RFC1157VarBind var;
  559.   var.name = oid;
  560.   var.value = value;
  562.   RFC1157VarBindList vars;
  563.   vars.len = 1;
  564.   vars.list = &var;
  566.   AsnInteger status, error;
  567.   if (!Query(SNMP_PDU_GET, &vars, &status, &error))
  568.     return FALSE;
  570.   if (status != SNMP_ERRORSTATUS_NOERROR)
  571.     return FALSE;
  573.   value = var.value;
  574.   oid = var.name;
  575.   return TRUE;
  576. }
  579. BOOL PWin32SnmpLibrary::GetNextOid(AsnObjectIdentifier & oid, AsnAny & value)
  580. {
  581.   if (!IsLoaded())
  582.     return FALSE;
  584.   SnmpVarBind var;
  585.   var.name = oid;
  586.   var.value = value;
  588.   SnmpVarBindList vars;
  589.   vars.len = 1;
  590.   vars.list = &var;
  592.   AsnInteger status, error;
  593.   if (!Query(SNMP_PDU_GETNEXT, &vars, &status, &error))
  594.     return FALSE;
  596.   if (status != SNMP_ERRORSTATUS_NOERROR)
  597.     return FALSE;
  599.   value = var.value;
  600.   oid = var.name;
  601.   return TRUE;
  602. }
  605. PString PWin32SnmpLibrary::GetInterfaceName(int ifNum)
  606. {
  607.   PIPSocket::Address gwAddr = 0;
  608.   PWin32AsnOid baseOid = "1.3.6.1.2.1.4.20.1";
  609.   PWin32AsnOid oid = baseOid;
  610.   PWin32AsnAny value;
  611.   while (GetNextOid(oid, value)) {
  612.     if (!(baseOid *= oid))
  613.       break;
  614.     if (value.asnType != ASN_IPADDRESS)
  615.       break;
  617.     oid[9] = 2;
  618.     AsnInteger ifIndex = -1;
  619.     if (!GetOid(oid, ifIndex) || ifIndex < 0)
  620.       break;
  622.     if (ifIndex == ifNum) {
  623.       value.GetIpAddress(gwAddr);
  624.       break;
  625.     }
  627.     oid[9] = 1;
  628.   }
  630.   if (gwAddr == 0)
  631.     return PString();
  633.   return GetInterfaceName(gwAddr);
  634. }
  637. PString PWin32SnmpLibrary::GetInterfaceName(PIPSocket::Address ipAddr)
  638. {
  639.   PString gatewayInterface, anInterface;
  641.   PWin32PacketDriver * tempDriver = PWin32PacketDriver::Create();
  643.   PINDEX ifIdx = 0;
  644.   while (gatewayInterface.IsEmpty() && tempDriver->EnumInterfaces(ifIdx++, anInterface)) {
  645.     if (tempDriver->BindInterface(anInterface)) {
  646.       PIPSocket::Address ifAddr, ifMask;
  647.       PINDEX ipIdx = 0;
  648.       if (tempDriver->EnumIpAddress(ipIdx++, ifAddr, ifMask) && ifAddr == ipAddr) {
  649.         gatewayInterface = anInterface;
  650.         break;
  651.       }
  652.     }
  653.   }
  655.   delete tempDriver;
  657.   return gatewayInterface;
  658. }
  661. ///////////////////////////////////////////////////////////////////////////////
  663. PWin32OidBuffer::PWin32OidBuffer(UINT oid, UINT len, const BYTE * data)
  664. {
  665.   size = sizeof(DWORD)*2 + len;
  666.   buffer = new DWORD[(size+sizeof(DWORD)-1)/sizeof(DWORD)];
  668.   buffer[0] = oid;
  669.   buffer[1] = len;
  670.   if (data != NULL)
  671.     memcpy(&buffer[2], data, len);
  672. }
  675. void PWin32OidBuffer::Move(BYTE * data, DWORD received)
  676. {
  677.   memcpy(data, &buffer[2], received-sizeof(DWORD)*2);
  678. }
  681. ///////////////////////////////////////////////////////////////////////////////
  683. PWin32PacketDriver * PWin32PacketDriver::Create()
  684. {
  685.   OSVERSIONINFO info;
  686.   info.dwOSVersionInfoSize = sizeof(info);
  687.   GetVersionEx(&info);
  688.   if (info.dwPlatformId == VER_PLATFORM_WIN32_NT)
  689.     return new PWin32PacketSYS;
  690.   else
  691.     return new PWin32PacketVxD;
  692. }
  695. PWin32PacketDriver::PWin32PacketDriver()
  696. {
  697.   hDriver = INVALID_HANDLE_VALUE;
  698.   dwError = ERROR_OPEN_FAILED;
  699. }
  702. PWin32PacketDriver::~PWin32PacketDriver()
  703. {
  704.   Close();
  705. }
  708. void PWin32PacketDriver::Close()
  709. {
  710.   if (hDriver != INVALID_HANDLE_VALUE) {
  711.     CloseHandle(hDriver);
  712.     hDriver = INVALID_HANDLE_VALUE;
  713.   }
  714. }
  717. BOOL PWin32PacketDriver::IsOpen() const
  718. {
  719.   return hDriver != INVALID_HANDLE_VALUE;
  720. }
  723. DWORD PWin32PacketDriver::GetLastError() const
  724. {
  725.   return dwError;
  726. }
  729. BOOL PWin32PacketDriver::IoControl(UINT func,
  730.                               const void * input, DWORD inSize,
  731.                               void * output, DWORD outSize, DWORD & received)
  732. {
  733.   PWin32Overlapped overlap;
  735.   if (DeviceIoControl(hDriver, func,
  736.                       (LPVOID)input, inSize, output, outSize,
  737.                       &received, &overlap)) {
  738.     dwError = ERROR_SUCCESS;
  739.     return TRUE;
  740.   }
  742.   dwError = ::GetLastError();
  743.   if (dwError != ERROR_IO_PENDING)
  744.     return FALSE;
  746.   return CompleteIO(received, overlap);
  747. }
  750. BOOL PWin32PacketDriver::CompleteIO(DWORD & received, PWin32Overlapped & overlap)
  751. {
  752.   received = 0;
  753.   if (GetOverlappedResult(hDriver, &overlap, &received, TRUE)) {
  754.     dwError = ERROR_SUCCESS;
  755.     return TRUE;
  756.   }
  758.   dwError = ::GetLastError();
  759.   return FALSE;
  760. }
  763. BOOL PWin32PacketDriver::QueryOid(UINT oid, UINT len, BYTE * data)
  764. {
  765.   PWin32OidBuffer buf(oid, len);
  766.   DWORD rxsize = 0;
  767.   if (!IoControl(GetQueryOidCommand(oid), buf, buf, buf, buf, rxsize))
  768.     return FALSE;
  770.   if (rxsize == 0)
  771.     return FALSE;
  773.   buf.Move(data, rxsize);
  774.   return TRUE;
  775. }
  778. BOOL PWin32PacketDriver::QueryOid(UINT oid, DWORD & data)
  779. {
  780.   DWORD oidData[3];
  781.   oidData[0] = oid;
  782.   oidData[1] = sizeof(data);
  783.   oidData[2] = 0x12345678;
  785.   DWORD rxsize = 0;
  786.   if (!IoControl(GetQueryOidCommand(oid),
  787.                  oidData, sizeof(oidData),
  788.                  oidData, sizeof(oidData),
  789.                  rxsize))
  790.     return FALSE;
  792.   if (rxsize == 0)
  793.     return FALSE;
  795.   data = oidData[2];
  796.   return TRUE;
  797. }
  800. BOOL PWin32PacketDriver::SetOid(UINT oid, UINT len, const BYTE * data)
  801. {
  802.   DWORD rxsize = 0;
  803.   PWin32OidBuffer buf(oid, len, data);
  804.   return IoControl(IOCTL_EPACKET_SET_OID, buf, buf, buf, buf, rxsize);
  805. }
  808. BOOL PWin32PacketDriver::SetOid(UINT oid, DWORD data)
  809. {
  810.   DWORD oidData[3];
  811.   oidData[0] = oid;
  812.   oidData[1] = sizeof(data);
  813.   oidData[2] = data;
  814.   DWORD rxsize;
  815.   return IoControl(IOCTL_EPACKET_SET_OID,
  816.                    oidData, sizeof(oidData), oidData, sizeof(oidData), rxsize);
  817. }
  820. ///////////////////////////////////////////////////////////////////////////////
  822. BOOL PWin32PacketVxD::EnumInterfaces(PINDEX idx, PString & name)
  823. {
  824.   static const PString RegBase = SERVICES_REGISTRY_KEY "Class\Net";
  826.   PString keyName;
  827.   RegistryKey registry(RegBase, RegistryKey::ReadOnly);
  828.   if (!registry.EnumKey(idx, keyName))
  829.     return FALSE;
  831.   PString description;
  832.   RegistryKey subkey(RegBase + "\" + keyName, RegistryKey::ReadOnly);
  833.   if (subkey.QueryValue("DriverDesc", description))
  834.     name = keyName + ": " + description;
  835.   else
  836.     name = keyName;
  838.   return TRUE;
  839. }
  842. static PString SearchRegistryKeys(const PString & key,
  843.                                   const PString & variable,
  844.                                   const PString & value)
  845. {
  846.   RegistryKey registry(key, RegistryKey::ReadOnly);
  848.   PString str;
  849.   if (registry.QueryValue(variable, str) && (str *= value))
  850.     return key;
  852.   for (PINDEX idx = 0; registry.EnumKey(idx, str); idx++) {
  853.     PString result = SearchRegistryKeys(key + str + '\', variable, value);
  854.     if (!result)
  855.       return result;
  856.   }
  858.   return PString();
  859. }
  862. BOOL PWin32PacketVxD::BindInterface(const PString & interfaceName)
  863. {
  864.   BYTE buf[20];
  865.   DWORD rxsize;
  867.   if (hDriver == INVALID_HANDLE_VALUE) {
  868.     hDriver = CreateFile("\\.\" PACKET_VXD_NAME ".VXD",
  869.                          GENERIC_READ | GENERIC_WRITE,
  870.                          0,
  871.                          NULL,
  872.                          OPEN_EXISTING,
  873.                          FILE_ATTRIBUTE_NORMAL |
  874.                              FILE_FLAG_OVERLAPPED |
  875.                              FILE_FLAG_DELETE_ON_CLOSE,
  876.                          NULL);
  877.     if (hDriver == INVALID_HANDLE_VALUE) {
  878.       dwError = ::GetLastError();
  879.       return FALSE;
  880.     }
  882. #ifndef USE_VPACKET
  883.     rxsize = 0;
  884.     if (!IoControl(IOCTL_EPACKET_VERSION, NULL, 0, buf, sizeof(buf), rxsize)) {
  885.       dwError = ::GetLastError();
  886.       return FALSE;
  887.     }
  889.     if (rxsize != 2 || buf[0] < 1 || buf[1] < 1) {  // Require driver version 1.1
  890.       Close();
  891.       dwError = ERROR_BAD_DRIVER;
  892.       return FALSE;
  893.     }
  894. #endif
  895.   }
  897.   PString devName;
  898.   PINDEX colon = interfaceName.Find(':');
  899.   if (colon != P_MAX_INDEX)
  900.     devName = interfaceName.Left(colon);
  901.   else
  902.     devName = interfaceName;
  903.   
  904.   rxsize = 0;
  905.   if (!IoControl(IOCTL_EPACKET_BIND,
  906.                  (const char *)devName, devName.GetLength()+1,
  907.                  buf, sizeof(buf), rxsize) || rxsize == 0) {
  908.     dwError = ::GetLastError();
  909.     if (dwError == 0)
  910.       dwError = ERROR_BAD_DRIVER;
  911.     return FALSE;
  912.   }
  914.   // Get a random OID to verify that the driver did actually open
  915.   if (!QueryOid(OID_GEN_DRIVER_VERSION, 2, buf))
  916.     return FALSE;
  918.   dwError = ERROR_SUCCESS;    // Successful, even if may not be bound.
  920.   PString devKey = SearchRegistryKeys("HKEY_LOCAL_MACHINE\Enum\", "Driver", "Net\" + devName);
  921.   if (devKey.IsEmpty())
  922.     return TRUE;
  924.   RegistryKey bindRegistry(devKey + "Bindings", RegistryKey::ReadOnly);
  925.   PString binding;
  926.   PINDEX idx = 0;
  927.   while (bindRegistry.EnumValue(idx++, binding)) {
  928.     if (binding.Left(6) *= "MSTCP\") {
  929.       RegistryKey mstcpRegistry("HKEY_LOCAL_MACHINE\Enum\Network\" + binding, RegistryKey::ReadOnly);
  930.       PString str;
  931.       if (mstcpRegistry.QueryValue("Driver", str))
  932.         transportBinding.AppendString(SERVICES_REGISTRY_KEY "Class\" + str);
  933.     }
  934.   }
  936.   return TRUE;
  937. }
  940. BOOL PWin32PacketVxD::EnumIpAddress(PINDEX idx,
  941.                                     PIPSocket::Address & addr,
  942.                                     PIPSocket::Address & net_mask)
  943. {
  944.   if (idx >= transportBinding.GetSize())
  945.     return FALSE;
  947.   RegistryKey transportRegistry(transportBinding[idx], RegistryKey::ReadOnly);
  948.   PString str;
  949.   if (transportRegistry.QueryValue("IPAddress", str))
  950.     addr = str;
  951.   else
  952.     addr = 0;
  954.   if (addr != 0) {
  955.     if (transportRegistry.QueryValue("IPMask", str))
  956.       net_mask = str;
  957.     else {
  958.       if (IN_CLASSA(addr))
  959.         net_mask = "255.0.0.0";
  960.       else if (IN_CLASSB(addr))
  961.         net_mask = "255.255.0.0";
  962.       else if (IN_CLASSC(addr))
  963.         net_mask = "255.255.255.0";
  964.       else
  965.         net_mask = 0;
  966.     }
  967.     return TRUE;
  968.   }
  970.   PEthSocket::Address macAddress;
  971.   if (!QueryOid(OID_802_3_CURRENT_ADDRESS, sizeof(macAddress), macAddress.b))
  972.     return FALSE;
  974.   PINDEX dhcpCount;
  975.   for (dhcpCount = 0; dhcpCount < 8; dhcpCount++) {
  976.     RegistryKey dhcpRegistry(psprintf(SERVICES_REGISTRY_KEY "VxD\DHCP\DhcpInfo%02u", dhcpCount),
  977.                              RegistryKey::ReadOnly);
  978.     if (dhcpRegistry.QueryValue("DhcpInfo", str)) {
  979.       struct DhcpInfo {
  980.         DWORD index;
  981.         PIPSocket::Address ipAddress;
  982.         PIPSocket::Address mask;
  983.         PIPSocket::Address server;
  984.         PIPSocket::Address anotherAddress;
  985.         DWORD unknown1;
  986.         DWORD unknown2;
  987.         DWORD unknown3;
  988.         DWORD unknown4;
  989.         DWORD unknown5;
  990.         DWORD unknown6;
  991.         BYTE  unknown7;
  992.         PEthSocket::Address macAddress;
  993.       } * dhcpInfo = (DhcpInfo *)(const char *)str;
  994.       if (dhcpInfo->macAddress == macAddress) {
  995.         addr = dhcpInfo->ipAddress;
  996.         net_mask = dhcpInfo->mask;
  997.         return TRUE;
  998.       }
  999.     }
  1000.     else if (dhcpRegistry.QueryValue("HardwareAddress", str) &&
  1001.              str.GetSize() >= sizeof(PEthSocket::Address)) {
  1002.       PEthSocket::Address hardwareAddress;
  1003.       memcpy(&hardwareAddress, (const char *)str, sizeof(hardwareAddress));
  1004.       if (hardwareAddress == macAddress) {
  1005.         if (dhcpRegistry.QueryValue("DhcpIPAddress", str) &&
  1006.             str.GetSize() >= sizeof(addr)) {
  1007.           memcpy(&addr, (const char *)str, sizeof(addr));
  1008.           if (dhcpRegistry.QueryValue("DhcpSubnetMask", str) &&
  1009.               str.GetSize() >= sizeof(net_mask)) {
  1010.             memcpy(&net_mask, (const char *)str, sizeof(net_mask));
  1011.             return TRUE;
  1012.           }
  1013.         }
  1014.       }
  1015.     }
  1016.   }
  1018.   return FALSE;
  1019. }
  1022. BOOL PWin32PacketVxD::BeginRead(void * buf, DWORD size, DWORD & received, PWin32Overlapped & overlap)
  1023. {
  1024.   received = 0;
  1025.   if (DeviceIoControl(hDriver, IOCTL_EPACKET_READ,
  1026.                       buf, size, buf, size, &received, &overlap)) {
  1027.     dwError = ERROR_SUCCESS;
  1028.     return TRUE;
  1029.   }
  1031.   dwError = ::GetLastError();
  1032.   return dwError == ERROR_IO_PENDING;
  1033. }
  1036. BOOL PWin32PacketVxD::BeginWrite(const void * buf, DWORD len, PWin32Overlapped & overlap)
  1037. {
  1038.   DWORD rxsize = 0;
  1039.   BYTE dummy[2];
  1040.   if (DeviceIoControl(hDriver, IOCTL_EPACKET_WRITE,
  1041.                       (void *)buf, len, dummy, sizeof(dummy), &rxsize, &overlap)) {
  1042.     dwError = ERROR_SUCCESS;
  1043.     return TRUE;
  1044.   }
  1046.   dwError = ::GetLastError();
  1047.   return dwError == ERROR_IO_PENDING;
  1048. }
  1051. ///////////////////////////////////////////////////////////////////////////////
  1053. PWin32PacketSYS::PWin32PacketSYS()
  1054. {
  1055.   // Start the packet driver service
  1056.   SC_HANDLE hManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
  1057.   if (hManager != NULL) {
  1058.     SC_HANDLE hService = OpenService(hManager, PACKET_SERVICE_NAME, SERVICE_START);
  1059.     if (hService != NULL) {
  1060.       StartService(hService, 0, NULL);
  1061.       dwError = ::GetLastError();
  1062.       CloseServiceHandle(hService);
  1063.     }
  1064.     CloseServiceHandle(hManager);
  1065.   }
  1066. }
  1069. static BOOL RegistryQueryMultiSz(RegistryKey & registry,
  1070.                                  const PString & variable,
  1071.                                  PINDEX idx,
  1072.                                  PString & value)
  1073. {
  1074.   PString allValues;
  1075.   if (!registry.QueryValue(variable, allValues))
  1076.     return FALSE;
  1078.   const char * ptr = allValues;
  1079.   while (*ptr != '' && idx-- > 0)
  1080.     ptr += strlen(ptr)+1;
  1082.   if (*ptr == '')
  1083.     return FALSE;
  1085.   value = ptr;
  1086.   return TRUE;
  1087. }
  1090. static const char PacketDeviceStr[] = "\Device\" PACKET_SERVICE_NAME "_";
  1092. BOOL PWin32PacketSYS::EnumInterfaces(PINDEX idx, PString & name)
  1093. {
  1094.   RegistryKey registry(SERVICES_REGISTRY_KEY PACKET_SERVICE_NAME "\Linkage",
  1095.                        RegistryKey::ReadOnly);
  1096.   if (!RegistryQueryMultiSz(registry, "Export", idx, name)) {
  1097.     dwError = ERROR_NO_MORE_ITEMS;
  1098.     return FALSE;
  1099.   }
  1101.   if (strnicmp(name, PacketDeviceStr, sizeof(PacketDeviceStr)-1) == 0)
  1102.     name.Delete(0, sizeof(PacketDeviceStr)-1);
  1104.   return TRUE;
  1105. }
  1108. BOOL PWin32PacketSYS::BindInterface(const PString & interfaceName)
  1109. {
  1110.   Close();
  1112.   if (!DefineDosDevice(DDD_RAW_TARGET_PATH,
  1113.                        PACKET_SERVICE_NAME "_" + interfaceName,
  1114.                        PacketDeviceStr + interfaceName)) {
  1115.     dwError = ::GetLastError();
  1116.     return FALSE;
  1117.   }
  1119.   ::SetLastError(0);
  1120.   hDriver = CreateFile("\\.\" PACKET_SERVICE_NAME "_" + interfaceName,
  1121.                        GENERIC_READ | GENERIC_WRITE,
  1122.                        0,
  1123.                        NULL,
  1124.                        CREATE_ALWAYS,
  1125.                        FILE_FLAG_OVERLAPPED,
  1126.                        NULL);
  1127.   if (hDriver == INVALID_HANDLE_VALUE) {
  1128.     dwError = ::GetLastError();
  1129.     return FALSE;
  1130.   }
  1132.   registryKey = SERVICES_REGISTRY_KEY + interfaceName + "\Parameters\Tcpip";
  1133.   dwError = ERROR_SUCCESS;
  1134.   return TRUE;
  1135. }
  1138. BOOL PWin32PacketSYS::EnumIpAddress(PINDEX idx,
  1139.                                     PIPSocket::Address & addr,
  1140.                                     PIPSocket::Address & net_mask)
  1141. {
  1142.   PString str;
  1143.   RegistryKey registry(registryKey, RegistryKey::ReadOnly);
  1145.   if (!RegistryQueryMultiSz(registry, "IPAddress", idx, str)) {
  1146.     dwError = ERROR_NO_MORE_ITEMS;
  1147.     return FALSE;
  1148.   }
  1149.   addr = str;
  1151.   if (!RegistryQueryMultiSz(registry, "SubnetMask", idx, str)) {
  1152.     dwError = ERROR_NO_MORE_ITEMS;
  1153.     return FALSE;
  1154.   }
  1155.   net_mask = str;
  1157.   return TRUE;
  1158. }
  1161. BOOL PWin32PacketSYS::BeginRead(void * buf, DWORD size, DWORD & received, PWin32Overlapped & overlap)
  1162. {
  1163.   overlap.Reset();
  1164.   received = 0;
  1166.   if (ReadFile(hDriver, buf, size, &received, &overlap)) {
  1167.     dwError = ERROR_SUCCESS;
  1168.     return TRUE;
  1169.   }
  1171.   return (dwError = ::GetLastError()) == ERROR_IO_PENDING;
  1172. }
  1175. BOOL PWin32PacketSYS::BeginWrite(const void * buf, DWORD len, PWin32Overlapped & overlap)
  1176. {
  1177.   overlap.Reset();
  1178.   DWORD sent = 0;
  1179.   if (WriteFile(hDriver, buf, len, &sent, &overlap)) {
  1180.     dwError = ERROR_SUCCESS;
  1181.     return TRUE;
  1182.   }
  1184.   dwError = ::GetLastError();
  1185.   return dwError == ERROR_IO_PENDING;
  1186. }
  1189. ///////////////////////////////////////////////////////////////////////////////
  1191. PEthSocket::PEthSocket(PINDEX nReadBuffers, PINDEX nWriteBuffers, PINDEX size)
  1192.   : readBuffers(min(nReadBuffers, MAXIMUM_WAIT_OBJECTS)),
  1193.     writeBuffers(min(nWriteBuffers, MAXIMUM_WAIT_OBJECTS))
  1194. {
  1195.   driver = PWin32PacketDriver::Create();
  1196.   snmp = new PWin32SnmpLibrary;
  1198.   PINDEX i;
  1199.   for (i = 0; i < nReadBuffers; i++)
  1200.     readBuffers.SetAt(i, new PWin32PacketBuffer(size));
  1201.   for (i = 0; i < nWriteBuffers; i++)
  1202.     writeBuffers.SetAt(i, new PWin32PacketBuffer(size));
  1204.   filterType = TypeAll;
  1205. }
  1208. PEthSocket::~PEthSocket()
  1209. {
  1210.   Close();
  1212.   delete driver;
  1213.   delete snmp;
  1214. }
  1217. BOOL PEthSocket::OpenSocket()
  1218. {
  1219.   PAssertAlways(PUnimplementedFunction);
  1220.   return FALSE;
  1221. }
  1224. BOOL PEthSocket::Close()
  1225. {
  1226.   driver->Close();
  1227.   os_handle = -1;
  1228.   return TRUE;
  1229. }
  1232. PString PEthSocket::GetName() const
  1233. {
  1234.   return interfaceName;
  1235. }
  1238. BOOL PEthSocket::Connect(const PString & newName)
  1239. {
  1240.   Close();
  1242.   if (!driver->BindInterface(newName)) {
  1243.     osError = driver->GetLastError()|0x40000000;
  1244.     return FALSE;
  1245.   }
  1247.   interfaceName = newName;
  1248.   os_handle = 1;
  1249.   return TRUE;
  1250. }
  1253. BOOL PEthSocket::EnumInterfaces(PINDEX idx, PString & name)
  1254. {
  1255.   return driver->EnumInterfaces(idx, name);
  1256. }
  1259. BOOL PEthSocket::GetAddress(Address & addr)
  1260. {
  1261.   if (driver->QueryOid(OID_802_3_CURRENT_ADDRESS, sizeof(addr), addr.b))
  1262.     return TRUE;
  1264.   osError = driver->GetLastError()|0x40000000;
  1265.   return FALSE;
  1266. }
  1269. BOOL PEthSocket::EnumIpAddress(PINDEX idx,
  1270.                                PIPSocket::Address & addr,
  1271.                                PIPSocket::Address & net_mask)
  1272. {
  1273.   if (IsOpen()) {
  1274.     if (driver->EnumIpAddress(idx, addr, net_mask))
  1275.       return TRUE;
  1277.     osError = ENOENT;
  1278.     lastError = NotFound;
  1279.   }
  1280.   else {
  1281.     osError = EBADF;
  1282.     lastError = NotOpen;
  1283.   }
  1285.   return FALSE;
  1286. }
  1289. static const struct {
  1290.   unsigned pwlib;
  1291.   DWORD    ndis;
  1292. } FilterMasks[] = {
  1293.   { PEthSocket::FilterDirected,     NDIS_PACKET_TYPE_DIRECTED },
  1294.   { PEthSocket::FilterMulticast,    NDIS_PACKET_TYPE_MULTICAST },
  1295.   { PEthSocket::FilterAllMulticast, NDIS_PACKET_TYPE_ALL_MULTICAST },
  1296.   { PEthSocket::FilterBroadcast,    NDIS_PACKET_TYPE_BROADCAST },
  1297.   { PEthSocket::FilterPromiscuous,  NDIS_PACKET_TYPE_PROMISCUOUS }
  1298. };
  1301. BOOL PEthSocket::GetFilter(unsigned & mask, WORD & type)
  1302. {
  1303.   if (!IsOpen()) {
  1304.     osError = EBADF;
  1305.     lastError = NotOpen;
  1306.     return FALSE;
  1307.   }
  1309.   DWORD filter = 0;
  1310.   if (!driver->QueryOid(OID_GEN_CURRENT_PACKET_FILTER, filter)) {
  1311.     osError = driver->GetLastError()|0x40000000;
  1312.     return FALSE;
  1313.   }
  1315.   if (filter == 0)
  1316.     return PEthSocket::FilterDirected;
  1318.   mask = 0;
  1319.   for (PINDEX i = 0; i < PARRAYSIZE(FilterMasks); i++) {
  1320.     if ((filter&FilterMasks[i].ndis) != 0)
  1321.       mask |= FilterMasks[i].pwlib;
  1322.   }
  1324.   type = (WORD)filterType;
  1325.   return TRUE;
  1326. }
  1329. BOOL PEthSocket::SetFilter(unsigned filter, WORD type)
  1330. {
  1331.   if (!IsOpen()) {
  1332.     osError = EBADF;
  1333.     lastError = NotOpen;
  1334.     return FALSE;
  1335.   }
  1337.   DWORD bits = 0;
  1338.   for (PINDEX i = 0; i < PARRAYSIZE(FilterMasks); i++) {
  1339.     if ((filter&FilterMasks[i].pwlib) != 0)
  1340.       bits |= FilterMasks[i].ndis;
  1341.   }
  1343.   if (!driver->SetOid(OID_GEN_CURRENT_PACKET_FILTER, bits)) {
  1344.     osError = driver->GetLastError()|0x40000000;
  1345.     return FALSE;
  1346.   }
  1348.   filterType = type;
  1349.   return TRUE;
  1350. }
  1353. PEthSocket::MediumTypes PEthSocket::GetMedium()
  1354. {
  1355.   if (!IsOpen()) {
  1356.     osError = EBADF;
  1357.     lastError = NotOpen;
  1358.     return NumMediumTypes;
  1359.   }
  1361.   DWORD medium = 0xffffffff;
  1362.   if (!driver->QueryOid(OID_GEN_MEDIA_SUPPORTED, medium) || medium == 0xffffffff) {
  1363.     osError = driver->GetLastError()|0x40000000;
  1364.     return NumMediumTypes;
  1365.   }
  1367.   static const DWORD MediumValues[NumMediumTypes] = {
  1368.     0xffffffff, NdisMedium802_3, NdisMediumWan, 0xffffffff
  1369.   };
  1371.   for (int type = Medium802_3; type < NumMediumTypes; type++) {
  1372.     if (MediumValues[type] == medium)
  1373.       return (MediumTypes)type;
  1374.   }
  1376.   return MediumUnknown;
  1377. }
  1380. BOOL PEthSocket::Read(void * data, PINDEX length)
  1381. {
  1382.   if (!IsOpen()) {
  1383.     osError = EBADF;
  1384.     lastError = NotOpen;
  1385.     return FALSE;
  1386.   }
  1388.   PINDEX idx;
  1389.   PINDEX numBuffers = readBuffers.GetSize();
  1391.   do {
  1392.     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  1394.     for (idx = 0; idx < numBuffers; idx++) {
  1395.       PWin32PacketBuffer & buffer = readBuffers[idx];
  1396.       if (buffer.InProgress()) {
  1397.         if (WaitForSingleObject(buffer.GetEvent(), 0) == WAIT_OBJECT_0)
  1398.           if (!buffer.ReadComplete(*driver))
  1399.             return ConvertOSError(-1);
  1400.       }
  1401.       else {
  1402.         if (!buffer.ReadAsync(*driver))
  1403.           return ConvertOSError(-1);
  1404.       }
  1406.       if (buffer.IsCompleted() && buffer.IsType(filterType)) {
  1407.         lastReadCount = buffer.GetData(data, length);
  1408.         return TRUE;
  1409.       }
  1411.       handles[idx] = buffer.GetEvent();
  1412.     }
  1414.     DWORD result;
  1415.     PINDEX retries = 100;
  1416.     for (;;) {
  1417.       result = WaitForMultipleObjects(numBuffers, handles, FALSE, INFINITE);
  1418.       if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0+numBuffers)
  1419.         break;
  1421.       if (::GetLastError() != ERROR_INVALID_HANDLE || retries == 0)
  1422.         return ConvertOSError(-1);
  1424.       retries--;
  1425.     }
  1427.     idx = result - WAIT_OBJECT_0;
  1428.     if (!readBuffers[idx].ReadComplete(*driver))
  1429.       return ConvertOSError(-1);
  1431.   } while (!readBuffers[idx].IsType(filterType));
  1433.   lastReadCount = readBuffers[idx].GetData(data, length);
  1434.   return TRUE;
  1435. }
  1438. BOOL PEthSocket::Write(const void * data, PINDEX length)
  1439. {
  1440.   if (!IsOpen()) {
  1441.     osError = EBADF;
  1442.     lastError = NotOpen;
  1443.     return FALSE;
  1444.   }
  1446.   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  1447.   PINDEX numBuffers = writeBuffers.GetSize();
  1449.   PINDEX idx;
  1450.   for (idx = 0; idx < numBuffers; idx++) {
  1451.     PWin32PacketBuffer & buffer = writeBuffers[idx];
  1452.     if (buffer.InProgress()) {
  1453.       if (WaitForSingleObject(buffer.GetEvent(), 0) == WAIT_OBJECT_0)
  1454.         if (!buffer.WriteComplete(*driver))
  1455.           return ConvertOSError(-1);
  1456.     }
  1458.     if (!buffer.InProgress()) {
  1459.       lastWriteCount = buffer.PutData(data, length);
  1460.       return ConvertOSError(buffer.WriteAsync(*driver) ? 0 : -1);
  1461.     }
  1463.     handles[idx] = buffer.GetEvent();
  1464.   }
  1466.   DWORD result = WaitForMultipleObjects(numBuffers, handles, FALSE, INFINITE);
  1467.   if (result < WAIT_OBJECT_0 || result >= WAIT_OBJECT_0+numBuffers)
  1468.     return ConvertOSError(-1);
  1470.   idx = result - WAIT_OBJECT_0;
  1471.   if (!writeBuffers[idx].WriteComplete(*driver))
  1472.     return ConvertOSError(-1);
  1474.   lastWriteCount = writeBuffers[idx].PutData(data, length);
  1475.   return ConvertOSError(writeBuffers[idx].WriteAsync(*driver) ? 0 : -1);
  1476. }
  1479. ///////////////////////////////////////////////////////////////////////////////
  1481. PWin32PacketBuffer::PWin32PacketBuffer(PINDEX sz)
  1482.   : PBYTEArray(sz)
  1483. {
  1484.   status = Uninitialised;
  1485.   count = 0;
  1486. }
  1489. PINDEX PWin32PacketBuffer::GetData(void * buf, PINDEX size)
  1490. {
  1491.   if (count > (DWORD)size)
  1492.     count = size;
  1494.   memcpy(buf, theArray, count);
  1496.   return count;
  1497. }
  1500. PINDEX PWin32PacketBuffer::PutData(const void * buf, PINDEX length)
  1501. {
  1502.   count = min(GetSize(), length);
  1504.   memcpy(theArray, buf, count);
  1506.   return count;
  1507. }
  1510. BOOL PWin32PacketBuffer::ReadAsync(PWin32PacketDriver & pkt)
  1511. {
  1512.   if (status == Progressing)
  1513.     return FALSE;
  1515.   status = Uninitialised;
  1516.   if (!pkt.BeginRead(theArray, GetSize(), count, overlap))
  1517.     return FALSE;
  1519.   if (pkt.GetLastError() == ERROR_SUCCESS)
  1520.     status = Completed;
  1521.   else
  1522.     status = Progressing;
  1523.   return TRUE;
  1524. }
  1527. BOOL PWin32PacketBuffer::ReadComplete(PWin32PacketDriver & pkt)
  1528. {
  1529.   if (status != Progressing)
  1530.     return status == Completed;
  1532.   if (!pkt.CompleteIO(count, overlap)) {
  1533.     status = Uninitialised;
  1534.     return FALSE;
  1535.   }
  1537.   status = Completed;
  1538.   return TRUE;
  1539. }
  1542. BOOL PWin32PacketBuffer::WriteAsync(PWin32PacketDriver & pkt)
  1543. {
  1544.   if (status == Progressing)
  1545.     return FALSE;
  1547.   status = Uninitialised;
  1548.   if (!pkt.BeginWrite(theArray, count, overlap))
  1549.     return FALSE;
  1551.   if (pkt.GetLastError() == ERROR_SUCCESS)
  1552.     status = Completed;
  1553.   else
  1554.     status = Progressing;
  1555.   return TRUE;
  1556. }
  1559. BOOL PWin32PacketBuffer::WriteComplete(PWin32PacketDriver & pkt)
  1560. {
  1561.   if (status != Progressing)
  1562.     return status == Completed;
  1564.   DWORD dummy;
  1565.   if (pkt.CompleteIO(dummy, overlap)) {
  1566.     status = Completed;
  1567.     return TRUE;
  1568.   }
  1570.   status = Uninitialised;
  1571.   return FALSE;
  1572. }
  1575. BOOL PWin32PacketBuffer::IsType(WORD filterType) const
  1576. {
  1577.   if (filterType == PEthSocket::TypeAll)
  1578.     return TRUE;
  1580.   const PEthSocket::Frame * frame = (const PEthSocket::Frame *)theArray;
  1582.   WORD len_or_type = ntohs(frame->snap.length);
  1583.   if (len_or_type > sizeof(*frame))
  1584.     return len_or_type == filterType;
  1586.   if (frame->snap.dsap == 0xaa && frame->snap.ssap == 0xaa)
  1587.     return ntohs(frame->snap.type) == filterType;   // SNAP header
  1589.   if (frame->snap.dsap == 0xff && frame->snap.ssap == 0xff)
  1590.     return PEthSocket::TypeIPX == filterType;   // Special case for Novell netware's stuffed up 802.3
  1592.   if (frame->snap.dsap == 0xe0 && frame->snap.ssap == 0xe0)
  1593.     return PEthSocket::TypeIPX == filterType;   // Special case for Novell netware's 802.2
  1595.   return frame->snap.dsap == filterType;    // A pure 802.2 protocol id
  1596. }
  1599. ///////////////////////////////////////////////////////////////////////////////
  1601. BOOL PIPSocket::GetGatewayAddress(Address & addr)
  1602. {
  1603.   PWin32SnmpLibrary snmp;
  1605.   PWin32AsnOid gatewayOid = "1.3.6.1.2.1.4.21.1.7.0.0.0.0";
  1606.   if (!snmp.GetOid(gatewayOid, addr))
  1607.     return FALSE;
  1609.   gatewayOid.Free();
  1610.   return TRUE;
  1611. }
  1614. PString PIPSocket::GetGatewayInterface()
  1615. {
  1616.   PWin32SnmpLibrary snmp;
  1618.   AsnInteger ifNum = -1;
  1619.   PWin32AsnOid gatewayOid = "1.3.6.1.2.1.4.21.1.2.0.0.0.0";
  1620.   if (!snmp.GetOid(gatewayOid, ifNum) && ifNum >= 0)
  1621.     return PString();
  1623.   gatewayOid.Free();
  1625.   return snmp.GetInterfaceName(ifNum);
  1626. }
  1629. BOOL PIPSocket::GetRouteTable(RouteTable & table)
  1630. {
  1631.   PWin32SnmpLibrary snmp;
  1633.   table.RemoveAll();
  1635.   PWin32AsnOid baseOid = "1.3.6.1.2.1.4.21.1";
  1636.   PWin32AsnOid oid = baseOid;
  1638.   DWORD lastVariable = 1;
  1639.   PWin32AsnAny value;
  1640.   PLongArray ifNum;
  1641.   PINDEX idx = 0;
  1643.   while (snmp.GetNextOid(oid, value) && (baseOid *= oid)) {
  1644.     if (lastVariable != oid[9]) {
  1645.       lastVariable = oid[9];
  1646.       if (lastVariable == 2)
  1647.         ifNum.SetSize(table.GetSize());
  1648.       idx = 0;
  1649.     }
  1651.     switch (lastVariable) {
  1652.       case 1 : // network address
  1653.         {
  1654.           Address addr;
  1655.           if (!value.GetIpAddress(addr))
  1656.             return FALSE;  // Very confused route table
  1658.           table.Append(new RouteEntry(addr));
  1659.           break;
  1660.         }
  1662.       case 2 : // device interface
  1663.         if (!value.GetInteger(ifNum[idx]))
  1664.           return FALSE;
  1665.         break;
  1667.       case 3 : // metric
  1668.         if (!value.GetInteger(table[idx].metric))
  1669.           return FALSE;
  1670.         break;
  1672.       case 7 : // Get destination (next hop)
  1673.         if (!value.GetIpAddress(table[idx].destination))
  1674.           return FALSE;
  1675.         break;
  1677.       case 11 : // Get mask
  1678.         if (!value.GetIpAddress(table[idx].net_mask))
  1679.           return FALSE;
  1680.         break;
  1681.     }
  1683.     idx++;
  1684.   }
  1686.   oid.Free();
  1688.   for (idx = 0; idx < table.GetSize(); idx++)
  1689.     table[idx].interfaceName = snmp.GetInterfaceName(ifNum[idx]);
  1691.   return TRUE;
  1692. }
  1695. BOOL PIPSocket::GetInterfaceTable(InterfaceTable & table)
  1696. {
  1697.   PWin32SnmpLibrary snmp;
  1699.   table.RemoveAll();
  1701.   PWin32AsnOid baseOid = "1.3.6.1.2.1.4.20.1";
  1702.   PWin32AsnOid oid = baseOid;
  1703.   PWin32AsnAny value;
  1704.   while (snmp.GetNextOid(oid, value)) {
  1705.     if (!(baseOid *= oid))
  1706.       break;
  1707.     if (value.asnType != ASN_IPADDRESS)
  1708.       break;
  1710.     Address ipAddr;
  1711.     value.GetIpAddress(ipAddr);
  1713.     oid[9] = 2;
  1714.     AsnInteger ifIndex = -1;
  1715.     if (!snmp.GetOid(oid, ifIndex))
  1716.       break;
  1718.     PString macAddr;
  1719.     PEthSocket::Address ifPhysAddress("");
  1720.     PWin32AsnOid ifOid = "1.3.6.1.2.1.2.2.1.6.0";
  1721.     ifOid[10] = ifIndex;
  1722.     UINT len;
  1723.     if (snmp.GetOid(ifOid, &ifPhysAddress, sizeof(ifPhysAddress), &len) && len > 0)
  1724.       macAddr = ifPhysAddress;
  1725.   
  1726.     PString name = snmp.GetInterfaceName(ipAddr);
  1727.     if (name.IsEmpty()) {
  1728.       PWin32AsnOid nameOid = "1.3.6.1.2.1.2.2.1.2.0";
  1729.       nameOid[10] = ifIndex;
  1730.       if (!snmp.GetOid(nameOid, name.GetPointer(100), 100))
  1731.         break;
  1732.       name.MakeMinimumSize();
  1733.     }
  1735.     table.Append(new InterfaceEntry(name, ipAddr, macAddr));
  1737.     oid[9] = 1;
  1738.   }
  1740.   return TRUE;
  1741. }
  1744. ///////////////////////////////////////////////////////////////////////////////