void CIPLayer::setProtocolStack(unsigned char* ipAddress, unsigned char* macAddress, int adapter_number)
{
((CARPLayer*)GetUnderLayer())->setSenderIPAddress(ipAddress);
((CARPLayer*)GetUnderLayer())->setSenderHardwareAddress(macAddress);
((CARPLayer*)GetUnderLayer())->setEthernetHardwareAddress(macAddress);
((CARPLayer*)GetUnderLayer())->setNICard(adapter_number);
}
void CS1APLayer::AttachReqMsg(int nlength)
{
///////////////////////////////////////////////////// 문제 ////////////////////////////////////////////////////
m_sHeader.s1ap_pdu = S1AP_PDU_INITIAL_MESSAGE; // a type of PDU
m_sHeader.s1ap_proc_code = S1AP_PROC_CODE_INITIAL_UE_MSG; // procedure code
((CSCTPLayer*)GetUnderLayer())->SetSSN(0); // Stream Sequence Number of UnderLayer
m_sHeader.s1ap_crit = 0x40;
m_sHeader.s1ap_length = nlength+3;
((CSCTPLayer*)GetUnderLayer())->SetFlags(SCTP_FLAGS_B | SCTP_FLAGS_E);
}
BOOL CARPLayer::Send(unsigned char* ppayload, int length)
{
CIPLayer::IPLayer_HEADER ipHeader;
memcpy( arpHeader.arpData, ppayload, length );
BOOL isCacheAvailable = FALSE;
list<ARP_CACHE_RECORD>::iterator cacheIter = arpCacheTable.begin();
for(cacheIter; cacheIter != arpCacheTable.end(); cacheIter++)
{
if(memcmp((*cacheIter).ipAddress, targetIPAddress, 4) == 0)
{
isCacheAvailable = TRUE;
break;
}
}
//if cache is vaild and complete record
if((isCacheAvailable == TRUE) && ((*cacheIter).isComplete == TRUE))
{
setTargetHardwareAddress((*cacheIter).ethernetAddress);
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress((*cacheIter).ethernetAddress);
}
//it is not valid record
else
{
memset(arpHeader.arpTargetHardwareAddress, 0, 6);
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress(BROADCAST_ADDR);
}
arpHeader.arpHardwareType = 0x0100;
arpHeader.arpProtocolType = 0x0008;
arpHeader.arpHardwareAddrSize = 0x6;
arpHeader.arpProtocolAddrSize = 0x4;
arpHeader.arpOperationType = ARP_REQUEST;
memcpy(arpHeader.arpSenderHardwareAddress, ownMACAddress, 6);
memcpy(arpHeader.arpSenderIPAddress, ownIPAddress, 4);
memcpy(arpHeader.arpTargetIPAddress, targetIPAddress, 4);
ARP_CACHE_RECORD newRecord;
newRecord.arpInterface = this->adapter;
memset(newRecord.ethernetAddress, 0, 6);
memcpy(newRecord.ipAddress, targetIPAddress, 4);
newRecord.isComplete = FALSE;
arpCacheTable.push_back(newRecord);
BOOL bSuccess = FALSE ;
bSuccess = mp_UnderLayer->Send((unsigned char*)&arpHeader,length+ARP_HEADER_SIZE);
return bSuccess;
}
void CS1APLayer::attachCompleteItems(int nlength)
{
///////////////////////////////////////////////////// 문제 ////////////////////////////////////////////////////
// AttachReqMsg 함수를 참고하여 작성하시오.
m_sHeader.s1ap_pdu = S1AP_PDU_INITIAL_MESSAGE; // 수정하시오.
m_sHeader.s1ap_proc_code = S1AP_PROC_CODE_INITIAL_UE_MSG; // 수정하시오.
((CSCTPLayer*)GetUnderLayer())->SetSSN(0); // 수정하시오.
m_sHeader.s1ap_crit = 0x40;
m_sHeader.s1ap_length = nlength+3;
((CSCTPLayer*)GetUnderLayer())->SetFlags(SCTP_FLAGS_B | SCTP_FLAGS_E);
}
void CS1APLayer::initialContextSetupRequestAttachAcceptItems(int nlength)
{
///////////////////////////////////////////////////// 문제 ////////////////////////////////////////////////////
// AttachReqMsg 함수를 참고하여 작성하시오.
m_sHeader.s1ap_pdu = S1AP_PDU_INITIAL_MESSAGE; // 수정하시오.
m_sHeader.s1ap_proc_code = S1AP_PROC_CODE_INITIAL_UE_MSG; // 수정하시오.
((CSCTPLayer*)GetUnderLayer())->SetSSN(0); // 수정하시오.
m_sHeader.s1ap_crit = htons(0x0080);
m_sHeader.s1ap_length = nlength+3;
((CSCTPLayer*)GetUnderLayer())->SetFlags(SCTP_FLAGS_B | SCTP_FLAGS_E);
}
BOOL CIPLayer::sendPacketViaGivenAddress(BOOL isHeaderedData, unsigned char* ppayload, unsigned char* route_address,
unsigned char* arp_target, unsigned char* ip_target, unsigned int length)
{
BOOL bSuccess = FALSE;
unsigned char* packet;
unsigned char* packet_reserv = (unsigned char*)malloc(length);
if(isHeaderedData == FALSE)
{
m_sHeader.ip_verlen = 0x49;
m_sHeader.ip_tos = 0x01;
m_sHeader.ip_len = 0x20;
m_sHeader.ip_id = 0x0000;
m_sHeader.ip_fragoff = 0x0000;
m_sHeader.ip_proto = 0x1;
m_sHeader.ip_cksum = 0x0000;
m_sHeader.ip_ttl = 24;
memcpy( m_sHeader.ip_data, ppayload, length ) ;
memcpy(m_sHeader.ip_dst, destip, 4);
memcpy(m_sHeader.ip_src, srcip, 4);
packet = (unsigned char*) &m_sHeader;
}
else
{
packet = ppayload;
((CARPLayer*)GetUnderLayer())->setSenderIPAddress(route_address);
}
memcpy(packet_reserv, packet, length);
PIPLayer_HEADER pFrame = (PIPLayer_HEADER) packet;
((CARPLayer*)GetUnderLayer())->next_ethernet_type = ETHER_PROTO_TYPE_ARP;
((CARPLayer*)GetUnderLayer())->setTargetIPAddress(arp_target);
//bSuccess = mp_UnderLayer->Send((unsigned char*)ppayload,sizeof(*ppayload));
bSuccess = mp_UnderLayer->Send((unsigned char*)packet, length);
if(bSuccess) //ARP Request Success
{
((CARPLayer*)GetUnderLayer())->next_ethernet_type = ETHER_PROTO_TYPE_IP;
((CARPLayer*)GetUnderLayer())->setTargetIPAddress(ip_target);
unsigned char targetMAC[6];
memcpy(targetMAC, ((CARPLayer*)GetUnderLayer())->getHardwareAddressByGivenIPAddress(arp_target), 6);
PIPLayer_HEADER pFrame = (PIPLayer_HEADER) packet;
((CARPLayer*)GetUnderLayer())->setTargetHardwareAddress(targetMAC);
bSuccess = mp_UnderLayer->Send((unsigned char*)packet_reserv, length);
}
return bSuccess;
}
void ImgLayer::BltRectSynthPixel(
IplImageExt* dst,
int d_x,
int d_y,
int s_x,
int s_y,
int width,
int height) const
{
if (m_Alpha == 0.0)
return;
IImgLayer_Ptr mask_layer = GetUnderLayer().lock();
if (IsClipWithUnderLayer() && mask_layer) {
RECT mask_rc;
mask_layer->GetLayerRect(&mask_rc);
LayerSynthesizerMG::BltSynth(
m_LayerSynthFourCC,
m_Alpha,
dst,
d_x, d_y,
width, height,
m_Img,
s_x - m_LayerRect.left,
s_y - m_LayerRect.top,
mask_layer->GetLayerImage(),
s_x - mask_rc.left,
s_y - mask_rc.top);
} else {
LayerSynthesizerMG::BltSynth(
m_LayerSynthFourCC,
m_Alpha,
dst,
d_x, d_y,
width, height,
m_Img,
s_x - m_LayerRect.left,
s_y - m_LayerRect.top);
}
}
void CARPLayer::setNICard(int adapter_number)
{
((CNILayer*)((CEthernetLayer*)GetUnderLayer())->GetUnderLayer())->SetOpenedAdapterObject(((CNILayer*)((CEthernetLayer*)GetUnderLayer())->GetUnderLayer())->adapterOpenedIndexList[adapter_number]);
}
void CARPLayer::setEthernetHardwareAddress(unsigned char* macAddress)
{
((CEthernetLayer*)GetUnderLayer())->SetEnetSrcAddress(macAddress);
}
BOOL CARPLayer::Receive(unsigned char* ppayload)
{
PARP_HEADER pARPFrame = (PARP_HEADER)ppayload;
BOOL bSuccess = FALSE ;
BOOL GratitousOccur = FALSE ;
BOOL isNotMyIPAddress = FALSE;
unsigned char receivedARPTargetIPAddress[4];
unsigned char receivedARPSenderIPAddress[4];
unsigned char receivedARPSenderHardwareAddress[6];
memcpy(receivedARPTargetIPAddress, (unsigned char*)pARPFrame->arpTargetIPAddress, 4); //받아온 패킷을 통해 목적지ip, 시작지ip , 시작지mac 을 설정
memcpy(receivedARPSenderIPAddress, (unsigned char*)pARPFrame->arpSenderIPAddress, 4);
memcpy(receivedARPSenderHardwareAddress, (unsigned char*)pARPFrame->arpSenderHardwareAddress, 6);
BOOL isARPRecordExist = FALSE;
list<ARP_CACHE_RECORD>::iterator arpIter = arpCacheTable.begin();
for(arpIter; arpIter != arpCacheTable.end(); arpIter++) // arp table을 본다.
{
if(memcmp((*arpIter).ipAddress,receivedARPSenderIPAddress, 4) == 0) //만약 해당 테이블의 ip 주소와 받은 패킷의 시작지 ip 주소 같다면
{
isARPRecordExist = TRUE; //이미 존재한다고 표시.
memcpy((*arpIter).ethernetAddress, receivedARPSenderHardwareAddress, 6);// 맥주소를 새로 받아온 걸로 갱신. 자세히는 gratitous, ???? , 중복상태를 나누어야하지만 그냥..
// 무조건 갱신하도록 함.
(*arpIter).isComplete = TRUE; // complete 되었다고 표시.
(*arpIter).lifeTimeCounter = COMPLETE_DELETE_TIME;
break;
}
}
if (memcmp(ownIPAddress, receivedARPSenderIPAddress, 4) == 0) // gratitous인지 확인.
GratitousOccur = TRUE;
if (memcmp(ownIPAddress, receivedARPTargetIPAddress, 4) != 0) // gratitous아니라는 걸 확인.
isNotMyIPAddress = TRUE;
BOOL isProxyAvailable = FALSE; //proxy table에 사용될 게 있느냐
list<ARP_CACHE_RECORD>::iterator proxyIter = arpProxyTable.begin();
for(proxyIter; proxyIter != arpProxyTable.end(); proxyIter++) //proxy table 살피기위해 for구문돌림.
{
if(memcmp((*proxyIter).ipAddress, receivedARPTargetIPAddress, 4) == 0) //만약 같은 ip가 있다면. 즉, 받은 패킷을 대신 reply 해 줄 능력이 있느냐.
{
isProxyAvailable = TRUE; //proxy table 사용 가능이라 표시.
break;
}
}
if(GratitousOccur == FALSE) //Gratitous가 발생하지 않았다면. Gratitous 발생은 arptable 갱신만을 필요로 하므로 위에서 다 처리되었음.
{
if(ntohs(pARPFrame->arpOperationType) == ntohs(ARP_REPLY)) // 받은 패킷이 reply라면
{
((CIPLayer*)GetUpperLayer(0))->semaphore = 1;
bSuccess = mp_aUpperLayer[0]->Receive((unsigned char*)pARPFrame->arpData); //상위계층으로 올려줌.
return bSuccess;
}
if(ntohs(pARPFrame->arpOperationType) == ntohs(ARP_REQUEST)) //받은 패킷이 request라면
{
if(isARPRecordExist == FALSE)// arptable에 중복되는 것이 없다면 table에 추가.
{
ARP_CACHE_RECORD newRecord;
newRecord.arpInterface = adapter;
memcpy(newRecord.ethernetAddress, receivedARPSenderHardwareAddress, 6);
memcpy(newRecord.ipAddress, receivedARPSenderIPAddress, 4);
newRecord.isComplete = TRUE;
newRecord.lifeTimeCounter = INCOMPLETE_DELETE_TIME;
arpCacheTable.push_back(newRecord);
}
}
// 주목! 이제 여기를 들어오는 건 받은 패킷이 ARP_REQUEST 상태만일 때일 것이다. reply를 보내주는 작업(send)은 진행 될 수 있다.
unsigned char tempHardwareAddress[6];
unsigned char tempIPAddress[4];
memset(tempHardwareAddress, 0, 6);
memset(tempIPAddress, 0, 4);
memcpy(tempHardwareAddress, receivedARPSenderHardwareAddress, 6);
memcpy(tempIPAddress, receivedARPSenderIPAddress, 4);
if ( (receivedARPTargetIPAddress[0] == ownIPAddress[0]) &&
(receivedARPTargetIPAddress[1] == ownIPAddress[1]) &&
(receivedARPTargetIPAddress[2] == ownIPAddress[2]) &&
(receivedARPTargetIPAddress[3] == ownIPAddress[3]))
{ // 받은 패킷의 목적지주소와 자신의 주소가 같다면, 보내줄 reply를 위한 mac주소를 설정한다. ip도 역시 설정해준다.
memcpy(arpHeader.arpSenderHardwareAddress, ownMACAddress, 6);
memcpy(arpHeader.arpSenderIPAddress, ownIPAddress, 4);
}
if(isProxyAvailable == TRUE) //proxytable 이용 가능하다면,
{
memcpy(arpHeader.arpSenderHardwareAddress, (*proxyIter).ethernetAddress, 6); // 그 proxytable에 있는 정보를 갖고 패킷을 형성해준다.
memcpy(arpHeader.arpSenderIPAddress, (*proxyIter).ipAddress, 4);
}
if(isNotMyIPAddress == TRUE && isProxyAvailable == FALSE)// proxy도 이용하지 못하고, 목적지 ip와 자신의 ip가 다르니, 버리는 작업.
return FALSE;
//이제 지금까지 했던 작업을 토대로 나머지 패킷을 만들어주는 작업을 한다.
memcpy(arpHeader.arpTargetHardwareAddress, tempHardwareAddress, 6);
memcpy(arpHeader.arpTargetIPAddress, tempIPAddress, 4);
arpHeader.arpHardwareType = 0x0100;
arpHeader.arpProtocolType = 0x0008;
arpHeader.arpHardwareAddrSize = 0x6;
arpHeader.arpProtocolAddrSize = 0x4;
arpHeader.arpOperationType = ARP_REPLY;
memset(arpHeader.arpData, 0, 1);
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress(arpHeader.arpTargetHardwareAddress);
((CEthernetLayer*)GetUnderLayer())->SetEnetSrcAddress(arpHeader.arpSenderHardwareAddress);
//사실상 proxytable을 이용하는 경우에는 Receive를 하지 않고 send만 해주면 된다, 수정이 필요한 곳.
//bSuccess = mp_aUpperLayer[0]->Receive((unsigned char*)pARPFrame->arpData); // 나한테 들어온 request 패킷을 상위계층으로 올려주는 것.
bSuccess = mp_UnderLayer->Send((unsigned char*)&arpHeader, ARP_HEADER_SIZE);// 내가 reply를 해주어야 하는 작업을 처리하는 것.
// ----정리---
// 1. Gratitous라면, 테이블 갱신만 해주고, 아무런 작업을 하지않음.
// 2. 들어온 패킷의 목적지 ip가 자신의 ip와 같고, 들어온 패킷이 reply라면, 상위 계층으로 올려주고 작업 끝.
// 3. 들어온 패킷의 목적지 ip가 자신의 ip와 같고, 들어온 패킷이 request라면, reply 패킷을 만들어서 send를 해주고, 받은 request 패킷은 상위계층으로 올려줌.
// 4. 들어온 패킷의 목적지 ip와 proxy table에 존재하는 ip가 일치한다면, 대신해서 mac주소 설정해준 뒤 reply 패킷을 만들어 send를 함.
//discard this message.
return bSuccess;
}
else //gratitous 가 발생 했다면 그냥리턴, 얘는 테이블갱신만 해주면 작업이 끝나는 것이므로.
return TRUE;
}
BOOL CARPLayer::Send(unsigned char* ppayload, int length)
{
memcpy( arpHeader.arpData, ppayload, length );
BOOL bSuccess = FALSE ;
BOOL isCacheSameIP = FALSE; //캐시 이용가능한지.
BOOL isCacheSameMAC = FALSE;
BOOL isGratuitousPacket = FALSE; //gratuitous 발생 했는지.
list<ARP_CACHE_RECORD>::iterator cacheIter = arpCacheTable.begin();
if(memcmp(targetIPAddress, ownIPAddress, 4) == 0) // gratuitous인지 확인.
isGratuitousPacket = TRUE;
else
{
for(cacheIter; cacheIter != arpCacheTable.end(); cacheIter++)// gratuitous 아니라면, cache에 있는 만큼 for구문돌림.
{
if(memcmp((*cacheIter).ipAddress, targetIPAddress, 4) == 0) //보내려는 ip와 같은 ip가 있다면
{
isCacheSameIP = TRUE;
break;
}
if(memcmp((*cacheIter).ethernetAddress, targetMACAddress, 6) == 0)
{
isCacheSameMAC = TRUE;
break;
}
}
}
//if cache is vaild and complete record
if(((isCacheSameIP == TRUE) || (isCacheSameMAC == TRUE)) && ((*cacheIter).isComplete == TRUE)) // 캐시에 사용가능한 것이 존재한다면,
{
setTargetHardwareAddress((*cacheIter).ethernetAddress); //캐시에 있다면 mac 주소를 알게 된 것이므로, 이 mac 주소로 재설정.
((CEthernetLayer*)GetUnderLayer())->m_sHeader.enet_type = next_ethernet_type;
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress((*cacheIter).ethernetAddress);// ethernet layer의 mac 주소도 다시 설정.
}
else if(isCacheSameIP == TRUE)
{
}
//it is not valid record
else // 캐시도 없고, gratuitous도 아니고.
{
memset(arpHeader.arpTargetHardwareAddress, 0, 6);
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress(BROADCAST_ADDR);
((CEthernetLayer*)GetUnderLayer())->m_sHeader.enet_type = next_ethernet_type;
ARP_CACHE_RECORD newRecord;
newRecord.arpInterface = this->adapter;
memset(newRecord.ethernetAddress, 0, 6);
memcpy(newRecord.ipAddress, targetIPAddress, 4);
newRecord.isComplete = FALSE;
newRecord.lifeTimeCounter = INCOMPLETE_DELETE_TIME;
arpCacheTable.push_back(newRecord);
}
if(next_ethernet_type == ETHER_PROTO_TYPE_IP)
bSuccess = mp_UnderLayer->Send((unsigned char*)ppayload, length);
else
{
// ----정리---
// 1. Gratuitous가 맞다면, 그냥 아무 작업 하지 않고, 패킷 만들어서 보냄.
// 2. 캐시 이용가능하다면, 캐시에 있는 값으로 맥주소 설정해서 보냄.
// 3. 이용가능한 캐시 없고, gratitous가 아니라면 broadcast로 목적지 설정해서 보냄.
arpHeader.arpHardwareType = 0x0100;
arpHeader.arpProtocolType = 0x0008;
arpHeader.arpHardwareAddrSize = 0x6;
arpHeader.arpProtocolAddrSize = 0x4;
arpHeader.arpOperationType = ARP_REQUEST;
memcpy(arpHeader.arpSenderHardwareAddress, ownMACAddress, 6);
memcpy(arpHeader.arpSenderIPAddress, ownIPAddress, 4);
memcpy(arpHeader.arpTargetIPAddress, targetIPAddress, 4);
bSuccess = mp_UnderLayer->Send((unsigned char*)&arpHeader,length+ARP_HEADER_SIZE);
}
return bSuccess;
}
BOOL CARPLayer::Receive(unsigned char* ppayload)
{
PARP_HEADER pARPFrame = (PARP_HEADER)ppayload;
BOOL bSuccess = FALSE ;
unsigned char* receivedARPTargetIPAddress = (unsigned char*)pARPFrame->arpTargetIPAddress;
unsigned char* receivedARPSenderIPAddress = (unsigned char*)pARPFrame->arpSenderIPAddress;
unsigned char* receivedARPSenderHardwareAddress = (unsigned char*)pARPFrame->arpSenderHardwareAddress;
if ( (receivedARPTargetIPAddress[0] == ownIPAddress[0]) &&
(receivedARPTargetIPAddress[1] == ownIPAddress[1]) &&
(receivedARPTargetIPAddress[2] == ownIPAddress[2]) &&
(receivedARPTargetIPAddress[3] == ownIPAddress[3]))
{
BOOL isARPRecordExist = FALSE;
list<ARP_CACHE_RECORD>::iterator arpIter = arpCacheTable.begin();
for(arpIter; arpIter != arpCacheTable.end(); arpIter++)
{
if(memcmp((*arpIter).ipAddress,receivedARPTargetIPAddress, 4) == 0)
{
isARPRecordExist = TRUE;
memcpy((*arpIter).ethernetAddress, receivedARPSenderHardwareAddress, 6);
(*arpIter).isComplete = TRUE;
break;
}
}
if(ntohs(pARPFrame->arpOperationType) == ntohs(ARP_REQUEST))
{
if(isARPRecordExist == FALSE)
{
ARP_CACHE_RECORD newRecord;
newRecord.arpInterface = adapter;
memcpy(newRecord.ethernetAddress, receivedARPSenderHardwareAddress, 6);
memcpy(newRecord.ipAddress, receivedARPSenderIPAddress, 4);
newRecord.isComplete = TRUE;
arpCacheTable.push_back(newRecord);
}
unsigned char tempHardwareAddress[6];
unsigned char tempIPAddress[4];
memset(tempHardwareAddress, 0, 6);
memset(tempIPAddress, 0, 4);
memcpy(tempHardwareAddress, receivedARPSenderHardwareAddress, 6);
memcpy(tempIPAddress, receivedARPSenderIPAddress, 4);
memcpy(arpHeader.arpSenderHardwareAddress, ownMACAddress, 6);
memcpy(arpHeader.arpTargetHardwareAddress, tempHardwareAddress, 6);
memcpy(arpHeader.arpSenderIPAddress, ownIPAddress, 4);
memcpy(arpHeader.arpTargetIPAddress, tempIPAddress, 4);
arpHeader.arpHardwareType = 0x0100;
arpHeader.arpProtocolType = 0x0008;
arpHeader.arpHardwareAddrSize = 0x6;
arpHeader.arpProtocolAddrSize = 0x4;
arpHeader.arpOperationType = ARP_REPLY;
memset(arpHeader.arpData, 0, 1);
((CEthernetLayer*)GetUnderLayer())->SetEnetDstAddress(arpHeader.arpTargetHardwareAddress);
((CEthernetLayer*)GetUnderLayer())->SetEnetSrcAddress(arpHeader.arpSenderHardwareAddress);
bSuccess = mp_aUpperLayer[0]->Receive((unsigned char*)pARPFrame->arpData);
bSuccess = mp_UnderLayer->Send((unsigned char*)&arpHeader, ARP_HEADER_SIZE);
}
return bSuccess;
}
else
{
//discard this message.
return bSuccess;
}
}
