static HRESULT StreamTimeGet( aout_stream_t *s, mtime_t *delay )
{
return TimeGet( s->sys, delay );
}
//////////////////////////////////////////////////////////////////////
// NPC Thread Callback Function
//
UINT NpcThreadProc(LPVOID pParam /* NPC_THREAD_INFO ptr */)
{
NPC_THREAD_INFO* pInfo = (NPC_THREAD_INFO*)pParam;
CNpc* pNpc = NULL;
CIOCPort* pIOCP = NULL;
CPoint pt;
int i = 0;
DWORD dwDiffTime = 0;
DWORD dwSleep = 250;
DWORD dwTickTime = 0;
srand( (unsigned)time( NULL ) );
myrand( 1, 10000 ); myrand( 1, 10000 );
float fTime2 = 0.0f;
float fTime3 = 0.0f;
int duration_damage=0;
if(!pInfo) return 0;
while(!g_bNpcExit)
{
fTime2 = TimeGet();
for(i = 0; i < NPC_NUM; i++)
{
pNpc = pInfo->pNpc[i];
pIOCP = pInfo->pIOCP;
if( !pNpc ) continue;
//if((pNpc->m_tNpcType == NPCTYPE_DOOR || pNpc->m_tNpcType == NPCTYPE_ARTIFACT || pNpc->m_tNpcType == NPCTYPE_PHOENIX_GATE || pNpc->m_tNpcType == NPCTYPE_GATE_LEVER) && !pNpc->m_bFirstLive) continue;
//if( pNpc->m_bFirstLive ) continue;
if( pNpc->m_sNid < 0 ) continue; // 잘못된 몬스터 (임시코드 2002.03.24)
fTime3 = fTime2 - pNpc->m_fDelayTime;
dwTickTime = fTime3 * 1000;
//if(i==0)
//TRACE("thread time = %.2f, %.2f, %.2f, delay=%d, state=%d, nid=%d\n", pNpc->m_fDelayTime, fTime2, fTime3, dwTickTime, pNpc->m_NpcState, pNpc->m_sNid+NPC_BAND);
if(pNpc->m_Delay > (int)dwTickTime && !pNpc->m_bFirstLive && pNpc->m_Delay != 0)
{
if(pNpc->m_Delay < 0) pNpc->m_Delay = 0;
//적발견시... (2002. 04.23수정, 부하줄이기)
if(pNpc->m_NpcState == NPC_STANDING && pNpc->CheckFindEnermy() ) {
if( pNpc->FindEnemy() ) {
pNpc->m_NpcState = NPC_ATTACKING;
pNpc->m_Delay = 0;
}
}
continue;
}
fTime3 = fTime2 - pNpc->m_fHPChangeTime;
dwTickTime = fTime3 * 1000;
if( 10000 < dwTickTime ) { // 10초마다 HP를 회복 시켜준다
pNpc->HpChange(pIOCP);
}
pNpc->DurationMagic_4(pIOCP, fTime2); // 마법 처리...
pNpc->DurationMagic_3(pIOCP, fTime2); // 지속마법..
switch(pNpc->m_NpcState)
{
case NPC_LIVE: // 방금 살아난 경우
pNpc->NpcLive(pIOCP);
break;
case NPC_STANDING: // 하는 일 없이 서있는 경우
pNpc->NpcStanding();
break;
case NPC_MOVING:
pNpc->NpcMoving(pIOCP);
break;
case NPC_ATTACKING:
pNpc->NpcAttacking(pIOCP);
break;
case NPC_TRACING:
pNpc->NpcTracing(pIOCP);
break;
case NPC_FIGHTING:
pNpc->NpcFighting(pIOCP);
break;
case NPC_BACK:
pNpc->NpcBack(pIOCP);
break;
case NPC_STRATEGY:
break;
case NPC_DEAD:
//pNpc->NpcTrace(_T("NpcDead"));
pNpc->m_NpcState = NPC_LIVE;
break;
case NPC_SLEEPING:
pNpc->NpcSleeping(pIOCP);
break;
case NPC_FAINTING:
pNpc->NpcFainting(pIOCP, fTime2);
break;
case NPC_HEALING:
pNpc->NpcHealing(pIOCP);
break;
default:
break;
}
}
dwSleep = 100;
Sleep(dwSleep);
}
return 0;
}
/**
* \test drops
*/
static int DetectDetectionFilterTestSig3(void)
{
Packet *p = NULL;
Signature *s = NULL;
ThreadVars th_v;
DetectEngineThreadCtx *det_ctx;
int result = 0;
int alerts = 0;
int drops = 0;
struct timeval ts;
HostInitConfig(HOST_QUIET);
memset (&ts, 0, sizeof(struct timeval));
TimeGet(&ts);
memset(&th_v, 0, sizeof(th_v));
p = UTHBuildPacketReal(NULL, 0, IPPROTO_TCP, "1.1.1.1", "2.2.2.2", 1024, 80);
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
goto end;
}
de_ctx->flags |= DE_QUIET;
s = de_ctx->sig_list = SigInit(de_ctx,"drop tcp any any -> any 80 (msg:\"detection_filter Test 2\"; detection_filter: track by_dst, count 2, seconds 60; sid:10;)");
if (s == NULL) {
goto end;
}
SigGroupBuild(de_ctx);
DetectEngineThreadCtxInit(&th_v, (void *)de_ctx, (void *)&det_ctx);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts = PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
TimeSetIncrementTime(200);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
drops += ((PACKET_TEST_ACTION(p, ACTION_DROP))?1:0);
p->action = 0;
if (alerts == 3 && drops == 3)
result = 1;
else {
if (alerts != 3)
printf("alerts: %d != 3: ", alerts);
if (drops != 3)
printf("drops: %d != 3: ", drops);
}
SigGroupCleanup(de_ctx);
SigCleanSignatures(de_ctx);
DetectEngineThreadCtxDeinit(&th_v, (void *)det_ctx);
DetectEngineCtxFree(de_ctx);
end:
UTHFreePackets(&p, 1);
HostShutdown();
return result;
}
static json_t *CreateJSONHeaderFromFlow(Flow *f, char *event_type)
{
char timebuf[64];
char srcip[46], dstip[46];
Port sp, dp;
json_t *js = json_object();
if (unlikely(js == NULL))
return NULL;
struct timeval tv;
memset(&tv, 0x00, sizeof(tv));
TimeGet(&tv);
CreateIsoTimeString(&tv, timebuf, sizeof(timebuf));
srcip[0] = '\0';
dstip[0] = '\0';
if (FLOW_IS_IPV4(f)) {
PrintInet(AF_INET, (const void *)&(f->src.addr_data32[0]), srcip, sizeof(srcip));
PrintInet(AF_INET, (const void *)&(f->dst.addr_data32[0]), dstip, sizeof(dstip));
} else if (FLOW_IS_IPV6(f)) {
PrintInet(AF_INET6, (const void *)&(f->src.address), srcip, sizeof(srcip));
PrintInet(AF_INET6, (const void *)&(f->dst.address), dstip, sizeof(dstip));
}
sp = f->sp;
dp = f->dp;
char proto[16];
if (SCProtoNameValid(f->proto) == TRUE) {
strlcpy(proto, known_proto[f->proto], sizeof(proto));
} else {
snprintf(proto, sizeof(proto), "%03" PRIu32, f->proto);
}
/* time */
json_object_set_new(js, "timestamp", json_string(timebuf));
CreateJSONFlowId(js, (const Flow *)f);
#if 0 // TODO
/* sensor id */
if (sensor_id >= 0)
json_object_set_new(js, "sensor_id", json_integer(sensor_id));
#endif
if (event_type) {
json_object_set_new(js, "event_type", json_string(event_type));
}
#if 0
/* vlan */
if (f->vlan_id[0] > 0) {
json_t *js_vlan;
switch (f->vlan_idx) {
case 1:
json_object_set_new(js, "vlan",
json_integer(f->vlan_id[0]));
break;
case 2:
js_vlan = json_array();
if (unlikely(js != NULL)) {
json_array_append_new(js_vlan,
json_integer(VLAN_GET_ID1(p)));
json_array_append_new(js_vlan,
json_integer(VLAN_GET_ID2(p)));
json_object_set_new(js, "vlan", js_vlan);
}
break;
default:
/* shouldn't get here */
break;
}
}
#endif
/* tuple */
json_object_set_new(js, "src_ip", json_string(srcip));
switch(f->proto) {
case IPPROTO_ICMP:
break;
case IPPROTO_UDP:
case IPPROTO_TCP:
case IPPROTO_SCTP:
json_object_set_new(js, "src_port", json_integer(sp));
break;
}
json_object_set_new(js, "dest_ip", json_string(dstip));
switch(f->proto) {
case IPPROTO_ICMP:
break;
case IPPROTO_UDP:
case IPPROTO_TCP:
case IPPROTO_SCTP:
json_object_set_new(js, "dest_port", json_integer(dp));
break;
}
json_object_set_new(js, "proto", json_string(proto));
switch (f->proto) {
case IPPROTO_ICMP:
case IPPROTO_ICMPV6:
json_object_set_new(js, "icmp_type",
json_integer(f->type));
json_object_set_new(js, "icmp_code",
json_integer(f->code));
break;
}
return js;
}
// sungyong 2002.05.22
void CGameSocket::RecvServerConnect(char *pBuf)
{
int index = 1;
int outindex = 0, zone_index = 0;
float fReConnectEndTime = 0.0f;
char pData[1024];
memset(pData, 0, 1024);
BYTE byZoneNumber = GetByte(pBuf, index);
BYTE byReConnect = GetByte(pBuf, index); // 0 : 처음접속, 1 : 재접속
CString logstr;
logstr.Format("[GameServer Connect - %d]", byZoneNumber);
m_pMain->m_StatusList.AddString( logstr );
TRACE(logstr);
if(byZoneNumber < 0) {
SetByte(pData, SERVER_CONNECT, outindex);
SetByte(pData, -1, outindex);
Send(pData, outindex);
}
m_sSocketID = byZoneNumber;
SetByte(pData, SERVER_CONNECT, outindex);
SetByte(pData, byZoneNumber, outindex);
SetByte(pData, byReConnect, outindex);
Send(pData, outindex);
if(byReConnect == 1) { // 재접속해서 리스트 받기 (강제로)
if(m_pMain->m_sReSocketCount == 0)
m_pMain->m_fReConnectStart = TimeGet();
m_pMain->m_sReSocketCount++;
TRACE("**** ReConnect - zone=%d, socket = %d ****\n ", byZoneNumber, m_pMain->m_sReSocketCount);
fReConnectEndTime = TimeGet();
if(fReConnectEndTime > m_pMain->m_fReConnectStart+120) { // 2분안에 모든 소켓이 재접됐다면...
TRACE("**** ReConnect - 단순한 접속... socket = %d ****\n ", m_pMain->m_sReSocketCount);
m_pMain->m_sReSocketCount = 0;
m_pMain->m_fReConnectStart = 0.0f;
}
if(m_pMain->m_sReSocketCount == MAX_AI_SOCKET) {
fReConnectEndTime = TimeGet();
if(fReConnectEndTime < m_pMain->m_fReConnectStart+60) { // 1분안에 모든 소켓이 재접됐다면...
TRACE("**** ReConnect - 모든 소켓 초기화 완료 socket = %d ****\n ", m_pMain->m_sReSocketCount);
m_pMain->m_bFirstServerFlag = TRUE;
m_pMain->m_sReSocketCount = 0;
m_pMain->AllNpcInfo();
}
else { // 하나의 떨어진 소켓이라면...
m_pMain->m_sReSocketCount = 0;
m_pMain->m_fReConnectStart = 0.0f;
}
}
}
else {
//m_pMain->PostMessage( WM_GAMESERVER_LOGIN, (LONG)byZoneNumber );
m_pMain->m_sSocketCount++;
TRACE("**** Connect - zone=%d, socket = %d ****\n ", byZoneNumber, m_pMain->m_sSocketCount);
if(m_pMain->m_sSocketCount == MAX_AI_SOCKET) {
TRACE("**** Connect - 모든 소켓 초기화 완료 socket = %d ****\n ", m_pMain->m_sSocketCount);
m_pMain->m_bFirstServerFlag = TRUE;
m_pMain->m_sSocketCount = 0;
m_pMain->AllNpcInfo();
}
}
}
void CAISocket::RecvNpcGiveItem(char* pBuf)
{
int index = 0, send_index = 0;
char send_buff[1024];
short sUid, sNid, sZone, regionx, regionz;
float fX, fZ, fY;
BYTE byCount;
int nItemNumber[NPC_HAVE_ITEM_LIST];
short sCount[NPC_HAVE_ITEM_LIST];
_ZONE_ITEM* pItem = NULL;
C3DMap* pMap = NULL;
CUser* pUser = NULL;
sUid = GetShort(pBuf,index); // Item을 가져갈 사람의 아이디... (이것을 참조해서 작업하셈~)
sNid = GetShort(pBuf,index);
sZone = GetShort(pBuf, index);
regionx = GetShort( pBuf, index );
regionz = GetShort( pBuf, index );
fX = Getfloat(pBuf,index);
fZ = Getfloat(pBuf,index);
fY = Getfloat(pBuf,index);
byCount = GetByte(pBuf,index);
for(int i=0; i<byCount; i++)
{
nItemNumber[i] = GetDWORD(pBuf, index);
sCount[i] = GetShort(pBuf,index);
}
if( sUid < 0 || sUid >= MAX_USER ) return;
pMap = m_pMain->GetZoneByID(sZone);
if (pMap == NULL)
return;
pItem = new _ZONE_ITEM;
for(int i=0; i<6; i++) {
pItem->itemid[i] = 0;
pItem->count[i] = 0;
}
pItem->bundle_index = pMap->m_wBundle;
pItem->time = TimeGet();
pItem->x = fX;
pItem->z = fZ;
pItem->y = fY;
for(int i=0; i<byCount; i++) {
if( m_pMain->m_ItemtableArray.GetData(nItemNumber[i]) ) {
pItem->itemid[i] = nItemNumber[i];
pItem->count[i] = sCount[i];
}
}
if (!pMap->RegionItemAdd(regionx, regionz, pItem ))
{
delete pItem;
return;
}
pUser = m_pMain->GetUserPtr(sUid);
if (pUser == NULL)
return;
send_index = 0;
SetByte( send_buff, WIZ_ITEM_DROP, send_index );
SetShort( send_buff, sNid, send_index );
SetDWORD( send_buff, pItem->bundle_index, send_index );
if( pUser->m_sPartyIndex == -1 )
pUser->Send( send_buff, send_index );
else
m_pMain->Send_PartyMember( pUser->m_sPartyIndex, send_buff, send_index );
}
/**
* \brief Recieves packets from an interface via libpfring.
*
* This function recieves packets from an interface and passes
* the packet on to the pfring callback function.
*
* \param tv pointer to ThreadVars
* \param data pointer that gets cast into PfringThreadVars for ptv
* \param slot slot containing task information
* \retval TM_ECODE_OK on success
* \retval TM_ECODE_FAILED on failure
*/
TmEcode ReceivePfringLoop(ThreadVars *tv, void *data, void *slot)
{
SCEnter();
PfringThreadVars *ptv = (PfringThreadVars *)data;
Packet *p = NULL;
struct pfring_pkthdr hdr;
TmSlot *s = (TmSlot *)slot;
time_t last_dump = 0;
struct timeval current_time;
ptv->slot = s->slot_next;
/* we have to enable the ring here as we need to do it after all
* the threads have called pfring_set_cluster(). */
int rc = pfring_enable_ring(ptv->pd);
if (rc != 0) {
SCLogError(SC_ERR_PF_RING_OPEN, "pfring_enable_ring failed returned %d ", rc);
SCReturnInt(TM_ECODE_FAILED);
}
while(1) {
if (suricata_ctl_flags & (SURICATA_STOP | SURICATA_KILL)) {
SCReturnInt(TM_ECODE_OK);
}
/* make sure we have at least one packet in the packet pool, to prevent
* us from alloc'ing packets at line rate */
PacketPoolWait();
p = PacketGetFromQueueOrAlloc();
if (p == NULL) {
SCReturnInt(TM_ECODE_FAILED);
}
PKT_SET_SRC(p, PKT_SRC_WIRE);
/* Some flavours of PF_RING may fail to set timestamp - see PF-RING-enabled libpcap code*/
hdr.ts.tv_sec = hdr.ts.tv_usec = 0;
/* Depending on what compile time options are used for pfring we either return 0 or -1 on error and always 1 for success */
u_char *pkt_buffer = GET_PKT_DIRECT_DATA(p);
u_int buffer_size = GET_PKT_DIRECT_MAX_SIZE(p);
int r = pfring_recv(ptv->pd, &pkt_buffer,
buffer_size,
&hdr,
LIBPFRING_WAIT_FOR_INCOMING);
/* Check for Zero-copy if buffer size is zero */
if (buffer_size == 0) {
PacketSetData(p, pkt_buffer, hdr.caplen);
}
if (r == 1) {
//printf("RecievePfring src %" PRIu32 " sport %" PRIu32 " dst %" PRIu32 " dstport %" PRIu32 "\n",
// hdr.parsed_pkt.ipv4_src,hdr.parsed_pkt.l4_src_port, hdr.parsed_pkt.ipv4_dst,hdr.parsed_pkt.l4_dst_port);
PfringProcessPacket(ptv, &hdr, p);
if (TmThreadsSlotProcessPkt(ptv->tv, ptv->slot, p) != TM_ECODE_OK) {
TmqhOutputPacketpool(ptv->tv, p);
SCReturnInt(TM_ECODE_FAILED);
}
/* Trigger one dump of stats every second */
TimeGet(¤t_time);
if (current_time.tv_sec != last_dump) {
PfringDumpCounters(ptv);
last_dump = current_time.tv_sec;
}
} else {
SCLogError(SC_ERR_PF_RING_RECV,"pfring_recv error %" PRId32 "", r);
TmqhOutputPacketpool(ptv->tv, p);
SCReturnInt(TM_ECODE_FAILED);
}
StatsSyncCountersIfSignalled(tv);
}
return TM_ECODE_OK;
}
static int DetectThresholdTestSig4(void)
{
Packet *p = NULL;
Signature *s = NULL;
ThreadVars th_v;
DetectEngineThreadCtx *det_ctx;
int result = 0;
int alerts = 0;
struct timeval ts;
HostInitConfig(HOST_QUIET);
memset (&ts, 0, sizeof(struct timeval));
TimeGet(&ts);
memset(&th_v, 0, sizeof(th_v));
p = UTHBuildPacketReal((uint8_t *)"A",1,IPPROTO_TCP, "1.1.1.1", "2.2.2.2", 1024, 80);
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
goto end;
}
de_ctx->flags |= DE_QUIET;
s = de_ctx->sig_list = SigInit(de_ctx,"alert tcp any any -> any 80 (msg:\"Threshold both\"; threshold: type both, track by_dst, count 2, seconds 60; sid:10;)");
if (s == NULL) {
goto end;
}
SigGroupBuild(de_ctx);
DetectEngineThreadCtxInit(&th_v, (void *)de_ctx, (void *)&det_ctx);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts = PacketAlertCheck(p, 10);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
TimeSetIncrementTime(200);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
alerts += PacketAlertCheck(p, 10);
if (alerts == 2)
result = 1;
else
goto cleanup;
cleanup:
SigGroupCleanup(de_ctx);
SigCleanSignatures(de_ctx);
DetectEngineThreadCtxDeinit(&th_v, (void *)det_ctx);
DetectEngineCtxFree(de_ctx);
end:
UTHFreePackets(&p, 1);
HostShutdown();
return result;
}
static int DetectThresholdTestSig3(void)
{
Packet *p = NULL;
Signature *s = NULL;
ThreadVars th_v;
DetectEngineThreadCtx *det_ctx;
int result = 0;
int alerts = 0;
struct timeval ts;
DetectThresholdEntry *lookup_tsh = NULL;
HostInitConfig(HOST_QUIET);
memset (&ts, 0, sizeof(struct timeval));
TimeGet(&ts);
memset(&th_v, 0, sizeof(th_v));
p = UTHBuildPacketReal((uint8_t *)"A",1,IPPROTO_TCP, "1.1.1.1", "2.2.2.2", 1024, 80);
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
if (de_ctx == NULL) {
goto end;
}
de_ctx->flags |= DE_QUIET;
s = de_ctx->sig_list = SigInit(de_ctx,"alert tcp any any -> any 80 (msg:\"Threshold limit\"; threshold: type limit, track by_dst, count 5, seconds 60; sid:10;)");
if (s == NULL) {
goto end;
}
SigGroupBuild(de_ctx);
DetectEngineThreadCtxInit(&th_v, (void *)de_ctx, (void *)&det_ctx);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
Host *host = HostLookupHostFromHash(&p->dst);
if (host == NULL) {
printf("host not found: ");
goto cleanup;
}
if (!(ThresholdHostHasThreshold(host))) {
HostRelease(host);
printf("host has no threshold: ");
goto cleanup;
}
HostRelease(host);
TimeSetIncrementTime(200);
TimeGet(&p->ts);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
SigMatchSignatures(&th_v, de_ctx, det_ctx, p);
host = HostLookupHostFromHash(&p->dst);
if (host == NULL) {
printf("host not found: ");
goto cleanup;
}
HostRelease(host);
lookup_tsh = HostGetStorageById(host, ThresholdHostStorageId());
if (lookup_tsh == NULL) {
HostRelease(host);
printf("lookup_tsh is NULL: ");
goto cleanup;
}
alerts = lookup_tsh->current_count;
if (alerts == 3)
result = 1;
else {
printf("alerts %u != 3: ", alerts);
goto cleanup;
}
cleanup:
SigGroupCleanup(de_ctx);
SigCleanSignatures(de_ctx);
DetectEngineThreadCtxDeinit(&th_v, (void *)det_ctx);
DetectEngineCtxFree(de_ctx);
end:
UTHFreePackets(&p, 1);
HostShutdown();
return result;
}
int MAP::IsRoomCheck(float fx, float fz)
{
// dungeion work
// 현재의 존이 던젼인지를 판단, 아니면 리턴처리
CRoomEvent* pRoom = NULL;
char notify[100]; memset(notify, 0x00, 100);
int nSize = m_arRoomEventArray.GetSize();
int nX = (int)fx;
int nZ = (int)fz;
int minX=0, minZ=0, maxX=0, maxZ=0;
int room_number = 0;
BOOL bFlag_1 = FALSE, bFlag_2 = FALSE;
for( int i = 1; i < nSize+1; i++) {
pRoom = m_arRoomEventArray.GetData( i );
if( !pRoom ) continue;
if( pRoom->m_byStatus == 3 ) continue; // 방이 실행중이거나 깬(clear) 상태라면 검색하지 않음
bFlag_1 = FALSE; bFlag_2 = FALSE;
if( pRoom->m_byStatus == 1 ) { // 방이 초기화 상태
minX = pRoom->m_iInitMinX; minZ = pRoom->m_iInitMinZ;
maxX = pRoom->m_iInitMaxX; maxZ = pRoom->m_iInitMaxZ;
}
else if( pRoom->m_byStatus == 2 ) { // 진행중인 상태
if( pRoom->m_Logic[0].sNumber != 4) continue; // 목표지점까지 이동하는게 아니라면,,
minX = pRoom->m_iEndMinX; minZ = pRoom->m_iEndMinZ;
maxX = pRoom->m_iEndMaxX; maxZ = pRoom->m_iEndMaxZ;
}
if( minX < maxX ) {
if( COMPARE(nX, minX, maxX) ) bFlag_1 = TRUE;
}
else {
if( COMPARE(nX, maxX, minX) ) bFlag_1 = TRUE;
}
if( minZ < maxZ ) {
if( COMPARE(nZ, minZ, maxZ) ) bFlag_2 = TRUE;
}
else {
if( COMPARE(nZ, maxZ, minZ) ) bFlag_2 = TRUE;
}
if( bFlag_1 == TRUE && bFlag_2 == TRUE ) {
if( pRoom->m_byStatus == 1 ) { // 방이 초기화 상태
pRoom->m_byStatus = 2; // 진행중 상태로 방상태 변환
pRoom->m_fDelayTime = TimeGet();
room_number = i;
TRACE(" Room Check - number = %d, x=%d, z=%d\n", i, nX, nZ);
//wsprintf(notify, "** 알림 : [%d Zone][%d] 방에 들어오신것을 환영합니다 **", m_nZoneNumber, pRoom->m_sRoomNumber);
//m_pMain->SendSystemMsg( notify, m_nZoneNumber, PUBLIC_CHAT, SEND_ALL);
}
else if( pRoom->m_byStatus == 2 ) { // 진행중인 상태
pRoom->m_byStatus = 3; // 클리어 상태로
//wsprintf(notify, "** 알림 : [%d Zone][%d] 목표지점까지 도착해서 클리어 됩니다ㅇ **", m_nZoneNumber, pRoom->m_sRoomNumber);
//m_pMain->SendSystemMsg( notify, m_nZoneNumber, PUBLIC_CHAT, SEND_ALL);
}
return room_number;
}
}
return room_number;
}
/**
* \brief UTHBuildPacketReal is a function that create tcp/udp packets for unittests
* specifying ip and port sources and destinations (IPV6)
*
* \param payload pointer to the payloadd buffer
* \param payload_len pointer to the length of the payload
* \param ipproto Protocols allowed atm are IPPROTO_TCP and IPPROTO_UDP
* \param src pointer to a string containing the ip source
* \param dst pointer to a string containing the ip destination
* \param sport pointer to a string containing the port source
* \param dport pointer to a string containing the port destination
*
* \retval Packet pointer to the built in packet
*/
Packet *UTHBuildPacketIPV6Real(uint8_t *payload, uint16_t payload_len,
uint8_t ipproto, char *src, char *dst,
uint16_t sport, uint16_t dport)
{
uint32_t in[4];
Packet *p = PacketGetFromAlloc();
if (unlikely(p == NULL))
return NULL;
TimeGet(&p->ts);
p->src.family = AF_INET6;
p->dst.family = AF_INET6;
p->payload = payload;
p->payload_len = payload_len;
p->proto = ipproto;
p->ip6h = SCMalloc(sizeof(IPV6Hdr));
if (p->ip6h == NULL)
goto error;
memset(p->ip6h, 0, sizeof(IPV6Hdr));
p->ip6h->s_ip6_nxt = ipproto;
p->ip6h->s_ip6_plen = htons(payload_len + sizeof(TCPHdr));
if (inet_pton(AF_INET6, src, &in) != 1)
goto error;
p->src.addr_data32[0] = in[0];
p->src.addr_data32[1] = in[1];
p->src.addr_data32[2] = in[2];
p->src.addr_data32[3] = in[3];
p->sp = sport;
p->ip6h->s_ip6_src[0] = in[0];
p->ip6h->s_ip6_src[1] = in[1];
p->ip6h->s_ip6_src[2] = in[2];
p->ip6h->s_ip6_src[3] = in[3];
if (inet_pton(AF_INET6, dst, &in) != 1)
goto error;
p->dst.addr_data32[0] = in[0];
p->dst.addr_data32[1] = in[1];
p->dst.addr_data32[2] = in[2];
p->dst.addr_data32[3] = in[3];
p->dp = dport;
p->ip6h->s_ip6_dst[0] = in[0];
p->ip6h->s_ip6_dst[1] = in[1];
p->ip6h->s_ip6_dst[2] = in[2];
p->ip6h->s_ip6_dst[3] = in[3];
p->tcph = SCMalloc(sizeof(TCPHdr));
if (p->tcph == NULL)
goto error;
memset(p->tcph, 0, sizeof(TCPHdr));
p->tcph->th_sport = htons(sport);
p->tcph->th_dport = htons(dport);
SET_PKT_LEN(p, sizeof(IPV6Hdr) + sizeof(TCPHdr) + payload_len);
return p;
error:
if (p != NULL) {
if (p->ip6h != NULL) {
SCFree(p->ip6h);
}
if (p->tcph != NULL) {
SCFree(p->tcph);
}
SCFree(p);
}
return NULL;
}
/**
* \brief UTHBuildPacketReal is a function that create tcp/udp packets for unittests
* specifying ip and port sources and destinations
*
* \param payload pointer to the payloadd buffer
* \param payload_len pointer to the length of the payload
* \param ipproto Protocols allowed atm are IPPROTO_TCP and IPPROTO_UDP
* \param src pointer to a string containing the ip source
* \param dst pointer to a string containing the ip destination
* \param sport pointer to a string containing the port source
* \param dport pointer to a string containing the port destination
*
* \retval Packet pointer to the built in packet
*/
Packet *UTHBuildPacketReal(uint8_t *payload, uint16_t payload_len,
uint8_t ipproto, char *src, char *dst,
uint16_t sport, uint16_t dport)
{
struct in_addr in;
Packet *p = PacketGetFromAlloc();
if (unlikely(p == NULL))
return NULL;
struct timeval tv;
TimeGet(&tv);
COPY_TIMESTAMP(&tv, &p->ts);
p->src.family = AF_INET;
p->dst.family = AF_INET;
p->payload = payload;
p->payload_len = payload_len;
p->proto = ipproto;
if (inet_pton(AF_INET, src, &in) != 1)
goto error;
p->src.addr_data32[0] = in.s_addr;
p->sp = sport;
if (inet_pton(AF_INET, dst, &in) != 1)
goto error;
p->dst.addr_data32[0] = in.s_addr;
p->dp = dport;
p->ip4h = (IPV4Hdr *)GET_PKT_DATA(p);
if (p->ip4h == NULL)
goto error;
p->ip4h->s_ip_src.s_addr = p->src.addr_data32[0];
p->ip4h->s_ip_dst.s_addr = p->dst.addr_data32[0];
p->ip4h->ip_proto = ipproto;
p->ip4h->ip_verhl = sizeof(IPV4Hdr);
p->proto = ipproto;
int hdr_offset = sizeof(IPV4Hdr);
switch (ipproto) {
case IPPROTO_UDP:
p->udph = (UDPHdr *)(GET_PKT_DATA(p) + sizeof(IPV4Hdr));
if (p->udph == NULL)
goto error;
p->udph->uh_sport = sport;
p->udph->uh_dport = dport;
hdr_offset += sizeof(UDPHdr);
break;
case IPPROTO_TCP:
p->tcph = (TCPHdr *)(GET_PKT_DATA(p) + sizeof(IPV4Hdr));
if (p->tcph == NULL)
goto error;
p->tcph->th_sport = htons(sport);
p->tcph->th_dport = htons(dport);
hdr_offset += sizeof(TCPHdr);
break;
case IPPROTO_ICMP:
p->icmpv4h = (ICMPV4Hdr *)(GET_PKT_DATA(p) + sizeof(IPV4Hdr));
if (p->icmpv4h == NULL)
goto error;
hdr_offset += sizeof(ICMPV4Hdr);
break;
default:
break;
/* TODO: Add more protocols */
}
if (payload && payload_len) {
PacketCopyDataOffset(p, hdr_offset, payload, payload_len);
}
SET_PKT_LEN(p, hdr_offset + payload_len);
p->payload = GET_PKT_DATA(p)+hdr_offset;
return p;
error:
SCFree(p);
return NULL;
}
