bool git_path_isvalid( git_repository *repo, const char *path, unsigned int flags) { const char *start, *c; /* Upgrade the ".git" checks based on platform */ if ((flags & GIT_PATH_REJECT_DOT_GIT)) flags = dotgit_flags(repo, flags); for (start = c = path; *c; c++) { if (!verify_char(*c, flags)) return false; if (*c == '/') { if (!verify_component(repo, start, (c - start), flags)) return false; start = c+1; } } return verify_component(repo, start, (c - start), flags); }
OMX_ERRORTYPE ste_adm_omx_callback_fill_buffer_done( OMX_IN OMX_HANDLETYPE component_handle, OMX_IN OMX_PTR app_data_p, OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) { struct comp* c = (struct comp*) app_data_p; verify_component(c); struct msg m; memset(&m,0,sizeof(m)); m.type = MSG_FILL_BUFFER_DONE; m.cmd.fill_buffer_done.client_handle = (int) c->client_handle; m.cmd.fill_buffer_done.client_bufhdr = (int) pBuffer->pAppPrivate; m.cmd.fill_buffer_done.out_buf_hdr.nOffset = pBuffer->nOffset; m.cmd.fill_buffer_done.out_buf_hdr.nTimeStamp = pBuffer->nTimeStamp; m.cmd.fill_buffer_done.out_buf_hdr.nFilledLen = pBuffer->nFilledLen; m.cmd.fill_buffer_done.out_buf_hdr.nFlags = pBuffer->nFlags; if (pBuffer->nAllocLen <= sizeof(m.cmd.fill_buffer_done.out_buf)) { memcpy(m.cmd.fill_buffer_done.out_buf, pBuffer->pBuffer, pBuffer->nAllocLen); } fprintf(stderr, "ILSRV: %08X [%20s] Dispatching fill_buffer_done\n", component_handle, last_part(c->name)); send_message(c->client_fd, &m); struct timeval tv; gettimeofday(&tv, NULL); fprintf(stderr, "ILSRV: (%d.%d) Ready to dispatch new events\n", tv.tv_sec, tv.tv_usec/1000); }
OMX_ERRORTYPE ste_adm_omx_callback_empty_buffer_done( OMX_IN OMX_HANDLETYPE component_handle, OMX_IN OMX_PTR app_data_p, OMX_IN OMX_BUFFERHEADERTYPE* buffer_done_p) { struct comp* c = (struct comp*) app_data_p; verify_component(c); verify_bufhdr(buffer_done_p); struct msg m; memset(&m,0,sizeof(m)); m.type = MSG_EMPTY_BUFFER_DONE; m.cmd.empty_buffer_done.client_handle = (int) c->client_handle; m.cmd.empty_buffer_done.client_bufhdr = (int) buffer_done_p->pAppPrivate; fprintf(stderr, "ILSRV: %08X [%20s] Dispatching empty_buffer_done\n", component_handle, last_part(c->name)); send_message(c->client_fd, &m); struct timeval tv; gettimeofday(&tv, NULL); fprintf(stderr, "ILSRV: (%d.%d) Ready to dispatch new events\n", tv.tv_sec, tv.tv_usec/1000); }
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; }