Solved

Sending Raw Packets (how to create data portion)

Posted on 2004-04-06
3
813 Views
Last Modified: 2013-11-20
Hello,

I am very new to Visual C++ and have  been fighting with this for hours.  I am trying to allow a user to enter raw packet data into an edit control on my mfc app.  I have TTL, source and dest ip all set.  I can't seem to find where I would go about variabling the data payload.  There will be an edit control where you should be able to enter the payload data. I know alot of this code is commented out, I was trying to find where the payload is constructed.  When running ethereal I noticed a portion of the payload appears to go though ascii characters. Any help would be GREATLY appreciated.  Code fixes/examples if possible.  Thanks

#include "stdafx.h"
#include "BinaryTree.h"
#include "SpoofSocket.h"



#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif




//Message handler
LRESULT CALLBACK SocketMessageHandler(HWND hwnd,      // handle to window
                                                 UINT uMsg,      // message identifier
                                               WPARAM wParam,  // first message parameter
                                               LPARAM lParam)   // second message parameter
                                                                 
{
     //first get the socket
     CSpoofSocket* cSock;

     cSock=CSpoofSocket::GetSocketByID((int)wParam);

     if (cSock)
          //Socket exists
          switch (uMsg)
          {
          case WM_SOCKET_GENERAL:
               if (WSAGETSELECTEVENT(lParam) == FD_READ)
                    return cSock->OnSocketReceive(WSAGETSELECTERROR(lParam));
               else if (WSAGETSELECTEVENT(lParam) == FD_WRITE)
                    return cSock->OnSocketWrite(WSAGETSELECTERROR(lParam));
               else if (WSAGETSELECTEVENT(lParam) == FD_OOB)
                    return cSock->OnSocketOOB(WSAGETSELECTERROR(lParam));
               else if (WSAGETSELECTEVENT(lParam) == FD_CLOSE)
                    return cSock->OnSocketClose(WSAGETSELECTERROR(lParam));
               break;
          case WM_SOCKET_CONNECT:
               if (WSAGETSELECTEVENT(lParam) == FD_CONNECT)
                    return cSock->OnSocketConnect(WSAGETSELECTERROR(lParam));
               break;
          case WM_SOCKET_ACCEPT:
               if (WSAGETSELECTEVENT(lParam) == FD_ACCEPT)
                    return cSock->OnSocketAccept(WSAGETSELECTERROR(lParam));
               break;
          case WM_TIMER:
               //Inform the socket
               return cSock->OnSocketTimeout();
          default:                       /* Passes it on if unproccessed    */
               return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));
          }
     else
          return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));

     return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CSpoofSocket

CSpoofSocket::CSpoofSocket()
{
     InitializeIP();
}

CSpoofSocket::CSpoofSocket(SOCKET sok)
{
     AssignSocket(sok);
}

CSpoofSocket::~CSpoofSocket()
{
     //Delete options
     SetOptions(FALSE);

     Close();
}

/////////////////////////////////////////////////////////////////////////////
// CSpoofSocket member functions

BOOL CSpoofSocket::Create(int iProtocol)
{
     //Here we create the raw socket

          m_SpoofSocket=socket(AF_INET,SOCK_RAW,iProtocol);              //iProtocol);

     //Check for socket validity
     if (m_SpoofSocket==INVALID_SOCKET)
     {
          //Error
          m_LastError=WSAGetLastError();
          return FALSE;
     }

     if (m_Raw)
     {
          //Set that the application will send the IP header
          unsigned int iTrue=1;

          if(setsockopt(m_SpoofSocket,IPPROTO_IP,IP_HDRINCL,(char*)&iTrue,sizeof(iTrue))==SOCKET_ERROR)
          {
               //Check for options error
               m_LastError=WSAGetLastError();
               return FALSE;
          }
          if (iProtocol==IPPROTO_ICMP)
               SetHandlers();
     }
     else
          SetHandlers();
     
     //Well no errors
     m_LastError=0;

     //Add socket to list
     AddSocketToList();

     return TRUE;
}

BOOL CSpoofSocket::Send(LPCSTR lpDestinationAddress,char* buf,int bufLength)
{
     //Quit if not ok
     if (!CheckSocketValid())
          return FALSE;

     //Define the target address
     sockaddr_in m_TargetAddress;
     memset(&m_TargetAddress,0,sizeof(m_TargetAddress));

     m_TargetAddress.sin_family=AF_INET;
     m_TargetAddress.sin_addr.s_addr=inet_addr(lpDestinationAddress);
     m_TargetAddress.sin_port=0;

     //packet send status ?
     int iResult;

     //Only if allowing raw headers !!
     if (m_Raw)
     {
          //Header length
          unsigned char ucHeaderLength=IpHeaderLength;

          if (m_Options)
               ucHeaderLength+=m_IPOptions->GetBufferLength();
         
          //First construct the packet
         

                   
         
     LPIpHeader lpHead=ConstructIPHeader(g_nMyVar,IpFragFlag_DONT_FRAG,m_TTL,GetCurrentProcessId(),ucHeaderLength);






          //Set the address
          SetIPHeaderAddress(lpHead,m_SourceAddress,lpDestinationAddress);

          //Now add some more options
          int iTotalLength;
          iTotalLength=ucHeaderLength+bufLength;

          //Set the header
          lpHead->TotalLength=htons(iTotalLength);

          //Need to construct a new packet
         
         
         
         
               
          char* newBuf=new char[iTotalLength];
         
         
         
         
         
         
          //Copy two buffers
          memcpy(newBuf,lpHead,IpHeaderLength);

          //Do we need to copy options ?
          if (m_Options)
               memcpy(newBuf+IpHeaderLength,m_IPOptions->GetBuffer(),m_IPOptions->GetBufferLength());

          //Only if not null
          if (buf)
     

               memcpy(newBuf+ucHeaderLength,buf,bufLength);


















          //Calculate the checksum
          lpHead->CheckSum=CalculateChecksum((unsigned short*)newBuf,iTotalLength);

          //Recopy the ip
          memcpy(newBuf,lpHead,IpHeaderLength);
         
          //Send the data
          iResult=sendto(getHandle(),newBuf,iTotalLength,0,(sockaddr*)&m_TargetAddress,sizeof(m_TargetAddress));

          //Dispose of the buffer
          delete newBuf;

          //Dispose the header
          delete lpHead;
     }
     else
     {
          iResult=!SOCKET_ERROR;

          //Insert options
          if (m_Options)
               if (setsockopt(getHandle(),IPPROTO_IP,IP_OPTIONS,m_IPOptions->GetBuffer(),m_IPOptions->GetBufferLength()==SOCKET_ERROR))
                    //Error
                    iResult=SOCKET_ERROR;
               else
                    ;
          else
               //No options
               //iResult=setsockopt(getHandle(),IPPROTO_IP,IP_OPTIONS,NULL,0);
               ;

          //Check if we had an error
          if (iResult!=SOCKET_ERROR)
               //Use regular send !!!
               iResult=sendto(getHandle(),(const char*)buf,bufLength,0,(sockaddr*)&m_TargetAddress,sizeof(m_TargetAddress));
     }

     if (iResult==SOCKET_ERROR)
          //Set the error
          SetLastError();
     else
          m_LastError=0;

     return iResult!=SOCKET_ERROR;
}

LPIpHeader CSpoofSocket::ConstructIPHeader(unsigned char  ucProtocol,
                                                     unsigned short usFragmentationFlags,
                                                     unsigned char  ucTTL,
                                                     unsigned short usIdentification,
                                                     unsigned char  ucHeaderLength)
{
     //Need to construct the IP header
     LPIpHeader lpHead=new _IpHeader;

     //Header length (in 32 bits)
     lpHead->HeaderLength_Version=ucHeaderLength/4 + IpVersion*16;

     //Protocol
     lpHead->Protocol=ucProtocol;

     //Fragmentation flags
     lpHead->FragmentationFlags=htons(usFragmentationFlags);

     //Time to live
     lpHead->TTL=ucTTL;

     //Checksum - set to 0
     lpHead->CheckSum=0;

     //Identification
     lpHead->Identification=htons(usIdentification);

     //Precedence
     lpHead->TypeOfService=IpService_ROUTINE;

     //Return IP to user
     return lpHead;
}

void CSpoofSocket::SetIPHeaderAddress(LPIpHeader lpHead, LPCSTR lpSourceAddress, LPCSTR lpDestinationAddress)
{
     //We need to place the header
     
     //If source is NULL then we need to use default source
     if (!lpSourceAddress)
     {
          //We will implement it
     }
     else
          //Use sockets2
          lpHead->sourceIPAddress=inet_addr(lpSourceAddress);

     //Place destination address
     lpHead->destIPAddress=inet_addr(lpDestinationAddress);

     //Done
}

void CSpoofSocket::SetLastError()
{
     m_LastError=WSAGetLastError();
}

int CSpoofSocket::GetLastError()
{
     return m_LastError;
}

BOOL CSpoofSocket::ValidSocket()
{
     return m_SpoofSocket!=INVALID_SOCKET;
}

unsigned short CSpoofSocket::CalculateChecksum(unsigned short *usBuf, int iSize)
{
     unsigned long usChksum=0;

     //Calculate the checksum
     while (iSize>1)
     {
          usChksum+=*usBuf++;
          iSize-=sizeof(unsigned short);
     }

     //If we have one char left
     if (iSize)
          usChksum+=*(unsigned char*)usBuf;

     //Complete the calculations
     usChksum=(usChksum >> 16) + (usChksum & 0xffff);
     usChksum+=(usChksum >> 16);

     //Return the value (inversed)
     return (unsigned short)(~usChksum);
}


BOOL CSpoofSocket::Bind(LPCSTR lpSourceAddress,int iPort)
{
     //Quit if not ok
     if (!CheckSocketValid())
          return FALSE;

     //Create the local address
     sockaddr_in soSrc;
     //Set to 0
     memset(&soSrc,0,sizeof(soSrc));
     soSrc.sin_family=AF_INET;
     soSrc.sin_addr.s_addr=inet_addr(lpSourceAddress);
     soSrc.sin_port=htons(iPort);

     //Now we need to bind it
     if (bind(getHandle(),(sockaddr*)&soSrc,sizeof(soSrc)))
     {
          //Error
          m_LastError=WSAGetLastError();
          return FALSE;
     }

     m_LastError=0;

     //If already has a source address then don't change it
     if (!m_SourceAddress)
          m_SourceAddress=lpSourceAddress;

     return TRUE;
}

SOCKET CSpoofSocket::getHandle()
{
     return m_SpoofSocket;
}

BOOL CSpoofSocket::CheckSocketValid()
{
     //Check if socket is invalid
     if (!ValidSocket())
     {
          m_LastError=WSAESHUTDOWN;
          return FALSE;
     }

     //OK
     return TRUE;
}

BOOL CSpoofSocket::Close()
{
     //Close the socket
     //Quit if not ok
     if (!CheckSocketValid())
          return FALSE;

     //Close it
     if (closesocket(getHandle())==SOCKET_ERROR)
     {
          //Error in closing ?
          m_LastError=WSAGetLastError();
          return FALSE;
     }

     //Set the socket to invalid
     m_SpoofSocket=INVALID_SOCKET;

     //Remove from tree
     RemoveSocketFromList();

     return TRUE;
}


BOOL CSpoofSocket::InitializeSockets()
{
     //Initialize the sockets
     WORD wVersionRequested;
     WSADATA wsaData;
     int err;
 
     wVersionRequested = MAKEWORD( 2, 2 );
 
     err = WSAStartup( wVersionRequested, &wsaData );
     if (err!=0)
          /* Tell the user that we could not find a usable */
          /* WinSock DLL.                                  */
          return FALSE;
 
     /* Confirm that the WinSock DLL supports 2.2.*/
     /* Note that if the DLL supports versions greater    */
     /* than 2.2 in addition to 2.2, it will still return */
     /* 2.2 in wVersion since that is the version we      */
     /* requested.                                        */
 
     if (LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)
     {
          /* Tell the user that we could not find a usable */
          /* WinSock DLL.                                  */
          WSACleanup();
          return FALSE;
     }

     //OK
     //Intialize the tree
     if (!m_SocketTree)
          m_SocketTree=new CBinaryTree;

     return TRUE;
}
 

void CSpoofSocket::SetProtocol(int iProtocol)
{
     m_Protocol=iProtocol;
}

void CSpoofSocket::SetSourceAddress(LPCSTR lpSourceAddress)
{
     //Set the source address, in case we want to spoof it
     m_SourceAddress=lpSourceAddress;
}

unsigned short CSpoofSocket::CalculatePseudoChecksum(char *buf, int BufLength,LPCSTR lpDestinationAddress,int iPacketLength)
{
     //Calculate the checksum
     LPPseudoHeader lpPseudo;
     lpPseudo=new PseudoHeader;

     lpPseudo->DestinationAddress=inet_addr(lpDestinationAddress);
     lpPseudo->SourceAddress=inet_addr(m_SourceAddress);
     lpPseudo->Zeros=0;
     lpPseudo->PTCL=m_Protocol;
     lpPseudo->Length=htons(iPacketLength);

     //Calculate checksum of all
     int iTotalLength;
     iTotalLength=PseudoHeaderLength+BufLength;

     char* tmpBuf;
     tmpBuf=new char[iTotalLength];

     ////Copy pseudo
     //memcpy(tmpBuf,lpPseudo,PseudoHeaderLength);

     ////Copy header
     //memcpy(tmpBuf+PseudoHeaderLength,buf,BufLength);

     //Calculate the checksum
     unsigned short usChecksum;
     usChecksum=CalculateChecksum((unsigned short*)tmpBuf,iTotalLength);

     //Delete all
     delete tmpBuf;
     delete lpPseudo;

     //Return checksum
     return usChecksum;
}

void CSpoofSocket::SetTTL(unsigned char ucTTL)
{
     if (m_Raw)
     {
          //Set the ttl
          m_TTL=ucTTL;
     }
     else
          setsockopt(getHandle(),IPPROTO_IP,IP_TTL,(const char*)&ucTTL,sizeof(ucTTL));

}

BOOL CSpoofSocket::Listen(int iBackLog)
{
     int iResult;
     iResult=listen(getHandle(),iBackLog);

     if (iResult)
          SetLastError();

     return !iResult;
}

BOOL CSpoofSocket::ShutdownSockets()
{
     //Clear windows
     BOOL bHandlers;
     bHandlers=RemoveHandlers();

     //Delete tree
     delete m_SocketTree;
     m_SocketTree=NULL;

     if (WSACleanup()==SOCKET_ERROR)
     {
          SetLastError();
          return FALSE;
     }
     else
          return bHandlers;


}

void CSpoofSocket::SetRaw(BOOL bRaw)
{
     //Do we want to create raw socket (YES!!)
     m_Raw=bRaw;
}

void CSpoofSocket::SetOptions(BOOL bOptions)
{
     //Do we want options, normaly not
     m_Options=bOptions;

     if (m_IPOptions)
     {
          delete m_IPOptions;
          m_IPOptions=NULL;
     }

     if (bOptions)
          m_IPOptions=new CIPOptions;

}

CIPOptions::CIPOptions()
{
     //Initialize our buffer
     m_Buffer=new char[IPOption_SIZE];

     //Set our buffer to nothing
     Reset();

     //Our buffer length
     m_BufferLength=0;

     //Set auto pad
     m_AutoPAD=TRUE;
}

CIPOptions::~CIPOptions()
{
     delete m_Buffer;
}

void CIPOptions::AddOption_Nothing()
{
     //Add option do nothing
     //tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_NO_OPERATION);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));
}

tOptionType CIPOptions::GetOption(unsigned char CopyFlag, unsigned char ClassFlag, unsigned char TypeFlag)
{
     //Return a single option type
     return CopyFlag | ClassFlag | TypeFlag;
}

void CIPOptions::AddToBuffer(char *buf, int BufLength)
{
     if (m_BufferLength<IPOption_SIZE)
     {
          //Add our option to the buffer
          /*memcpy(m_Buffer+m_BufferLength,buf,BufLength);
          m_BufferLength+=BufLength;*/
     }
}

const char* CIPOptions::GetBuffer()
{
     return m_Buffer;
}

int CIPOptions::GetBufferLength()
{
     //Check if auto pad or not
     if (m_AutoPAD)
          if (m_BufferLength/IPOption_WRAPSIZE==(m_BufferLength/IPOption_WRAPSIZE)*IPOption_WRAPSIZE && m_BufferLength>=IPOption_WRAPSIZE)
               return m_BufferLength;
          else
               return int((float)m_BufferLength/IPOption_WRAPSIZE+1)*IPOption_WRAPSIZE;
     else
          return m_BufferLength;
}

void CIPOptions::AddOption_ENDLIST()
{
     //End the list of options
     tOptionType OT;

     //Get the option
     OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_END_OPTION);


     //AddToBuffer((char*)&OT,(OT));
}

void CIPOptions::SetAutoPad(BOOL bAutoPAD)
{
     m_AutoPAD=bAutoPAD;
}

CIPOptions* CSpoofSocket::GetOptions()
{
     return m_IPOptions;
}

void CIPOptions::Reset()
{
     //Set all to zeros
memset(m_Buffer,0,IPOption_SIZE);
}

void CIPOptions::AddOption_Security(unsigned short usType)
{
     ////Add option security
     //tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_COPY,IPOption_CONTROL,IPOption_SECURITY);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add length
     //OT=IPOption_SECURITY_LENGTH;
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add options
     //AddToBuffer((char*)&usType,sizeof(usType));

     //Add zeros
     unsigned short usZeros=0;
     unsigned char ucZeros=0;

     //A hacker would enumarate these values, according to the RFC
     //Compartments
     //AddToBuffer((char*)&usZeros,sizeof(usZeros));

     ////Handling restrictions
     //AddToBuffer((char*)&usZeros,sizeof(usZeros));


     ////Transmition control code (TCC)
     //AddToBuffer((char*)&usZeros,sizeof(usZeros));
     //AddToBuffer((char*)&ucZeros,sizeof(ucZeros));

     ////Done
}

void CIPOptions::AddOption_Stream(unsigned short usStreamID)
{
     //     //Add option security
     //tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_COPY,IPOption_CONTROL,IPOption_STREAM);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add length
     //OT=IPOption_STREAM_LENGTH;
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add options
     //unsigned short usnStreamID;
     //usnStreamID=htons(usStreamID);

     //AddToBuffer((char*)&usnStreamID,sizeof(usnStreamID));
}

void CIPOptions::AddOption_StrictRoute(tRouting tRoute)
{
     /*AddOption_Route(IPOption_STRICT_ROUTING,tRoute);*/
}

void CIPOptions::AddOption_RecordRoute(int iMaxRoutes)
{
     ////Option for strict routine
     ////Add option strict route
     //tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_RECORD_ROUTE);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add the length
     //OT=iMaxRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
     //AddToBuffer((char*)&OT,sizeof(OT));
     //
     ////Add the pointer
     //OT=IPOption_STRICT_ROUTING_POINTER;
     //AddToBuffer((char*)&OT,sizeof(OT));
     //
     //char cNothing[IPOption_SIZE]="";
     //AddToBuffer(cNothing,iMaxRoutes*4);
}

void CIPOptions::AddOption_Route(tOptionType tRouteType,tRouting tRoute)
{
     //Option for strict routine
     //Add option strict route
     tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_COPY,IPOption_CONTROL,tRouteType);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add the length
     //OT=tRoute.iRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
     //AddToBuffer((char*)&OT,sizeof(OT));
     //
     ////Add the pointer
     //OT=IPOption_STRICT_ROUTING_POINTER;
     //AddToBuffer((char*)&OT,sizeof(OT));
     //
     ////Add the routing table
     //AddToBuffer((char*)tRoute.ulRoutes,tRoute.iRoutes*4);
}

void CIPOptions::AddOption_LooseRoute(tRouting tRoute)
{
     AddOption_Route(IPOption_LOOSE_ROUTING,tRoute);
}

void CIPOptions::AddOption_Timestamp(tOptionType tFlags, int iMaxStamps)
{
     ////Add option for timestamp
     //tOptionType OT;

     ////Get the option
     //OT=GetOption(IPOption_DONT_COPY,IPOption_DEBUGGING,IPOption_TIMESTAMP);

     ////Add it to buffer
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add the length
     //OT=iMaxStamps*IPOption_TIMESTAMP_SIZE+IPOption_TIMESTAMP_LENGTH-1;
     //AddToBuffer((char*)&OT,sizeof(OT));
     //
     ////Add the pointer
     //OT=IPOption_TIMESTAMP_LENGTH;
     //AddToBuffer((char*)&OT,sizeof(OT));

     ////Add the flags
     //AddToBuffer((char*)&tFlags,sizeof(tFlags));

     ////Add the empty buffer
     //char cNothing[IPOption_SIZE]="";
     //AddToBuffer(cNothing,iMaxStamps*IPOption_TIMESTAMP_SIZE);
}

BOOL CSpoofSocket::SetHandlers()
{
     //Check if we allow async sockets
     if (!m_Async)
          return TRUE;

     //First create the window class
     if (!m_Window)
          if (!RegisterWindow())
          {
               //Error
               m_LastError=::GetLastError();
               return FALSE;
          }
          else
          {
               m_WindowHandle=CreateWindowEx(0,CSpoofSocket_Class,"Socket notification sink",
                                                    WS_OVERLAPPED,0,0,0,0,0,NULL,GetInstance(),NULL);
               //Check the value of the window
               if (!m_WindowHandle)
               {
                    //Error
                    m_LastError=::GetLastError();
                    return FALSE;
               }
               else
                    //We have a window
                    m_Window=TRUE;
          }

     //Created !!
     //Success
     return TRUE;
}

HINSTANCE CSpoofSocket::GetInstance()
{
     //Returns the instance of the application, must be overided
     return m_Instance;
}

BOOL CSpoofSocket::OnSocketReceive(int iErrorCode)
{
     //Must override!
     return TRUE;
}

BOOL CSpoofSocket::OnSocketWrite(int iErrorCode)
{
     return TRUE;
}

BOOL CSpoofSocket::OnSocketOOB(int iErrorCode)
{
     return TRUE;
}

BOOL CSpoofSocket::OnSocketClose(int iErrorCode)
{
     return TRUE;
}

BOOL CSpoofSocket::OnSocketAccept(int iErrorCode)
{
     return TRUE;
}

BOOL CSpoofSocket::OnSocketConnect(int iErrorCode)
{
     return TRUE;
}

int CSpoofSocket::GetSocketID()
{
     return m_SocketID;
}

CSpoofSocket* CSpoofSocket::GetSocketByID(int iSockID)
{
     //Get the socket
     CBinaryTree* retVal;

     retVal=m_SocketTree->getNode(iSockID);

     //Check if valid
     if (retVal)
          //Got socket
          return (CSpoofSocket*)retVal->getData();
     else
          //Nothing
          return NULL;
}

BOOL CSpoofSocket::RegisterWindow()
{
     WNDCLASS wc;

     /* Fill in window class structure with parameters that describe the       */
    /* main window.                                                           */

    wc.style = 0;                                                    /* Class style(s).                    */
    wc.lpfnWndProc = (WNDPROC)SocketMessageHandler;       /* Function to retrieve messages for  */
                                        /* windows of this class.             */
    wc.cbClsExtra = 0;                  /* No per-class extra data.           */
    wc.cbWndExtra = 0;                  /* No per-window extra data.          */
    wc.hIcon = NULL;                        /* Icon name from .RC        */
    wc.hInstance = GetInstance();          /* Application that owns the class.   */
    wc.hCursor = NULL;
    wc.hbrBackground = NULL;
    wc.lpszMenuName =  NULL;   /* Name of menu resource in .RC file. */
    wc.lpszClassName = CSpoofSocket_Class ; /* Name used in call to CreateWindow. */

    /* Register the window class and return success/failure code. */

    return (RegisterClass(&wc));
}

//Static members
CBinaryTree* CSpoofSocket::m_SocketTree=NULL;
BOOL CSpoofSocket::m_Window=FALSE;
HWND CSpoofSocket::m_WindowHandle=0;

void CSpoofSocket::SetInstance(HINSTANCE hInst)
{
     m_Instance=hInst;
}

BOOL CSpoofSocket::isRaw()
{
     return m_Raw;
}

BOOL CSpoofSocket::RemoveHandlers()
{
     //First shut down the windows
     if (m_Window)
     {
          if (!DestroyWindow(m_WindowHandle))
               return FALSE;

          if (!UnregisterClass(CSpoofSocket_Class,GetInstance()))
               return FALSE;
     }

     m_Window=FALSE;
     m_WindowHandle=NULL;

     return TRUE;
}

HWND CSpoofSocket::getWindowHandle()
{
     return m_WindowHandle;
}

void CSpoofSocket::InitializeIP()
{
     //Invalid the socket
     m_SpoofSocket=INVALID_SOCKET;

     //More invalids
     m_SourceAddress=NULL;

     //Some defaults
     
     
     
     
         
     
     
     
     
     
     
     
     
     
     m_TTL=g_nTTLVAR;














     //We don't want raw header (so it can work on win 98/NT)
     m_Raw=FALSE;

     //Set our options
     m_IPOptions=NULL;

     //Set options to false
     SetOptions(FALSE);

     //We want async socket
     SetBlocking(FALSE);
}

void CSpoofSocket::AssignSocket(SOCKET sok)
{
     //Binds to a socket
     m_SpoofSocket=sok;

     //Set non raw
     SetRaw(FALSE);

     //Set the handlers
     SetHandlers();

     //Append socket to list
     AddSocketToList();
}

void CSpoofSocket::AddSocketToList()
{
     //Add socket to list
     m_SocketID=m_SpoofSocket;
     m_SocketTree->newNode(GetSocketID())->setData(this);
}

void CSpoofSocket::RemoveSocketFromList()
{
     m_SocketTree->deleteNode(m_SocketID);
}

int CSpoofSocket::Receive(char *buf, int bufLen)
{
     if (!ValidSocket())
          return SOCKET_ERROR;

     //Receive data
     int iResult;

     //Receive
     if (m_Protocol!=IPPROTO_TCP)
          iResult=recvfrom(getHandle(),buf,bufLen,NULL,NULL,NULL);
     else
          iResult=recv(getHandle(),buf,bufLen,NULL);

     //Check if error
     if (iResult==SOCKET_ERROR)
          //Error
          SetLastError();

     //Number of bytes received
     return iResult;
}

char FAR * CSpoofSocket::LongToString(long lAddr)
{
     //First create the address
     in_addr addr;

     //Assign it
     addr.S_un.S_addr=lAddr;

     //Return the value
     return inet_ntoa(addr);
}

BOOL CSpoofSocket::OnSocketTimeout()
{
     //Indicating timeout proccessed
     return FALSE;
}

BOOL CSpoofSocket::SetTimeout(int iMs)
{
     if (!m_Window)
          return FALSE;

     //Set the timer
     return SetTimer(getWindowHandle(),getHandle(),iMs,NULL);
}

BOOL CSpoofSocket::KillTimer()
{
     if (!m_Window)
          return FALSE;

     return ::KillTimer(getWindowHandle(),getHandle());
}

BOOL CSpoofSocket::ValidAddress(LPCTSTR lpAddress)
{
     return inet_addr(lpAddress)!=INADDR_NONE;
}

void CSpoofSocket::SetBlocking(BOOL bBlock)
{
     //Do we want blocking socket
     m_Async=!bBlock;
}


easy 500 points here I just need to know where to insert data payload text...
0
Comment
Question by:bluedragon99
3 Comments
 
LVL 45

Accepted Solution

by:
sunnycoder earned 500 total points
Comment Utility
this is where you need to add the payload - ::Send()
looks like you get the buffer to send and the length of the buffer as parameters here ...
Ideally the payload should be written by the function that calls Send() and the buffer and length passed to this as parameter.
Suprisingly, I cannot locate where you are calling this function !!! You are using the sendto etc. for sending at other places ... If you are calling it from some other place (or a place in the code which I missed), then write the payload there and pass it as an argument here

BOOL CSpoofSocket::Send(LPCSTR lpDestinationAddress,char* buf,int bufLength)
0
 
LVL 1

Author Comment

by:bluedragon99
Comment Utility
Thanks! it worked.  I am calling send() from main dialog.cpp
0

Featured Post

Free Trending Threat Insights Every Day

Enhance your security with threat intelligence from the web. Get trending threat insights on hackers, exploits, and suspicious IP addresses delivered to your inbox with our free Cyber Daily.

Join & Write a Comment

Introduction: The undo support, implementing a stack. Continuing from the eigth article about sudoku.   We need a mechanism to keep track of the digits entered so as to implement an undo mechanism.  This should be a ‘Last In First Out’ collec…
Introduction: Dialogs (1) modal - maintaining the database. Continuing from the ninth article about sudoku.   You might have heard of modal and modeless dialogs.  Here with this Sudoku application will we use one of each type: a modal dialog …
This video will show you how to get GIT to work in Eclipse.   It will walk you through how to install the EGit plugin in eclipse and how to checkout an existing repository.
When you create an app prototype with Adobe XD, you can insert system screens -- sharing or Control Center, for example -- with just a few clicks. This video shows you how. You can take the full course on Experts Exchange at http://bit.ly/XDcourse.

772 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

15 Experts available now in Live!

Get 1:1 Help Now