void verify_bufhdr(OMX_BUFFERHEADERTYPE* c) { pthread_mutex_lock(&list_mutex); int idx = get_bufhdr_idx(c); pthread_mutex_unlock(&list_mutex); if (idx == -1) { fprintf(stderr, "verify_bufhdr failed for %X\n", c); error_found(); } }
void verify_component_and_keep_lock(struct comp* c) { pthread_mutex_lock(&list_mutex); int idx = get_component_idx(c); if (idx == -1) { fprintf(stderr, "verify_component failed for %X\n", c); error_found(); } }
tParams * parser_parse(char * buff) { error_reset(); parser_generate_args(buff); if(!error_found()) { params.args_amount = args_amount; params.args = args; return ¶ms; } else return NULL; }
static void send_message(int fd, struct msg* msg) { pthread_mutex_lock(&il_srv_fd_mutex); int t=0; while (t < (int) sizeof(*msg)) { int w = send(fd, ((char*)msg)+t, sizeof(*msg)-t, MSG_NOSIGNAL); if (w == -1) { fprintf(stderr, "send of event: Socket %d not working (error: '%s')\n", fd, strerror(errno)); error_found(); } t += w; } pthread_mutex_unlock(&il_srv_fd_mutex); }
void add_component(struct comp* c) { pthread_mutex_lock(&list_mutex); if (num_valid_comps >= MAX_COMPONENTS) { fprintf(stderr, "Too many components\n"); error_found(); } valid_comps[num_valid_comps++] = c; pthread_mutex_unlock(&list_mutex); }
static void handle_msg(int fd, struct msg* m) { switch (m->type) { case MSG_GET_HANDLE: { struct comp* c = (struct comp*) malloc(sizeof(struct comp)); fprintf(stderr, "ILSRV: GetHandle '%s'\n", m->cmd.get_handle.name); m->result = OMX_GetHandle(&c->real_handle, m->cmd.get_handle.name, c, &callbacks); m->cmd.get_handle.out_srv_handle = (int) c; c->client_handle = m->cmd.get_handle.in_client_handle; c->client_fd = fd; c->state = OMX_StateLoaded; strncpy(c->name, m->cmd.get_handle.name, sizeof(c->name)); c->name[sizeof(c->name)-1]=0; add_component(c); fprintf(stderr, "ILSRV: %08X [%20s] --> %s%s\n", c->real_handle, last_part(c->name), m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SET_PARAM:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] SetParam %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_SetParameter(c->real_handle, (OMX_INDEXTYPE) m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_PARAM:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetParam %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_GetParameter(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_CONFIG:{ struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetConfig %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_GetConfig(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SET_CONFIG: { struct comp* c = (struct comp*) m->cmd.param.srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] SetConfig %s\n", c->real_handle, last_part(c->name), adm_log_index2str(m->cmd.param.index)); m->result = OMX_SetConfig(c->real_handle, (OMX_INDEXTYPE)m->cmd.param.index, m->cmd.param.buf); // TODO: Protect fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_FREE_HANDLE: { struct comp* c = (struct comp*) m->cmd.free_handle.srv_handle; verify_component(c); if (c->state != OMX_StateLoaded) { fprintf(stderr, "ILSRV: FreeHandle called for %X which is in wrong state (%s)\m", c->real_handle, adm_log_state2str(c->state)); error_found(); } fprintf(stderr, "ILSRV: %08X [%20s] Freehandle (internal=%X)\n", c->real_handle, last_part(c->name), c); m->result = OMX_FreeHandle(c->real_handle); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); del_component(c); memset(c, 0xFE, sizeof(*c)); free(c); return; } case MSG_SEND_COMMAND: { struct comp* c = (struct comp*) m->cmd.free_handle.srv_handle; verify_component(c); if (m->cmd.command.cmd == OMX_CommandStateSet) { fprintf(stderr, "ILSRV: %08X [%20s] SendCommand StateSet %s\n", c->real_handle, last_part(c->name), adm_log_state2str((OMX_STATETYPE) m->cmd.command.nParam1)); } else { fprintf(stderr, "ILSRV: %08X [%20s] SendCommand StateSet %s 0x%X\n", c->real_handle, last_part(c->name), adm_log_cmd2str(m->cmd.command.cmd), m->cmd.command.nParam1); } m->result = OMX_SendCommand(c->real_handle, m->cmd.command.cmd, m->cmd.command.nParam1, 0); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_SETUP_TUNNEL: { struct comp* c_in = (struct comp*) m->cmd.tunnel.srv_handle_in; struct comp* c_out = (struct comp*) m->cmd.tunnel.srv_handle_out; verify_component(c_in); verify_component(c_out); fprintf(stderr, "ILSRV: SetupTunnel %08X [%20s].%d --> %08X [%20s].%d\n", c_out->real_handle, last_part(c_out->name), m->cmd.tunnel.port_out, c_in->real_handle, last_part(c_in->name), m->cmd.tunnel.port_in); m->result = OMX_SetupTunnel(c_out->real_handle, m->cmd.tunnel.port_out, c_in->real_handle, m->cmd.tunnel.port_in); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_GET_STATE: { struct comp* c = (struct comp*) m->cmd.get_state.in_srv_handle; verify_component(c); fprintf(stderr, "ILSRV: %08X [%20s] GetState\n", c->real_handle, last_part(c->name)); m->result = OMX_GetState(c->real_handle, &m->cmd.get_state.out_state); fprintf(stderr, "ILSRV: --> %s %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result), adm_log_state2str(m->cmd.get_state.out_state)); return; } case MSG_ALLOC_BUFFER: { struct comp* c = (struct comp*) m->cmd.alloc_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* bufhdr; fprintf(stderr, "ILSRV: %08X [%20s] AllocBuf port=%d size=%d\n", c->real_handle, last_part(c->name), m->cmd.alloc_buffer.port, m->cmd.alloc_buffer.size); m->result = OMX_AllocateBuffer(c->real_handle, &bufhdr, m->cmd.alloc_buffer.port, (void*) m->cmd.alloc_buffer.in_client_buf_hdr, m->cmd.alloc_buffer.size); if (m->result == OMX_ErrorNone) { memcpy(&m->cmd.alloc_buffer.out_buf_hdr, bufhdr, sizeof(OMX_BUFFERHEADERTYPE)); m->cmd.alloc_buffer.out_srv_buf_hdr = (int) bufhdr; add_bufhdr(bufhdr); } fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_EMPTY_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* client_bufhdr = (OMX_BUFFERHEADERTYPE*) &m->cmd.empty_buffer.in_buf_hdr; OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) client_bufhdr->pPlatformPrivate; verify_bufhdr(bufhdr); if (bufhdr->nAllocLen <= sizeof(m->cmd.empty_buffer.in_buf)) { bufhdr->nOffset = client_bufhdr->nOffset; bufhdr->nTimeStamp = client_bufhdr->nTimeStamp; bufhdr->nFilledLen = client_bufhdr->nFilledLen; bufhdr->nFlags = client_bufhdr->nFlags; memcpy(bufhdr->pBuffer, &m->cmd.empty_buffer.in_buf, bufhdr->nAllocLen); fprintf(stderr, "ILSRV: %08X [%20s] EmptyBuffer port=%d size=%d\n", c->real_handle, last_part(c->name), bufhdr->nInputPortIndex, bufhdr->nAllocLen); m->result = OMX_EmptyThisBuffer(c->real_handle, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); } else { assert(0); } return; } case MSG_FILL_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* client_bufhdr = (OMX_BUFFERHEADERTYPE*) &m->cmd.fill_buffer.in_buf_hdr; OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) client_bufhdr->pPlatformPrivate; verify_bufhdr(bufhdr); fprintf(stderr, "ILSRV: %08X [%20s] FillBuffer port=%d size=%d\n", c->real_handle, last_part(c->name), bufhdr->nOutputPortIndex, bufhdr->nAllocLen); m->result = OMX_FillThisBuffer(c->real_handle, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } case MSG_FREE_BUFFER: { struct comp* c = (struct comp*) m->cmd.empty_buffer.in_srv_handle; verify_component(c); OMX_BUFFERHEADERTYPE* bufhdr = (OMX_BUFFERHEADERTYPE*) m->cmd.free_buffer.in_srv_buf_hdr; verify_bufhdr(bufhdr); del_bufhdr(bufhdr); fprintf(stderr, "ILSRV: %08X [%20s] FreeBuffer\n", c->real_handle, last_part(c->name)); m->result = OMX_FreeBuffer(c->real_handle, m->cmd.free_buffer.in_port, bufhdr); fprintf(stderr, "ILSRV: --> %s %s\n", m->result == OMX_ErrorNone ? "" : "ERROR ", adm_log_err2str(m->result)); return; } default: fprintf(stderr, "ILSRV: Unhandled request received\n"); m->result = OMX_ErrorNotImplemented; error_found(); return; }
int main() { fprintf(stderr, "IL server starting up\n"); OMX_Init(); struct sockaddr_un local_sockaddr_un; int listener_sck_fd = socket(AF_UNIX, SOCK_STREAM, 0); memset(&local_sockaddr_un, 0, sizeof(local_sockaddr_un)); local_sockaddr_un.sun_family = AF_UNIX; strcpy(local_sockaddr_un.sun_path, "/tmp/il-server-socket"); /* Unlink any previous socket */ unlink("/tmp/il-server-socket"); if (bind(listener_sck_fd, (struct sockaddr *) &local_sockaddr_un, sizeof(local_sockaddr_un)) < 0) { fprintf(stderr, "bind() %s\n", strerror(errno)); error_found(); } if (listen(listener_sck_fd, 10)) { fprintf(stderr, "listen() %s\n", strerror(errno)); error_found(); } fd_set master_socket_fds; int highest_fd = listener_sck_fd; FD_ZERO(&master_socket_fds); FD_SET(listener_sck_fd, &master_socket_fds); signal(SIGPIPE, SIG_IGN); for (;;) { int num_active_fds; fd_set tmp_read_socket_fds; tmp_read_socket_fds = master_socket_fds; /* Poll for new requests on the FD_sets */ num_active_fds = select(highest_fd+1, &tmp_read_socket_fds, NULL, NULL, NULL); if (num_active_fds == -1) { fprintf(stderr, "num_active_fds == -1\n"); exit(10); } /* If listener socket is ready for read, this means a client is trying to connect to it */ if (FD_ISSET(listener_sck_fd, &tmp_read_socket_fds)) { int client_sck_fd; /* Try to accept the client connection. We need to always accept and then close connection if we have an overflow of clients */ client_sck_fd = accept(listener_sck_fd, NULL,/* Don't care remote address */ NULL /* Don't care remote size */); if (listener_sck_fd == -1) { fprintf(stderr, "accept() %s\n", strerror(errno)); error_found(); } /* check if we need to update upper bound used by the select() function */ if (client_sck_fd > highest_fd) { highest_fd = client_sck_fd; } /* add the socket descriptor to the master set */ FD_SET(client_sck_fd, &master_socket_fds); fprintf(stderr, "New client connected; got fd=%d\n", client_sck_fd); continue; } int cur_fd; for (cur_fd=3 ; cur_fd <= highest_fd ; cur_fd++) { if (FD_ISSET(cur_fd, &tmp_read_socket_fds)) { handle_request(cur_fd); } } } return 0; }
OMX_ERRORTYPE ste_adm_omx_callback_event_handler( OMX_IN OMX_HANDLETYPE component_handle, OMX_IN OMX_PTR app_data_p, OMX_IN OMX_EVENTTYPE ev, OMX_IN OMX_U32 data1, OMX_IN OMX_U32 data2, OMX_IN OMX_PTR event_data_p) { if (event_data_p != NULL) { fprintf(stderr, "Received event with event_data_p != NULL\n"); error_found(); } fprintf(stderr, "ILSRV: Received event: %X, %X, %X, %X, %X, %X\n", component_handle, app_data_p, ev, data1, data2, event_data_p); struct comp* c = (struct comp*) app_data_p; verify_component_and_keep_lock(c); struct msg m; memset(&m,0,sizeof(m)); m.type = MSG_EVENT; m.cmd.event.client_handle = c->client_handle; m.cmd.event.ev = ev; m.cmd.event.nData1 = data1; m.cmd.event.nData2 = data2; if (ev == OMX_EventCmdComplete) { if (data1 == OMX_CommandStateSet) { c->state = (OMX_STATETYPE) data2; fprintf(stderr, "ILSRV: %08X [%20s] Dispatching CmdComplete StateSet %s\n", component_handle, last_part(c->name), adm_log_state2str((OMX_STATETYPE) data2)); } else if (data1 == OMX_CommandPortDisable) { fprintf(stderr, "ILSRV: %08X [%20s] Dispatching CmdComplete PortDisable %d\n", component_handle, last_part(c->name), data2); } else if (data1 == OMX_CommandPortEnable) { fprintf(stderr, "ILSRV: %08X [%20s] Dispatching CmdComplete PortEnable %d\n", component_handle, last_part(c->name), data2); } else { fprintf(stderr, "ILSRV: %08X [%20s] Dispatching %s nData2=%X\n", component_handle, last_part(c->name), adm_log_cmd2str((OMX_COMMANDTYPE) data1), data2); } } else if (ev == OMX_EventError) { fprintf(stderr, "ILSRV: %08X [%20s] Dispatching EventError %s nData2=%d\n", component_handle, last_part(c->name), adm_log_err2str((OMX_ERRORTYPE) data1), data2); } else { fprintf(stderr, "ILSRV: %08X [%20s] Dispatching Event %s nData1=%X nData2=%X\n", component_handle, last_part(c->name), adm_log_event2str(ev), data1,data2); } send_message(c->client_fd, &m); pthread_mutex_unlock(&list_mutex); struct timeval tv; gettimeofday(&tv, NULL); fprintf(stderr, "ILSRV: (%d.%d) Ready to dispatch new events\n", tv.tv_sec, tv.tv_usec/1000); return OMX_ErrorNone; // Pointless }
void add_bufhdr(OMX_BUFFERHEADERTYPE* c) { pthread_mutex_lock(&list_mutex); if (num_valid_bufhdrs >= MAX_BUFHDRS) { fprintf(stderr, "Too many buffers\n"); error_found(); } valid_bufhdrs[num_valid_bufhdrs++] = c; pthread_mutex_unlock(&list_mutex); }