int on_d2gs_shutdown(void *p) {
internal_packet_t ip = *INTERNAL_CAST(p);
if (*(dword *)(ip.data) == ENGINE_SHUTDOWN) {
pthread_mutex_lock(&d2gs_engine_shutdown_mutex);
pthread_cond_signal(&d2gs_engine_shutdown_cond_v);
pthread_mutex_unlock(&d2gs_engine_shutdown_mutex);
}
return FORWARD_PACKET;
}
int on_d2gs_cleanup(void *p) {
internal_packet_t *packet = INTERNAL_CAST(p);
if (*(dword *)(packet->data) == MODULES_CLEANUP) {
pthread_mutex_lock(&d2gs_cleanup_m);
d2gs_cleanup = TRUE;
pthread_cond_signal(&d2gs_cleanup_cv);
pthread_mutex_unlock(&d2gs_cleanup_m);
}
return FORWARD_PACKET;
}
int on_mcp_cleanup(void *p) {
internal_packet_t ip = *INTERNAL_CAST(p);
if (*(dword *)(ip.data) == MODULES_CLEANUP) {
pthread_mutex_lock(&mcp_cleanup_m);
mcp_cleanup = TRUE;
pthread_cond_signal(&mcp_cleanup_cv);
pthread_mutex_unlock(&mcp_cleanup_m);
}
return FORWARD_PACKET;
}
int invoke_packet_handlers(packet_t type, void *packet) {
int forward = FORWARD_PACKET;
packet_handler_t *handler;
byte id;
switch (type) {
case BNCS_RECEIVED:
case BNCS_SENT:
id = BNCS_CAST(packet)->id;
break;
case MCP_RECEIVED:
case MCP_SENT:
id = MCP_CAST(packet)->id;
break;
case D2GS_RECEIVED:
case D2GS_SENT:
id = D2GS_CAST(packet)->id;
break;
case INTERNAL:
id = INTERNAL_CAST(packet)->id;
break;
default:
return forward;
}
struct iterator i = list_iterator(&packet_handlers[type][id]);
while ((handler = iterator_next(&i))) {
void *c;
void *data = NULL;
switch (type) {
case BNCS_RECEIVED:
case BNCS_SENT:
c = calloc(1, sizeof(bncs_packet_t));
BNCS_CAST(c)->id = id;
BNCS_CAST(c)->len = BNCS_CAST(packet)->len;
if (bncs_has_payload(BNCS_CAST(packet))) {
BNCS_CAST(c)->data = malloc(BNCS_CAST(packet)->len);
data = BNCS_CAST(c)->data;
memcpy(BNCS_CAST(c)->data, BNCS_CAST(packet)->data, BNCS_CAST(packet)->len - BNCS_HEADER_SIZE);
}
break;
case MCP_RECEIVED:
case MCP_SENT:
c = calloc(1, sizeof(mcp_packet_t));
MCP_CAST(c)->id = id;
MCP_CAST(c)->len = MCP_CAST(packet)->len;
if (mcp_has_payload(MCP_CAST(packet))) {
MCP_CAST(c)->data = malloc(MCP_CAST(packet)->len);
data = MCP_CAST(c)->data;
memcpy(MCP_CAST(c)->data, MCP_CAST(packet)->data, MCP_CAST(packet)->len - MCP_HEADER_SIZE);
}
break;
case D2GS_RECEIVED:
case D2GS_SENT:
c = calloc(1, sizeof(d2gs_packet_t));
D2GS_CAST(c)->id = id;
D2GS_CAST(c)->len = D2GS_CAST(packet)->len;
if (d2gs_has_payload(D2GS_CAST(packet))) {
D2GS_CAST(c)->data = malloc(D2GS_CAST(packet)->len);
data = D2GS_CAST(c)->data;
memcpy(D2GS_CAST(c)->data, D2GS_CAST(packet)->data, D2GS_CAST(packet)->len - D2GS_HEADER_SIZE);
}
break;
case INTERNAL:
c = calloc(1, sizeof(internal_packet_t));
INTERNAL_CAST(c)->id = id;
INTERNAL_CAST(c)->len = INTERNAL_CAST(packet)->len;
if (internal_has_payload(INTERNAL_CAST(packet))) {
INTERNAL_CAST(c)->data = malloc(INTERNAL_CAST(packet)->len);
data = INTERNAL_CAST(c)->data;
memcpy(INTERNAL_CAST(c)->data, INTERNAL_CAST(packet)->data, INTERNAL_CAST(packet)->len - INTERNAL_HEADER_SIZE);
}
break;
default:
return forward;
}
forward = (*handler)((void *) c);
free(c);
if (data) {
free(data);
}
if (forward == HIDE_PACKET || forward == BLOCK_PACKET) {
iterator_destroy(&i);
break;
}
}
return forward;
}
