/*% * looks up "ina" in _res.ns_addr_list[] * * returns: *\li 0 : not found *\li >0 : found * * author: *\li paul vixie, 29may94 */ int res_ourserver_p(const res_state statp, const struct sockaddr *sa) { const struct sockaddr_in *inp, *srv; const struct sockaddr_in6 *in6p, *srv6; int ns; switch (sa->sa_family) { case AF_INET: inp = (const struct sockaddr_in *)sa; for (ns = 0; ns < statp->nscount; ns++) { srv = (struct sockaddr_in *)get_nsaddr(statp, ns); if (srv->sin_family == inp->sin_family && srv->sin_port == inp->sin_port && (srv->sin_addr.s_addr == INADDR_ANY || srv->sin_addr.s_addr == inp->sin_addr.s_addr)) return (1); } break; case AF_INET6: if (EXT(statp).ext == NULL) break; in6p = (const struct sockaddr_in6 *)sa; for (ns = 0; ns < statp->nscount; ns++) { srv6 = (struct sockaddr_in6 *)get_nsaddr(statp, ns); if (srv6->sin6_family == in6p->sin6_family && srv6->sin6_port == in6p->sin6_port && #ifdef HAVE_SIN6_SCOPE_ID (srv6->sin6_scope_id == 0 || srv6->sin6_scope_id == in6p->sin6_scope_id) && #endif (IN6_IS_ADDR_UNSPECIFIED(&srv6->sin6_addr) || IN6_ARE_ADDR_EQUAL(&srv6->sin6_addr, &in6p->sin6_addr))) return (1); } break; default: break; } return (0); }
static void command_get_capabilities(char * token, Channel * c) { char id[256]; Context * ctx; OutputStream * out = &c->out; int err = 0; json_read_string(&c->inp, id, sizeof(id)); json_test_char(&c->inp, MARKER_EOA); json_test_char(&c->inp, MARKER_EOM); ctx = id2ctx(id); if (ctx == NULL) err = ERR_INV_CONTEXT; else if (ctx->exited) err = ERR_ALREADY_EXITED; write_stringz(out, "R"); write_stringz(out, token); write_errno(out, err); write_stream(out, '['); if (!err) { unsigned i; ContextExtensionRS * ext = EXT(get_reset_context(ctx)); for (i = 0; i < ext->resets_cnt; i++) { ResetInfo * ri = ext->resets + i; if (i > 0) write_stream(&c->out, ','); write_stream(out, '{'); json_write_string(out, "Type"); write_stream(out, ':'); json_write_string(out, ri->type); write_stream(out, ','); json_write_string(out, "Description"); write_stream(out, ':'); json_write_string(out, ri->desc); write_stream(out, '}'); } } write_stream(out, ']'); write_stream(out, 0); write_stream(out, MARKER_EOM); }
static int get_bp_info(Context * ctx) { uint32_t buf = 0; ContextExtensionARM * bps = EXT(ctx); if (bps->info_ok) return 0; if (ptrace(PTRACE_GETHBPREGS, id2pid(ctx->id, NULL), 0, &buf) < 0) { /* Kernel does not support hardware breakpoints */ bps->arch = 0; bps->wp_size = 0; bps->wp_cnt = 0; bps->bp_cnt = 0; bps->info_ok = 1; return 0; } bps->arch = (uint8_t)(buf >> 24); bps->wp_size = (uint8_t)(buf >> 16); bps->wp_cnt = (uint8_t)(buf >> 8); bps->bp_cnt = (uint8_t)buf; if (bps->wp_cnt > MAX_HWP) bps->wp_cnt = MAX_HWP; if (bps->bp_cnt > MAX_HBP) bps->bp_cnt = MAX_HBP; bps->info_ok = 1; return 0; }
static int find_cache_symbol(Context * ctx, int frame, ULONG64 pc, PCSTR name, Symbol * sym) { ContextExtensionWinSym * ext = EXT(ctx->mem); if (ext->symbol_cache != NULL) { int cnt = 0; SymbolCacheEntry * entry = ext->symbol_cache[symbol_hash(pc, name)]; while (entry != NULL) { if (entry->pc == pc && strcmp(entry->name, name) == 0) { if (entry->error == NULL) { if (entry->frame_relative) { assert(frame >= 0); sym->frame = frame - STACK_NO_FRAME; } else { ctx = ctx->mem; } sym->ctx = ctx; sym->sym_class = entry->sym_class; sym->module = entry->module; sym->index = entry->index; } set_error_report_errno(entry->error); return 1; } else if (cnt > 32) { while (entry->next) { SymbolCacheEntry * next = entry->next; entry->next = next->next; release_error_report(next->error); loc_free(next); } return 0; } entry = entry->next; cnt++; } } return 0; }
int context_continue(Context * ctx) { ContextExtensionVxWorks * ext = EXT(ctx); VXDBG_CTX vxdbg_ctx; assert(is_dispatch_thread()); assert(ctx->parent != NULL); assert(ctx->stopped); assert(!ctx->pending_intercept); assert(!ctx->exited); assert(taskIsStopped(ext->pid)); trace(LOG_CONTEXT, "context: continue ctx %#lx, id %#x", ctx, ext->pid); if (ext->regs_dirty) { if (taskRegsSet(ext->pid, ext->regs) != OK) { int error = errno; trace(LOG_ALWAYS, "context: can't set regs ctx %#lx, id %#x: %s", ctx, ext->pid, errno_to_str(error)); return -1; } ext->regs_dirty = 0; } vxdbg_ctx.ctxId = ext->pid; vxdbg_ctx.ctxType = VXDBG_CTX_TASK; taskLock(); if (vxdbgCont(vxdbg_clnt_id, &vxdbg_ctx) != OK) { int error = errno; taskUnlock(); trace(LOG_ALWAYS, "context: can't continue ctx %#lx, id %#x: %s", ctx, ext->pid, errno_to_str(error)); return -1; } assert(!taskIsStopped(ext->pid)); taskUnlock(); send_context_started_event(ctx); return 0; }
static void event_module_loaded(Context * ctx, void * client_data) { unsigned i; SymbolCacheEntry ** symbol_cache = EXT(ctx)->symbol_cache; assert(ctx->mem == ctx); if (symbol_cache == NULL) return; for (i = 0; i < SYMBOL_CACHE_SIZE; i++) { SymbolCacheEntry * prev = NULL; SymbolCacheEntry * next = symbol_cache[i]; while (next != NULL) { SymbolCacheEntry * entry = next; next = next->next; if (entry->error) { if (prev) prev->next = next; else symbol_cache[i] = next; release_error_report(entry->error); loc_free(entry); } else { prev = entry; } } } }
static void command_get_capabilities_cache_client(void * x) { int error = 0; Context * ctx = NULL; ContextExtensionDS * ext = NULL; GetCapabilitiesCmdArgs * args = (GetCapabilitiesCmdArgs *)x; Channel * c = cache_channel(); ctx = id2ctx(args->id); if (ctx == NULL) error = ERR_INV_CONTEXT; else if (ctx->exited) error = ERR_ALREADY_EXITED; else ext = EXT(context_get_group(ctx, CONTEXT_GROUP_CPU)); cache_exit(); if (!is_channel_closed(c)) { OutputStream * out = &c->out; write_stringz(out, "R"); write_stringz(out, args->token); write_errno(out, error); write_stream(out, '['); if (ext != NULL) { unsigned i; for (i = 0; i < ext->disassemblers_cnt; i++) { if (i > 0) write_stream(out, ','); write_stream(out, '{'); json_write_string(out, "ISA"); write_stream(out, ':'); json_write_string(out, ext->disassemblers[i].isa); write_stream(out, '}'); } } write_stream(out, ']'); write_stream(out, 0); write_stream(out, MARKER_EOM); } }
static void command_get_capabilities(char * token, Channel * c) { int error = 0; char id[256]; Context * ctx = NULL; ContextExtensionDS * ext = NULL; unsigned i, j; json_read_string(&c->inp, id, sizeof(id)); if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX); if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); ctx = id2ctx(id); if (ctx == NULL) error = ERR_INV_CONTEXT; else if (ctx->exited) error = ERR_ALREADY_EXITED; ctx = context_get_group(ctx, CONTEXT_GROUP_CPU); ext = EXT(ctx); write_stringz(&c->out, "R"); write_stringz(&c->out, token); write_errno(&c->out, error); write_stream(&c->out, '['); for (i = 0, j = 0; i < ext->disassemblers_cnt; i++) { if (j > 0) write_stream(&c->out, ','); write_stream(&c->out, '{'); json_write_string(&c->out, "ISA"); write_stream(&c->out, ':'); json_write_string(&c->out, ext->disassemblers[i].isa); write_stream(&c->out, '}'); j++; } write_stream(&c->out, ']'); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); }
int context_continue(Context * ctx) { int signal = 0; assert(is_dispatch_thread()); assert(ctx->stopped); assert(!ctx->exited); assert(!ctx->pending_intercept); assert(!EXT(ctx)->pending_step); if (skip_breakpoint(ctx, 0)) return 0; if (!EXT(ctx)->syscall_enter) { unsigned n = 0; while (sigset_get_next(&ctx->pending_signals, &n)) { if (sigset_get(&ctx->sig_dont_pass, n)) { sigset_set(&ctx->pending_signals, n, 0); } else { signal = n; break; } } assert(signal != SIGSTOP); assert(signal != SIGTRAP); } trace(LOG_CONTEXT, "context: resuming ctx %#lx, id %s, with signal %d", ctx, ctx->id, signal); #if defined(__i386__) if (EXT(ctx)->regs->__eflags & 0x100) { EXT(ctx)->regs->__eflags &= ~0x100; EXT(ctx)->regs_dirty = 1; } #elif defined(__x86_64__) if (EXT(ctx)->regs->__rflags & 0x100) { EXT(ctx)->regs->__rflags &= ~0x100; EXT(ctx)->regs_dirty = 1; } #endif if (EXT(ctx)->regs_dirty) { unsigned int state_count; if (thread_set_state(EXT(ctx)->pid, x86_THREAD_STATE32, EXT(ctx)->regs, &state_count) != KERN_SUCCESS) { int err = errno; trace(LOG_ALWAYS, "error: thread_set_state failed: ctx %#lx, id %s, error %d %s", ctx, ctx->id, err, errno_to_str(err)); errno = err; return -1; } EXT(ctx)->regs_dirty = 0; } if (ptrace(PT_CONTINUE, EXT(ctx)->pid, 0, signal) < 0) { int err = errno; if (err == ESRCH) { send_context_started_event(ctx); return 0; } trace(LOG_ALWAYS, "error: ptrace(PT_CONTINUE, ...) failed: ctx %#lx, id %s, error %d %s", ctx, ctx->id, err, errno_to_str(err)); errno = err; return -1; } sigset_set(&ctx->pending_signals, signal, 0); if (syscall_never_returns(ctx)) { EXT(ctx)->syscall_enter = 0; EXT(ctx)->syscall_exit = 0; EXT(ctx)->syscall_id = 0; } send_context_started_event(ctx); return 0; }
const char * context_suspend_reason(Context * ctx) { if (EXT(ctx)->event == TRACE_EVENT_STEP) return REASON_STEP; return REASON_USER_REQUEST; }
static void event_handler(void * arg) { struct event_info * info = (struct event_info *)arg; Context * current_ctx = context_find_from_pid(info->current_ctx.ctxId, 1); Context * stopped_ctx = context_find_from_pid(info->stopped_ctx.ctxId, 1); switch (info->event) { case EVENT_HOOK_BREAKPOINT: if (stopped_ctx == NULL) break; assert(!stopped_ctx->stopped); assert(!EXT(stopped_ctx)->regs_dirty); if (EXT(stopped_ctx)->regs_error) { release_error_report(EXT(stopped_ctx)->regs_error); EXT(stopped_ctx)->regs_error = NULL; } memcpy(EXT(stopped_ctx)->regs, &info->regs, sizeof(REG_SET)); EXT(stopped_ctx)->event = 0; stopped_ctx->signal = SIGTRAP; stopped_ctx->stopped = 1; stopped_ctx->stopped_by_bp = info->bp_info_ok; stopped_ctx->stopped_by_exception = 0; assert(get_regs_PC(stopped_ctx) == info->addr); if (stopped_ctx->stopped_by_bp && !is_breakpoint_address(stopped_ctx, info->addr)) { /* Break instruction that is not planted by us */ stopped_ctx->stopped_by_bp = 0; stopped_ctx->pending_intercept = 1; } EXT(stopped_ctx)->bp_info = info->bp_info; if (current_ctx != NULL) EXT(stopped_ctx)->bp_pid = EXT(current_ctx)->pid; assert(taskIsStopped(EXT(stopped_ctx)->pid)); trace(LOG_CONTEXT, "context: stopped by breakpoint: ctx %#lx, id %#x", stopped_ctx, EXT(stopped_ctx)->pid); send_context_stopped_event(stopped_ctx); break; case EVENT_HOOK_STEP_DONE: if (current_ctx == NULL) break; assert(!current_ctx->stopped); assert(!EXT(current_ctx)->regs_dirty); if (EXT(current_ctx)->regs_error) { release_error_report(EXT(current_ctx)->regs_error); EXT(current_ctx)->regs_error = NULL; } memcpy(EXT(current_ctx)->regs, &info->regs, sizeof(REG_SET)); EXT(current_ctx)->event = TRACE_EVENT_STEP; current_ctx->signal = SIGTRAP; current_ctx->stopped = 1; current_ctx->stopped_by_bp = 0; current_ctx->stopped_by_exception = 0; assert(taskIsStopped(EXT(current_ctx)->pid)); trace(LOG_CONTEXT, "context: stopped by end of step: ctx %#lx, id %#x", current_ctx, EXT(current_ctx)->pid); send_context_stopped_event(current_ctx); break; case EVENT_HOOK_STOP: if (stopped_ctx == NULL) break; assert(!stopped_ctx->exited); if (stopped_ctx->stopped) break; if (EXT(stopped_ctx)->regs_error) { release_error_report(EXT(stopped_ctx)->regs_error); EXT(stopped_ctx)->regs_error = NULL; } if (taskRegsGet(EXT(stopped_ctx)->pid, EXT(stopped_ctx)->regs) != OK) { EXT(stopped_ctx)->regs_error = get_error_report(errno); assert(EXT(stopped_ctx)->regs_error != NULL); } EXT(stopped_ctx)->event = 0; stopped_ctx->signal = SIGSTOP; stopped_ctx->stopped = 1; stopped_ctx->stopped_by_bp = 0; stopped_ctx->stopped_by_exception = 0; assert(taskIsStopped(EXT(stopped_ctx)->pid)); trace(LOG_CONTEXT, "context: stopped by sofware request: ctx %#lx, id %#x", stopped_ctx, EXT(stopped_ctx)->pid); send_context_stopped_event(stopped_ctx); break; case EVENT_HOOK_TASK_ADD: if (current_ctx == NULL) break; assert(stopped_ctx == NULL); stopped_ctx = create_context(pid2id((pid_t)info->stopped_ctx.ctxId, EXT(current_ctx->parent)->pid)); EXT(stopped_ctx)->pid = (pid_t)info->stopped_ctx.ctxId; EXT(stopped_ctx)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); stopped_ctx->mem = current_ctx->mem; stopped_ctx->big_endian = current_ctx->mem->big_endian; (stopped_ctx->creator = current_ctx)->ref_count++; (stopped_ctx->parent = current_ctx->parent)->ref_count++; assert(stopped_ctx->mem == stopped_ctx->parent->mem); list_add_last(&stopped_ctx->cldl, &stopped_ctx->parent->children); link_context(stopped_ctx); trace(LOG_CONTEXT, "context: created: ctx %#lx, id %#x", stopped_ctx, EXT(stopped_ctx)->pid); send_context_created_event(stopped_ctx); break; default: assert(0); break; } loc_free(info); SPIN_LOCK_ISR_TAKE(&events_lock); events_cnt--; SPIN_LOCK_ISR_GIVE(&events_lock); }
int get_context_task_id(Context * ctx) { return EXT(ctx)->pid; }
static void event_pid_stopped(pid_t pid, int signal, int event, int syscall) { int stopped_by_exception = 0; Context * ctx = NULL; trace(LOG_EVENTS, "event: pid %d stopped, signal %d, event %s", pid, signal, event_name(event)); ctx = context_find_from_pid(pid, 1); if (ctx == NULL) { ctx = find_pending(pid); if (ctx != NULL) { Context * prs = ctx; assert(prs->ref_count == 0); ctx = create_context(pid2id(pid, pid)); EXT(ctx)->pid = pid; EXT(ctx)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); ctx->pending_intercept = 1; ctx->mem = prs; ctx->parent = prs; ctx->big_endian = prs->big_endian; prs->ref_count++; list_add_last(&ctx->cldl, &prs->children); link_context(prs); link_context(ctx); send_context_created_event(prs); send_context_created_event(ctx); if (EXT(prs)->attach_callback) { EXT(prs)->attach_callback(0, prs, EXT(prs)->attach_data); EXT(prs)->attach_callback = NULL; EXT(prs)->attach_data = NULL; } } } if (ctx == NULL) return; assert(!ctx->exited); assert(!EXT(ctx)->attach_callback); if (signal != SIGSTOP && signal != SIGTRAP) { assert(signal < 32); ctx->pending_signals |= 1 << signal; if ((ctx->sig_dont_stop & (1 << signal)) == 0) { ctx->pending_intercept = 1; stopped_by_exception = 1; } } if (ctx->stopped) { send_context_changed_event(ctx); } else { ContextAddress pc0 = 0; ContextAddress pc1 = 0; assert(!EXT(ctx)->regs_dirty); EXT(ctx)->end_of_step = 0; EXT(ctx)->ptrace_event = event; ctx->signal = signal; ctx->stopped_by_bp = 0; ctx->stopped_by_exception = stopped_by_exception; ctx->stopped = 1; if (EXT(ctx)->regs_error) { release_error_report(EXT(ctx)->regs_error); EXT(ctx)->regs_error = NULL; } else { pc0 = get_regs_PC(ctx); } if (ptrace(PTRACE_GETREGS, EXT(ctx)->pid, 0, (int)EXT(ctx)->regs) < 0) { assert(errno != 0); if (errno == ESRCH) { /* Racing condition: somebody resumed this context while we are handling stop event. * * One possible cause: main thread has exited forcing children to exit too. * I beleive it is a bug in PTRACE implementation - PTRACE should delay exiting of * a context while it is stopped, but it does not, which causes a nasty racing. * * Workaround: Ignore current event, assume context is running. */ ctx->stopped = 0; return; } EXT(ctx)->regs_error = get_error_report(errno); trace(LOG_ALWAYS, "error: ptrace(PTRACE_GETREGS) failed; id %s, error %d %s", ctx->id, errno, errno_to_str(errno)); } else { pc1 = get_regs_PC(ctx); } trace(LOG_EVENTS, "event: pid %d stopped at PC = %#lx", pid, pc1); if (signal == SIGTRAP && event == 0 && !syscall) { size_t break_size = 0; get_break_instruction(ctx, &break_size); ctx->stopped_by_bp = !EXT(ctx)->regs_error && is_breakpoint_address(ctx, pc1 - break_size); EXT(ctx)->end_of_step = !ctx->stopped_by_bp && EXT(ctx)->pending_step; if (ctx->stopped_by_bp) set_regs_PC(ctx, pc1 - break_size); } EXT(ctx)->pending_step = 0; send_context_stopped_event(ctx); } }
static int set_debug_regs(Context * ctx, int * step_over_hw_bp) { int i, j; ContextAddress pc = 0; Context * grp = context_get_group(ctx, CONTEXT_GROUP_BREAKPOINT); ContextExtensionARM * ext = EXT(ctx); ContextExtensionARM * bps = EXT(grp); pid_t pid = id2pid(ctx->id, NULL); assert(bps->info_ok); ext->armed = 0; *step_over_hw_bp = 0; if (read_reg(ctx, pc_def, pc_def->size, &pc) < 0) return -1; for (i = 0; i < bps->bp_cnt + bps->wp_cnt; i++) { uint32_t cr = 0; ContextBreakpoint * cb = bps->hw_bps[i]; if (i == 0 && ext->hw_stepping) { uint32_t vr = 0; if (ext->hw_stepping == 1) { vr = (uint32_t)ext->step_addr & ~0x1; cr |= 0x3 << 5; } else { vr = (uint32_t)pc; cr |= 0x1 << 22; cr |= 0xf << 5; } cr |= 0x7u; if (ptrace(PTRACE_SETHBPREGS, pid, 1, &vr) < 0) return -1; } else if (cb != NULL) { if (i < bps->bp_cnt && ((uint32_t)cb->address & ~0x1) == pc) { /* Skipping the breakpoint */ *step_over_hw_bp = 1; } else if (bps->arch >= ARM_DEBUG_ARCH_V7_ECP14 && (ext->skip_wp_set & (1u << i))) { /* Skipping the watchpoint */ assert(i >= bps->bp_cnt); *step_over_hw_bp = 1; } else { uint32_t vr = (uint32_t)cb->address & ~0x1; if (i < bps->bp_cnt) { cr |= 0x3 << 5; } else { vr = (uint32_t)cb->address & ~0x3; for (j = 0; j < 4; j++) { if (vr + j < cb->address) continue; if (vr + j >= cb->address + cb->length) continue; cr |= 1 << (5 + j); } if (cb->access_types & CTX_BP_ACCESS_DATA_READ) cr |= 1 << 3; if (cb->access_types & CTX_BP_ACCESS_DATA_WRITE) cr |= 1 << 4; } cr |= 0x7; if (i < bps->bp_cnt) { if (ptrace(PTRACE_SETHBPREGS, pid, i * 2 + 1, &vr) < 0) return -1; } else { if (ptrace(PTRACE_SETHBPREGS, pid, -(i * 2 + 1), &vr) < 0) return -1; } ext->armed |= 1 << i; } } if (cr == 0) { /* Linux kernel does not allow 0 as Control Register value */ cr |= 0x3u << 1; cr |= 0xfu << 5; if (i >= bps->bp_cnt) { cr |= 1u << 4; } } if (i < bps->bp_cnt) { if (ptrace(PTRACE_SETHBPREGS, pid, i * 2 + 2, &cr) < 0) return -1; } else { if (ptrace(PTRACE_SETHBPREGS, pid, -(i * 2 + 2), &cr) < 0) return -1; } } ext->hw_bps_regs_generation = bps->hw_bps_generation; return 0; }
static int checkInputKBCTL (void) { return (EXT(GPLR,25)); /* check KBCTL has data to send */ }
void set_reset_group(Context * ctx, int group) { ContextExtensionRS * ext = EXT(ctx); ext->group = group; }
#define EXT(key) ((key)+0x100) #define ISEXT(val) ((val)&0x100) #define EXTVAL(val) ((val)&0xff) struct kbd { short keycode; /* virtual keycode */ short normal; /* BIOS keycode - normal */ short shift; /* BIOS keycode - Shift- */ short ctrl; /* BIOS keycode - Ctrl- */ short alt; /* BIOS keycode - Alt- */ } kbdtab [] = { /* Virtual key Normal Shift Control Alt */ { VK_BACK, 0x08, 0x08, 0x7f, EXT(14) }, { VK_TAB, 0x09, EXT(15), EXT(148), EXT(165) }, { VK_RETURN, 0x0d, 0x0d, 0x0a, EXT(166) }, { VK_ESCAPE, 0x1b, 0x1b, 0x1b, EXT(1) }, { VK_SPACE, 0x20, 0x20, EXT(3), 0x20, }, { '0', '0', ')', -1, EXT(129) }, { '1', '1', '!', -1, EXT(120) }, { '2', '2', '@', EXT(0), EXT(121) }, { '3', '3', '#', -1, EXT(122) }, { '4', '4', '$', -1, EXT(123) }, { '5', '5', '%', -1, EXT(124) }, { '6', '6', '^', 0x1e, EXT(125) }, { '7', '7', '&', -1, EXT(126) }, { '8', '8', '*', -1, EXT(127) }, { '9', '9', '(', -1, EXT(128) },
void *glXGetProcAddressARB(const char *name) { LOAD_EGL(eglGetProcAddress); // generated gles wrappers #ifdef USE_ES2 #include "gles2funcs.inc" #else #include "glesfuncs.inc" #endif #ifndef ANDROID // glX calls EX(glXChooseVisual); EX(glXCopyContext); EX(glXCreateContext); EX(glXCreateNewContext); EX(glXCreateContextAttribsARB); EX(glXCreateGLXPixmap); EX(glXDestroyContext); EX(glXDestroyGLXPixmap); EX(glXGetConfig); EX(glXGetCurrentDisplay); EX(glXGetCurrentDrawable); EX(glXIsDirect); EX(glXMakeCurrent); EX(glXMakeContextCurrent); EX(glXQueryExtensionsString); EX(glXQueryServerString); EX(glXSwapBuffers); EX(glXSwapIntervalEXT); #endif //ANDROID EX(glXSwapIntervalMESA); EX(glXSwapIntervalSGI); #ifndef ANDROID EX(glXUseXFont); EX(glXWaitGL); EX(glXWaitX); EX(glXGetCurrentContext); EX(glXQueryExtension); EX(glXQueryDrawable); EX(glXQueryVersion); EX(glXGetClientString); EX(glXGetFBConfigs); EX(glXChooseFBConfig); EX(glXChooseFBConfigSGIX); EX(glXGetFBConfigAttrib); EX(glXQueryContext); EX(glXGetVisualFromFBConfig); EX(glXCreateWindow); EX(glXDestroyWindow); STUB(glXCreatePbuffer); // to do, using Renderbuffers.... STUB(glXDestroyPbuffer); STUB(glXCreatePixmap); STUB(glXDestroyPixmap); STUB(glXGetCurrentReadDrawable); STUB(glXGetSelectedEvent); STUB(glXSelectEvent); #endif //ANDROID // GL_ARB_vertex_buffer_object ARB(glBindBuffer); ARB(glBufferData); ARB(glBufferSubData); ARB(glDeleteBuffers); ARB(glGenBuffers); ARB(glIsBuffer); EX(glGetBufferPointerv); ARB(glGetBufferPointerv); EX(glMapBuffer); EX(glUnmapBuffer); ARB(glMapBuffer); ARB(glUnmapBuffer); ARB(glGetBufferParameteriv); EX(glGetBufferSubData); ARB(glGetBufferSubData); // GL_ARB_frameBuffer_ext EX(glFramebufferTexture1D); EX(glFramebufferTexture3D); EX(glFramebufferTextureLayer); EX(glRenderbufferStorageMultisample); EX(glBlitFramebuffer); EXT(glGenFramebuffers); EXT(glDeleteFramebuffers); EXT(glIsFramebuffer); EXT(glCheckFramebufferStatus); EXT(glBindFramebuffer); EXT(glFramebufferTexture2D); EXT(glFramebufferTexture1D); EXT(glFramebufferTexture3D); EXT(glGenRenderbuffers); EXT(glFramebufferRenderbuffer); EXT(glDeleteRenderbuffers); EXT(glRenderbufferStorage); EXT(glRenderbufferStorageMultisample); EXT(glBindRenderbuffer); EXT(glIsRenderbuffer); EXT(glGenerateMipmap); EXT(glGetFramebufferAttachmentParameteriv); EXT(glGetRenderbufferParameteriv); EXT(glFramebufferTextureLayer); EXT(glBlitFramebuffer); ARB(glGenFramebuffers); ARB(glDeleteFramebuffers); ARB(glIsFramebuffer); ARB(glCheckFramebufferStatus); ARB(glBindFramebuffer); ARB(glFramebufferTexture2D); ARB(glFramebufferTexture1D); ARB(glFramebufferTexture3D); ARB(glGenRenderbuffers); ARB(glFramebufferRenderbuffer); ARB(glDeleteRenderbuffers); ARB(glRenderbufferStorage); ARB(glRenderbufferStorageMultisample); ARB(glBindRenderbuffer); ARB(glIsRenderbuffer); ARB(glGenerateMipmap); ARB(glGetFramebufferAttachmentParameteriv); ARB(glGetRenderbufferParameteriv); ARB(glFramebufferTextureLayer); ARB(glBlitFramebuffer); STUB(glDrawBuffersARB); /* MAP_EGL(glGenFramebuffersARB, glGenFramebuffersOES); MAP_EGL(glDeleteFramebuffersARB, glDeleteFramebuffersOES); MAP_EGL(glBindFramebufferARB, glBindFramebufferOES); MAP_EGL(glFramebufferRenderbufferARB, glFramebufferRenderbufferOES); MAP_EGL(glFramebufferTexture2DARB, glFramebufferTexture2DOES); MAP_EGL(glIsFramebufferARB, glIsFramebufferOES); MAP_EGL(glGenRenderbuffersARB, glGenRenderbuffersOES); MAP_EGL(glDeleteRenderbuffersARB, glDeleteRenderbuffersOES); MAP_EGL(glCheckFramebufferStatusARB, glCheckFramebufferStatusOES); MAP_EGL(glRenderbufferStorageARB, glRenderbufferStorageOES); MAP_EGL(glBindRenderbufferARB, glBindRenderbufferOES); MAP_EGL(glIsRenderbufferARB, glIsRenderbufferOES); */ // GL_EXT_vertex_array EXT(glArrayElement); EXT(glDrawArrays); EXT(glVertexPointer); EXT(glNormalPointer); EXT(glColorPointer); EX(glIndexPointer); //TODO, stub for now EXT(glTexCoordPointer); EX(glEdgeFlagPointer); //TODO, stub for now //EXT(glGetPointerv); //TODO // OES wrapper EX(glClearDepthfOES); EX(glClipPlanefOES); EX(glDepthRangefOES); EX(glFrustumfOES); EX(glGetClipPlanefOES); EX(glOrthofOES); // passthrough // batch thunking! #define THUNK(suffix, type) \ EX(glColor3##suffix##v); \ EX(glColor3##suffix); \ EX(glColor4##suffix##v); \ EX(glColor4##suffix); \ EX(glSecondaryColor3##suffix##v); \ EX(glSecondaryColor3##suffix); \ EXT(glSecondaryColor3##suffix##v); \ EXT(glSecondaryColor3##suffix); \ EX(glIndex##suffix##v); \ EX(glIndex##suffix); \ EX(glNormal3##suffix##v); \ EX(glNormal3##suffix); \ EX(glRasterPos2##suffix##v); \ EX(glRasterPos2##suffix); \ EX(glRasterPos3##suffix##v); \ EX(glRasterPos3##suffix); \ EX(glRasterPos4##suffix##v); \ EX(glRasterPos4##suffix); \ EX(glWindowPos2##suffix##v); \ EX(glWindowPos2##suffix); \ EX(glWindowPos3##suffix##v); \ EX(glWindowPos3##suffix); \ EX(glVertex2##suffix##v); \ EX(glVertex2##suffix); \ EX(glVertex3##suffix##v); \ EX(glVertex3##suffix); \ EX(glVertex4##suffix##v); \ EX(glVertex4##suffix); \ EX(glTexCoord1##suffix##v); \ EX(glTexCoord1##suffix); \ EX(glTexCoord2##suffix##v); \ EX(glTexCoord2##suffix); \ EX(glTexCoord3##suffix##v); \ EX(glTexCoord3##suffix); \ EX(glTexCoord4##suffix##v); \ EX(glTexCoord4##suffix); \ EX(glMultiTexCoord1##suffix##v); \ EX(glMultiTexCoord1##suffix); \ EX(glMultiTexCoord2##suffix##v); \ EX(glMultiTexCoord2##suffix); \ EX(glMultiTexCoord3##suffix##v); \ EX(glMultiTexCoord3##suffix); \ EX(glMultiTexCoord4##suffix##v); \ EX(glMultiTexCoord4##suffix); \ EXT(glMultiTexCoord1##suffix##v); \ EXT(glMultiTexCoord1##suffix); \ EXT(glMultiTexCoord2##suffix##v); \ EXT(glMultiTexCoord2##suffix); \ EXT(glMultiTexCoord3##suffix##v); \ EXT(glMultiTexCoord3##suffix); \ EXT(glMultiTexCoord4##suffix##v); \ EXT(glMultiTexCoord4##suffix); \ ARB(glMultiTexCoord1##suffix##v); \ ARB(glMultiTexCoord1##suffix); \ ARB(glMultiTexCoord2##suffix##v); \ ARB(glMultiTexCoord2##suffix); \ ARB(glMultiTexCoord3##suffix##v); \ ARB(glMultiTexCoord3##suffix); \ ARB(glMultiTexCoord4##suffix##v); \ ARB(glMultiTexCoord4##suffix); THUNK(b, GLbyte); THUNK(d, GLdouble); THUNK(i, GLint); THUNK(s, GLshort); THUNK(ub, GLubyte); THUNK(ui, GLuint); THUNK(us, GLushort); THUNK(f, GLfloat); #undef THUNK EX(glPointParameterf); EX(glPointParameterfv); ARB(glPointParameterf); ARB(glPointParameterfv); EXT(glPointParameterf); EXT(glPointParameterfv); #ifdef USE_ES2 EX(glCompileShaderARB); EX(glCreateShaderObjectARB); EX(glGetObjectParameterivARB); EX(glShaderSourceARB); #endif // functions we actually define EXT(glActiveTexture); ARB(glActiveTexture); EX(glArrayElement); EX(glBegin); EX(glBitmap); /*EXT(glBlendColor); ARB(glBlendColor);*/ EXT(glBlendEquation); ARB(glBlendEquation); EXT(glBlendFunc); ARB(glBlendFunc); #ifndef ODROID EXT(glBlendEquationSeparate); ARB(glBlendEquationSeparate); EX(glBlendEquationSeparatei); EXT(glBlendEquationSeparatei); ARB(glBlendEquationSeparatei); EXT(glBlendFuncSeparate); ARB(glBlendFuncSeparate); EX(glBlendFuncSeparatei); EXT(glBlendFuncSeparatei); ARB(glBlendFuncSeparatei); #endif EX(glCallList); EX(glCallLists); EX(glClearDepth); EXT(glClientActiveTexture); ARB(glClientActiveTexture); EX(glClipPlane); EX(glCopyPixels); EX(glDeleteLists); EX(glDepthRange); EX(glDrawBuffer); EX(glDrawPixels); EX(glDrawRangeElements); EX(glDrawRangeElementsEXT); EX(glEdgeFlag); EX(glEnd); EX(glEndList); EX(glEvalCoord1d); EX(glEvalCoord1f); EX(glEvalCoord2d); EX(glEvalCoord2f); EX(glEvalMesh1); EX(glEvalMesh2); EX(glEvalPoint1); EX(glEvalPoint2); EX(glFogCoordd); EX(glFogCoorddv); EX(glFogCoordf); EX(glFogCoordfv); EX(glFogi); EX(glFogiv); EX(glFrustum); EX(glGenLists); EX(glGetDoublev); EX(glGetIntegerv); EX(glGetMapdv); EX(glGetMapfv); EX(glGetMapiv); EX(glGetTexImage); EX(glGetTexLevelParameterfv); EX(glGetTexLevelParameteriv); EX(glInitNames); EX(glInterleavedArrays); EX(glIsList); #ifndef USE_ES2 EX(glLighti); EX(glLightiv); EX(glLightModeli); EX(glLightModeliv); #endif EX(glLineStipple); EX(glListBase); EX(glLoadMatrixd); EX(glLoadName); EX(glLockArraysEXT); EX(glMap1d); EX(glMap1f); EX(glMap2d); EX(glMap2f); EX(glMapGrid1d); EX(glMapGrid1f); EX(glMapGrid2d); EX(glMapGrid2f); EX(glMateriali); EX(glMultMatrixd); EX(glNewList); EX(glOrtho); EX(glPixelTransferf); EX(glPixelTransferi); EX(glPixelZoom); EX(glPolygonMode); EX(glPolygonStipple); EX(glPopAttrib); EX(glPopClientAttrib); EX(glPopName); EX(glPushAttrib); EX(glPushClientAttrib); EX(glPushName); EX(glRasterPos2i); EX(glReadBuffer); EX(glRectd); EX(glRectf); EX(glRecti); EX(glRects); EX(glRectdv); EX(glRectfv); EX(glRectiv); EX(glRectsv); EX(glRenderMode); EX(glRotated); EX(glScaled); EX(glSecondaryColorPointer); EXT(glSecondaryColorPointer); EX(glTexEnvf); EX(glTexEnviv); EX(glTexGend); EX(glTexGendv); EX(glTexGenf); EX(glTexGenfv); EX(glTexGeni); EX(glTexGeniv); EX(glTexImage1D); EX(glTexImage3D); EX(glTexSubImage1D); EX(glTexSubImage3D); EX(glCompressedTexImage1D); EX(glCompressedTexSubImage1D); EX(glCompressedTexImage3D); EX(glCompressedTexSubImage3D); EX(glGetCompressedTexImage); EXT(glCompressedTexImage2D); EXT(glCompressedTexSubImage2D); EXT(glCompressedTexImage1D); EXT(glCompressedTexSubImage1D); EXT(glCompressedTexImage3D); EXT(glCompressedTexSubImage3D); EXT(glGetCompressedTexImage); ARB(glCompressedTexImage2D); ARB(glCompressedTexSubImage2D); ARB(glCompressedTexImage1D); ARB(glCompressedTexSubImage1D); ARB(glCompressedTexImage3D); ARB(glCompressedTexSubImage3D); ARB(glGetCompressedTexImage); EX(glCopyTexImage1D); EX(glCopyTexSubImage1D); EX(glTranslated); EX(glUnlockArraysEXT); EX(glGetTexGenfv); EX(glLoadTransposeMatrixf); EX(glLoadTransposeMatrixd); EX(glMultTransposeMatrixd); EX(glMultTransposeMatrixf); // stubs for unimplemented functions STUB(glAccum); STUB(glAreTexturesResident); STUB(glClearAccum); STUB(glColorMaterial); STUB(glCopyTexImage3D); STUB(glCopyTexSubImage3D); STUB(glFeedbackBuffer); STUB(glGetClipPlane); STUB(glGetLightiv); STUB(glGetMaterialiv); STUB(glGetPixelMapfv); STUB(glGetPixelMapuiv); STUB(glGetPixelMapusv); STUB(glGetPolygonStipple); STUB(glGetStringi); STUB(glGetTexGendv); //STUB(glGetTexGenfv); STUB(glGetTexGeniv); //TODO STUB(glMaterialiv); //TODO STUB(glPassThrough); STUB(glPixelMapfv); STUB(glPixelMapuiv); STUB(glPixelMapusv); EX(glPixelStoref); STUB(glPrioritizeTextures); STUB(glSelectBuffer); //TODO STUB(glFogCoordPointer); STUB(glEdgeFlagPointerEXT); STUB(glIndexPointerEXT); printf("glXGetProcAddress: %s not found.\n", name); return NULL; }
static void waitInputKBCTL (void) { while (EXT(GPLR,25)); }
static Context * get_reset_context(Context * ctx) { ContextExtensionRS * ext = EXT(ctx); if (ext->group > 0) return context_get_group(ctx, ext->group); return context_get_group(ctx, CONTEXT_GROUP_CPU); }
static void event_pid_exited(pid_t pid, int status, int signal) { Context * ctx; ctx = context_find_from_pid(pid, 1); if (ctx == NULL) { ctx = find_pending(pid); if (ctx == NULL) { trace(LOG_EVENTS, "event: ctx not found, pid %d, exit status %d, term signal %d", pid, status, signal); } else { assert(ctx->ref_count == 0); ctx->ref_count = 1; if (EXT(ctx)->attach_callback != NULL) { if (status == 0) status = EINVAL; EXT(ctx)->attach_callback(status, ctx, EXT(ctx)->attach_data); } assert(list_is_empty(&ctx->children)); assert(ctx->parent == NULL); ctx->exited = 1; context_unlock(ctx); } } else { /* Note: ctx->exiting should be 1 here. However, PTRACE_EVENT_EXIT can be lost by PTRACE because of racing * between PTRACE_CONT (or PTRACE_SYSCALL) and SIGTRAP/PTRACE_EVENT_EXIT. So, ctx->exiting can be 0. */ if (EXT(ctx->parent)->pid == pid) ctx = ctx->parent; assert(EXT(ctx)->attach_callback == NULL); if (ctx->exited) { trace(LOG_EVENTS, "event: ctx %#lx, pid %d, exit status %d unexpected, stopped %d, exited %d", ctx, pid, status, ctx->stopped, ctx->exited); } else { trace(LOG_EVENTS, "event: ctx %#lx, pid %d, exit status %d, term signal %d", ctx, pid, status, signal); ctx->exiting = 1; if (ctx->stopped) send_context_started_event(ctx); if (!list_is_empty(&ctx->children)) { LINK * l = ctx->children.next; while (l != &ctx->children) { Context * c = cldl2ctxp(l); l = l->next; assert(c->parent == ctx); if (!c->exited) { c->exiting = 1; if (c->stopped) send_context_started_event(c); release_error_report(EXT(c)->regs_error); loc_free(EXT(c)->regs); EXT(c)->regs_error = NULL; EXT(c)->regs = NULL; send_context_exited_event(c); } } } release_error_report(EXT(ctx)->regs_error); loc_free(EXT(ctx)->regs); EXT(ctx)->regs_error = NULL; EXT(ctx)->regs = NULL; send_context_exited_event(ctx); } } }
static void event_pid_stopped(pid_t pid, int signal, int event, int syscall) { int stopped_by_exception = 0; unsigned long msg = 0; Context * ctx = NULL; Context * ctx2 = NULL; trace(LOG_EVENTS, "event: pid %d stopped, signal %d", pid, signal); ctx = context_find_from_pid(pid, 1); if (ctx == NULL) { ctx = find_pending(pid); if (ctx != NULL) { Context * prs = ctx; assert(prs->ref_count == 0); ctx = create_context(pid2id(pid, pid)); EXT(ctx)->pid = pid; EXT(ctx)->regs = (REG_SET *)loc_alloc(sizeof(REG_SET)); ctx->pending_intercept = 1; ctx->mem = prs; ctx->parent = prs; ctx->big_endian = prs->big_endian; prs->ref_count++; list_add_last(&ctx->cldl, &prs->children); link_context(prs); link_context(ctx); send_context_created_event(prs); send_context_created_event(ctx); if (EXT(prs)->attach_callback) { EXT(prs)->attach_callback(0, prs, EXT(prs)->attach_data); EXT(prs)->attach_callback = NULL; EXT(prs)->attach_data = NULL; } } } if (ctx == NULL) return; assert(!ctx->exited); assert(!EXT(ctx)->attach_callback); if (signal != SIGSTOP && signal != SIGTRAP) { sigset_set(&ctx->pending_signals, signal, 1); if (sigset_get(&ctx->sig_dont_stop, signal) == 0) { ctx->pending_intercept = 1; stopped_by_exception = 1; } } if (ctx->stopped) { send_context_changed_event(ctx); } else { thread_state_t state; unsigned int state_count; ContextAddress pc0 = 0; ContextAddress pc1 = 0; assert(!EXT(ctx)->regs_dirty); EXT(ctx)->end_of_step = 0; EXT(ctx)->ptrace_event = event; ctx->signal = signal; ctx->stopped_by_bp = 0; ctx->stopped_by_exception = stopped_by_exception; ctx->stopped = 1; if (EXT(ctx)->regs_error) { release_error_report(EXT(ctx)->regs_error); EXT(ctx)->regs_error = NULL; } else { pc0 = get_regs_PC(ctx); } if (thread_get_state(EXT(ctx)->pid, x86_THREAD_STATE32, EXT(ctx)->regs, &state_count) != KERN_SUCCESS) { assert(errno != 0); EXT(ctx)->regs_error = get_error_report(errno); trace(LOG_ALWAYS, "error: thread_get_state failed; id %s, error %d %s", ctx->id, errno, errno_to_str(errno)); } else { pc1 = get_regs_PC(ctx); } if (!EXT(ctx)->syscall_enter || EXT(ctx)->regs_error || pc0 != pc1) { EXT(ctx)->syscall_enter = 0; EXT(ctx)->syscall_exit = 0; EXT(ctx)->syscall_id = 0; EXT(ctx)->syscall_pc = 0; } trace(LOG_EVENTS, "event: pid %d stopped at PC = %#lx", pid, pc1); if (signal == SIGTRAP && event == 0 && !syscall) { size_t break_size = 0; get_break_instruction(ctx, &break_size); ctx->stopped_by_bp = !EXT(ctx)->regs_error && is_breakpoint_address(ctx, pc1 - break_size); EXT(ctx)->end_of_step = !ctx->stopped_by_bp && EXT(ctx)->pending_step; if (ctx->stopped_by_bp) set_regs_PC(ctx, pc1 - break_size); } EXT(ctx)->pending_step = 0; send_context_stopped_event(ctx); } }
static int internal_function FCT (const CHAR *pattern, const CHAR *string, const CHAR *string_end, bool no_leading_period, int flags) { register const CHAR *p = pattern, *n = string; register UCHAR c; #ifdef _LIBC # if WIDE_CHAR_VERSION const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC); # else const UCHAR *collseq = (const UCHAR *) _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQMB); # endif #endif while ((c = *p++) != L_('\0')) { bool new_no_leading_period = false; c = FOLD (c); switch (c) { case L_('?'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } if (n == string_end) return FNM_NOMATCH; else if (*n == L_('/') && (flags & FNM_FILE_NAME)) return FNM_NOMATCH; else if (*n == L_('.') && no_leading_period) return FNM_NOMATCH; break; case L_('\\'): if (!(flags & FNM_NOESCAPE)) { c = *p++; if (c == L_('\0')) /* Trailing \ loses. */ return FNM_NOMATCH; c = FOLD (c); } if (n == string_end || FOLD ((UCHAR) *n) != c) return FNM_NOMATCH; break; case L_('*'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } if (n != string_end && *n == L_('.') && no_leading_period) return FNM_NOMATCH; for (c = *p++; c == L_('?') || c == L_('*'); c = *p++) { if (*p == L_('(') && (flags & FNM_EXTMATCH) != 0) { const CHAR *endp = END (p); if (endp != p) { /* This is a pattern. Skip over it. */ p = endp; continue; } } if (c == L_('?')) { /* A ? needs to match one character. */ if (n == string_end) /* There isn't another character; no match. */ return FNM_NOMATCH; else if (*n == L_('/') && __builtin_expect (flags & FNM_FILE_NAME, 0)) /* A slash does not match a wildcard under FNM_FILE_NAME. */ return FNM_NOMATCH; else /* One character of the string is consumed in matching this ? wildcard, so *??? won't match if there are less than three characters. */ ++n; } } if (c == L_('\0')) /* The wildcard(s) is/are the last element of the pattern. If the name is a file name and contains another slash this means it cannot match, unless the FNM_LEADING_DIR flag is set. */ { int result = (flags & FNM_FILE_NAME) == 0 ? 0 : FNM_NOMATCH; if (flags & FNM_FILE_NAME) { if (flags & FNM_LEADING_DIR) result = 0; else { if (MEMCHR (n, L_('/'), string_end - n) == NULL) result = 0; } } return result; } else { const CHAR *endp; endp = MEMCHR (n, (flags & FNM_FILE_NAME) ? L_('/') : L_('\0'), string_end - n); if (endp == NULL) endp = string_end; if (c == L_('[') || (__builtin_expect (flags & FNM_EXTMATCH, 0) != 0 && (c == L_('@') || c == L_('+') || c == L_('!')) && *p == L_('('))) { int flags2 = ((flags & FNM_FILE_NAME) ? flags : (flags & ~FNM_PERIOD)); bool no_leading_period2 = no_leading_period; for (--p; n < endp; ++n, no_leading_period2 = false) if (FCT (p, n, string_end, no_leading_period2, flags2) == 0) return 0; } else if (c == L_('/') && (flags & FNM_FILE_NAME)) { while (n < string_end && *n != L_('/')) ++n; if (n < string_end && *n == L_('/') && (FCT (p, n + 1, string_end, flags & FNM_PERIOD, flags) == 0)) return 0; } else { int flags2 = ((flags & FNM_FILE_NAME) ? flags : (flags & ~FNM_PERIOD)); int no_leading_period2 = no_leading_period; if (c == L_('\\') && !(flags & FNM_NOESCAPE)) c = *p; c = FOLD (c); for (--p; n < endp; ++n, no_leading_period2 = false) if (FOLD ((UCHAR) *n) == c && (FCT (p, n, string_end, no_leading_period2, flags2) == 0)) return 0; } } /* If we come here no match is possible with the wildcard. */ return FNM_NOMATCH; case L_('['): { /* Nonzero if the sense of the character class is inverted. */ register bool not; CHAR cold; UCHAR fn; if (posixly_correct == 0) posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1; if (n == string_end) return FNM_NOMATCH; if (*n == L_('.') && no_leading_period) return FNM_NOMATCH; if (*n == L_('/') && (flags & FNM_FILE_NAME)) /* `/' cannot be matched. */ return FNM_NOMATCH; not = (*p == L_('!') || (posixly_correct < 0 && *p == L_('^'))); if (not) ++p; fn = FOLD ((UCHAR) *n); c = *p++; for (;;) { if (!(flags & FNM_NOESCAPE) && c == L_('\\')) { if (*p == L_('\0')) return FNM_NOMATCH; c = FOLD ((UCHAR) *p); ++p; if (c == fn) goto matched; } else if (c == L_('[') && *p == L_(':')) { /* Leave room for the null. */ CHAR str[CHAR_CLASS_MAX_LENGTH + 1]; size_t c1 = 0; #if defined _LIBC || WIDE_CHAR_SUPPORT wctype_t wt; #endif const CHAR *startp = p; for (;;) { if (c1 == CHAR_CLASS_MAX_LENGTH) /* The name is too long and therefore the pattern is ill-formed. */ return FNM_NOMATCH; c = *++p; if (c == L_(':') && p[1] == L_(']')) { p += 2; break; } if (c < L_('a') || c >= L_('z')) { /* This cannot possibly be a character class name. Match it as a normal range. */ p = startp; c = L_('['); goto normal_bracket; } str[c1++] = c; } str[c1] = L_('\0'); #if defined _LIBC || WIDE_CHAR_SUPPORT wt = IS_CHAR_CLASS (str); if (wt == 0) /* Invalid character class name. */ return FNM_NOMATCH; # if defined _LIBC && ! WIDE_CHAR_VERSION /* The following code is glibc specific but does there a good job in speeding up the code since we can avoid the btowc() call. */ if (_ISCTYPE ((UCHAR) *n, wt)) goto matched; # else if (ISWCTYPE (BTOWC ((UCHAR) *n), wt)) goto matched; # endif #else if ((STREQ (str, L_("alnum")) && ISALNUM ((UCHAR) *n)) || (STREQ (str, L_("alpha")) && ISALPHA ((UCHAR) *n)) || (STREQ (str, L_("blank")) && ISBLANK ((UCHAR) *n)) || (STREQ (str, L_("cntrl")) && ISCNTRL ((UCHAR) *n)) || (STREQ (str, L_("digit")) && ISDIGIT ((UCHAR) *n)) || (STREQ (str, L_("graph")) && ISGRAPH ((UCHAR) *n)) || (STREQ (str, L_("lower")) && ISLOWER ((UCHAR) *n)) || (STREQ (str, L_("print")) && ISPRINT ((UCHAR) *n)) || (STREQ (str, L_("punct")) && ISPUNCT ((UCHAR) *n)) || (STREQ (str, L_("space")) && ISSPACE ((UCHAR) *n)) || (STREQ (str, L_("upper")) && ISUPPER ((UCHAR) *n)) || (STREQ (str, L_("xdigit")) && ISXDIGIT ((UCHAR) *n))) goto matched; #endif c = *p++; } #ifdef _LIBC else if (c == L_('[') && *p == L_('=')) { UCHAR str[1]; uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; c = *++p; if (c == L_('\0')) { p = startp; c = L_('['); goto normal_bracket; } str[0] = c; c = *++p; if (c != L_('=') || p[1] != L_(']')) { p = startp; c = L_('['); goto normal_bracket; } p += 2; if (nrules == 0) { if ((UCHAR) *n == str[0]) goto matched; } else { const int32_t *table; # if WIDE_CHAR_VERSION const int32_t *weights; const int32_t *extra; # else const unsigned char *weights; const unsigned char *extra; # endif const int32_t *indirect; int32_t idx; const UCHAR *cp = (const UCHAR *) str; /* This #include defines a local function! */ # if WIDE_CHAR_VERSION # include <locale/weightwc.h> # else # include <locale/weight.h> # endif # if WIDE_CHAR_VERSION table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC); weights = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC); extra = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC); indirect = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC); # else table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB); weights = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB); indirect = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB); # endif idx = findidx (&cp); if (idx != 0) { /* We found a table entry. Now see whether the character we are currently at has the same equivalance class value. */ int len = weights[idx]; int32_t idx2; const UCHAR *np = (const UCHAR *) n; idx2 = findidx (&np); if (idx2 != 0 && len == weights[idx2]) { int cnt = 0; while (cnt < len && (weights[idx + 1 + cnt] == weights[idx2 + 1 + cnt])) ++cnt; if (cnt == len) goto matched; } } } c = *p++; } #endif else if (c == L_('\0')) /* [ (unterminated) loses. */ return FNM_NOMATCH; else { bool is_range = false; #ifdef _LIBC bool is_seqval = false; if (c == L_('[') && *p == L_('.')) { uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; size_t c1 = 0; while (1) { c = *++p; if (c == L_('.') && p[1] == L_(']')) { p += 2; break; } if (c == '\0') return FNM_NOMATCH; ++c1; } /* We have to handling the symbols differently in ranges since then the collation sequence is important. */ is_range = *p == L_('-') && p[1] != L_('\0'); if (nrules == 0) { /* There are no names defined in the collation data. Therefore we only accept the trivial names consisting of the character itself. */ if (c1 != 1) return FNM_NOMATCH; if (!is_range && *n == startp[1]) goto matched; cold = startp[1]; c = *p++; } else { int32_t table_size; const int32_t *symb_table; # ifdef WIDE_CHAR_VERSION char str[c1]; size_t strcnt; # else # define str (startp + 1) # endif const unsigned char *extra; int32_t idx; int32_t elem; int32_t second; int32_t hash; # ifdef WIDE_CHAR_VERSION /* We have to convert the name to a single-byte string. This is possible since the names consist of ASCII characters and the internal representation is UCS4. */ for (strcnt = 0; strcnt < c1; ++strcnt) str[strcnt] = startp[1 + strcnt]; # endif table_size = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZEMB); symb_table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_TABLEMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); /* Locate the character in the hashing table. */ hash = elem_hash (str, c1); idx = 0; elem = hash % table_size; second = hash % (table_size - 2); while (symb_table[2 * elem] != 0) { /* First compare the hashing value. */ if (symb_table[2 * elem] == hash && c1 == extra[symb_table[2 * elem + 1]] && memcmp (str, &extra[symb_table[2 * elem + 1] + 1], c1) == 0) { /* Yep, this is the entry. */ idx = symb_table[2 * elem + 1]; idx += 1 + extra[idx]; break; } /* Next entry. */ elem += second; } if (symb_table[2 * elem] != 0) { /* Compare the byte sequence but only if this is not part of a range. */ # ifdef WIDE_CHAR_VERSION int32_t *wextra; idx += 1 + extra[idx]; /* Adjust for the alignment. */ idx = (idx + 3) & ~3; wextra = (int32_t *) &extra[idx + 4]; # endif if (! is_range) { # ifdef WIDE_CHAR_VERSION for (c1 = 0; (int32_t) c1 < wextra[idx]; ++c1) if (n[c1] != wextra[1 + c1]) break; if ((int32_t) c1 == wextra[idx]) goto matched; # else for (c1 = 0; c1 < extra[idx]; ++c1) if (n[c1] != extra[1 + c1]) break; if (c1 == extra[idx]) goto matched; # endif } /* Get the collation sequence value. */ is_seqval = true; # ifdef WIDE_CHAR_VERSION cold = wextra[1 + wextra[idx]]; # else /* Adjust for the alignment. */ idx += 1 + extra[idx]; idx = (idx + 3) & ~4; cold = *((int32_t *) &extra[idx]); # endif c = *p++; } else if (c1 == 1) { /* No valid character. Match it as a single byte. */ if (!is_range && *n == str[0]) goto matched; cold = str[0]; c = *p++; } else return FNM_NOMATCH; } } else # undef str #endif { c = FOLD (c); normal_bracket: /* We have to handling the symbols differently in ranges since then the collation sequence is important. */ is_range = (*p == L_('-') && p[1] != L_('\0') && p[1] != L_(']')); if (!is_range && c == fn) goto matched; cold = c; c = *p++; } if (c == L_('-') && *p != L_(']')) { #if _LIBC /* We have to find the collation sequence value for C. Collation sequence is nothing we can regularly access. The sequence value is defined by the order in which the definitions of the collation values for the various characters appear in the source file. A strange concept, nowhere documented. */ uint32_t fcollseq; uint32_t lcollseq; UCHAR cend = *p++; # ifdef WIDE_CHAR_VERSION /* Search in the `names' array for the characters. */ fcollseq = __collseq_table_lookup (collseq, fn); if (fcollseq == ~((uint32_t) 0)) /* XXX We don't know anything about the character we are supposed to match. This means we are failing. */ goto range_not_matched; if (is_seqval) lcollseq = cold; else lcollseq = __collseq_table_lookup (collseq, cold); # else fcollseq = collseq[fn]; lcollseq = is_seqval ? cold : collseq[(UCHAR) cold]; # endif is_seqval = false; if (cend == L_('[') && *p == L_('.')) { uint32_t nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); const CHAR *startp = p; size_t c1 = 0; while (1) { c = *++p; if (c == L_('.') && p[1] == L_(']')) { p += 2; break; } if (c == '\0') return FNM_NOMATCH; ++c1; } if (nrules == 0) { /* There are no names defined in the collation data. Therefore we only accept the trivial names consisting of the character itself. */ if (c1 != 1) return FNM_NOMATCH; cend = startp[1]; } else { int32_t table_size; const int32_t *symb_table; # ifdef WIDE_CHAR_VERSION char str[c1]; size_t strcnt; # else # define str (startp + 1) # endif const unsigned char *extra; int32_t idx; int32_t elem; int32_t second; int32_t hash; # ifdef WIDE_CHAR_VERSION /* We have to convert the name to a single-byte string. This is possible since the names consist of ASCII characters and the internal representation is UCS4. */ for (strcnt = 0; strcnt < c1; ++strcnt) str[strcnt] = startp[1 + strcnt]; # endif table_size = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_SYMB_HASH_SIZEMB); symb_table = (const int32_t *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_TABLEMB); extra = (const unsigned char *) _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); /* Locate the character in the hashing table. */ hash = elem_hash (str, c1); idx = 0; elem = hash % table_size; second = hash % (table_size - 2); while (symb_table[2 * elem] != 0) { /* First compare the hashing value. */ if (symb_table[2 * elem] == hash && (c1 == extra[symb_table[2 * elem + 1]]) && memcmp (str, &extra[symb_table[2 * elem + 1] + 1], c1) == 0) { /* Yep, this is the entry. */ idx = symb_table[2 * elem + 1]; idx += 1 + extra[idx]; break; } /* Next entry. */ elem += second; } if (symb_table[2 * elem] != 0) { /* Compare the byte sequence but only if this is not part of a range. */ # ifdef WIDE_CHAR_VERSION int32_t *wextra; idx += 1 + extra[idx]; /* Adjust for the alignment. */ idx = (idx + 3) & ~4; wextra = (int32_t *) &extra[idx + 4]; # endif /* Get the collation sequence value. */ is_seqval = true; # ifdef WIDE_CHAR_VERSION cend = wextra[1 + wextra[idx]]; # else /* Adjust for the alignment. */ idx += 1 + extra[idx]; idx = (idx + 3) & ~4; cend = *((int32_t *) &extra[idx]); # endif } else if (symb_table[2 * elem] != 0 && c1 == 1) { cend = str[0]; c = *p++; } else return FNM_NOMATCH; } # undef str } else { if (!(flags & FNM_NOESCAPE) && cend == L_('\\')) cend = *p++; if (cend == L_('\0')) return FNM_NOMATCH; cend = FOLD (cend); } /* XXX It is not entirely clear to me how to handle characters which are not mentioned in the collation specification. */ if ( # ifdef WIDE_CHAR_VERSION lcollseq == 0xffffffff || # endif lcollseq <= fcollseq) { /* We have to look at the upper bound. */ uint32_t hcollseq; if (is_seqval) hcollseq = cend; else { # ifdef WIDE_CHAR_VERSION hcollseq = __collseq_table_lookup (collseq, cend); if (hcollseq == ~((uint32_t) 0)) { /* Hum, no information about the upper bound. The matching succeeds if the lower bound is matched exactly. */ if (lcollseq != fcollseq) goto range_not_matched; goto matched; } # else hcollseq = collseq[cend]; # endif } if (lcollseq <= hcollseq && fcollseq <= hcollseq) goto matched; } # ifdef WIDE_CHAR_VERSION range_not_matched: # endif #else /* We use a boring value comparison of the character values. This is better than comparing using `strcoll' since the latter would have surprising and sometimes fatal consequences. */ UCHAR cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == L_('\\')) cend = *p++; if (cend == L_('\0')) return FNM_NOMATCH; /* It is a range. */ if (cold <= fn && fn <= cend) goto matched; #endif c = *p++; } } if (c == L_(']')) break; } if (!not) return FNM_NOMATCH; break; matched: /* Skip the rest of the [...] that already matched. */ do { ignore_next: c = *p++; if (c == L_('\0')) /* [... (unterminated) loses. */ return FNM_NOMATCH; if (!(flags & FNM_NOESCAPE) && c == L_('\\')) { if (*p == L_('\0')) return FNM_NOMATCH; /* XXX 1003.2d11 is unclear if this is right. */ ++p; } else if (c == L_('[') && *p == L_(':')) { int c1 = 0; const CHAR *startp = p; while (1) { c = *++p; if (++c1 == CHAR_CLASS_MAX_LENGTH) return FNM_NOMATCH; if (*p == L_(':') && p[1] == L_(']')) break; if (c < L_('a') || c >= L_('z')) { p = startp; goto ignore_next; } } p += 2; c = *p++; } else if (c == L_('[') && *p == L_('=')) { c = *++p; if (c == L_('\0')) return FNM_NOMATCH; c = *++p; if (c != L_('=') || p[1] != L_(']')) return FNM_NOMATCH; p += 2; c = *p++; } else if (c == L_('[') && *p == L_('.')) { ++p; while (1) { c = *++p; if (c == '\0') return FNM_NOMATCH; if (*p == L_('.') && p[1] == L_(']')) break; } p += 2; c = *p++; } } while (c != L_(']')); if (not) return FNM_NOMATCH; } break; case L_('+'): case L_('@'): case L_('!'): if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(') { int res; res = EXT (c, p, n, string_end, no_leading_period, flags); if (res != -1) return res; } goto normal_match; case L_('/'): if (NO_LEADING_PERIOD (flags)) { if (n == string_end || c != (UCHAR) *n) return FNM_NOMATCH; new_no_leading_period = true; break; } /* FALLTHROUGH */ default: normal_match: if (n == string_end || c != FOLD ((UCHAR) *n)) return FNM_NOMATCH; } no_leading_period = new_no_leading_period; ++n; } if (n == string_end) return 0; if ((flags & FNM_LEADING_DIR) && n != string_end && *n == L_('/')) /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; }
int cpu_bp_remove(ContextBreakpoint * bp) { ContextExtensionARM * bps = EXT(bp->ctx); clear_bp(bp); bps->hw_bps_generation++; return 0; }
static kripto_ae *eax_create ( const kripto_ae_desc *desc, unsigned int rounds, const void *key, unsigned int key_len, const void *iv, unsigned int iv_len, unsigned int tag_len ) { kripto_ae *s; uint8_t *buf; unsigned int len; (void)tag_len; len = kripto_block_size(EXT(desc)->block); buf = malloc(len); if(!buf) goto err0; s = malloc(sizeof(kripto_ae) + len); if(!s) goto err1; s->obj.desc = desc; s->obj.multof = 1; s->iv = (uint8_t *)s + sizeof(kripto_ae); s->len = len; /* create CTR descriptor */ s->ctr_desc = kripto_stream_ctr(EXT(desc)->block); if(!s->ctr_desc) goto err2; /* create OMAC descriptor */ s->omac_desc = kripto_mac_omac(EXT(desc)->block); if(!s->omac_desc) goto err3; /* OMAC IV (nonce) */ s->omac = kripto_mac_create(s->omac_desc, rounds, key, key_len, len); if(!s->omac) goto err4; memset(buf, 0, len); kripto_mac_input(s->omac, buf, len); kripto_mac_input(s->omac, iv, iv_len); kripto_mac_tag(s->omac, s->iv, iv_len); /* recreate OMAC for encryption/decryption */ s->omac = kripto_mac_recreate(s->omac, rounds, key, key_len, len); if(!s->omac) goto err5; buf[len - 1] = 2; kripto_mac_input(s->omac, buf, len); /* create CTR */ s->ctr = kripto_stream_create(s->ctr_desc, rounds, key, key_len, s->iv, iv_len); if(!s->ctr) goto err6; /* create OMAC for header */ s->header = kripto_mac_create(s->omac_desc, rounds, key, key_len, len); if(!s->header) goto err7; buf[len - 1] = 1; kripto_mac_input(s->header, buf, len); free(buf); return s; err7: kripto_stream_destroy(s->ctr); err6: kripto_mac_destroy(s->omac); err5: kripto_memwipe(s->iv, len); err4: free(s->omac_desc); err3: free(s->ctr_desc); err2: free(s); err1: free(buf); err0: return 0; }