Packet Sniffer SDK DLL Edition

HNTcpManager wrapper for C#

 Previous Next

File: HNTcpManager.cs

using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Runtime.InteropServices;

namespace microOLAP.PSSDK
{
    /// <summary>
    /// Summary description for HNTcpManager.
    /// </summary>
    public partial class HNTCPManager : Component
    {
        #region DLL exports

        /// <summary>
        /// Creates the HNTcpManager object.
        /// </summary>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrCreate")]
        private static extern IntPtr TcpMgrCreate();

        /// <summary>
        /// Destroys the HNTcpManager object.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrDestroy")]
        private static extern int TcpMgrDestroy(IntPtr hTcpMgr);

        /// <summary>
        /// Returns the TCP packet checksum verification flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetCheckTcpSum")]
        private static extern bool TcpMgrGetCheckTcpSum(IntPtr hTcpMgr);

        /// <summary>
        /// Sets the TCP packet checksum verification flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="CheckTcpSum"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetCheckTcpSum")]
        private static extern bool TcpMgrSetCheckTcpSum(IntPtr hTcpMgr, bool CheckTcpSum);

        /// <summary>
        /// Returns the TCP sessions capturing mode flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetInvaderMode")]
        private static extern bool TcpMgrGetInvaderMode(IntPtr hTcpMgr);

        /// <summary>
        /// Sets the TCP sessions capturing mode flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="InvaderMode"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetInvaderMode")]
        private static extern bool TcpMgrSetInvaderMode(IntPtr hTcpMgr, bool InvaderMode);

        /// <summary>
        /// Returns the maximum number of TCP sessions to be monitored at the same time.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetMaxSessionsCount")]
        private static extern uint TcpMgrGetMaxSessionsCount(IntPtr hTcpMgr);

        /// <summary>
        /// Sets the maximum number of TCP sessions to be monitored at the same time.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="MaxSessionsCount"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetMaxSessionsCount")]
        private static extern uint TcpMgrSetMaxSessionsCount(IntPtr hTcpMgr, uint MaxSessionsCount);

        /// <summary>
        /// Returns the current number of TCP sessions are monitored.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetSessionsCount")]
        private static extern int TcpMgrGetSessionsCount(IntPtr hTcpMgr);

        /// <summary>
        /// Returns the virtual TCP sessions mode status flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetVirtualMode")]
        private static extern bool TcpMgrGetVirtualMode(IntPtr hTcpMgr);

        /// <summary>
        /// Sets the virtual TCP sessions mode status flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="VirtualMode"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetVirtualMode")]
        private static extern bool TcpMgrSetVirtualMode(IntPtr hTcpMgr, bool VirtualMode);

        /// <summary>
        /// Returns the number of packets awaiting for processing.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetPendingPacketsCount")]
        private static extern uint TcpMgrGetPendingPacketsCount(IntPtr hTcpMgr);

        /// <summary>
        /// Sends HNPacket object to the HNTcpManager component for further processing.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="hPkt"></param>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrProcessPacket")]
        private static extern void TcpMgrProcessPacket(IntPtr hTcpMgr, IntPtr hPkt);

        /// <summary>
        /// Deletes all HNTcpSession objects.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrResetSessions")]
        private static extern void TcpMgrResetSessions(IntPtr hTcpMgr);

        /// <summary>
        /// Deletes obsolete HNTcpSession objects.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="TimeOut"></param>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrResetOnTimeOut")]
        private static extern void TcpMgrResetOnTimeOut(IntPtr hTcpMgr, int TimeOut);

        /// <summary>
        /// Stops tracking of TCP session.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="hTcpSes"></param>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrCloseSession")]
        private static extern void TcpMgrCloseSession(IntPtr hTcpMgr, IntPtr hTcpSes);

        /// <summary>
        /// Deletes tracked TCP session.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="hTcpSes"></param>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrDeleteSession")]
        private static extern void TcpMgrDeleteSession(IntPtr hTcpMgr, IntPtr hTcpSes);

        /// <summary>
        /// Sets the OnSessionCreate event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnCreate"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnCreate")]
        private static extern IntPtr TcpMgrSetOnCreate(IntPtr hTcpMgr, CallBackOnSessionCreate pfOnCreate, IntPtr Param);

        /// <summary>
        /// Sets the OnSessionConnect event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnConnect"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnConnect")]
        private static extern IntPtr TcpMgrSetOnConnect(IntPtr hTcpMgr, CallBackOnSessionConnect pfOnConnect, IntPtr Param);

        /// <summary>
        /// Sets the OnClientData event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnClient"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnClient")]
        private static extern IntPtr TcpMgrSetOnClient(IntPtr hTcpMgr, CallBackOnClientData pfOnClient, IntPtr Param);

        /// <summary>
        /// Sets the OnServerData event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnServer"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnServer")]
        private static extern IntPtr TcpMgrSetOnServer(IntPtr hTcpMgr, CallBackOnServerData pfOnServer, IntPtr Param);

        /// <summary>
        /// Sets the OnSessionClose event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnClose"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnClose")]
        private static extern IntPtr TcpMgrSetOnClose(IntPtr hTcpMgr, CallBackOnSessionClose pfOnClose, IntPtr Param);

        /// <summary>
        /// Sets the OnSessionDelete event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnDelete"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnDelete")]
        private static extern IntPtr TcpMgrSetOnDelete(IntPtr hTcpMgr, CallBackOnSessionDelete pfOnDelete, IntPtr Param);

        /// <summary>
        /// Sets the OnPacketReturn event.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="pfOnReturn"></param>
        /// <param name="Param"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetOnReturn")]
        private static extern IntPtr TcpMgrSetOnReturn(IntPtr hTcpMgr, CallBackOnPacketReturn pfOnReturn, IntPtr Param);

        /// <summary>
        /// Returns the IP packet checksum verification flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrGetCheckIpSum")]
        private static extern bool TcpMgrGetCheckIpSum(IntPtr hTcpMgr);

        /// <summary>
        /// Sets the IP packet checksum verification flag.
        /// </summary>
        /// <param name="hTcpMgr"></param>
        /// <param name="CheckIpSum"></param>
        /// <returns></returns>
        [DllImport("pssdk.dll", EntryPoint = "TcpMgrSetCheckIpSum")]
        private static extern bool TcpMgrSetCheckIpSum(IntPtr hTcpMgr, bool CheckIpSum);

        #endregion

        #region HNTcpManager evets

        /// <summary>
        /// CallBack OnSessionCreate.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="Need"></param>
        private delegate void CallBackOnSessionCreate(IntPtr Param, IntPtr hTcpSession, ref bool Need);

        /// <summary>
        /// CallBack OnSessionConnect.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        private delegate void CallBackOnSessionConnect(IntPtr Param, IntPtr hTcpSession);

        /// <summary>
        /// CallBack OnClientData.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="hPacket"></param>
        /// <param name="pData"></param>
        /// <param name="DataSize"></param>
        private delegate void CallBackOnClientData(IntPtr Param, IntPtr hTcpSession, IntPtr hPacket, IntPtr pData, uint DataSize);

        /// <summary>
        /// CallBack OnServerData.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="hPacket"></param>
        /// <param name="pData"></param>
        /// <param name="DataSize"></param>
        private delegate void CallBackOnServerData(IntPtr Param, IntPtr hTcpSession, IntPtr hPacket, IntPtr pData, uint DataSize);

        /// <summary>
        /// CallBack OnSessionClose.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="Need"></param>
        private delegate void CallBackOnSessionClose(IntPtr Param, IntPtr hTcpSession, ref bool Need);

        /// <summary>
        /// CallBack OnSessionDelete.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        private delegate void CallBackOnSessionDelete(IntPtr Param, IntPtr hTcpSession);

        /// <summary>
        /// CallBack OnPacketReturn.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hPacket"></param>
        /// <param name="Reason"></param>
        private delegate void CallBackOnPacketReturn(IntPtr Param, IntPtr hPacket, int Reason);

        /// <summary>
        /// CallBack variable OnSessionCreate.
        /// </summary>
        private CallBackOnSessionCreate pfOnSessionCreate;

        /// <summary>
        /// CallBack variable OnSessionConnect.
        /// </summary>
        private CallBackOnSessionConnect pfOnSessionConnect;

        /// <summary>
        /// CallBack variable OnClientData.
        /// </summary>
        private CallBackOnClientData pfOnClientData;

        /// <summary>
        /// CallBack variable OnServerData.
        /// </summary>
        private CallBackOnServerData pfOnServerData;

        /// <summary>
        /// CallBack variable OnSessionClose.
        /// </summary>
        private CallBackOnSessionClose pfOnSessionClose;

        /// <summary>
        /// CallBack variable OnSessionDelete.
        /// </summary>
        private CallBackOnSessionDelete pfOnSessionDelete;

        /// <summary>
        /// CallBack variable OnPacketReturn.
        /// </summary>
        private CallBackOnPacketReturn pfOnPacketReturn;

        /// <summary>
        /// OnSessionCreate event handler.
        /// </summary>
        public event OnSessionCreateEventHandler OnSessionCreate;

        /// <summary>
        /// OnSessionConnect event handler.
        /// </summary>
        public event OnSessionConnectEventHandler OnSessionConnect;

        /// <summary>
        /// OnClientData event handler.
        /// </summary>
        public event OnClientDataEventHandler OnClientData;

        /// <summary>
        /// OnServerData event handler.
        /// </summary>
        public event OnServerDataEventHandler OnServerData;

        /// <summary>
        /// OnSessionClose event handler.
        /// </summary>
        public event OnSessionCloseEventHandler OnSessionClose;

        /// <summary>
        /// OnSessionDelete event handler.
        /// </summary>
        public event OnSessionDeleteEventHandler OnSessionDelete;

        /// <summary>
        /// OnPacketReturn event handler.
        /// </summary>
        public event OnPacketReturnEventHandler OnPacketReturn;

        #endregion

        /// <summary>
        /// Handle of the HNTcpManager object.
        /// </summary>
        private IntPtr hTcpMgr = IntPtr.Zero;

        /// <summary>
        /// Creates the HNTcpManager object.
        /// </summary>
        public HNTCPManager()
        {
            InitializeComponent();

            hTcpMgr = TcpMgrCreate();
            if (hTcpMgr != IntPtr.Zero)
            {
                pfOnSessionCreate = new CallBackOnSessionCreate(this.DoOnSessionCreate);
                TcpMgrSetOnCreate(hTcpMgr, pfOnSessionCreate, IntPtr.Zero);

                pfOnSessionConnect = new CallBackOnSessionConnect(this.DoOnSessionConnect);
                TcpMgrSetOnConnect(hTcpMgr, pfOnSessionConnect, IntPtr.Zero);

                pfOnClientData = new CallBackOnClientData(this.DoOnClientData);
                TcpMgrSetOnClient(hTcpMgr, pfOnClientData, IntPtr.Zero);

                pfOnServerData = new CallBackOnServerData(this.DoOnServerData);
                TcpMgrSetOnServer(hTcpMgr, pfOnServerData, IntPtr.Zero);

                pfOnSessionClose = new CallBackOnSessionClose(this.DoOnSessionClose);
                TcpMgrSetOnClose(hTcpMgr, pfOnSessionClose, IntPtr.Zero);

                pfOnSessionDelete = new CallBackOnSessionDelete(this.DoOnSessionDelete);
                TcpMgrSetOnDelete(hTcpMgr, pfOnSessionDelete, IntPtr.Zero);

                pfOnPacketReturn = new CallBackOnPacketReturn(this.DoOnPacketReturn);
                TcpMgrSetOnReturn(hTcpMgr, pfOnPacketReturn, IntPtr.Zero);
            }
        }

        /// <summary>
        /// Destroys the HNTcpManager object.
        /// </summary>
        ~HNTCPManager()
        {
            if (hTcpMgr != IntPtr.Zero) TcpMgrDestroy(hTcpMgr);
        }

        #region HNTcpManager properties
        
        /// <summary>
        /// Checks if the HNTcpManager object has been created correctly.
        /// </summary>
        [Browsable(false)]
        public bool IsValid
        {
            get
            {
                return (hTcpMgr != IntPtr.Zero);
            }
        }

        /// <summary>
        /// Sets/Returns the IP packet checksum verification flag.
        /// </summary>
        public bool CheckIpSum
        {
            get
            {
                return TcpMgrGetCheckIpSum(hTcpMgr);
            }
            set
            {
                TcpMgrSetCheckIpSum(hTcpMgr, value);
            }
        }

        /// <summary>
        /// Sets/Returns the TCP packet checksum verification flag.
        /// </summary>
        public bool CheckTcpSum
        {
            get
            {
                return TcpMgrGetCheckTcpSum(hTcpMgr);
            }
            set
            {
                TcpMgrSetCheckTcpSum(hTcpMgr, value);
            }
        }

        /// <summary>
        /// Sets/Returns the TCP sessions capturing mode flag.
        /// </summary>
        public bool InvaderMode
        {
            get
            {
                return TcpMgrGetInvaderMode(hTcpMgr);
            }
            set
            {
                TcpMgrSetInvaderMode(hTcpMgr, value);
            }
        }

        /// <summary>
        /// Sets/Returns the maximum number of TCP sessions to be monitored at the same time.
        /// </summary>
        public uint MaxSessionsCount
        {
            get
            {
                return TcpMgrGetMaxSessionsCount(hTcpMgr);
            }
            set
            {
                TcpMgrSetMaxSessionsCount(hTcpMgr, value);
            }
        }

        /// <summary>
        /// Returns the current number of TCP sessions are monitored.
        /// </summary>
        [Browsable(false)]
        public int SessionsCount
        {
            get
            {
                return TcpMgrGetSessionsCount(hTcpMgr);
            }
        }

        /// <summary>
        /// Sets/Returns the virtual TCP sessions mode status flag.
        /// </summary>
        public bool VirtualMode
        {
            get
            {
                return TcpMgrGetVirtualMode(hTcpMgr);
            }
            set
            {
                TcpMgrSetVirtualMode(hTcpMgr, value);
            }
        }

        /// <summary>
        /// Returns the number of packets awaiting for processing.
        /// </summary>
        [Browsable(false)]
        public uint PendingPacketsCount
        {
            get
            {
                return TcpMgrGetPendingPacketsCount(hTcpMgr);
            }
        }

        #endregion        
        
        #region HNTcpManager methods

        /// <summary>
        /// Sends HNPacket object to the HNTcpManager component for further processing.
        /// </summary>
        /// <param name="hPacket"></param>
        public void ProcessPacket(IntPtr hPacket)
        {
            TcpMgrProcessPacket(hTcpMgr, hPacket);
        }

        /// <summary>
        /// Deletes all HNTcpSession objects.
        /// </summary>
        public void ResetSessions()
        {
            TcpMgrResetSessions(hTcpMgr);
        }

        /// <summary>
        /// Deletes obsolete HNTcpSession objects.
        /// </summary>
        /// <param name="TimeOut"></param>
        public void ResetOnTimeOut(int TimeOut)
        {
            TcpMgrResetOnTimeOut(hTcpMgr, TimeOut);
        }

        /// <summary>
        /// Stops tracking of TCP session.
        /// </summary>
        /// <param name="hTcpSes"></param>
        public void CloseSession(IntPtr hTcpSes)
        {
            TcpMgrCloseSession(hTcpMgr, hTcpSes);
        }

        /// <summary>
        /// Deletes tracked TCP session.
        /// </summary>
        /// <param name="hTcpSes"></param>
        public void DeleteSession(IntPtr hTcpSes)
        {
            TcpMgrDeleteSession(hTcpMgr, hTcpSes);
        }

        #endregion
        
        #region HNTcpManager callbacks
        
        /// <summary>
        /// Fires on the new TCP session is registered by HNTcpManager object.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="Need"></param>
        private void DoOnSessionCreate(IntPtr Param, IntPtr hTcpSession, ref bool Need)
        {
            if (OnSessionCreate != null)
                OnSessionCreate(this, hTcpSession, ref Need);
        }

        /// <summary>
        /// Fires immediately after successful establishing of TCP connection.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        private void DoOnSessionConnect(IntPtr Param, IntPtr hTcpSession)
        {
            if (OnSessionConnect != null)
                OnSessionConnect(this, hTcpSession);
        }

        /// <summary>
        /// Fires immediately after receiving of data sent by client.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="hPacket"></param>
        /// <param name="pData"></param>
        /// <param name="DataSize"></param>
        private void DoOnClientData(IntPtr Param, IntPtr hTcpSession, IntPtr hPacket, IntPtr pData, uint DataSize)
        {
            if (OnClientData != null)
                OnClientData(this, hTcpSession, hPacket, pData, DataSize);
        }

        /// <summary>
        /// Fires immediately after receiving of data sent by server.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        /// <param name="hPacket"></param>
        /// <param name="pData"></param>
        /// <param name="DataSize"></param>
        private void DoOnServerData(IntPtr Param, IntPtr hTcpSession, IntPtr hPacket, IntPtr pData, uint DataSize)
        {
            if (OnServerData != null)
                OnServerData(this, hTcpSession, hPacket, pData, DataSize);
        }

        /// <summary>
        /// DoOnSessionClose - Fires immediately after stopping tracking a session by HNTcpManager object.
        /// </summary>
        private void DoOnSessionClose(IntPtr Param, IntPtr hTcpSession, ref bool Need)
        {
            if (OnSessionClose != null)
                OnSessionClose(this, hTcpSession, ref Need);
        }

        /// <summary>
        /// Fires immediately before deletion of HNTcpSession object.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hTcpSession"></param>
        private void DoOnSessionDelete(IntPtr Param, IntPtr hTcpSession)
        {
            if (OnSessionDelete != null)
                OnSessionDelete(this, hTcpSession);
        }

        /// <summary>
        /// Fired immediately after releasing a packet for further using.
        /// </summary>
        /// <param name="Param"></param>
        /// <param name="hPacket"></param>
        /// <param name="Reason"></param>
        private void DoOnPacketReturn(IntPtr Param, IntPtr hPacket, int Reason)
        {
            if (OnPacketReturn != null)
                OnPacketReturn(this, hPacket, (HNTcpReturnReason)Reason);
        }

        #endregion
    }
}
See also:HNTcpManager, All wrappers in one ZIP archive