static
void
cd_JSONRequest (struct evhttp_request* request, CDServer* server)
{
struct evbuffer* buffer = evhttp_request_get_input_buffer(request);
char* text = CD_alloc(evbuffer_get_length(buffer) + 1);
evbuffer_remove(buffer, text, evbuffer_get_length(buffer));
json_error_t error;
json_t* input = json_loads(text, 0, &error);
json_t* output = json_object();
printf("%s\n", text);
if (evhttp_request_get_command(request) != EVHTTP_REQ_POST) {
goto error;
}
if (input == NULL) {
SERR(server, "RPC.JSON: error on line %d: %s", error.line, error.text);
goto error;
}
CD_EventDispatch(server, "RPC.JSON", input, output);
done: {
char* outString = json_dumps(output, JSON_INDENT(2));
struct evbuffer* outBuffer = evbuffer_new();
evbuffer_add_printf(outBuffer, "%s", outString);
evhttp_send_reply(request, HTTP_OK, "OK", outBuffer);
evbuffer_free(outBuffer);
free(outString);
json_delete(output);
json_delete(input);
CD_free(text);
return;
}
error: {
evhttp_send_error(request, HTTP_INTERNAL, "Internal server error");
CD_free(text);
if (input) {
json_delete(input);
}
if (output) {
json_delete(output);
}
return;
}
}
void
CD_DestroyWorkers (CDWorkers* self)
{
assert(self);
for (size_t i = 0; i < self->length; i++) {
CD_StopWorker(self->item[i]);
}
pthread_mutex_lock(&self->lock.mutex);
pthread_cond_broadcast(&self->lock.condition);
pthread_mutex_unlock(&self->lock.mutex);
for (size_t i = 0; i < self->length; i++) {
CD_DestroyWorker(self->item[i]);
}
CD_free(self->item);
CD_DestroyList(self->jobs);
pthread_mutex_destroy(&self->lock.mutex);
pthread_cond_destroy(&self->lock.condition);
CD_free(self);
}
void
SV_DestroyPacket (SVPacket* self)
{
assert(self);
SV_DestroyPacketData(self);
CD_free((void*) self->data);
CD_free(self);
}
void
CD_DestroyPacket (CDPacket* self)
{
assert(self);
CD_DestroyPacketData(self);
CD_free((void*) self->data);
CD_free(self);
}
void
MC_DestroyMetadata (MCMetadata* self)
{
for (size_t i = 0; i < self->length; i++) {
MC_DestroyData(self->item[i]);
}
CD_free(self->item);
CD_free(self);
}
static
CDPointer
cd_ListDelete (CDList* self, CDPointer data, CDListCompareCallback callback)
{
CDPointer result = CDNull;
assert(self);
if (!self->head) {
return CDNull;
}
if (callback(data, self->head->value) == 0) {
CDListItem* item = self->head;
result = item->value;
self->head = item->next;
if (self->head) {
self->head->prev = NULL;
}
self->changed = true;
CD_free(item);
}
else {
CDListItem *item = self->head;
while (item->next) {
if (callback(data, item->next->value) == 0) {
result = item->value;
CDListItem* toDelete = item->next;
item->next = toDelete->next;
if (item->next) {
item->next->prev = item;
}
CD_free(toDelete);
self->changed = true;
break;
}
else {
item = item->next;
}
}
}
return result;
}
void
CD_DestroyString (CDString* self)
{
assert(self);
if (self->external) {
CD_free(self->raw);
}
else {
bdestroy(self->raw);
}
CD_free(self);
}
void
CD_BufferAddBuffer (CDBuffer* self, CDBuffer* data)
{
CDPointer stuff = CD_BufferContent(data);
evbuffer_add(self->raw, (void*) stuff, CD_BufferLength(data));
CD_free((void*) stuff);
}
void
cdadmin_DestroyTicket (CDATicket* self)
{
if (self->content) {
CD_DestroyString(self->content);
}
CD_free(self);
}
CDRawString
CD_DestroyStringKeepData (CDString* self)
{
CDRawString result = self->raw;
CD_free(self);
return result;
}
void
CD_DestroyBuffer (CDBuffer* self)
{
if (!self->external) {
evbuffer_free(self->raw);
}
CD_free(self);
}
void
MC_DestroyData (MCData* self)
{
// Destroy the bstring, the other types lay on the stack
if (self->type == MCTypeString) {
CD_DestroyString(self->data.S);
}
CD_free(self);
}
static inline
void
cd_MakeStringInternal (CDString* self)
{
if (!self->external) {
return;
}
bstring data = bstrcpy(self->raw);
CD_free(self->raw);
self->raw = data;
self->external = false;
}
void
CD_DestroyWorker (CDWorker* self)
{
assert(self);
if (self->thread) {
self->working = false;
pthread_join(self->thread, NULL);
}
if (self->job) {
CD_DestroyJob(self->job);
}
CD_free(self);
}
static
void
cd_ListSortInsert (CDList* self, CDListCompareCallback callback)
{
CDListItem* walker = self->head;
self->head = NULL;
self->tail = NULL;
while (walker) {
CDListItem* toDestroy = walker;
cd_ListInsertSorted(self, walker->value, callback);
walker = walker->next;
CD_free(toDestroy);
}
}
void
CD_DestroyClient (CDClient* self)
{
assert(self);
CD_EventDispatch(self->server, "Client.destroy", self);
if (self->buffers) {
bufferevent_flush(self->buffers->raw, EV_READ | EV_WRITE, BEV_FINISHED);
bufferevent_disable(self->buffers->raw, EV_READ | EV_WRITE);
bufferevent_free(self->buffers->raw);
CD_DestroyBuffers(self->buffers);
}
CD_DestroyDynamic(DYNAMIC(self));
pthread_rwlock_destroy(&self->lock.status);
CD_free(self);
}
void
SV_DestroyPacketData (SVPacket* self)
{
if (!self->data) {
return;
}
switch (self->chain) {
case SVRequest: {
switch (self->type) {
case SVLogin: {
SVPacketLogin* packet = (SVPacketLogin*) self->data;
SV_DestroyString(packet->request.username);
} break;
case SVHandshake: {
SVPacketHandshake* packet = (SVPacketHandshake*) self->data;
SV_DestroyString(packet->request.username);
} break;
case SVChat: {
SVPacketChat* packet = (SVPacketChat*) self->data;
SV_DestroyString(packet->request.message);
} break;
case SVEntityMetadata: {
SVPacketEntityMetadata* packet = (SVPacketEntityMetadata*) self->data;
SV_DestroyMetadata(packet->request.metadata);
} break;
case SVUpdateSign: {
SVPacketUpdateSign* packet = (SVPacketUpdateSign*) self->data;
SV_DestroyString(packet->request.first);
SV_DestroyString(packet->request.second);
SV_DestroyString(packet->request.third);
SV_DestroyString(packet->request.fourth);
} break;
case SVDisconnect: {
SVPacketDisconnect* packet = (SVPacketDisconnect*) self->data;
SV_DestroyString(packet->request.reason);
}
default: break;
}
} break;
case SVResponse: {
switch (self->type) {
case SVLogin: {
SVPacketLogin* packet = (SVPacketLogin*) self->data;
SV_DestroyString(packet->response.serverName);
} break;
case SVHandshake: {
SVPacketHandshake* packet = (SVPacketHandshake*) self->data;
SV_DestroyString(packet->response.hash);
} break;
case SVChat: {
SVPacketChat* packet = (SVPacketChat*) self->data;
SV_DestroyString(packet->request.message);
} break;
case SVNamedEntitySpawn: {
SVPacketNamedEntitySpawn* packet = (SVPacketNamedEntitySpawn*) self->data;
SV_DestroyString(packet->response.name);
} break;
case SVSpawnMob: {
SVPacketSpawnMob* packet = (SVPacketSpawnMob*) self->data;
SV_DestroyMetadata(packet->response.metadata);
} break;
case SVPainting: {
SVPacketPainting* packet = (SVPacketPainting*) self->data;
SV_DestroyString(packet->response.title);
} break;
case SVEntityMetadata: {
SVPacketEntityMetadata* packet = (SVPacketEntityMetadata*) self->data;
SV_DestroyMetadata(packet->response.metadata);
} break;
case SVMapChunk: {
SVPacketMapChunk* packet = (SVPacketMapChunk*) self->data;
CD_free(packet->response.item);
} break;
case SVMultiBlockChange: {
SVPacketMultiBlockChange* packet = (SVPacketMultiBlockChange*) self->data;
CD_free(packet->response.coordinate);
CD_free(packet->response.type);
CD_free(packet->response.metadata);
} break;
case SVExplosion: {
SVPacketExplosion* packet = (SVPacketExplosion*) self->data;
CD_free(packet->response.item);
} break;
case SVOpenWindow: {
SVPacketOpenWindow* packet = (SVPacketOpenWindow*) self->data;
SV_DestroyString(packet->response.title);
} break;
case SVWindowItems: {
SVPacketWindowItems* packet = (SVPacketWindowItems*) self->data;
CD_free(packet->response.item);
} break;
case SVDisconnect: {
SVPacketDisconnect* packet = (SVPacketDisconnect*) self->data;
SV_DestroyString(packet->response.reason);
} break;
default: break;
}
} break;
}
}
void
CD_DestroyEventCallback (CDEventCallback* self)
{
CD_free(self);
}
CD_LIST_FOREACH(parameters, it) {
CD_free((char*) CD_ListIteratorValue(it));
}
