int Hex2Bin(const char* hex, int len, uint8* bin) { int i; if (len & 1) { printf("invalid hex number (odd length): '%s'\n", hex); return ERR_INVALID; } for (i = 0; i < len; i += 2) { int hi = hex[i + 0]; int lo = hex[i + 1]; #define HEX(ch) (\ '0' <= ch && ch <= '9' \ ? ch - '0' \ : 'A' <= ch && ch <= 'F' \ ? 10 + ch - 'A' \ : 'a' <= ch && ch <= 'f' \ ? 10 + ch - 'a' \ : -1) int b = HEX(hi) << 4 | HEX(lo); #undef HEX if (b < 0) { printf("invalid hex number (non hex digit): '%s'\n", hex); return ERR_INVALID; } bin[i / 2] = b; } return 0; }
char *camera_get_msr_filename(char *buf, int buf_size, char *sensor, int cam) { snprintf(buf, buf_size, "%02d%s-%s%x-%s%x-%s%x.drvb", cam, sensor, HEX(spid.vendor_id), HEX(spid.platform_family_id), HEX(spid.product_line_id)); return buf; }
int set_reminder ( reminder_t *reminder, S710_Packet_Index which, S710_Driver *d ) { packet_t *p; int lower = S710_SET_REMINDER_1; int upper = S710_SET_REMINDER_7; if ( which < lower || which > upper ) { fprintf(stderr,"set_reminder: index %d outside of [%d,%d]\n", which,lower,upper); return 0; } p = make_set_packet(which); if ( p == NULL ) return 0; p->data[0] = reminder->which - 1; p->data[1] = HEX(reminder->date.tm_min); p->data[2] = HEX(reminder->date.tm_hour); p->data[3] = HEX(reminder->date.tm_mday); p->data[4] = HEX(reminder->date.tm_year - 100); p->data[5] = BINU(reminder->on) | BINL(reminder->date.tm_mon + 1); encode_label(reminder->label,&p->data[6],7); p->data[13] = BINU(reminder->repeat) | BINL(reminder->exercise); return send_set_packet(p,d); }
static void fromhex(const char input[], char output[], int n) { int i; for (i=0;i<n;i++) { char hi,low; HEX(hi, input[i*2]); HEX(low, input[i*2+1]); output[i] = hi<<4 | low; } }
// does not return void Binary::runBasic(int argc, char* argv[]){ long res; pid_t pid = fork(); if (pid == 0){ // child that runs bin PTRACE_AND_CHECK(PTRACE_TRACEME, 0, NULL, NULL); EPAXOut << "child (" << getName(); for (int i = 1; i < argc; i++){ std::cout << " " << argv[i]; } std::cout << ") will start at " << HEX(getStartAddr()) << ENDL; int ret = execve(argv[0], argv, NULL); EPAXAssert(false, "exec returned with an error: " << DEC(ret)); } // parent/epax process siginfo_t s; struct user_regs bregs; // wait, then be sure the signal caught is a SIGTRAP from child's execve wait(NULL); PTRACE_AND_CHECK(PTRACE_GETSIGINFO, pid, NULL, &s); EPAXAssert(s.si_signo == SIGTRAP, "unexpected signal caught (expect SIGTRAP resulting from execve)"); // grab the PC of the child process PTRACE_AND_CHECK(PTRACE_GETREGS, pid, NULL, &bregs); EPAXOut << getName() << " PC: " << HEX(bregs.uregs[15]) << ENDL; // TODO: get magic num 15 from armd long b = ptrace(PTRACE_PEEKTEXT, pid, bregs.uregs[15], NULL); EPAXOut << getName() << " instruction bytes: " << HEX(b) << ENDL; // TODO: get magic num 15 from armd // plan: here we need to inject code that copies the contents of the parent process (epax) into the child. // this code can then shepherd the child process, taking control back at every BB, for example. PTRACE_AND_CHECK(PTRACE_POKETEXT, pid, bregs.uregs[15], b); // prints out the instruction stream, 1 PC at a time //#define SINGLE_STEP_THROUGH #ifdef SINGLE_STEP_THROUGH while (1){ PTRACE_AND_CHECK(PTRACE_SINGLESTEP, pid, NULL, NULL); wait(NULL); PTRACE_AND_CHECK(PTRACE_GETREGS, pid, NULL, &bregs); EPAXOut << getName() << " PC: " << HEX(bregs.rip) << ENDL; } #else PTRACE_AND_CHECK(PTRACE_CONT, pid, NULL, NULL); #endif wait(NULL); exit(0); }
string pCFGIterator::genRandColor(unsigned int curPSet) { stringstream color; boost::mt19937 seed(static_cast<unsigned int> (time(0) + curPSet)); boost::uniform_smallint<> color_component(0, 255); boost::variate_generator< boost::mt19937, boost::uniform_smallint<> > hex(seed, color_component); int r = hex(); int g = hex(); int b = hex(); color << "\"# " << HEX(r) << HEX(g) << HEX(b) << "\""; //cout << std::hex << r << endl; return color.str(); }
void Binary::construct(std::string n, BinaryFormat f){ if (f == BinaryFormat_undefined){ f = detectFormat(n); } format = f; EPAXOut << "File " << n << " is a " << getFormatName() << " file" << ENDL; EPAXAssert(format != BinaryFormat_undefined, "Cannot determine format of " << n << ". Try specifying it manually."); switch (format){ case BinaryFormat_Elf32: binary = new Elf::ElfBinary32(n); break; case BinaryFormat_Elf64: binary = new Elf::ElfBinary64(n); break; case BinaryFormat_MachO32: binary = new MachO::MachOBinary32(n); break; case BinaryFormat_MachO64: binary = new MachO::MachOBinary64(n); break; default: EPAXDie("Unimplemented binary format " << getFormatName() << " given."); } EPAXOut << "Program entry point at vaddr " << HEX(binary->getStartAddr()) << ENDL; lineinfo = new LineInformation(binary); binary->describe(); //EPAXAssert(binary->isARM(), "This binary contains non-ARM code... bailing"); }
void PostIncTestInt64() { size_t i; for( i = 0; i < COUNTOF(inc_int64); ++i ) { bool fSuccess = true; try { SafeInt< __int64 > si(inc_int64[i].x); SafeInt< __int64 > vv = si++; if(vv != inc_int64[i].x) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != inc_int64[i].fExpected ) { cerr << "Error in case inc_int64 throw (2): "; cerr << HEX(8) << inc_int64[i].x << ", "; cerr << "expected = " << inc_int64[i].fExpected << endl; } } }
int main() { char ch = 0; printf("请输入一个十六进制数位字符:"); scanf("%c", &ch); printf("转换结果是%d\n", HEX(ch)); return 0; }
void PostDecTestInt8() { size_t i; for( i = 0; i < COUNTOF(dec_int8); ++i ) { bool fSuccess = true; try { SafeInt< __int8 > si(dec_int8[i].x); SafeInt< __int8 > vv = si--; if(vv != dec_int8[i].x) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != dec_int8[i].fExpected ) { cerr << "Error in case dec_int8 throw (2): "; cerr << HEX(2) << (0xFF & (int)dec_int8[i].x) << ", "; cerr << "expected = " << dec_int8[i].fExpected << endl; } } }
void PreIncTestInt32() { size_t i; for( i = 0; i < COUNTOF(inc_int32); ++i ) { bool fSuccess = true; try { SafeInt< __int32 > si(inc_int32[i].x); SafeInt< __int32 > vv = ++si; if(vv != inc_int32[i].y) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != inc_int32[i].fExpected ) { cerr << "Error in case inc_int32 throw (1): "; cerr << HEX(8) << inc_int32[i].x << ", "; cerr << "expected = " << inc_int32[i].fExpected << endl; } } }
void PostDecTestUint64() { size_t i; for( i = 0; i < COUNTOF(dec_uint64); ++i ) { bool fSuccess = true; try { SafeInt<unsigned __int64> si(dec_uint64[i].x); SafeInt<unsigned __int64> vv = si--; if(vv != dec_uint64[i].x) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != dec_uint64[i].fExpected ) { cerr << "Error in case dec_uint64 throw (2): "; cerr << HEX(16) << dec_uint64[i].x << ", "; cerr << "expected = " << dec_uint64[i].fExpected << endl; } } }
void PreDecTestUint32() { size_t i; for( i = 0; i < COUNTOF(dec_uint32); ++i ) { bool fSuccess = true; try { SafeInt<unsigned __int32> si(dec_uint32[i].x); SafeInt<unsigned __int32> vv = --si; if(vv != dec_uint32[i].y) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != dec_uint32[i].fExpected ) { cerr << "Error in case dec_uint32 throw (1): "; cerr << HEX(8) << dec_uint32[i].x << ", "; cerr << "expected = " << dec_uint32[i].fExpected << endl; } } }
void PreIncTestUint8() { size_t i; for( i = 0; i < COUNTOF(inc_uint8); ++i ) { bool fSuccess = true; try { SafeInt<unsigned __int8> si(inc_uint8[i].x); SafeInt<unsigned __int8> vv = ++si; if(vv != inc_uint8[i].y) { fSuccess = false; } } catch(SafeIntException&) { fSuccess = false; } if( fSuccess != inc_uint8[i].fExpected ) { cerr << "Error in case inc_uint8 throw (1): "; cerr << HEX(2) << (0xFF & (int)inc_uint8[i].x) << ", "; cerr << "expected = " << inc_uint8[i].fExpected << endl; } } }
static PyObject * add_to_pointerlist(struct pointerlist *n, struct key_thing *other) { HEX(n); HEX(other); INT(other->key); HEX(other->self); XX(print_pointerlist(n)); if (n == NULL) { PyErr_SetString(PyExc_RuntimeError, "add_to_pointerlist: null list??"); return NULL; } if (other == NULL) { PyErr_SetString(PyExc_RuntimeError, "add_to_pointerlist: second arg is NULL"); return NULL; } if (other->key == 0) { printf("BADNESS: "); PyObject_Print(other->self, stdout, 0); printf("\n"); PyErr_SetString(PyExc_RuntimeError, "add_to_pointerlist: key is zero"); return NULL; } /* we already have somebody with the same key, so remove it */ if (has_key(n, other->key) != NULL) { if (remove_from_pointerlist(n, other->key) == NULL) return NULL; } n->size++; if (n->size > n->arraysize) { printf("GROW LIST FROM %d to %d\n", n->arraysize, 2 * n->arraysize); n->arraysize *= 2; n->lst = (struct key_thing **) realloc(n->lst, n->arraysize * sizeof(struct key_thing *)); } n->lst[n->size-1] = other; Py_INCREF(other->self); MARK(); XX(print_pointerlist(n)); Py_INCREF(Py_None); return Py_None; }
std::string coloritcolor(float val, float perfect, float a, float b, float c, float d) { if (val < 0.00001) return "ffffff"; else if (val > perfect) return "aa88ff"; else { float red,green,blue; if (val >= a) { // blue -> green red = 200; green = 200 + 55*(perfect-val)/(float(perfect-a)); blue = 255 - 55*(perfect-val)/(float(perfect-a)); } else if (val >= b) { // green -> yellow red = 200 + 55*(a-val)/(float(a-b)); green = 255; blue = 200; } else if (val >= c) { // yellow -> pink red = 255; green = 255 - 55*(b-val)/(float(b-c)); blue = 200; } else if (val >= d) { // pink -> red; red = 255; green = 200 - 200*(c-val)/(float(c-d)); blue = 200 - 200*(c-val)/(float(c-d)); } else { // dark red red = 200; green = 0; blue = 0; } return HEX(red) + HEX(green) + HEX(blue); } }
int ImagingHexDecode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes) { UINT8* ptr; int a, b; ptr = buf; for (;;) { if (bytes < 2) return ptr - buf; a = HEX(ptr[0]); b = HEX(ptr[1]); if (a < 0 || b < 0) { ptr++; bytes--; } else { ptr += 2; bytes -= 2; state->buffer[state->x] = (a<<4) + b; if (++state->x >= state->bytes) { /* Got a full line, unpack it */ state->shuffle((UINT8*) im->image[state->y], state->buffer, state->xsize); state->x = 0; if (++state->y >= state->ysize) { /* End of file (errcode = 0) */ return -1; } } } } }
// Encodes and prints string using Percent-encoding specified // in RFC 1738, Section 2.2 static int print_encoded_string(Print* print, const char* str) { int bytes = 0; for (int i = 0; str[i] != 0; i++) { if (((str[i] >= 'A') && (str[i] <= 'Z')) || ((str[i] >= 'a') && (str[i] <= 'z')) || ((str[i] >= '0') && (str[i] <= '9')) || (str[i] == '-') || (str[i] == '_') || (str[i] == '.') || (str[i] == '~')) { bytes += print->print(str[i]); } else { // Encode all other characters bytes += print->print('%'); bytes += print->print(HEX(str[i] / 16)); bytes += print->print(HEX(str[i] % 16)); } } return bytes; }
/* * This function should vanish when 2.5 comes around and * we have pnpbios_module_init() */ static void pnp_init(void) { const struct pnpbios_device_id *id; struct pci_dev *dev = NULL; #ifdef SERIAL_DEBUG_PNP printk("Entered probe_serial_pnp()\n"); #endif isapnp_for_each_dev(dev) { char slot_name[8]; u32 pnpid; if (dev->active) continue; pnpid = dev->vendor << 16 | dev->device; pnpid = cpu_to_le32(pnpid); #define HEX(id,a) hex[((id)>>a) & 15] #define CHAR(id,a) (0x40 + (((id)>>a) & 31)) slot_name[0] = CHAR(pnpid, 26); slot_name[1] = CHAR(pnpid, 21); slot_name[2] = CHAR(pnpid, 16); slot_name[3] = HEX(pnpid, 12); slot_name[4] = HEX(pnpid, 8); slot_name[5] = HEX(pnpid, 4); slot_name[6] = HEX(pnpid, 0); slot_name[7] = '\0'; for (id = pnp_dev_table; id->id[0]; id++) if (memcmp(id->id, slot_name, 7) == 0) break; if (id->id[0]) pnp_init_one(dev, id, slot_name); else pnp_init_one(dev, NULL, slot_name); } #ifdef SERIAL_DEBUG_PNP printk("Leaving probe_serial_pnp() (probe finished)\n"); #endif }
BOOL WlanMisc_String2Mac(char *pszString, PBYTE pbMac) { UCHAR i, nargs = 0; char *argv[6]; while (nargs < 6) { while ((*pszString == ' ') || (*pszString == '\t')) { ++ pszString; } if (*pszString == '\0') { argv[nargs] = NULL; break; } argv[nargs ++] = pszString; while (*pszString && (*pszString != ':')) { ++ pszString; } if (*pszString == '\0') { argv[nargs] = NULL; break; } *pszString ++ = '\0'; } if (nargs != 6) return FALSE; for (i = 0; i < 6; i ++) { UINT8 val1, val2; val1 = HEX(argv[i][0]); val2 = HEX(argv[i][1]); pbMac[i] = (val1 << 4) + val2; } return TRUE; }
void SPIDevice::debugDumpRegisters(unsigned int number){ cout << "SPI Mode: " << this->mode << endl; cout << "Bits per word: " << (int)this->bits << endl; cout << "Max speed: " << this->speed << endl; cout << "Dumping Registers for Debug Purposes:" << endl; unsigned char *registers = this->readRegisters(number); for(int i=0; i<(int)number; i++){ cout << HEX(*(registers+i)) << " "; if (i%16==15) cout << endl; } cout << dec; }
void display_planet(struct planet p) { glColor3f(HEX(p.color)); glPushMatrix(); glTranslatef(p.x, p.y, p.z); glRotatef(p.angle, 15, 25, 1); int lines = p.radius / 2.5; glutWireSphere(p.radius, lines, lines); glPopMatrix(); if (p.satellite) { display_planet(*p.satellite); } }
UCHAR WlanMisc_ASCII2WEPKey(CHAR *pszKeyASCII, UCHAR *pucKeyMaterial) { UCHAR ucSize = (UCHAR)strlen(pszKeyASCII); TRACE("+SetWEPKey()\r\n"); switch (ucSize) { case KeySizeValue_40_64bit_ASCII: case KeySizeValue_104_128bit_ASCII: CopyMemory(pucKeyMaterial, pszKeyASCII, strlen(pszKeyASCII)); ucSize = (UCHAR)strlen(pszKeyASCII); break; case KeySizeValue_40_64bit_HEX: case KeySizeValue_104_128bit_HEX: { UCHAR *psz = (UCHAR*)pszKeyASCII; UCHAR *pTarget = pucKeyMaterial; while (*psz) { UINT8 val1, val2; val1 = HEX(*psz); psz ++; val2 = HEX(*psz); psz ++; *pTarget = (val1 << 4) + val2; pTarget ++; } ucSize = pTarget - pucKeyMaterial; break; } default: return 0; } TRACE("-SetWEPKey()\r\n"); return ucSize; }
static ssize_t emv_pk_read_bin(char *buf, unsigned char *bin, size_t size, size_t *read) { size_t left = size; char *p = buf; while (*p && *p == ' ') p++; while (left > 0) { int c1, c2; c1 = HEX(*p); if (c1 == -1) return -(p - buf); p++; c2 = HEX(*p); if (c2 == -1) return -(p - buf); p++; *bin = (c1 * 16 + c2); bin ++; left --; if (*p == ':') p++; else if (read) { *read = (size - left); break; } else if (left == 0) break; else return -(p - buf); } while (*p && *p == ' ') p++; p--; return (p - buf); }
string toHex(int num) { string HEX("0123456789abcdef"); if (num == 0) { return "0"; } string res; int count = 0; while (num && count < 8) { res += HEX[num & 0xf]; count++; num >>= 4; } reverse(res.begin(), res.end()); return res; }
static void list_output(int32_t offset, const void *data, enum out_type type, uint64_t size) { char q[20]; if (!listp || suppress || user_nolist) /* fbk - 9/2/00 */ return; switch (type) { case OUT_RAWDATA: { uint8_t const *p = data; if (size == 0 && !listdata[0]) listoffset = offset; while (size--) { HEX(q, *p); q[2] = '\0'; list_out(offset++, q); p++; } break; } case OUT_ADDRESS: list_address(offset, "[]", *(int64_t *)data, abs((int)size)); break; case OUT_REL1ADR: list_address(offset, "()", *(int64_t *)data, 1); break; case OUT_REL2ADR: list_address(offset, "()", *(int64_t *)data, 2); break; case OUT_REL4ADR: list_address(offset, "()", *(int64_t *)data, 4); break; case OUT_REL8ADR: list_address(offset, "()", *(int64_t *)data, 8); break; case OUT_RESERVE: { snprintf(q, sizeof(q), "<res %08"PRIX64">", size); list_out(offset, q); break; } } }
static void list_address(int32_t offset, const char *brackets, int64_t addr, int size) { char q[20]; char *r = q; nasm_assert(size <= 8); *r++ = brackets[0]; while (size--) { HEX(r, addr); addr >>= 8; r += 2; } *r++ = brackets[1]; *r = '\0'; list_out(offset, q); }
int main() { char passwd[MAX_LEN], hash[HASH_LENGTH], out[MAX_LEN * 2]; size_t passwd_len; # ifdef USE_GCRYPT gcry_error_t err; /* Initialize libgcrypt so it does not put warning messages in the syslog. */ if (!gcry_check_version(GCRYPT_VERSION)) { printf("libgcrypt version mismatch. %s or higher is required.\n", GCRYPT_VERSION); exit(1); } /* Since we will just be hashing, secure memory is not needed. */ if (!(err = gcry_control(GCRYCTL_DISABLE_SECMEM,0))) err = gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); if (GPG_ERR_NO_ERROR != err) { printf("Libgcrypt error: %s\n", gcry_strerror(err)); exit(1); } # endif passwd_len = -1; memset(passwd, 0, MAX_LEN); memset(out, 0, MAX_LEN * 2); if (get_hash_via_env_var(hash)) if (get_hash_via_username_and_inode(hash, passwd, &passwd_len)) exit(1); if (-1 == passwd_len) { prompt_passwd(passwd); passwd_len = strlen(passwd); } maskpass(passwd, passwd_len, hash, HASH_LENGTH); HEX(passwd, out, passwd_len * 2); printf("%s\n", out); return 0; }
gcolor from_hex(char *hex) { gcolor c = {0, 0, 0}; if (!hex || !(*hex == '#')) { return c; } c.r = (16*HEX(hex[1]) + HEX(hex[2])); c.g = (16*HEX(hex[3]) + HEX(hex[4])); c.b = (16*HEX(hex[5]) + HEX(hex[6])); if (c.r<0 || c.g<0 || c.b<0) { c = (gcolor){0,0,0}; } return c; }
int ATCommandResponse::setData(std::vector<unsigned char> frame) { // Check frame type if (frame[0] != 0x88) { std::cout << __FILE__ << ":" << __LINE__ << "ATCommandResponse::setData(): Unknown type (" << HEX(frame[0]) << ")" << std::endl; return -1; } // Check size if (frame.size() < 5) { std::cout << __FILE__ << ":" << __LINE__ << "ATCommandResponse::setData(): Frame not large " << "enough! Expected at least 5 bytes, size " << frame.size() << std::endl; return -1; } // Frame ID is next m_frameId = frame[1]; for (int i = 0; i < 2; i++) { m_command.push_back(frame[i+2]); // command is bytes 2 and 3 } m_status = frame[4]; // Status is byte 4 (starting from 0) // Any remaining bytes are the arg, starting at 15 m_arg = 0; for (unsigned int i = 5; i < frame.size(); i++) { m_argData.push_back(frame[i]); m_arg = m_arg << 8; m_arg += frame[i]; } return 0; }