static void
team_gone(team_id team, void *_session)
{
Session *session = (Session *)_session;
session->Lock();
stop_session(session);
}
void helper(const char* server)
{
MirDemoState mcd;
mcd.connection = 0;
mcd.surface = 0;
mcd.prompt_session = 0;
mcd.state = mir_prompt_session_state_stopped;
mcd.client_fd_count = 0;
start_session(server, "helper", &mcd);
// We create a prompt session
mcd.prompt_session = mir_connection_create_prompt_session_sync(mcd.connection, getpid(), prompt_session_event_callback, &mcd);
assert(mcd.prompt_session != NULL);
assert(mcd.state == mir_prompt_session_state_started);
puts("helper: Started prompt session");
mir_wait_for(mir_prompt_session_new_fds_for_prompt_providers(mcd.prompt_session, 1, client_fd_callback, &mcd));
assert(mcd.client_fd_count == 1);
puts("helper: Added waiting FD");
printf("helper: Starting child application 'mir_demo_client_basic' with fd://%d\n", mcd.client_fds[0]);
mcd.child_pid = fork();
if (mcd.child_pid == 0)
{
char buffer[128] = {0};
sprintf(buffer, "fd://%d", mcd.client_fds[0]);
char* args[4];
args[0] = "mir_demo_client_basic";
args[1] = "-m";
args[2] = &buffer[0];
args[3] = NULL;
errno = 0;
execvp("mir_demo_client_basic", args);
return;
}
int status;
printf("helper: Waiting on child application: %d\n", mcd.child_pid);
waitpid(mcd.child_pid, &status, 0);
if (mcd.state == mir_prompt_session_state_started)
{
mir_prompt_session_release_sync(mcd.prompt_session);
mcd.prompt_session = NULL;
puts("helper: Stopped prompt session");
}
else
{
puts("helper: Prompt session stopped by server");
}
puts("helper: Done");
stop_session(&mcd, "helper");
}
void
SessionGetter::Stop()
{
if (fSession == sMainSession)
sMainSession = NULL;
stop_session(fSession);
fSession = NULL;
}
void SoundOutput_Impl::fill_mix_buffers()
{
std::unique_lock<std::recursive_mutex> mutex_lock(mutex);
std::vector< SoundBuffer_Session > ended_sessions;
std::vector< SoundBuffer_Session >::iterator it;
for (it = sessions.begin(); it != sessions.end(); ++it)
{
SoundBuffer_Session session = *it;
bool playing = session.impl->mix_to(mix_buffers, temp_buffers, mix_buffer_size, 2);
if (!playing) ended_sessions.push_back(session);
}
// Release any sessions pending for removal:
int size_ended_sessions = ended_sessions.size();
for (int i = 0; i < size_ended_sessions; i++) stop_session(ended_sessions[i]);
}
static gboolean
receive_message(Session *session)
{
session->message_size =
read(session->socket_fd, session->message, MESSAGE_SIZE);
if (session->message_size == -1) {
perror("failed to read()");
return FALSE;
}
if (session->message_size == 0) {
return stop_session(session);
}
if (parse_data) {
if (session->message[0] == '{') {
JsonParser *parser;
parser = json_parser_new();
json_parser_load_from_data(parser,
session->message, session->message_size,
NULL);
g_object_unref(parser);
} else {
msgpack_unpacked unpacked;
size_t offset;
msgpack_unpacked_init(&unpacked);
msgpack_unpack_next(&unpacked,
session->message, session->message_size,
&offset);
msgpack_unpacked_destroy(&unpacked);
}
}
{
int epoll_fd = session->context->epoll_fd;
struct epoll_event event;
event.events = EPOLLOUT;
event.data.ptr = session;
if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, session->socket_fd, &event) == -1) {
perror("failed to epoll_ctl(EPOLL_CTL_MOD, client_socket_fd)");
return FALSE;
}
}
return TRUE;
}
static status_t
launch_speedup_control(const char *subsystem, uint32 function,
void *buffer, size_t bufferSize)
{
switch (function) {
case LAUNCH_SPEEDUP_START_SESSION:
{
char name[B_OS_NAME_LENGTH];
if (!IS_USER_ADDRESS(buffer)
|| user_strlcpy(name, (const char *)buffer, B_OS_NAME_LENGTH) < B_OK)
return B_BAD_ADDRESS;
if (isdigit(name[0]) || name[0] == '.')
return B_BAD_VALUE;
sMainSession = start_session(-1, -1, -1, name, 60);
sMainSession->Unlock();
return B_OK;
}
case LAUNCH_SPEEDUP_STOP_SESSION:
{
char name[B_OS_NAME_LENGTH];
if (!IS_USER_ADDRESS(buffer)
|| user_strlcpy(name, (const char *)buffer, B_OS_NAME_LENGTH) < B_OK)
return B_BAD_ADDRESS;
// ToDo: this check is not thread-safe
if (sMainSession == NULL || strcmp(sMainSession->Name(), name))
return B_BAD_VALUE;
if (!strcmp(name, "system boot"))
dprintf("STOP BOOT %Ld\n", system_time());
sMainSession->Lock();
stop_session(sMainSession);
sMainSession = NULL;
return B_OK;
}
}
return B_BAD_VALUE;
}
static gint32
mca_exec_svr_command (guint32 cmd, void *data, guint32 datalen)
{
gint retval = 0;
gint32 nr_data_h = 0;
DEBUG_PRINT("mca_exec_command(): cmd=%08X [%d bytes]\n", cmd, datalen);
if (datalen > 0)
nr_data_h = ntohl(*(guint32 *)data);
switch (cmd) {
//server-to-client message/command
case MKW_OWED_CASH: //CS_SETOWED:
DBG_PRINT("mca_exec_command(): cmd = MKW_OWED_CASH: [%d]\n", nr_data_h);
set_owed_cash(nr_data_h);
break;
case MKW_PRODUCTS_CASH: //CS_SETADDITIONAL:
DBG_PRINT("mca_exec_command(): cmd = MKW_PRODUCTS_CASH: [%d]\n", datalen);
set_products_cash(nr_data_h);
break;
case MKW_SESSION_TIME: //CS_SETTIME:
DBG_PRINT("mca_exec_command(): cmd = MKW_SESSION_TIME: [%d]\n", datalen);
set_time_len (nr_data_h);
break;
case MKW_SERVER_MESSAGE: //CS_DISPLAYMESSAGE:
DBG_PRINT("mca_exec_command(): cmd = MKW_SERVER_MESSAGE: [%d]\n", datalen);
show_server_message((gchar *)data);
break;
case MKW_ACK_ASSIST: //CS_CALLASSIST:
DBG_PRINT("mca_exec_command(): cmd = MKW_ACK_ASSIST: [%d]\n", datalen);
ack_assist_request((gchar *) data, datalen);
break;
//session control
case MKW_STOP_SESSION: //CS_STOP:
DBG_PRINT("mca_exec_command(): cmd = MKW_STOP_SESSION: [%d]\n", datalen);
stop_session();
break;
case MKW_START_SESSION: //CS_START:
DBG_PRINT("mca_exec_command(): cmd = MKW_START_SESSION: [%d]\n", datalen);
start_session();
break;
case MKW_PAUSE_SESSION: //CS_PAUSE:
DBG_PRINT("mca_exec_command(): cmd = MKW_PAUSE_SESSION: [%d]\n", datalen);
pause_session();
break;
case MKW_RESUME_SESSION: //CS_RESUME:
DBG_PRINT("mca_exec_command(): cmd = MKW_RESUME_SESSION: [%d]\n", datalen);
resume_session();
break;
case MKW_TIMEOUT_SESSION: //CS_SETTIMEOUT:
DBG_PRINT("mca_exec_command(): cmd = MKW_TIMEOUT_SESSION: [%d]\n", datalen);
start_session_timeout(nr_data_h);
break;
//system control
case MKW_BLANK_MONITOR: //CS_MONITOROFF:
DBG_PRINT("mca_exec_command(): cmd = MKW_BLANK_MONITOR: [%d]\n", datalen);
blank_monitor();
break;
case MKW_SHUTDOWN_SYSTEM: // CS_SHUTDOWN:
DBG_PRINT("mca_exec_command(): cmd = MKW_SHUTDOWN_SYSTEM: [%d]\n", datalen);
shutdown_system();
break;
case MKW_REBOOT_SYSTEM: //CS_REBOOT:
DBG_PRINT("mca_exec_command(): cmd = MKW_REBOOT_SYSTEM: [%d]\n", datalen);
reboot_system();
break;
case MKW_EXIT_MCA: //CS_QUITCLIENT:
DBG_PRINT("mca_exec_command(): cmd = MKW_EXIT_MCA: [%d]\n", datalen);
exit_mca_program();
break;
case MKW_SET_ADMIN_PASSWD: //CS_SETADMINPASS:
DBG_PRINT("mca_exec_command(): cmd = MKW_SET_ADMIN_PASSWD: [%d]\n", datalen);
set_admin_passwd((gchar *)data, datalen);
break;
case MKW_SET_POLL_INTERVAL: // CS_SETPOLLINTERVAL:
DBG_PRINT("mca_exec_command(): cmd = MKW_SET_POLL_INTERVAL: [%d]\n", datalen);
set_poll_interval( nr_data_h );
break;
//utils
case MKW_UNBLOCK_SCREEN : //CS_UNLOCKSCREEN:
DBG_PRINT("mca_exec_command(): cmd = MKW_UNBLOCK_SCREEN: [%d]\n", datalen);
unblock_screen();
break;
case MKW_BLOCK_SCREEN: //CS_LOCKSCREEN:
DBG_PRINT("mca_exec_command(): cmd = MKW_BLOCK_SCREEN: [%d]\n", datalen);
block_screen();
break;
//UI and program state
case MKW_ENABLE_PASSWD_BUTTON: //CS_ENABLEPASSWORDEDIT:
DBG_PRINT("mca_exec_command(): cmd = MKW_ENABLE_PASSWD_BUTTON: [%d]\n", datalen);
set_passwd_edit_state(nr_data_h);
break;
case MKW_ALLOW_MEMBER_LOGIN: // CS_ALLOWMEMBERLOGIN:
DBG_PRINT("mca_exec_command(): cmd = MKW_ALLOW_MEMBER_LOGIN: [%d]\n", datalen);
set_member_loginable(nr_data_h);
break;
case MKW_ALLOW_TICKET_LOGIN: //CS_ALLOWTICKETLOGIN:
DBG_PRINT("mca_exec_command(): cmd = MKW_ALLOW_TICKET_LOGIN: [%d]\n", datalen);
set_ticket_loginable(nr_data_h);
break;
case MKW_ALLOW_USER_LOGIN: //CS_ALLOWUSERLOGIN:
DBG_PRINT("mca_exec_command(): cmd = MKW_ALLOW_USER_LOGIN: [%d]\n", datalen);
set_user_loginable(nr_data_h);
break;
case MKW_ENABLE_ASSIST_BUTTON: //CS_ENABLEASSIST:
DBG_PRINT("mca_exec_command(): cmd = MKW_ENABLE_ASSIST_BUTTON: [%d]\n", datalen);
set_assist_able(nr_data_h);
break;
//update
case MKW_START_UPDATE: //CS_UPDATE:
DBG_PRINT("mca_exec_command(): cmd = MKW_START_UPDATE: [%d]\n", datalen);
start_mkw_update ((gchar *) data, datalen);
break;
case MKW_UPDATE_DATA: // CS_UPDATEDATA:
DBG_PRINT("mca_exec_command(): cmd = MKW_UPDATE_DATA: [%d]\n", datalen);
proc_mkw_update_data((gchar *)data, datalen);
break;
case MKW_END_UPDATE: //CS_UPDATEEND:
DBG_PRINT("mca_exec_command(): cmd = MKW_END_UPDATE: [%d]\n", datalen);
end_mkw_update((gchar *)data, datalen);
break;
}
return retval;
}
int
main(int argc, char **argv)
{
struct addrinfo *addresses;
{
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new("server side implementation by thread");
g_option_context_add_main_entries(context, entries, NULL);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_print("failed to parse options: %s\n", error->message);
g_error_free(error);
g_option_context_free(context);
return EXIT_FAILURE;
}
g_option_context_free(context);
}
{
struct addrinfo hints;
int error;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
hints.ai_protocol = 0;
error = getaddrinfo(NULL, port, &hints, &addresses);
if (error != 0) {
g_print("failed to getaddrinfo(): %s\n", g_strerror(error));
return EXIT_FAILURE;
}
}
{
struct addrinfo *address = addresses;
int accept_socket_fd;
accept_socket_fd = socket(address->ai_family,
address->ai_socktype,
address->ai_protocol);
if (accept_socket_fd == -1) {
perror("failed to socket()");
return EXIT_FAILURE;
}
{
gboolean reuse_address = TRUE;
if (setsockopt(accept_socket_fd, SOL_SOCKET, SO_REUSEADDR,
&reuse_address, sizeof(reuse_address)) == -1) {
perror("failed to setsockopt(SO_REUSEADDR): %s");
return EXIT_FAILURE;
}
}
if (bind(accept_socket_fd, address->ai_addr, address->ai_addrlen) == -1) {
perror("failed to bind()");
return EXIT_FAILURE;
}
{
const int backlog = 1024;
if (listen(accept_socket_fd, backlog) == -1) {
perror("failed to listen()");
return EXIT_FAILURE;
}
}
{
Context context;
Session accept_session;
int not_used_size = 1;
#define MAX_EVENTS 10
struct epoll_event events[MAX_EVENTS];
context.epoll_fd = epoll_create(not_used_size);
if (context.epoll_fd == -1) {
perror("failed to epoll_create()");
return EXIT_FAILURE;
}
{
struct epoll_event event;
int epoll_fd = context.epoll_fd;
event.events = EPOLLIN;
event.data.ptr = &accept_session;
accept_session.socket_fd = accept_socket_fd;
accept_session.message_size = 0;
accept_session.context = &context;
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, accept_socket_fd, &event) == -1) {
perror("failed to epoll_ctl(EPOLL_CTL_ADD, accept_fd)");
return EXIT_FAILURE;
}
while (TRUE) {
int i, n_events;
n_events = epoll_wait(context.epoll_fd, events, MAX_EVENTS, -1);
for (i = 0; i < n_events; i++) {
struct epoll_event *event = events + i;
Session *session;
session = event->data.ptr;
if (session->socket_fd == accept_socket_fd) {
if (!start_session(&context, session->socket_fd)) {
return EXIT_FAILURE;
}
continue;
}
if (event->events & (EPOLLIN | EPOLLPRI)) {
if (!receive_message(session)) {
return EXIT_FAILURE;
}
} else if (event->events & EPOLLOUT) {
if (!send_message(session)) {
return EXIT_FAILURE;
}
} else if (event->events & (EPOLLHUP | EPOLLERR)) {
if (!stop_session(session)) {
return EXIT_FAILURE;
}
}
}
}
}
}
}
freeaddrinfo(addresses);
return EXIT_SUCCESS;
}
