/* * destination buffer size */ size_t _elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) { Elf_Type type = src->d_type; unsigned sv = src->d_version; xlator op; if (!valid_version(sv) || !valid_version(dv)) { seterr(ERROR_UNKNOWN_VERSION); return (size_t)-1; } if (tof) { /* * Encoding doesn't really matter (the translator only looks at * the source, which resides in memory), but we need a proper * encoding to select a translator... */ encode = ELFDATA2LSB; } else if (!valid_encoding(encode)) { seterr(ERROR_UNKNOWN_ENCODING); return (size_t)-1; } if (!valid_type(type)) { seterr(ERROR_UNKNOWN_TYPE); return (size_t)-1; } if (!(op = translator(sv, dv, encode, type, tof))) { seterr(ERROR_UNKNOWN_TYPE); return (size_t)-1; } return (*op)(NULL, src->d_buf, src->d_size); }
/* * Extension: report memory size */ size_t gcgcef_msize(CGCEf *cgcef, CGCEf_Type type, size_t count, unsigned ver) { size_t n; if (cgcef) { if (cgcef->e_kind != CGCEF_K_CGCEF) { seterr(ERROR_NOTCGCEF); } else if (!valid_class(cgcef->e_class)) { seterr(ERROR_UNKNOWN_CLASS); } else if (!valid_version(ver)) { seterr(ERROR_UNKNOWN_VERSION); } else if (!valid_type(type)) { seterr(ERROR_UNKNOWN_TYPE); } else if (!(n = _msize(cgcef->e_class, ver, type))) { seterr(ERROR_UNKNOWN_TYPE); } else { return count * n; } } return 0; }
int TSolver::checkexpr() {int i,j; int SL=strlen(S); if (SL==1) if (!(isconst(S[0])||isnumc(S[0])) ) {seterr(E_EXPR); return 0; } else return 1; if (!(isnumc(S[SL-1])||S[SL-1]==')'||S[SL-1]==']'||isconst(S[SL-1]))) {seterr(E_EXPR); return 0; } #define ib(x) (i>0?(x):1) for (i=0;i<SL-1;i++) {if (isfn(S[i])||isconst(S[i])||issymbevul(S[i])||S[i]=='('||S[i]=='[') if(!( ( isfn(S[i]) && (S[i+1]=='(') )|| ( i>0?S[i]=='(' && isfn(S[i-1]):1 )|| ( isconst(S[i]) && (issymbevul(S[i+1])||S[i+1]==')'||S[i+1]==']') )|| ( ((issymbevul(S[i])||S[i]=='('||S[i]=='[')&&(isnumc(S[i+1])||S[i+1]=='-'||S[i+1]=='_'||isstrevul(S[i+1])||S[i+1]=='('||S[i+1]=='[')) ) ) ) {seterr(E_EXPR); return 0; } } return 1; }
/* * initialize the external bucket sorting data structures */ static IEBucks* initiebucks(Part *part, int bits, uint32_t size) { IEBucks *ib; int i; ib = MKZ(IEBucks); if(ib == nil){ seterr(EOk, "out of memory"); return nil; } ib->bits = bits; ib->nbucks = 1 << bits; ib->size = size; ib->usable = (size - U32Size) / IEntrySize * IEntrySize; ib->bucks = MKNZ(IEBuck, ib->nbucks); if(ib->bucks == nil){ seterr(EOk, "out of memory allocation sorting buckets"); freeiebucks(ib); return nil; } ib->xbuf = MKN(uint8_t, size * ((1 << bits)+1)); ib->buf = (uint8_t*)(((uintptr)ib->xbuf+size-1)&~(uintptr)(size-1)); if(ib->buf == nil){ seterr(EOk, "out of memory allocating sorting buckets' buffers"); freeiebucks(ib); return nil; } for(i = 0; i < ib->nbucks; i++){ ib->bucks[i].head = TWID32; ib->bucks[i].buf = &ib->buf[i * size]; } ib->part = part; return ib; }
GElf_Phdr* gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst) { GElf_Phdr buf; char *tmp; size_t n; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); tmp = _elf_getphdr(elf, elf->e_class); if (!tmp) { return NULL; } if (ndx < 0 || ndx >= elf->e_phnum) { seterr(ERROR_BADINDEX); return NULL; } n = _msize(elf->e_class, _elf_version, ELF_T_PHDR); if (n == 0) { seterr(ERROR_UNIMPLEMENTED); return NULL; } if (!dst) { dst = &buf; } if (elf->e_class == ELFCLASS64) { *dst = *(Elf64_Phdr*)(tmp + ndx * n); } else if (elf->e_class == ELFCLASS32) { Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n); check_and_copy(GElf_Word, dst, src, p_type, NULL); check_and_copy(GElf_Word, dst, src, p_flags, NULL); check_and_copy(GElf_Off, dst, src, p_offset, NULL); check_and_copy(GElf_Addr, dst, src, p_vaddr, NULL); check_and_copy(GElf_Addr, dst, src, p_paddr, NULL); check_and_copy(GElf_Xword, dst, src, p_filesz, NULL); check_and_copy(GElf_Xword, dst, src, p_memsz, NULL); check_and_copy(GElf_Xword, dst, src, p_align, NULL); } else { if (valid_class(elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); } else { seterr(ERROR_UNKNOWN_CLASS); } return NULL; } if (dst == &buf) { dst = (GElf_Phdr*)malloc(sizeof(GElf_Phdr)); if (!dst) { seterr(ERROR_MEM_PHDR); return NULL; } *dst = buf; } return dst; }
void* _elf_read(Elf *elf, void *buffer, size_t off, size_t len) { void *tmp; elf_assert(elf); elf_assert(elf->e_magic == ELF_MAGIC); elf_assert(off >= 0 && off + len <= elf->e_size); if (elf->e_disabled) { seterr(ERROR_FDDISABLED); } else if (len) { off += elf->e_base; if (lseek(elf->e_fd, (off_t)off, SEEK_SET) != (off_t)off) { seterr(ERROR_IO_SEEK); } else if (!(tmp = buffer) && !(tmp = malloc(len))) { seterr(ERROR_IO_2BIG); } else if (read(elf->e_fd, tmp, len) != (int)len) { seterr(ERROR_IO_READ); if (tmp != buffer) { free(tmp); } } else { return tmp; } } return NULL; }
char* elf_strptr(Elf *elf, size_t section, size_t offset) { Elf_Scn *scn; Elf_Data *sd; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (!(scn = elf_getscn(elf, section))) { return NULL; } if (scn->s_type != SHT_STRTAB) { seterr(ERROR_NOSTRTAB); return NULL; } if (offset >= 0 && offset < scn->s_size) { sd = NULL; while ((sd = elf_getdata(scn, sd))) { if (sd->d_buf && offset >= (size_t)sd->d_off && offset < (size_t)sd->d_off + sd->d_size) { return (char*)sd->d_buf + (offset - sd->d_off); } } } seterr(ERROR_BADSTROFF); return NULL; }
void *run_main( void *in ) { mxArray *N; /* Matrix containing n. */ mxArray *R = NULL; /* Result matrix. */ int n; /* Integer parameter from command line. */ seterr(0); /*reset the error code */ /* Get any command line parameter. */ if (((inputs*)in)->ac >= 2) { n = atoi(((inputs*)in)->av[1]); } else { n = 12; } /* Call the mclInitializeApplication routine. Make sure that the application * was initialized properly by checking the return status. This initialization * has to be done before calling any MATLAB API's or MATLAB Compiler generated * shared library functions. */ if( !mclInitializeApplication(NULL,0) ) { fprintf(stderr, "Could not initialize the application.\n"); seterr(-2); return in; } /* Call the library intialization routine and make sure that the * library was initialized properly */ if (!libPkgInitialize()) { fprintf(stderr,"Could not initialize the library.\n"); seterr(-3); } else { /* Create a 1-by-1 matrix containing n. */ N = mxCreateScalarDouble(n); /* Call mlfMrank, the compiled version of mrank.m. */ mlfMrank(1, &R, N); /* Print the results. */ mlfPrintmatrix(R); /* Free the matrices allocated during this computation. */ mxDestroyArray(N); mxDestroyArray(R); libPkgTerminate(); /* Terminate the library of M-functions */ } /* On MAC, you need to call mclSetExitCode with the appropriate exit status * Also, note that you should call mclTerminate application in the end of * your application. mclTerminateApplication terminates the entire * application and exits with the exit code set using mclSetExitCode. Note * that this behavior is only on MAC platform. */ #ifdef __APPLE_CC__ mclSetExitCode(((inputs*)in)->err); #endif mclTerminateApplication(); return in; }
Elf_Data* elf_newdata(Elf_Scn *scn) { Scn_Data *sd; if (!scn) { return NULL; } elf_assert(scn->s_magic == SCN_MAGIC); if (scn->s_index == SHN_UNDEF) { seterr(ERROR_NULLSCN); } else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) { seterr(ERROR_MEM_SCNDATA); } else { *sd = _elf_data_init; sd->sd_data_flags = ELF_F_DIRTY; sd->sd_freeme = 1; sd->sd_data.d_version = _elf_version; if (scn->s_data_n) { scn->s_data_n->sd_link = sd; } else { scn->s_data_1 = sd; } scn->s_data_n = sd; return &sd->sd_data; } return NULL; }
/* * Extension: report memory size */ size_t gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) { size_t n; if (elf) { if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (!valid_class(elf->e_class)) { seterr(ERROR_UNKNOWN_CLASS); } else if (!valid_version(ver)) { seterr(ERROR_UNKNOWN_VERSION); } else if (!valid_type(type)) { seterr(ERROR_UNKNOWN_TYPE); } else if (!(n = _msize(elf->e_class, ver, type))) { seterr(ERROR_UNKNOWN_TYPE); } else { return count * n; } } return 0; }
int gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src) { if (!scn || !src) { return 0; } elf_assert(scn->s_magic == SCN_MAGIC); elf_assert(scn->s_elf); elf_assert(scn->s_elf->e_magic == ELF_MAGIC); if (scn->s_elf->e_class == ELFCLASS64) { scn->s_shdr64 = *src; } else if (scn->s_elf->e_class == ELFCLASS32) { Elf32_Shdr *dst = &scn->s_shdr32; check_and_copy(Elf32_Word, dst, src, sh_name, 0); check_and_copy(Elf32_Word, dst, src, sh_type, 0); check_and_copy(Elf32_Word, dst, src, sh_flags, 0); check_and_copy(Elf32_Addr, dst, src, sh_addr, 0); check_and_copy(Elf32_Off, dst, src, sh_offset, 0); check_and_copy(Elf32_Word, dst, src, sh_size, 0); check_and_copy(Elf32_Word, dst, src, sh_link, 0); check_and_copy(Elf32_Word, dst, src, sh_info, 0); check_and_copy(Elf32_Word, dst, src, sh_addralign, 0); check_and_copy(Elf32_Word, dst, src, sh_entsize, 0); } else if (valid_class(scn->s_elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); return 0; } else { seterr(ERROR_UNKNOWN_CLASS); return 0; } return 1; }
/* * Return code: * 0 - End Of Table * -1 - Error * -2 - Last change changed - again * +1 - ok, continue */ static int table_check_response(struct tabwork *work, const struct snmp_pdu *resp) { const struct snmp_value *b; struct entry *e; if (resp->error_status != SNMP_ERR_NOERROR) { if (snmp_client.version == SNMP_V1 && resp->error_status == SNMP_ERR_NOSUCHNAME && resp->error_index == (work->descr->last_change.len == 0) ? 1 : 2) /* EOT */ return (0); /* Error */ seterr(&snmp_client, "error fetching table: status=%d index=%d", resp->error_status, resp->error_index); return (-1); } for (b = resp->bindings; b < resp->bindings + resp->nbindings; b++) { if (work->descr->last_change.len != 0 && b == resp->bindings) { if (!asn_is_suboid(&work->descr->last_change, &b->var) || b->var.len != work->descr->last_change.len + 1 || b->var.subs[work->descr->last_change.len] != 0) { seterr(&snmp_client, "last_change: bad response"); return (-1); } if (b->syntax != SNMP_SYNTAX_TIMETICKS) { seterr(&snmp_client, "last_change: bad syntax %u", b->syntax); return (-1); } if (work->first) { work->last_change = b->v.uint32; work->first = 0; } else if (work->last_change != b->v.uint32) { if (++work->iter >= work->descr->max_iter) { seterr(&snmp_client, "max iteration count exceeded"); return (-1); } table_free(work, 1); return (-2); } continue; } if (!asn_is_suboid(&work->descr->table, &b->var) || b->syntax == SNMP_SYNTAX_ENDOFMIBVIEW) return (0); if ((e = table_find(work, &b->var)) == NULL) return (-1); if (table_value(work->descr, e, b)) return (-1); } return (+1); }
static char* _elf_newehdr(Elf *elf, unsigned cls) { size_t size; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (elf->e_readable) { return _elf_getehdr(elf, cls); } else if (!elf->e_ehdr) { size = _msize(cls, _elf_version, ELF_T_EHDR); elf_assert(size); if ((elf->e_ehdr = (char*)malloc(size))) { memset(elf->e_ehdr, 0, size); elf->e_free_ehdr = 1; elf->e_ehdr_flags |= ELF_F_DIRTY; elf->e_kind = ELF_K_ELF; elf->e_class = cls; return elf->e_ehdr; } seterr(ERROR_MEM_EHDR); } else if (elf->e_class != cls) { seterr(ERROR_CLASSMISMATCH); } else { elf_assert(elf->e_kind == ELF_K_ELF); return elf->e_ehdr; } return NULL; }
CGCEf_Scn* cgcef_nextscn(CGCEf *cgcef, CGCEf_Scn *scn) { if (!cgcef) { return NULL; } cgcef_assert(cgcef->e_magic == CGCEF_MAGIC); if (scn) { cgcef_assert(scn->s_magic == SCN_MAGIC); if (scn->s_cgcef == cgcef) { return scn->s_link; } seterr(ERROR_CGCEFSCNMISMATCH); } else if (cgcef->e_kind != CGCEF_K_CGCEF) { seterr(ERROR_NOTCGCEF); } else if (cgcef->e_ehdr || _cgcef_cook(cgcef)) { cgcef_assert(cgcef->e_ehdr); for (scn = cgcef->e_scn_1; scn; scn = scn->s_link) { cgcef_assert(scn->s_magic == SCN_MAGIC); cgcef_assert(scn->s_cgcef == cgcef); if (scn->s_index == 1) { return scn; } } seterr(ERROR_NOSUCHSCN); } return NULL; }
Elf_Scn* elf_nextscn(Elf *elf, Elf_Scn *scn) { if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (scn) { elf_assert(scn->s_magic == SCN_MAGIC); if (scn->s_elf == elf) { return scn->s_link; } seterr(ERROR_ELFSCNMISMATCH); } else if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (elf->e_ehdr || _elf_cook(elf)) { elf_assert(elf->e_ehdr); for (scn = elf->e_scn_1; scn; scn = scn->s_link) { elf_assert(scn->s_magic == SCN_MAGIC); elf_assert(scn->s_elf == elf); if (scn->s_index == 1) { return scn; } } seterr(ERROR_NOSUCHSCN); } return NULL; }
Elf* elf_memory(char *image, size_t size) { Elf *elf; elf_assert(_elf_init.e_magic == ELF_MAGIC); if (_elf_version == EV_NONE) { seterr(ERROR_VERSION_UNSET); return NULL; } else if (size == 0 || image == NULL) { /* TODO: set error code? */ return NULL; } if (!(elf = (Elf*)malloc(sizeof(Elf)))) { seterr(ERROR_MEM_ELF); return NULL; } *elf = _elf_init; elf->e_size = elf->e_dsize = size; elf->e_data = elf->e_rawdata = image; elf->e_readable = 1; elf->e_disabled = 1; elf->e_memory = 1; _elf_check_type(elf, size); return elf; }
int wbisect(ISect *is) { ZBlock *b; b = alloczblock(HeadSize, 1, 0); if(b == nil){ /* ZZZ set error? */ return -1; } if(packisect(is, b->data) < 0){ seterr(ECorrupt, "can't make index section header: %r"); freezblock(b); return -1; } if(writepart(is->part, PartBlank, b->data, HeadSize) < 0 || flushpart(is->part) < 0){ seterr(EAdmin, "can't write index section header: %r"); freezblock(b); return -1; } freezblock(b); return 0; }
ISect* initisect(Part *part) { ISect *is; ZBlock *b; int ok; b = alloczblock(HeadSize, 0, 0); if(b == nil || readpart(part, PartBlank, b->data, HeadSize) < 0){ seterr(EAdmin, "can't read index section header: %r"); return nil; } is = MKZ(ISect); if(is == nil){ freezblock(b); return nil; } is->part = part; ok = unpackisect(is, b->data); freezblock(b); if(ok < 0){ seterr(ECorrupt, "corrupted index section header: %r"); freeisect(is); return nil; } if(is->version != ISectVersion1 && is->version != ISectVersion2){ seterr(EAdmin, "unknown index section version %d", is->version); freeisect(is); return nil; } return initisect1(is); }
int elf_getshstrndx(Elf *elf, size_t *resultp) { size_t num = 0; size_t dummy; Elf_Scn *scn; if (!elf) { return LIBELF_FAILURE; } elf_assert(elf->e_magic == ELF_MAGIC); if (resultp == NULL) { resultp = &dummy; /* handle NULL pointer gracefully */ } if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); return LIBELF_FAILURE; } if (!elf->e_ehdr && !_elf_cook(elf)) { return LIBELF_FAILURE; } if (elf->e_class == ELFCLASS32) { num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shstrndx; } #if __LIBELF64 else if (elf->e_class == ELFCLASS64) { num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shstrndx; } #endif /* __LIBELF64 */ else { if (valid_class(elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); } else { seterr(ERROR_UNKNOWN_CLASS); } return LIBELF_FAILURE; } if (num != SHN_XINDEX) { *resultp = num; return LIBELF_SUCCESS; } /* * look at first section header */ if (!(scn = elf->e_scn_1)) { seterr(ERROR_NOSUCHSCN); return LIBELF_FAILURE; } elf_assert(scn->s_magic == SCN_MAGIC); #if __LIBELF64 if (elf->e_class == ELFCLASS64) { *resultp = scn->s_shdr64.sh_link; return LIBELF_SUCCESS; } #endif /* __LIBELF64 */ *resultp = scn->s_shdr32.sh_link; return LIBELF_SUCCESS; }
int parseindex(IFile *f, Index *ix) { AMapN amn; u32int v; char *s; /* * magic */ s = ifileline(f); if(s == nil || strcmp(s, IndexMagic) != 0){ seterr(ECorrupt, "bad index magic for %s", f->name); return -1; } /* * version */ if(ifileu32int(f, &v) < 0){ seterr(ECorrupt, "syntax error: bad version number in %s", f->name); return -1; } ix->version = v; if(ix->version != IndexVersion){ seterr(ECorrupt, "bad version number in %s", f->name); return -1; } /* * name */ if(ifilename(f, ix->name) < 0){ seterr(ECorrupt, "syntax error: bad index name in %s", f->name); return -1; } /* * block size */ if(ifileu32int(f, &v) < 0){ seterr(ECorrupt, "syntax error: bad block size number in %s", f->name); return -1; } ix->blocksize = v; if(parseamap(f, &amn) < 0) return -1; ix->nsects = amn.n; ix->smap = amn.map; if(parseamap(f, &amn) < 0) return -1; ix->narenas = amn.n; ix->amap = amn.map; return 0; }
static char* _elf_item(Elf *elf, Elf_Type type, size_t n, size_t off, int *flag) { Elf_Data src, dst; *flag = 0; elf_assert(n); elf_assert(valid_type(type)); if (off > elf->e_size) { seterr(ERROR_OUTSIDE); return NULL; } src.d_type = type; src.d_version = elf->e_version; src.d_size = n * _fsize(elf->e_class, src.d_version, type); elf_assert(src.d_size); if ((elf->e_size - off) < src.d_size) { seterr(truncerr(type)); return NULL; } dst.d_version = _elf_version; dst.d_size = n * _msize(elf->e_class, dst.d_version, type); elf_assert(dst.d_size); elf_assert(elf->e_data); if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) { dst.d_buf = elf->e_data + off; } else if (!(dst.d_buf = malloc(dst.d_size))) { seterr(memerr(type)); return NULL; } else { *flag = 1; } if (elf->e_rawdata) { src.d_buf = elf->e_rawdata + off; } else { src.d_buf = elf->e_data + off; } if (_elf_xlatetom(elf, &dst, &src)) { if (!*flag) { elf->e_cooked = 1; } return (char*)dst.d_buf; } if (*flag) { free(dst.d_buf); *flag = 0; } return NULL; }
/* * Some of this logic is duplicated in hdisk.c */ Packet* readlump(u8int *score, int type, u32int size, int *cached) { Lump *u; Packet *p; IAddr ia; u32int n; trace(TraceLump, "readlump enter"); /* qlock(&stats.lock); stats.lumpreads++; qunlock(&stats.lock); */ if(scorecmp(score, zeroscore) == 0) return packetalloc(); u = lookuplump(score, type); if(u->data != nil){ trace(TraceLump, "readlump lookuplump hit"); if(cached) *cached = 1; n = packetsize(u->data); if(n > size){ seterr(EOk, "read too small: asked for %d need at least %d", size, n); putlump(u); return nil; } p = packetdup(u->data, 0, n); putlump(u); return p; } if(cached) *cached = 0; if(lookupscore(score, type, &ia) < 0){ /* ZZZ place to check for someone trying to guess scores */ seterr(EOk, "no block with score %V/%d exists", score, type); putlump(u); return nil; } if(ia.size > size){ seterr(EOk, "read too small 1: asked for %d need at least %d", size, ia.size); putlump(u); return nil; } trace(TraceLump, "readlump readilump"); p = readilump(u, &ia, score); putlump(u); trace(TraceLump, "readlump exit"); return p; }
static char* _elf_newphdr(Elf *elf, size_t count, unsigned cls) { char *phdr = NULL; size_t size; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (!elf->e_ehdr && !elf->e_readable) { seterr(ERROR_NOEHDR); } else if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (elf->e_class != cls) { seterr(ERROR_CLASSMISMATCH); } else if (elf->e_ehdr || _elf_cook(elf)) { size = _msize(cls, _elf_version, ELF_T_PHDR); elf_assert(size); if (count) { if (!(phdr = (char*)malloc(count * size))) { seterr(ERROR_MEM_PHDR); return NULL; } memset(phdr, 0, count * size); } elf_assert(elf->e_ehdr); if (cls == ELFCLASS32) { ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum = elf->e_phnum = count; } #if __LIBELF64 else if (cls == ELFCLASS64) { ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum = elf->e_phnum = count; } #endif /* __LIBELF64 */ else { seterr(ERROR_UNIMPLEMENTED); if (phdr) { free(phdr); } return NULL; } if (elf->e_free_phdr) { elf_assert(elf->e_phdr); free(elf->e_phdr); } elf->e_phdr = phdr; elf->e_free_phdr = phdr ? 1 : 0; elf->e_phdr_flags |= ELF_F_DIRTY; elf->e_ehdr_flags |= ELF_F_DIRTY; return phdr; } return NULL; }
GElf_Ehdr* gelf_getehdr(Elf *elf, GElf_Ehdr *dst) { GElf_Ehdr buf; char *tmp; if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); tmp = _elf_getehdr(elf, elf->e_class); if (!tmp) { return NULL; } if (!dst) { dst = &buf; } if (elf->e_class == ELFCLASS64) { *dst = *(Elf64_Ehdr*)tmp; } else if (elf->e_class == ELFCLASS32) { Elf32_Ehdr *src = (Elf32_Ehdr*)tmp; memcpy(dst->e_ident, src->e_ident, EI_NIDENT); check_and_copy(GElf_Half, dst, src, e_type, NULL); check_and_copy(GElf_Half, dst, src, e_machine, NULL); check_and_copy(GElf_Word, dst, src, e_version, NULL); check_and_copy(GElf_Addr, dst, src, e_entry, NULL); check_and_copy(GElf_Off, dst, src, e_phoff, NULL); check_and_copy(GElf_Off, dst, src, e_shoff, NULL); check_and_copy(GElf_Word, dst, src, e_flags, NULL); check_and_copy(GElf_Half, dst, src, e_ehsize, NULL); check_and_copy(GElf_Half, dst, src, e_phentsize, NULL); check_and_copy(GElf_Half, dst, src, e_phnum, NULL); check_and_copy(GElf_Half, dst, src, e_shentsize, NULL); check_and_copy(GElf_Half, dst, src, e_shnum, NULL); check_and_copy(GElf_Half, dst, src, e_shstrndx, NULL); } else if (valid_class(elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); return NULL; } else { seterr(ERROR_UNKNOWN_CLASS); return NULL; } if (dst == &buf) { dst = (GElf_Ehdr*)malloc(sizeof(GElf_Ehdr)); if (!dst) { seterr(ERROR_MEM_EHDR); return NULL; } *dst = buf; } return dst; }
/* * save away a lump, and return it's score. * doesn't store duplicates, but checks that the data is really the same. */ int writelump(Packet *p, u8int *score, int type, u32int creator, uint ms) { Lump *u; int ok; /* qlock(&stats.lock); stats.lumpwrites++; qunlock(&stats.lock); */ packetsha1(p, score); if(packetsize(p) == 0 || writestodevnull==1){ packetfree(p); return 0; } u = lookuplump(score, type); if(u->data != nil){ ok = 0; if(packetcmp(p, u->data) != 0){ uchar nscore[VtScoreSize]; packetsha1(u->data, nscore); if(scorecmp(u->score, score) != 0) seterr(EStrange, "lookuplump returned bad score %V not %V", u->score, score); else if(scorecmp(u->score, nscore) != 0) seterr(EStrange, "lookuplump returned bad data %V not %V", nscore, u->score); else seterr(EStrange, "score collision %V", score); ok = -1; } packetfree(p); putlump(u); return ok; } if(writestodevnull==2){ packetfree(p); return 0; } if(queuewrites) return queuewrite(u, p, creator, ms); ok = writeqlump(u, p, creator, ms); putlump(u); return ok; }
static Packet* readilump(Lump *u, IAddr *ia, u8int *score) { Arena *arena; ZBlock *zb; Packet *p, *pp; Clump cl; u64int aa; u8int sc[VtScoreSize]; trace(TraceLump, "readilump enter"); arena = amapitoa(mainindex, ia->addr, &aa); if(arena == nil){ trace(TraceLump, "readilump amapitoa failed"); return nil; } trace(TraceLump, "readilump loadclump"); zb = loadclump(arena, aa, ia->blocks, &cl, sc, paranoid); if(zb == nil){ trace(TraceLump, "readilump loadclump failed"); return nil; } if(ia->size != cl.info.uncsize){ seterr(EInconsist, "index and clump size mismatch"); freezblock(zb); return nil; } if(ia->type != cl.info.type){ seterr(EInconsist, "index and clump type mismatch"); freezblock(zb); return nil; } if(scorecmp(score, sc) != 0){ seterr(ECrash, "score mismatch"); freezblock(zb); return nil; } trace(TraceLump, "readilump success"); p = zblock2packet(zb, cl.info.uncsize); freezblock(zb); pp = packetdup(p, 0, packetsize(p)); trace(TraceLump, "readilump insertlump"); insertlump(u, pp); trace(TraceLump, "readilump exit"); return p; }
GElf_Shdr* gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst) { GElf_Shdr buf; if (!scn) { return NULL; } elf_assert(scn->s_magic == SCN_MAGIC); elf_assert(scn->s_elf); elf_assert(scn->s_elf->e_magic == ELF_MAGIC); if (!dst) { dst = &buf; } if (scn->s_elf->e_class == ELFCLASS64) { *dst = scn->s_shdr64; } else if (scn->s_elf->e_class == ELFCLASS32) { Elf32_Shdr *src = &scn->s_shdr32; check_and_copy(GElf_Word, dst, src, sh_name, NULL); check_and_copy(GElf_Word, dst, src, sh_type, NULL); check_and_copy(GElf_Xword, dst, src, sh_flags, NULL); check_and_copy(GElf_Addr, dst, src, sh_addr, NULL); check_and_copy(GElf_Off, dst, src, sh_offset, NULL); check_and_copy(GElf_Xword, dst, src, sh_size, NULL); check_and_copy(GElf_Word, dst, src, sh_link, NULL); check_and_copy(GElf_Word, dst, src, sh_info, NULL); check_and_copy(GElf_Xword, dst, src, sh_addralign, NULL); check_and_copy(GElf_Xword, dst, src, sh_entsize, NULL); } else { if (valid_class(scn->s_elf->e_class)) { seterr(ERROR_UNIMPLEMENTED); } else { seterr(ERROR_UNKNOWN_CLASS); } return NULL; } if (dst == &buf) { dst = (GElf_Shdr*)malloc(sizeof(GElf_Shdr)); if (!dst) { seterr(ERROR_MEM_SHDR); return NULL; } *dst = buf; } return dst; }
static size_t _elf_fsize(unsigned cls, Elf_Type type, unsigned ver) { size_t n = 0; if (!valid_version(ver)) { seterr(ERROR_UNKNOWN_VERSION); } else if (!valid_type(type)) { seterr(ERROR_UNKNOWN_TYPE); } else if (!(n = _fsize(cls, ver, type))) { seterr(ERROR_UNKNOWN_TYPE); } return n; }
size_t gelf_fsize(Elf *elf, Elf_Type type, size_t count, unsigned ver) { if (elf) { if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (valid_class(elf->e_class)) { return count * _elf_fsize(elf->e_class, type, ver); } else { seterr(ERROR_UNKNOWN_CLASS); } } return 0; }
char *_elf_getphdr(Elf * elf, unsigned cls) { if (!elf) { return NULL; } elf_assert(elf->e_magic == ELF_MAGIC); if (elf->e_kind != ELF_K_ELF) { seterr(ERROR_NOTELF); } else if (elf->e_class != cls) { seterr(ERROR_CLASSMISMATCH); } else if (elf->e_ehdr || _elf_cook(elf)) { return elf->e_phdr; } return NULL; }