static gboolean
handle_new_connection ( GIOChannel *chan,
GIOCondition cond,
gpointer *data )
{
gint client_socket;
struct sockaddr_un client_addr;
socklen_t client_addr_len = sizeof ( struct sockaddr_un );
GIOChannel *client_chan;
command cmd;
memset ( &client_addr, 0, sizeof(struct sockaddr_un) );
if ( (client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &client_addr_len)) < 0 )
{
log_print ( "core: unable to accept new connection: %s.\n", strerror(errno) );
return FALSE;
}
client_chan = g_io_channel_unix_new ( client_socket );
chainrefd_read_command ( client_chan, &cmd );
g_io_channel_shutdown ( client_chan, TRUE, NULL );
g_io_channel_unref ( client_chan );
switch ( cmd.type )
{
case CMD_NOP:
break;
case CMD_SHUTDOWN:
handle_shutdown ( 0 );
return FALSE;
case CMD_APPEND_BLOCK_DATA:
blockchain_append_single_block_data ( BLOCKCHAIN, cmd.data );
/* log_print ( "core: appending data\n" ); */
break;
#ifdef WITH_POOLS
case CMD_APPEND_POOLS_DATA:
blockchain_append_single_pools_data ( BLOCKCHAIN, cmd.window, cmd.data );
/* log_print ( "core: appending pools data\n" ); */
break;
#endif
case CMD_STATS:
handle_alive_timeout ( NULL );
break;
case CMD_ERROR:
log_print ( "core: handling of command channel failed.\n" );
break;
}
return TRUE;
}
void server_loop(void)
{
double tick;
double tmr500 = 0;
double tmr1000 = 0;
double lastupdatesaveplayers = 0;
double lastupdatemapspawnitems = 0;
double lastupdateplayervitals = 0;
while(server_is_online){
tick = gettickcount();
if(tick > tmr500){
update_npc_ai();
tmr500 = gettickcount() + .5;
}
if(tick > tmr1000){
if(shutting_down())
handle_shutdown();
tmr1000 = gettickcount() + 1;
}
if(tick > lastupdateplayervitals){
update_player_vitals();
lastupdateplayervitals = gettickcount() + 5;
}
if(tick > lastupdatemapspawnitems){
update_map_spawn_items();
lastupdatemapspawnitems = gettickcount() + 30;
}
if(tick > lastupdatesaveplayers){
update_save_players();
lastupdatesaveplayers = gettickcount() + 60;
}
}
return;
}
static void handle_message(message_t *message, void *d)
{
driver_listener_t *driver = (driver_listener_t*) d;
switch(message->type)
{
case MESSAGE_SESSION_CLOSED:
handle_session_closed(driver, message->message.session_closed.session_id);
break;
case MESSAGE_DATA_IN:
/* TODO: I'm gonna have to re-think this a bit (it's gonna need a session, we can't just broadcast data from all sessions) */
/*handle_data_in(driver, message->message.data_in.session_id, message->message.data_in.data, message->message.data_in.length);*/
break;
case MESSAGE_SHUTDOWN:
handle_shutdown();
break;
default:
LOG_FATAL("driver_listener received an invalid message!");
abort();
}
}
void driver_command_data_received(driver_command_t *driver, uint8_t *data, size_t length)
{
command_packet_t *in = NULL;
command_packet_t *out = NULL;
buffer_add_bytes(driver->stream, data, length);
while((in = command_packet_read(driver->stream)))
{
/* TUNNEL_DATA commands are too noisy to print. */
if(in->command_id != TUNNEL_DATA)
{
printf("Got a command: ");
command_packet_print(in);
}
switch(in->command_id)
{
case COMMAND_PING:
out = handle_ping(driver, in);
break;
case COMMAND_SHELL:
out = handle_shell(driver, in);
break;
case COMMAND_EXEC:
out = handle_exec(driver, in);
break;
case COMMAND_DOWNLOAD:
out = handle_download(driver, in);
break;
case COMMAND_UPLOAD:
out = handle_upload(driver, in);
break;
case COMMAND_SHUTDOWN:
out = handle_shutdown(driver, in);
break;
case COMMAND_DELAY:
out = handle_delay(driver, in);
break;
case TUNNEL_CONNECT:
out = handle_tunnel_connect(driver, in);
break;
case TUNNEL_DATA:
out = handle_tunnel_data(driver, in);
break;
case TUNNEL_CLOSE:
out = handle_tunnel_close(driver, in);
break;
case COMMAND_ERROR:
out = handle_error(driver, in);
break;
default:
LOG_ERROR("Got a command packet that we don't know how to handle!\n");
out = command_packet_create_error_response(in->request_id, 0xFFFF, "Not implemented yet!");
}
/* Respond if and only if an outgoing packet was created. */
if(out)
{
uint8_t *data;
size_t length;
if(out->command_id != TUNNEL_DATA)
{
printf("Response: ");
command_packet_print(out);
}
data = command_packet_to_bytes(out, &length);
buffer_add_bytes(driver->outgoing_data, data, length);
safe_free(data);
command_packet_destroy(out);
}
command_packet_destroy(in);
}
}
int kvm_run(kvm_context_t kvm, int vcpu)
{
int r;
int fd = kvm->vcpu_fd[vcpu];
struct kvm_run *run = kvm->run[vcpu];
/*if (kvm_abi == 10)
return kvm_run_abi10(kvm, vcpu);*/
again:
// if (!kvm->irqchip_in_kernel)
// run->request_interrupt_window = try_push_interrupts(kvm);
//r = pre_kvm_run(kvm, vcpu);
//if (r)
// return r;
r = ioctl(fd, KVM_RUN, 0);
printf("here\n");
//post_kvm_run(kvm, vcpu);
if (r == -1 && errno != EINTR && errno != EAGAIN) {
r = -errno;
printf("kvm_run: %m\n");
return r;
}
if (r == -1) {
r = handle_io_window(kvm);
goto more;
}
if (1) {
switch (run->exit_reason) {
case KVM_EXIT_UNKNOWN:
fprintf(stderr, "unhandled vm exit: 0x%x\n",
(unsigned)run->hw.hardware_exit_reason);
kvm_show_regs(kvm, vcpu);
abort();
break;
case KVM_EXIT_FAIL_ENTRY:
fprintf(stderr, "kvm_run: failed entry, reason %u\n",
(unsigned)run->fail_entry.hardware_entry_failure_reason & 0xffff);
return -ENOEXEC;
break;
case KVM_EXIT_EXCEPTION:
fprintf(stderr, "exception %d (%x)\n",
run->ex.exception,
run->ex.error_code);
kvm_show_regs(kvm, vcpu);
kvm_show_code(kvm, vcpu);
abort();
break;
case KVM_EXIT_IO:
r = handle_io(kvm, run, vcpu);
break;
case KVM_EXIT_DEBUG:
r = handle_debug(kvm, vcpu);
break;
case KVM_EXIT_MMIO:
r = handle_mmio(kvm, run);
break;
case KVM_EXIT_HLT:
r = handle_halt(kvm, vcpu);
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
break;
case KVM_EXIT_SHUTDOWN:
r = handle_shutdown(kvm, vcpu);
break;
case KVM_EXIT_SET_TPR:
break;
default:
fprintf(stderr, "unhandled vm exit: 0x%x\n", run->exit_reason);
kvm_show_regs(kvm, vcpu);
abort();
break;
}
}
more:
if (!r)
goto again;
return r;
}
int kvm_run(CPUState *env)
{
int r;
kvm_context_t kvm = &env->kvm_state->kvm_context;
struct kvm_run *run = env->kvm_run;
int fd = env->kvm_fd;
again:
if (env->kvm_vcpu_dirty) {
kvm_arch_load_regs(env, KVM_PUT_RUNTIME_STATE);
env->kvm_vcpu_dirty = 0;
}
push_nmi(kvm);
#if !defined(__s390__)
if (!kvm->irqchip_in_kernel) {
run->request_interrupt_window = kvm_arch_try_push_interrupts(env);
}
#endif
r = pre_kvm_run(kvm, env);
if (r) {
return r;
}
if (env->exit_request) {
env->exit_request = 0;
pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
}
r = ioctl(fd, KVM_RUN, 0);
if (r == -1 && errno != EINTR && errno != EAGAIN) {
r = -errno;
post_kvm_run(kvm, env);
fprintf(stderr, "kvm_run: %s\n", strerror(-r));
return r;
}
post_kvm_run(kvm, env);
kvm_flush_coalesced_mmio_buffer();
#if !defined(__s390__)
if (r == -1) {
r = handle_io_window(kvm);
goto more;
}
#endif
if (1) {
switch (run->exit_reason) {
case KVM_EXIT_UNKNOWN:
r = handle_unhandled(run->hw.hardware_exit_reason);
break;
case KVM_EXIT_FAIL_ENTRY:
r = handle_failed_vmentry(run->fail_entry.hardware_entry_failure_reason);
break;
case KVM_EXIT_EXCEPTION:
fprintf(stderr, "exception %d (%x)\n", run->ex.exception,
run->ex.error_code);
kvm_show_regs(env);
kvm_show_code(env);
abort();
break;
case KVM_EXIT_IO:
r = kvm_handle_io(run->io.port,
(uint8_t *)run + run->io.data_offset,
run->io.direction,
run->io.size,
run->io.count);
r = 0;
break;
case KVM_EXIT_DEBUG:
r = handle_debug(env);
break;
case KVM_EXIT_MMIO:
r = handle_mmio(env);
break;
case KVM_EXIT_HLT:
r = kvm_arch_halt(env);
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
break;
case KVM_EXIT_SHUTDOWN:
r = handle_shutdown(kvm, env);
break;
#if defined(__s390__)
case KVM_EXIT_S390_SIEIC:
r = kvm_s390_handle_intercept(kvm, env, run);
break;
case KVM_EXIT_S390_RESET:
r = kvm_s390_handle_reset(kvm, env, run);
break;
#endif
case KVM_EXIT_INTERNAL_ERROR:
kvm_handle_internal_error(env, run);
r = 1;
break;
default:
if (kvm_arch_run(env)) {
fprintf(stderr, "unhandled vm exit: 0x%x\n", run->exit_reason);
kvm_show_regs(env);
abort();
}
break;
}
}
more:
if (!r) {
goto again;
}
return r;
}
int __cdecl kvm_run(kvm_context_t kvm, int vcpu)
{
int r = 0;
int fd = kvm->vcpu_fd[vcpu];
struct kvm_run kvm_run;
int retlen;
BOOL ret = FALSE;
kvm_run.emulated = 0;
kvm_run.mmio_completed = 0;
kvm_run.vcpu_fd = fd;
again:
kvm_run.request_interrupt_window = try_push_interrupts(kvm);
pre_kvm_run(kvm, &kvm_run);
/* r = ioctl(fd, KVM_RUN, &kvm_run); */
ret = DeviceIoControl(
kvm->hnd,
KVM_RUN,
&kvm_run,
sizeof(kvm_run),
&kvm_run,
sizeof(kvm_run),
&retlen,
NULL);
if (retlen != sizeof(kvm_run)) {
fprintf(stderr, "kvm_run: invalid return value\n");
return r;
}
post_kvm_run(kvm, &kvm_run);
kvm_run.emulated = 0;
kvm_run.mmio_completed = 0;
if (!ret) {
fprintf(stderr, "kvm_run: failed\n");
return -1;
}
if (kvm_run.ioctl_r == -1 && kvm_run._errno != EINTR) {
r = -(kvm_run._errno);
fprintf(stderr, "kvm_run: %d\n", kvm_run._errno);
return r;
}
if (kvm_run.ioctl_r == -1) {
r = handle_io_window(kvm, &kvm_run);
goto more;
}
/*
if (kvm_run.ioctl_r == -EINTR) {
r = handle_io_window(kvm, &kvm_run);
r = 1;
goto more;
}
*/
switch (kvm_run.exit_type) {
case KVM_EXIT_TYPE_FAIL_ENTRY:
fprintf(stderr, "kvm_run: failed entry, reason %u\n",
kvm_run.exit_reason & 0xffff);
return -ENOEXEC;
break;
case KVM_EXIT_TYPE_VM_EXIT:
switch (kvm_run.exit_reason) {
case KVM_EXIT_UNKNOWN:
fprintf(stderr, "unhandled vm exit: 0x%x\n",
kvm_run.hw.hardware_exit_reason);
kvm_show_regs(kvm, vcpu);
abort();
break;
case KVM_EXIT_EXCEPTION:
fprintf(stderr, "exception %d (%x)\n",
kvm_run.ex.exception,
kvm_run.ex.error_code);
kvm_show_regs(kvm, vcpu);
abort();
break;
case KVM_EXIT_IO:
r = handle_io(kvm, &kvm_run, vcpu);
break;
case KVM_EXIT_CPUID:
r = handle_cpuid(kvm, &kvm_run, vcpu);
break;
case KVM_EXIT_DEBUG:
r = handle_debug(kvm, &kvm_run, vcpu);
break;
case KVM_EXIT_MMIO:
r = handle_mmio(kvm, &kvm_run);
break;
case KVM_EXIT_HLT:
r = handle_halt(kvm, &kvm_run, vcpu);
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
break;
case KVM_EXIT_SHUTDOWN:
r = handle_shutdown(kvm, &kvm_run, vcpu);
break;
default:
fprintf(stderr, "unhandled vm exit: 0x%x\n", kvm_run.exit_reason);
kvm_show_regs(kvm, vcpu);
abort();
break;
}
}
more:
if (!r)
goto again;
return r;
}
