SVMetadata*
SV_CreateMetadata (void)
{
SVMetadata* self = CD_malloc(sizeof(SVMetadata));
if (!self) {
return NULL;
}
self->length = 0;
self->item = CD_malloc(0);
return self;
}
CDPointer
CD_BufferRemove (CDBuffer* self, size_t length)
{
CDPointer result = (CDPointer) CD_malloc(length);
evbuffer_remove(self->raw, (void*) result, length);
return result;
}
CDPointer
CD_BufferContent (CDBuffer* self)
{
CDPointer data = (CDPointer) CD_malloc(CD_BufferLength(self));
evbuffer_copyout(self->raw, (void*) data, CD_BufferLength(self));
return data;
}
CDString*
CD_CreateStringFromBuffer (const char* buffer, size_t size)
{
CDString* self = CD_malloc(sizeof(CDString));
self->raw = CD_malloc(sizeof(*self->raw));
self->external = true;
assert(self->raw);
self->raw->data = (unsigned char*) buffer;
self->raw->mlen = size;
self->raw->slen = size;
cd_UpdateLength(self);
return self;
}
CDEventCallback*
CD_CreateEventCallback (CDEventCallbackFunction function, int priority)
{
CDEventCallback* self = CD_malloc(sizeof(CDEventCallback));
self->function = function;
self->priority = priority;
return self;
}
MCData*
MC_CreateData (void)
{
MCData* self = CD_malloc(sizeof(MCData));
if (!self) {
return NULL;
}
return self;
}
SVData*
SV_CreateData (void)
{
SVData* self = CD_malloc(sizeof(SVData));
if (!self) {
return NULL;
}
return self;
}
static
CDListItem*
cd_ListCreateItem (CDPointer data)
{
CDListItem* item = (CDListItem*) CD_malloc(sizeof(CDListItem));
item->next = NULL;
item->prev = NULL;
item->value = data;
return item;
}
CDBuffer*
CD_CreateBuffer (void)
{
CDBuffer* self = CD_malloc(sizeof(CDBuffer));
self->raw = evbuffer_new();
self->external = false;
evbuffer_enable_locking(self->raw, NULL);
return self;
}
CDBuffer*
CD_WrapBuffer (CDRawBuffer buffer)
{
CDBuffer* self = CD_malloc(sizeof(CDBuffer));
self->raw = buffer;
self->external = true;
evbuffer_enable_locking(self->raw, NULL);
return self;
}
CDWorker*
CD_CreateWorker (CDServer* server)
{
CDWorker* self = CD_malloc(sizeof(CDWorker));
self->server = server;
self->thread = 0;
self->id = 0;
self->working = false;
self->job = NULL;
return self;
}
CDString*
CD_CreateString (void)
{
CDString* self = CD_malloc(sizeof(CDString));
self->raw = bfromcstr("");
self->length = 0;
self->external = false;
assert(self->raw);
return self;
}
CDString*
CD_CreateStringFromBufferCopy (const char* buffer, size_t length)
{
CDString* self = CD_malloc(sizeof(CDString));
self->raw = blk2bstr(buffer, length);
self->external = false;
assert(self->raw);
cd_UpdateLength(self);
return self;
}
CDATicket*
cdadmin_CreateTicket (CDPlayer* requester, CDString* content)
{
CDATicket* self = CD_malloc(sizeof(CDATicket));
assert(self);
self->requester = requester;
self->assignee = NULL;
self->status = CDTicketOpen;
self->content = content;
return self;
}
CDString*
CD_CreateStringFromCStringCopy (const char* string)
{
CDString* self = CD_malloc(sizeof(CDString));
self->raw = bfromcstr(string);
self->external = false;
assert(self->raw);
cd_UpdateLength(self);
return self;
}
CDString*
CD_CreateStringFromCString (const char* string)
{
CDString* self = CD_malloc(sizeof(CDString));
self->raw = CD_malloc(sizeof(*self->raw));
if (string == NULL) {
self->raw->data = (unsigned char*) "";
}
else {
self->raw->data = (unsigned char*) string;
}
self->raw->slen = strlen((const char*) self->raw->data);
self->raw->mlen = self->raw->slen;
self->external = true;
cd_UpdateLength(self);
return self;
}
CDList*
CD_CreateList (void)
{
CDList* self = CD_malloc(sizeof(CDList));
self->head = NULL;
self->tail = NULL;
self->changed = false;
self->length = 0;
if (pthread_rwlock_init(&self->lock, NULL) != 0) {
CD_abort("pthread rwlock failed to initialize");
}
return self;
}
CDList*
CD_CreateList (void)
{
CDList* self = CD_malloc(sizeof(CDList));
assert(self);
self->head = NULL;
self->tail = NULL;
self->changed = false;
self->length = 0;
assert(pthread_rwlock_init(&self->lock, NULL) == 0);
return self;
}
SVString
SV_BufferRemoveString (CDBuffer* self)
{
char* data = NULL;
SVShort length = 0;
CDString* result;
evbuffer_remove(self->raw, &length, SVShortSize);
length = ntohs(length);
data = CD_malloc(length + 1);
evbuffer_remove(self->raw, data, length);
data[length] = '\0';
result = CD_CreateStringFromBuffer(data, length + 1);
result->external = false;
return result;
}
CDClient*
CD_CreateClient (CDServer* server)
{
CDClient* self = CD_malloc(sizeof(CDClient));
if (pthread_rwlock_init(&self->lock.status, NULL) != 0) {
CD_abort("pthread rwlock failed to initialize");
}
self->server = server;
self->status = CDClientConnect;
self->jobs = 0;
self->buffers = NULL;
DYNAMIC(self) = CD_CreateDynamic();
ERROR(self) = CDNull;
return self;
}
CDHTTPd*
CD_CreateHTTPd (CDServer* server)
{
CDHTTPd* self = CD_malloc(sizeof(CDHTTPd));
if (pthread_attr_init(&self->attributes) != 0) {
CD_abort("pthread attribute failed to initialize");
}
if (pthread_attr_setdetachstate(&self->attributes, PTHREAD_CREATE_DETACHED) != 0) {
CD_abort("pthread attribute failed to set in detach state");
}
self->server = server;
self->event.base = event_base_new();
self->event.httpd = evhttp_new(self->event.base);
evhttp_set_cb(self->event.httpd, "/rpc/json", (void (*)(struct evhttp_request*, void*)) cd_JSONRequest, server);
evhttp_set_gencb(self->event.httpd, (void (*)(struct evhttp_request*, void*)) cd_StaticRequest, server);
return self;
}
SVPacket*
SV_PacketFromBuffers (CDBuffers* buffers)
{
SVPacket* self = CD_malloc(sizeof(SVPacket));
assert(self);
self->chain = SVRequest;
self->type = (uint32_t) (uint8_t) SV_BufferRemoveByte(buffers->input);
self->data = SV_GetPacketDataFromBuffer(self, buffers->input);
if (!self->data) {
ERR("unparsable packet 0x%.2X", self->type);
SV_DestroyPacket(self);
errno = EILSEQ;
return NULL;
}
return self;
}
CDWorkers*
CD_CreateWorkers (CDServer* server)
{
CDWorkers* self = CD_malloc(sizeof(CDWorkers));
assert(self);
self->server = server;
self->last = 0;
self->length = 0;
self->item = NULL;
self->jobs = CD_CreateList();
if (pthread_attr_init(&self->attributes) != 0) {
CD_abort("pthread attribute failed to initialize");
}
if (pthread_attr_setdetachstate(&self->attributes, PTHREAD_CREATE_DETACHED) != 0) {
CD_abort("pthread attribute failed to set in detach state");
}
if (pthread_attr_setstacksize(&self->attributes, CD_THREAD_STACK) != 0) {
CD_abort("pthread attribute failed to set stack size");
}
if (pthread_mutex_init(&self->lock.mutex, NULL) != 0) {
CD_abort("pthread mutex failed to initialize");
}
if (pthread_cond_init(&self->lock.condition, NULL) != 0) {
CD_abort("pthread cond failed to initialize");
}
return self;
}
CDPointer
SV_GetPacketDataFromBuffer (SVPacket* self, CDBuffer* input)
{
assert(self);
assert(input);
switch (self->type) {
case SVKeepAlive: {
return (CDPointer) CD_malloc(sizeof(SVPacketKeepAlive));
}
case SVLogin: {
SVPacketLogin* packet = (SVPacketLogin*) CD_malloc(sizeof(SVPacketLogin));
SV_BufferRemoveFormat(input, "iUlb",
&packet->request.version,
&packet->request.username,
&packet->request.mapSeed,
&packet->request.dimension
);
return (CDPointer) packet;
}
case SVHandshake: {
SVPacketHandshake* packet = (SVPacketHandshake*) CD_malloc(sizeof(SVPacketHandshake));
packet->request.username = SV_BufferRemoveString16(input);
return (CDPointer) packet;
}
case SVChat: {
SVPacketChat* packet = (SVPacketChat*) CD_malloc(sizeof(SVPacketChat));
packet->request.message = SV_BufferRemoveString16(input);
return (CDPointer) packet;
}
case SVUseEntity: {
SVPacketUseEntity* packet = (SVPacketUseEntity*) CD_malloc(sizeof(SVPacketUseEntity));
SV_BufferRemoveFormat(input, "iib",
&packet->request.user,
&packet->request.target,
&packet->request.leftClick
);
return (CDPointer) packet;
}
case SVRespawn: {
return (CDPointer) CD_malloc(sizeof(SVPacketRespawn));
}
case SVOnGround: {
SVPacketOnGround* packet = (SVPacketOnGround*) CD_malloc(sizeof(SVPacketOnGround));
packet->request.onGround = SV_BufferRemoveBoolean(input);
return (CDPointer) packet;
}
case SVPlayerPosition: {
SVPacketPlayerPosition* packet = (SVPacketPlayerPosition*) CD_malloc(sizeof(SVPacketPlayerPosition));
SV_BufferRemoveFormat(input, "ddddb",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.stance,
&packet->request.position.z,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case SVPlayerLook: {
SVPacketPlayerLook* packet = (SVPacketPlayerLook*) CD_malloc(sizeof(SVPacketPlayerLook));
SV_BufferRemoveFormat(input, "ffb",
&packet->request.yaw,
&packet->request.pitch,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case SVPlayerMoveLook: {
SVPacketPlayerMoveLook* packet = (SVPacketPlayerMoveLook*) CD_malloc(sizeof(SVPacketPlayerMoveLook));
SV_BufferRemoveFormat(input, "ddddffb",
&packet->request.position.x,
&packet->request.stance,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.yaw,
&packet->request.pitch,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case SVPlayerDigging: {
SVPacketPlayerDigging* packet = (SVPacketPlayerDigging*) CD_malloc(sizeof(SVPacketPlayerDigging));
packet->request.status = SV_BufferRemoveByte(input);
SV_BufferRemoveFormat(input, "ibi",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z
);
packet->request.face = SV_BufferRemoveByte(input);
return (CDPointer) packet;
}
case SVPlayerBlockPlacement: {
SVPacketPlayerBlockPlacement* packet = (SVPacketPlayerBlockPlacement*) CD_malloc(sizeof(SVPacketPlayerBlockPlacement));
SV_BufferRemoveFormat(input, "ibibs",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.direction,
&packet->request.item.id
);
if (packet->request.item.id != -1) {
SV_BufferRemoveFormat(input, "bs",
&packet->request.item.count,
&packet->request.item.uses
);
}
return (CDPointer) packet;
}
case SVHoldChange: {
SVPacketHoldChange* packet = (SVPacketHoldChange*) CD_malloc(sizeof(SVPacketHoldChange));
packet->request.item.id = SV_BufferRemoveShort(input);
return (CDPointer) packet;
}
case SVAnimation: {
SVPacketAnimation* packet = (SVPacketAnimation*) CD_malloc(sizeof(SVPacketAnimation));
SV_BufferRemoveFormat(input, "ib",
&packet->request.entity.id,
&packet->request.type
);
return (CDPointer) packet;
}
case SVEntityAction: {
SVPacketEntityAction* packet = (SVPacketEntityAction*) CD_malloc(sizeof(SVPacketEntityAction));
packet->request.entity.id = SV_BufferRemoveInteger(input);
packet->request.action = SV_BufferRemoveByte(input);
return (CDPointer) packet;
}
case SVEntityMetadata: {
SVPacketEntityMetadata* packet = (SVPacketEntityMetadata*) CD_malloc(sizeof(SVPacketEntityMetadata));
SV_BufferRemoveFormat(input, "iM",
&packet->request.entity.id,
&packet->request.metadata
);
return (CDPointer) packet;
}
case SVCloseWindow: {
SVPacketCloseWindow* packet = (SVPacketCloseWindow*) CD_malloc(sizeof(SVPacketCloseWindow));
packet->request.id = SV_BufferRemoveByte(input);
return (CDPointer) packet;
}
case SVWindowClick: {
SVPacketWindowClick* packet = (SVPacketWindowClick*) CD_malloc(sizeof(SVPacketWindowClick));
SV_BufferRemoveFormat(input, "bsBss",
&packet->request.id,
&packet->request.slot,
&packet->request.rightClick,
&packet->request.action,
&packet->request.item.id
);
if (packet->request.item.id != -1) {
SV_BufferRemoveFormat(input, "bs",
&packet->request.item.count,
&packet->request.item.uses
);
}
return (CDPointer) packet;
}
case SVTransaction: {
SVPacketTransaction* packet = (SVPacketTransaction*) CD_malloc(sizeof(SVPacketTransaction));
SV_BufferRemoveFormat(input, "bsB",
&packet->request.id,
&packet->request.action,
&packet->request.accepted
);
return (CDPointer) packet;
}
case SVUpdateSign: {
SVPacketUpdateSign* packet = (SVPacketUpdateSign*) CD_malloc(sizeof(SVPacketUpdateSign));
SV_BufferRemoveFormat(input, "iisiUUUU",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.first,
&packet->request.second,
&packet->request.third,
&packet->request.fourth
);
return (CDPointer) packet;
}
case SVIncrementStatistic: {
SVPacketIncrementStatistic* packet = (SVPacketIncrementStatistic*) CD_malloc(sizeof(SVPacketIncrementStatistic));
SV_BufferRemoveFormat(input, "ib",
&packet->request.id,
&packet->request.amount
);
return (CDPointer) packet;
}
case SVDisconnect: {
SVPacketDisconnect* packet = (SVPacketDisconnect*) CD_malloc(sizeof(SVPacketDisconnect));
packet->request.reason = SV_BufferRemoveString16(input);
return (CDPointer) packet;
}
default: {
return (CDPointer) NULL;
}
}
}
CDPointer
CD_GetPacketDataFromBuffer (CDPacket* self, CDBuffer* input)
{
assert(self);
assert(input);
switch (self->type) {
case CDKeepAlive: {
return (CDPointer) CD_malloc(sizeof(CDPacketKeepAlive));
}
case CDLogin: {
CDPacketLogin* packet = (CDPacketLogin*) CD_malloc(sizeof(CDPacketLogin));
CD_BufferRemoveFormat(input, "iSSlb",
&packet->request.version,
&packet->request.username,
&packet->request.password,
&packet->request.mapSeed,
&packet->request.dimension
);
return (CDPointer) packet;
}
case CDHandshake: {
CDPacketHandshake* packet = (CDPacketHandshake*) CD_malloc(sizeof(CDPacketHandshake));
packet->request.username = CD_BufferRemoveString(input);
return (CDPointer) packet;
}
case CDChat: {
CDPacketChat* packet = (CDPacketChat*) CD_malloc(sizeof(CDPacketChat));
packet->request.message = CD_BufferRemoveString(input);
return (CDPointer) packet;
}
case CDUseEntity: {
CDPacketUseEntity* packet = (CDPacketUseEntity*) CD_malloc(sizeof(CDPacketUseEntity));
CD_BufferRemoveFormat(input, "iib",
&packet->request.user,
&packet->request.target,
&packet->request.leftClick
);
return (CDPointer) packet;
}
case CDRespawn: {
return (CDPointer) CD_malloc(sizeof(CDPacketRespawn));
}
case CDOnGround: {
CDPacketOnGround* packet = (CDPacketOnGround*) CD_malloc(sizeof(CDPacketOnGround));
packet->request.onGround = CD_BufferRemoveBoolean(input);
return (CDPointer) packet;
}
case CDPlayerPosition: {
CDPacketPlayerPosition* packet = (CDPacketPlayerPosition*) CD_malloc(sizeof(CDPacketPlayerPosition));
CD_BufferRemoveFormat(input, "ddddb",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.stance,
&packet->request.position.z,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case CDPlayerLook: {
CDPacketPlayerLook* packet = (CDPacketPlayerLook*) CD_malloc(sizeof(CDPacketPlayerLook));
CD_BufferRemoveFormat(input, "ffb",
&packet->request.yaw,
&packet->request.pitch,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case CDPlayerMoveLook: {
CDPacketPlayerMoveLook* packet = (CDPacketPlayerMoveLook*) CD_malloc(sizeof(CDPacketPlayerMoveLook));
CD_BufferRemoveFormat(input, "ddddffb",
&packet->request.position.x,
&packet->request.stance,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.yaw,
&packet->request.pitch,
&packet->request.is.onGround
);
return (CDPointer) packet;
}
case CDPlayerDigging: {
CDPacketPlayerDigging* packet = (CDPacketPlayerDigging*) CD_malloc(sizeof(CDPacketPlayerDigging));
CD_BufferRemoveFormat(input, "bibib",
&packet->request.status,
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.face
);
return (CDPointer) packet;
}
case CDPlayerBlockPlacement: {
CDPacketPlayerBlockPlacement* packet = (CDPacketPlayerBlockPlacement*) CD_malloc(sizeof(CDPacketPlayerBlockPlacement));
CD_BufferRemoveFormat(input, "ibibs",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.direction,
&packet->request.item.id
);
if (packet->request.item.id != -1) {
CD_BufferRemoveFormat(input, "bs",
&packet->request.item.count,
&packet->request.item.uses
);
}
return (CDPointer) packet;
}
case CDHoldChange: {
CDPacketHoldChange* packet = (CDPacketHoldChange*) CD_malloc(sizeof(CDPacketHoldChange));
packet->request.item.id = CD_BufferRemoveShort(input);
return (CDPointer) packet;
}
case CDAnimation: {
CDPacketAnimation* packet = (CDPacketAnimation*) CD_malloc(sizeof(CDPacketAnimation));
CD_BufferRemoveFormat(input, "ib",
&packet->request.entity.id,
&packet->request.type
);
return (CDPointer) packet;
}
case CDEntityAction: {
CDPacketEntityAction* packet = (CDPacketEntityAction*) CD_malloc(sizeof(CDPacketEntityAction));
CD_BufferRemoveFormat(input, "ib",
&packet->request.entity.id,
&packet->request.action
);
return (CDPointer) packet;
}
case CDEntityMetadata: {
CDPacketEntityMetadata* packet = (CDPacketEntityMetadata*) CD_malloc(sizeof(CDPacketEntityMetadata));
CD_BufferRemoveFormat(input, "iM",
&packet->request.entity.id,
&packet->request.metadata
);
return (CDPointer) packet;
}
case CDCloseWindow: {
CDPacketCloseWindow* packet = (CDPacketCloseWindow*) CD_malloc(sizeof(CDPacketCloseWindow));
packet->request.id = CD_BufferRemoveByte(input);
return (CDPointer) packet;
}
case CDWindowClick: {
CDPacketWindowClick* packet = (CDPacketWindowClick*) CD_malloc(sizeof(CDPacketWindowClick));
CD_BufferRemoveFormat(input, "bsBss",
&packet->request.id,
&packet->request.slot,
&packet->request.rightClick,
&packet->request.action,
&packet->request.item.id
);
if (packet->request.item.id != -1) {
CD_BufferRemoveFormat(input, "bs",
&packet->request.item.count,
&packet->request.item.uses
);
}
return (CDPointer) packet;
}
case CDTransaction: {
CDPacketTransaction* packet = (CDPacketTransaction*) CD_malloc(sizeof(CDPacketTransaction));
CD_BufferRemoveFormat(input, "bsB",
&packet->request.id,
&packet->request.action,
&packet->request.accepted
);
return (CDPointer) packet;
}
case CDUpdateSign: {
CDPacketUpdateSign* packet = (CDPacketUpdateSign*) CD_malloc(sizeof(CDPacketUpdateSign));
CD_BufferRemoveFormat(input, "iisiSSSS",
&packet->request.position.x,
&packet->request.position.y,
&packet->request.position.z,
&packet->request.first,
&packet->request.second,
&packet->request.third,
&packet->request.fourth
);
return (CDPointer) packet;
}
case CDDisconnect: {
CDPacketDisconnect* packet = (CDPacketDisconnect*) CD_malloc(sizeof(CDPacketDisconnect));
packet->request.reason = CD_BufferRemoveString(input);
return (CDPointer) packet;
}
default: {
return (CDPointer) NULL;
}
}
}
