Don't use lower case class names (#632)

Author: kayoub5

SharpPcap/LibPcap/BpfProgram.cs

@@ -85,7 +85,7 @@ public static BpfProgram Create(LinkLayers linktype, string filter, int optimize
         private BpfProgram()
             : base(true)
         {
-            var bpfProgram = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.bpf_program)));
+            var bpfProgram = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.BpfProgram)));
             SetHandle(bpfProgram);
         }
 

SharpPcap/LibPcap/LibPcapSafeNativeMethods.Encoding.cs

@@ -117,7 +117,6 @@ public unsafe object MarshalNativeToManaged(IntPtr nativeData)
         }
     }
 
-    [StructLayout(LayoutKind.Sequential)]
     internal struct ErrorBuffer
     {
         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]

SharpPcap/LibPcap/LibPcapSafeNativeMethods.Interop.cs

@@ -39,7 +39,7 @@ out ErrorBuffer /* char* */ errbuf
         [DllImport(PCAP_DLL, CallingConvention = CallingConvention.Cdecl)]
         internal extern static int pcap_findalldevs_ex(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PcapStringMarshaler))] string /*char **/source,
-            ref pcap_rmtauth /*pcap_rmtauth **/auth,
+            ref PcapRmtAuth /*pcap_rmtauth **/auth,
             ref IntPtr /*pcap_if_t ** */alldevs,
             out ErrorBuffer /* char* */ errbuf
         );
@@ -53,7 +53,7 @@ out ErrorBuffer /* char* */ errbuf
             int packetLen,
             int flags,
             int read_timeout,
-            ref pcap_rmtauth rmtauth,
+            ref PcapRmtAuth rmtauth,
             out ErrorBuffer /* char* */ errbuf
         );
 
@@ -235,7 +235,9 @@ out ErrorBuffer /* char* */ errbuf
         /// A <see cref="int"/>
         /// </returns>
         [DllImport(PCAP_DLL, CallingConvention = CallingConvention.Cdecl)]
-        internal extern static int pcap_stats(PcapHandle /* pcap_t* */ adapter, IntPtr /* struct pcap_stat* */ stat);
+        internal extern static int pcap_stats(PcapHandle /* pcap_t* */ adapter, ref PcapStatUnix stat);
+        [DllImport(PCAP_DLL, CallingConvention = CallingConvention.Cdecl)]
+        internal extern static int pcap_stats(PcapHandle /* pcap_t* */ adapter, ref PcapStatWindows stat);
 
         /// <summary>
         /// Returns the snapshot length
@@ -336,7 +338,7 @@ out ErrorBuffer /* char* */ errbuf
         /// during the send. The error can be caused by a driver/adapter 
         /// problem or by an inconsistent/bogus send queue.</returns>
         [DllImport(PCAP_DLL, CallingConvention = CallingConvention.Cdecl)]
-        internal extern static int pcap_sendqueue_transmit(PcapHandle /*pcap_t * */p, ref pcap_send_queue queue, int sync);
+        internal extern static int pcap_sendqueue_transmit(PcapHandle /*pcap_t * */p, ref PcapSendQueue queue, int sync);
         #endregion
 
         #region Timestamp related functions

SharpPcap/LibPcap/PcapAddress.cs

@@ -36,7 +36,7 @@ public class PcapAddress
         internal PcapAddress()
         { }
 
-        internal PcapAddress(PcapUnmanagedStructures.pcap_addr pcap_addr)
+        internal PcapAddress(PcapUnmanagedStructures.PcapAddr pcap_addr)
         {
             if (pcap_addr.Addr != IntPtr.Zero)
                 Addr = new Sockaddr(pcap_addr.Addr);

SharpPcap/LibPcap/PcapHeader.cs

@@ -26,13 +26,13 @@ private static int GetTimevalSize()
         {
             if (is32BitTs)
             {
-                return Marshal.SizeOf<timeval_windows>();
+                return Marshal.SizeOf<TimevalWindows>();
             }
             if (isMacOSX)
             {
-                return Marshal.SizeOf<timeval_macosx>();
+                return Marshal.SizeOf<TimevalMacosx>();
             }
-            return Marshal.SizeOf<timeval_unix>();
+            return Marshal.SizeOf<TimevalUnix>();
         }
 
         /// <summary>
@@ -44,19 +44,19 @@ private unsafe PcapHeader(IntPtr pcap_pkthdr, TimestampResolution resolution)
             ulong tv_usec;
             if (is32BitTs)
             {
-                var ts = *(timeval_windows*)pcap_pkthdr;
+                var ts = *(TimevalWindows*)pcap_pkthdr;
                 tv_sec = (ulong)ts.tv_sec;
                 tv_usec = (ulong)ts.tv_usec;
             }
             else if (isMacOSX)
             {
-                var ts = *(timeval_macosx*)pcap_pkthdr;
+                var ts = *(TimevalMacosx*)pcap_pkthdr;
                 tv_sec = (ulong)ts.tv_sec;
                 tv_usec = (ulong)ts.tv_usec;
             }
             else
             {
-                var ts = *(timeval_unix*)pcap_pkthdr;
+                var ts = *(TimevalUnix*)pcap_pkthdr;
                 tv_sec = (ulong)ts.tv_sec;
                 tv_usec = (ulong)ts.tv_usec;
             }
@@ -119,7 +119,7 @@ public IntPtr MarshalToIntPtr(TimestampResolution resolution)
             if (is32BitTs)
             {
                 // setup the structure to marshal
-                var timeval = new timeval_windows
+                var timeval = new TimevalWindows
                 {
                     tv_sec = (int)tv_sec,
                     tv_usec = (int)tv_usec
@@ -128,7 +128,7 @@ public IntPtr MarshalToIntPtr(TimestampResolution resolution)
             }
             else if (isMacOSX)
             {
-                var timeval = new timeval_macosx
+                var timeval = new TimevalMacosx
                 {
                     tv_sec = (IntPtr)tv_sec,
                     tv_usec = (int)tv_usec
@@ -137,7 +137,7 @@ public IntPtr MarshalToIntPtr(TimestampResolution resolution)
             }
             else
             {
-                var timeval = new timeval_unix
+                var timeval = new TimevalUnix
                 {
                     tv_sec = (IntPtr)tv_sec,
                     tv_usec = (IntPtr)tv_usec

SharpPcap/LibPcap/PcapInterface.cs

@@ -63,7 +63,7 @@ public class PcapInterface
         /// </summary>
         public PhysicalAddress? MacAddress { get; }
 
-        internal PcapInterface(pcap_if pcapIf, NetworkInterface? networkInterface, RemoteAuthentication? credentials)
+        internal unsafe PcapInterface(PcapIf pcapIf, NetworkInterface? networkInterface, RemoteAuthentication? credentials)
         {
             Name = pcapIf.Name;
             Description = pcapIf.Description;
@@ -77,9 +77,9 @@ internal PcapInterface(pcap_if pcapIf, NetworkInterface? networkInterface, Remot
             while (address != IntPtr.Zero)
             {
                 // Marshal memory pointer into a sockaddr struct
-                var addr = Marshal.PtrToStructure<pcap_addr>(address);
+                var addr = (PcapAddr*)address;
 
-                PcapAddress newAddress = new PcapAddress(addr);
+                PcapAddress newAddress = new PcapAddress(*addr);
                 Addresses.Add(newAddress);
 
                 // is this a hardware address?
@@ -98,7 +98,7 @@ internal PcapInterface(pcap_if pcapIf, NetworkInterface? networkInterface, Remot
                     }
                 }
 
-                address = addr.Next; // move to the next address
+                address = addr->Next; // move to the next address
             }
 
             // attempt to populate the mac address,
@@ -227,7 +227,7 @@ static private IReadOnlyList<PcapInterface> GetAllPcapInterfaces(IntPtr devicePt
             while (nextDevPtr != IntPtr.Zero)
             {
                 // Marshal pointer into a struct
-                var pcap_if_unmanaged = Marshal.PtrToStructure<pcap_if>(nextDevPtr);
+                var pcap_if_unmanaged = Marshal.PtrToStructure<PcapIf>(nextDevPtr);
                 NetworkInterface? networkInterface = null;
                 foreach (var nic in nics)
                 {

SharpPcap/LibPcap/PcapStatistics.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Runtime.InteropServices;
+using static SharpPcap.LibPcap.PcapUnmanagedStructures;
 
 namespace SharpPcap.LibPcap
 {
@@ -36,66 +37,52 @@ internal PcapStatistics() { }
         /// pcap_t* for the adapter
         /// A <see cref="IntPtr"/>
         /// </param>
-        internal PcapStatistics(PcapHandle pcap_t)
+        internal unsafe PcapStatistics(PcapHandle pcap_t)
         {
-            IntPtr stat;
+            PcapStatUnix statUnix = new();
+            PcapStatWindows statWindows = new();
+            int result;
 
             if (Environment.OSVersion.Platform == PlatformID.Unix)
             {
-                // allocate memory for the struct
-                stat = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.pcap_stat_unix)));
+                result = LibPcapSafeNativeMethods.pcap_stats(pcap_t, ref statUnix);
             }
             else
             {
-                // allocate memory for the struct
-                stat = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.pcap_stat_windows)));
+                result = LibPcapSafeNativeMethods.pcap_stats(pcap_t, ref statWindows);
             }
 
             // retrieve the stats
-            var result = (PcapUnmanagedStructures.PcapStatReturnValue)LibPcapSafeNativeMethods.pcap_stats(pcap_t, stat);
 
             // process the return value
-            switch (result)
+            switch ((PcapStatReturnValue)result)
             {
-                case PcapUnmanagedStructures.PcapStatReturnValue.Error:
+                case PcapStatReturnValue.Error:
                     // retrieve the error information
                     var error = LibPcapLiveDevice.GetLastError(pcap_t);
-
-                    // free the stats memory so we don't leak before we throw
-                    Marshal.FreeHGlobal(stat);
-
                     throw new StatisticsException(error);
-                case PcapUnmanagedStructures.PcapStatReturnValue.Success:
+                case PcapStatReturnValue.Success:
                     // nothing to do upon success
                     break;
             }
 
             // marshal the unmanaged memory into an object of the proper type
             if (Environment.OSVersion.Platform == PlatformID.Unix)
             {
-                var managedStat = Marshal.PtrToStructure<PcapUnmanagedStructures.pcap_stat_unix>(stat);
-
                 // copy the values
-                this.ReceivedPackets = (uint)managedStat.ps_recv.ToInt64();
-                this.DroppedPackets = (uint)managedStat.ps_drop.ToInt64();
-                //                this.InterfaceDroppedPackets = (uint)managedStat.ps_ifdrop;
+                this.ReceivedPackets = (uint)statUnix.ps_recv;
+                this.DroppedPackets = (uint)statUnix.ps_drop;
             }
             else
             {
-                var managedStat = Marshal.PtrToStructure<PcapUnmanagedStructures.pcap_stat_windows>(stat);
-
                 // copy the values
-                this.ReceivedPackets = (uint)managedStat.ps_recv;
-                this.DroppedPackets = (uint)managedStat.ps_drop;
-                //                this.InterfaceDroppedPackets = (uint)managedStat.ps_ifdrop;
+                this.ReceivedPackets = statWindows.ps_recv;
+                this.DroppedPackets = statWindows.ps_drop;
             }
 
             // NOTE: Not supported on unix or npcap, no need to
             //       put a bogus value in this field
             this.InterfaceDroppedPackets = 0;
-
-            // free the stats
-            Marshal.FreeHGlobal(stat);
         }
 
         /// <summary>