in_addr iAddr;
		iAddr.S_un.S_un_b.s_b1=bOctet1;
		iAddr.S_un.S_un_b.s_b2=bOctet2;
		iAddr.S_un.S_un_b.s_b3=bOctet3;
		iAddr.S_un.S_un_b.s_b4=bOctet4;

		return inet_ntoa(iAddr);
	}
}

void CPacketCrafterDlg::SetIPCrafter(CIPCrafter *pCrafter)
{
	//Conversion from combo to fragmentation flags
	static const unsigned short ConvertFragFlag[4]={IpFragFlag_MAY_FRAG,IpFragFlag_MORE_FRAG,IpFragFlag_LAST_FRAG,IpFragFlag_DONT_FRAG};

	//Set the values
	pCrafter->SetDefault();

	//Check if we use default checksum
	pCrafter->SetUseDefaultChecksum(m_DefaultChecksum);

	//And do we need to set it
	if (!m_DefaultChecksum)
		pCrafter->SetChecksum(m_CheckSum);

	//Do we need to set the header size
	if (!m_DefaultSize)
		pCrafter->SetHeaderLength(m_HeaderSize);

	//Set the type of service
	pCrafter->SetTypeOfService(m_TypeOfService);

	//Set the fragmentation flag
	pCrafter->SetFragmentationFlags(ConvertFragFlag[m_FragmentationType] | m_Offset/8);
}

void CPacketCrafterDlg::SendIP(CSpoofSocket *pSocket)
{
	//Get the addresses
	std::string sSourceAddress;
	sSourceAddress=IPCtrlToSTR(&m_FromAddress);

	std::string sDestinationAddress;
	sDestinationAddress=IPCtrlToSTR(&m_ToAddress);

	//Set the source address
	pSocket->SetSourceAddress(sSourceAddress);

	//Create it
	if (!pSocket->Create(IPPROTO_IP))
	{
		AfxMessageBox("Failed to create raw socket with IP_HDRINCL flag!");
		return;
	}
	
	//Set the time to live
	pSocket->SetTTL(m_TTL);

	//Create a buffer to supplement the header size
	char* pBuffer;
	pBuffer=GetData();

	//Protect the buffer
	CArray_ptr<char> pProtection(pBuffer);

	int iSendSize;

	//Calculate the needed size
	if (m_DefaultSize)
		iSendSize=0;
	else
		iSendSize=m_HeaderSize-IpHeaderLength;

	//And sent a packet
	if (pSocket->Send(sDestinationAddress,
					  pBuffer,
					  iSendSize+m_DataSize,
					  m_DestinationPort)==SOCKET_ERROR)
	{
		AfxMessageBox("Failed to send data!");
		return;
	}
}

void CPacketCrafterDlg::OnSendUdp() 
{
	//First validate the data
	//First resync
	UpdateData(TRUE);

	//Send only if valid
	if (CheckValidIP())
	{
		CUDPDialog dlg(this);
	
		int nResponse = dlg.DoModal();
	}
}

void CPacketCrafterDlg::SendUDP(unsigned short usUDPChecksum,BOOL bDefaultUDPChecksum)
{
	//OK construct our packet
	CUDPCrafter* pCrafter;
	pCrafter=new CUDPCrafter;

	//Protect it
	std::auto_ptr<CUDPCrafter> pProtection(pCrafter);

	//Set the crafter parameters
	pCrafter->SetUDPChecksum(usUDPChecksum);
	pCrafter->SetUDPUseDefaultChecksum(bDefaultUDPChecksum);

	//Set the crafter parameters
	SetIPCrafter(pCrafter);

	//Get the addresses
	std::string sSourceAddress;
	sSourceAddress=IPCtrlToSTR(&m_FromAddress);

	std::string sDestinationAddress;
	sDestinationAddress=IPCtrlToSTR(&m_ToAddress);

	//Set the source address
	pCrafter->SetSourceAddress(sSourceAddress);

	//Create it
	if (!pCrafter->Create())
	{
		AfxMessageBox("Failed to create raw socket with IP_HDRINCL flag!");
		return;
	}

	//Set the time to live
	pCrafter->SetTTL(m_TTL);

	//Create a buffer to supplement the header size
	char* pBuffer;
	pBuffer=GetData();

	//Protect the buffer
	CArray_ptr<char> pProtection2(pBuffer);

	//And sent a packet
	if (pCrafter->Send(m_SourcePort,
					   sDestinationAddress,
					   m_DestinationPort,
					   pBuffer,
					   m_DataSize)==SOCKET_ERROR)
	{
		AfxMessageBox("Failed to send data!");
		return;
	}
}

void CPacketCrafterDlg::OnSendTcp() 
{
	//First validate the data
	//First resync
	UpdateData(TRUE);

	//Send only if valid
	if (CheckValidIP())
	{
		CTCPDialog dlg(this);
	
		int nResponse = dlg.DoModal();
	}
}

void CPacketCrafterDlg::SendTCP(unsigned char ucFlags,
								DWORD Acknowledge,
								DWORD Sequence,
								BYTE Offset,
								UINT Urgent,
								unsigned short usWindow,
								BOOL bDefaultChecksum,
			 					unsigned short usChecksum)
{
	//OK construct our packet
	CTCPCrafter* pCrafter;
	pCrafter=new CTCPCrafter;

	//Protect the crafter
	std::auto_ptr<CTCPCrafter> pProtection(pCrafter);

	//Set the crafter parameters
	pCrafter->SetFlags(ucFlags);
	pCrafter->SetAcknowledgeNumber(Acknowledge);
	pCrafter->SetTCPUseDefaultChecksum(bDefaultChecksum);
	pCrafter->SetTCPChecksum(usChecksum);
	pCrafter->SetSequenceNumber(Sequence);
	pCrafter->SetDataOffset(Offset);
	pCrafter->SetUrgentPointer(Urgent);
	pCrafter->SetWindow(usWindow);

	//Set the crafter parameters
	SetIPCrafter(pCrafter);

	//Get the addresses
	std::string sSourceAddress;
	sSourceAddress=IPCtrlToSTR(&m_FromAddress);

	std::string sDestinationAddress;
	sDestinationAddress=IPCtrlToSTR(&m_ToAddress);

	//Set the source address
	pCrafter->SetSourceAddress(sSourceAddress);

	//Set the time to live
	pCrafter->SetTTL(m_TTL);

	//Create it
	//Create it
	if (!pCrafter->Create())
	{
		AfxMessageBox("Failed to create raw socket with IP_HDRINCL flag!");
		return;
	}

	//Create a buffer to supplement the header size
	char* pBuffer;
	pBuffer=GetData();

	//Protect the buffer
	CArray_ptr<char> pProtection2(pBuffer);

	//And sent a packet
	if (pCrafter->SendRaw(m_SourcePort,
						  sDestinationAddress,
						  m_DestinationPort,
						  pBuffer,
						  m_DataSize,
						  0)==SOCKET_ERROR)
	{
		AfxMessageBox("Failed to send data!");
		return;
	}
}

char* CPacketCrafterDlg::GetData()
{
	//Check the string size, against the data size
	if (m_DataSize!=m_sData.GetLength())
	{
		//Ask the question
		if (AfxMessageBox("Data length is different then string data, do you want to use string length?",
						  MB_YESNO)==IDYES)
		{
			//Adjust the datasize
			m_DataSize=m_sData.GetLength();

			//Allocate and copy the data
			if (!m_DataSize)
				return NULL;
			else
			{
				//Copy the data
				char* pData;
				pData=new char[m_DataSize];
				memcpy(pData,
					   (const char*)m_sData,
					   m_DataSize);

				//And exit
				return pData;
			}
		}
		else if (m_DataSize)
		{
			//Copy the data
			char* pData;
			pData=new char[m_DataSize];
			memcpy(pData,
				   (const char*)m_sData,
				   m_DataSize);

			//Exit
			return pData;
		}
		else
			;
	}
	else if (m_DataSize)
	{
		//Copy the data
		char* pData;
		pData=new char[m_DataSize];
		memcpy(pData,
			   (const char*)m_sData,
			   m_DataSize);

		//Exit
		return pData;
	}

	//Done
	return NULL;
}

void CPacketCrafterDlg::OnSendICMP() 
{
	//First validate the data
	//First resync
	UpdateData(TRUE);

	//Send only if valid
	if (CheckValidIP())
	{
		CICMPDialog dlg(this);
	
		int nResponse = dlg.DoModal();
	}
}