int eeprom_sscanf(char *str, unsigned char *mac_addr) { int count = 0; unsigned char digit1, digit2; int i; while (isspace(*str)) { str++; } for (i = 0; i < 6; i++) { digit1 = *str++; digit2 = *str++; if (isxdigit(digit1) && isxdigit(digit2)) { count++; mac_addr[i] = (atoh(digit1) << 4) | atoh(digit2); #ifdef DEBUG_EEPROM printf("Digit1 = %c Digit 2= %c\n", digit1, digit2); printf("MAC_ADDR[%d] = %x\n", i, mac_addr[i]); #endif } if (*str++ != ':' && i <= 4) break; } return count; }
/* * Take a string like "0ab1" and make it * a series of bytes: { 0x0a, 0xb1 } * * @len is the strlen() of the ascii * * Destroys the original string. */ char *convert_ascii_to_hex(char *ascii) { int i; char *hex; int len = strlen(ascii); // Make it just as long as the ASCII password, even though it // will only end up half as long hex = strdup(ascii); if (len%2) { fprintf(stderr, "%s() must be even number of bytes: %d\n", __func__, len); exit(2); } for (i=0; i < len; i+=2) { int high = atoh(ascii[i]); int low = atoh(ascii[i+1]); u8 byte = (high<<4 | low); if (high < 0 || low < 0) { fprintf(stderr, "unable to parse hex string: '%s'\n", ascii); return NULL; } debug_printf(6, "high: %02x low: %02x, both: %02x\n", high, low, byte); hex[i/2] = byte; } for (i=len/2; i < len; i++) hex[i] = '\0'; return hex; }
// src: http://timzaman.wordpress.com/code-c-arduino/checksum-xor-cpp/ // Validates the checksum on an (for instance NMEA) string // Returns 1 on valid checksum, 0 otherwise int validateChecksum(void) { char gotSum[2]; gotSum[0] = buffer[strlen(buffer) - 2]; gotSum[1] = buffer[strlen(buffer) - 1]; // Check that the checksums match up if ((16 * atoh(gotSum[0])) + atoh(gotSum[1]) == getCheckSum(buffer)) return 1; else return 0; }
void gitg_utils_sha1_to_hash(gchar const *sha, gchar *hash) { int i; for (i = 0; i < HASH_BINARY_SIZE; ++i) { gchar h = atoh(*(sha++)) << 4; hash[i] = h | atoh(*(sha++)); } }
void cmd_adxl362_write(BaseSequentialStream *chp, int argc, char *argv[]) { (void)argv; int address = 0x00; int data = 0x00; if (argc == 2) { atoh(argv[0],&address); atoh(argv[1],&data); adxl362_write_register((uint16_t) address, (uint8_t) data); } else { chprintf(chp, "%d ERR\n\r", argc); } }
static int cvthexkey(const char *hexstr, char **ptrp) /* turn hex key string into octets */ { int i; int len = 0; char *retval; const char *s; unsigned char *us; char c; char savec = '\0'; /* count */ for (s = hexstr; *s; s++) { if (!isascii(*s)) return -1; if (isspace(*s)) continue; if (!isxdigit(*s)) return -1; len++; } /* if 0 or odd, then there was an error */ if (len == 0 || (len & 1) == 1) return -1; /* now we know that the input is good */ len >>= 1; retval = malloc (len); if (!retval) { fprintf (stderr, "%s: unable to allocate %d bytes for hexkey\n", ProgramName, len); return -1; } for (us = (unsigned char *) retval, i = len; i > 0; hexstr++) { c = *hexstr; if (isspace(c)) continue; /* already know it is ascii */ if (isupper(c)) c = tolower(c); if (savec) { #define atoh(c) ((c) - (((c) >= '0' && (c) <= '9') ? '0' : ('a'-10))) *us = (unsigned char)((atoh(savec) << 4) + atoh(c)); #undef atoh savec = 0; /* ready for next character */ us++; i--; } else { savec = c; } } *ptrp = retval; return len; }
int dump_mftrecord(char *a) { char buf[512]; memset(&buf,0,512); int ia = atoh(a); obraz_dysku = fopen("/ntfs_100M", "rb"); fseek(obraz_dysku, ia, SEEK_SET); fread(&buf, 512, 1, obraz_dysku); fclose(obraz_dysku); MFT_RECORD *mra = (MFT_RECORD *)buf; printf("DUMP MFT RECORD:\n"); printf("\tattr_offset:\t\t%x\n", mra->attrs_offset); printf("\tbase_mft_record:\t\t%x\n", mra->base_mft_record); printf("\tbytes_allocated:\t\t%x\n", mra->bytes_allocated); printf("\tbytes_in_use:\t\t%x\n", mra->bytes_in_use); printf("\tflags:\t\t%x\n", mra->flags); printf("\tlink_count:\t\t%x\n", mra->link_count); printf("\tlsn:\t\t%x\n", mra->lsn); printf("\tmagic:\t\t%x\n", mra->magic); printf("\tmft_record_number:\t\t%x\n", mra->mft_record_number); printf("\tnext_attr_instance:\t\t%x\n", mra->next_attr_instance); printf("\treserved:\t\t%x\n", mra->reserved); printf("\tsequence_number:\t\t%x\n", mra->sequence_number); printf("\tusa_count:\t\t%x\n", mra->usa_count); printf("\tusa_ofs:\t\t%x\n", mra->usa_ofs); printf("\n"); attr_offset = mra->attrs_offset; }
int main(int argc, char** argv) { if(argc!=2) printf("DUMP: za malo argumentow\n"); else { unsigned long long ret = atoh(argv[1]); printf("%d\n", ret); } return 0; if(argc!=2) printf("DUMP: za malo argumentow\n"); else //dump(argv[1], argv[2], argv[3]); //dump_mftrecord(argv[2]); dump_attrrecord(argv[1]); return 0; if(otworz_plik("/ntfs_100M")) { printf("Nie podano nazwy pliku\n"); return EXIT_FAILURE; } pobierz_pierwszy_sektor(); //pokaz_pierwszy_sektor(); //pokaz_sygnaturke(); wylicz_pierwsza_partycje(); pobierz_bs_pierwszej_partycji(); mamy_bs(); ustaw_zmienne_dla_partycji(); pokazwpetli_FILE0(); zamknij_plik(); return (EXIT_SUCCESS); }
struct signatures_s * retrieve_signatures() { // Read signatures from spoon.conf, and add them to a linked list. FILE *config; char *header, *footer, *ext; int len; struct signatures_s *sigs = (struct signatures_s *) malloc(sizeof(struct signatures_s)); config = fopen("spoon.conf", "r"); while (fscanf(config, "%ms %ms %ms %d", &ext, &header, &footer, &len) != EOF) { append_signature(sigs, make_signature(atoh(header), atoh(footer), ext, len)); } fclose(config); return sigs; }
/******************************************************************************* 函数名称 : llb_control_memory_show 功能描述 : 显示内存函数 输入参数 : void 输出参数 : 返 回 值 : void -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 修改目的 : 修改日期 : *******************************************************************************/ s32 llb_control_memory_show(s32 argc, s8** argv) { s8 ch = 0; s32 err_id, i; llb_memory_show_buf buff; u32 *p; if(argc < 2) { return ERROR_FAIL; } memset(&buff, 0, sizeof(buff)); if(strlen(argv[1]) == 10 && argv[1][0] == '0' && (argv[1][1] == 'x' || argv[1][1] == 'X')) { buff.baseaddr = atoh((u8 *)argv[1] ,10); printf("Show address %lx or not (y/n):", buff.baseaddr); scanf("%c", &ch); if(ch != 'y' && ch != 'Y') { printf("You conceled this oprate!\n"); return ERROR_FAIL; } } else { memcpy(buff.memory, argv[1], strlen(argv[1])); } if(argc == 3) { buff.offset = (u32)atoi(argv[2]); if(buff.offset > 65536) { printf("Memory offset out of range!\n"); buff.offset = 0; } } conplat_syscall(MODULEID_ADN_LLB, LLB_SHOW_MEMORY, &buff, sizeof(buff), &err_id); if(1 == buff.result) { for(i=0; i<8; i++) { p = (u32 *)&(buff.memory[i*16]); printf("<%lx> %.8x %.8x %.8x %.8x\n", buff.baseaddr+buff.offset+16*i , p[0], p[1], p[2], p[3]); } } else { printf("Show memory of %s error!\n", argv[1]); } return ERROR_SUCCESS; }
uint32_t JPWiFly::getoptInt(int opt, uint8_t base) { String buf; if (!getopt(opt, buf)) return 0; if (base == DEC) return atou(buf.c_str()); else return atoh(buf.c_str()); }
void cmd_adxl362_read(BaseSequentialStream *chp, int argc, char *argv[]) { (void)argv; int address = 0x00; if (argc == 1) { atoh(argv[0],&address); chprintf(chp,"0x%02x\n\r",adxl362_read_register(address)); } else { chprintf(chp, "%d ERR\n\r", argc); } }
void mac_public_code(unsigned char *bin_pubkey, unsigned char *ch_pubkey, const unsigned char *mac) { unsigned char feed_code[12] = {10, 12, 13, 13, 8, 11, 13, 2, 8, 9, 1, 12}; unsigned char solt[12] = {73,42, 29 ,20, 69, 120, 216, 239, 47, 102, 183,141}; int i = 0; unsigned char maccode[6 + 1] = {0}; maccode[0] = atoh(&mac[0]); maccode[1] = atoh(&mac[3]); maccode[2] = atoh(&mac[6]); maccode[3] = atoh(&mac[9]); maccode[4] = atoh(&mac[12]); maccode[5] = atoh(&mac[15]); for ( i = 0; i < 12; i = i + 2 ) { bin_pubkey[i] = solt[i] ^ (maccode[i] & 0xF0 | feed_code[i]); bin_pubkey[i + 1] = solt[i + 1] ^ ((maccode[i] << 4) & 0xF0 | feed_code[i + 1]); } bin_pubkey[12] = 0; i = 0; while ( i < 12 ) { bin_pubkey[12] += bin_pubkey[i++]; } if( ch_pubkey ) { while ( i < 13 ) { sprintf(&ch_pubkey[i*2], "%02X", bin_pubkey[i]); i++; } } }
int main(int argc, char * argv[]) { char * input = argv[1]; int size = strlen(input); char * hex = atoh(input); for(int i = 0; i < size/2; i++){ printf("%x ",hex[i]); } return 0; }
/******************************************************************************* 函数名称 : llb_control_memory_set 功能描述 : 设置内存函数 输入参数 : void 输出参数 : 返 回 值 : void -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 修改目的 : 修改日期 : *******************************************************************************/ s32 llb_control_memory_set(s32 argc, s8** argv) { s8 ch = 0; s32 err_id; llb_memory_set_buf buff; if(argc != 3 || strlen(argv[1]) != 10 || strlen(argv[2]) != 10 || argv[1][0] != '0' || (argv[1][1] != 'x' && argv[1][1] != 'X') || argv[2][0] != '0' || (argv[2][1] != 'x' && argv[2][1] != 'X')) { return ERROR_FAIL; } buff.address = atoh((u8 *)argv[1] ,10); buff.value = atoh((u8 *)argv[2] ,10); buff.result = 0; printf("Set address %#x = %#x or not (y/n):", buff.address, buff.value); scanf("%c", &ch); if(ch != 'y' && ch != 'Y') { printf("You conceled this oprate!\n"); return ERROR_FAIL; } conplat_syscall(MODULEID_ADN_LLB, LLB_SET_MEMORY, &buff, sizeof(buff), &err_id); if(1 == buff.result) { printf("Set address %#x = %#x successful!\n", buff.address, buff.value); } else { printf("Set address %#x = %#x error!\n", buff.address, buff.value); } return ERROR_SUCCESS; }
int dump(char *str, char *address, char *size) { char *str_f = str; off_t address_f = atoh(address); size_t size_f = atoi(size); obraz_dysku = fopen("/ntfs_100M", "rb"); fseek(obraz_dysku, address_f, SEEK_SET); size_t i; printf("Address: %x, ", address_f); for(i=0; i<size_f; i++) { printf("%x ", fgetc(obraz_dysku)); } printf("\n"); fclose(obraz_dysku); }
int color::read_encoding(const color_scheme cs, const char * const s, const size_t n) { size_t hex_length = 2; scheme = cs; char *p = (char *) s; p++; if (*p == '#') { hex_length = 4; p++; } for (size_t i = 0; i < n; i++) { if (!atoh(&(components[i]), p, hex_length)) return 0; if (hex_length == 2) components[i] *= 0x101; // scale up -- 0xff should become 0xffff p += hex_length; } return 1; }
/* Added due to jxespace option. Used to parse string values into hex long equivalents from the command line Assumes a hex string of 8 characters or less and terminate on a space, comma, or end of string. Returns a long hex value. */ U_32 parseStringToLong(char* strarg) { char value[16]; /* hopefully 16 bytes is enough on all platforms */ if (isxdigit(strarg[0])) { int i; for (i = 0; i < 8; i++) { if (isxdigit(strarg[i])) { value[i] = strarg[i]; if (strarg[i+1] == ',' || strarg[i+1] == 0x20 || strarg[i+1] == 0x0) { value[i+1] = 0x0; return atoh(&value[0]); } } else { return 0; } } } return 0; }
int dump_attrrecord(char *a) { char buf[0x1000]; memset(&buf,0,0x1000); int ia = atoh(a); obraz_dysku = fopen("/ntfs_100M", "rb"); fseek(obraz_dysku, ia, SEEK_SET); fread(&buf, 0x1000, 1, obraz_dysku); fclose(obraz_dysku); MFT_RECORD *m = (MFT_RECORD *)buf; le16 ao = m->attrs_offset; char *para = (char *)&buf[ao]; ATTR_RECORD *ara=(ATTR_RECORD *)para; for(;;) { ATTR_RECORD *ara=(ATTR_RECORD *)para; if(ara->type == 0xffffffff) break; printf("DUMP ATTR RECORD:\n"); printf("\ttype:\t%x\n", ara->type); printf("\tlength:\t%x\n", ara->length); printf("\tnon_resident:\t%x\n", ara->non_resident); printf("\tname_length:\t%x\n", ara->name_length); printf("\tname_offset:\t%x\n", ara->name_offset); printf("\tflags:\t%x\n", ara->flags); printf("\tinstance:\t%x\n", ara->instance); printf("\n"); para=para+ara->length; } }
/******************************************************************************* 函数名称 : llb_control_inter_display 功能描述 : 显示帮助 输入参数 : void 输出参数 : 返 回 值 : void -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 修改目的 : 修改日期 : *******************************************************************************/ s32 llb_control_inter_display(s32 argc, s8** argv) { u32 callid; s32 sys_result; if(argc < 2) { return ERROR_FAIL; } if(strlen(argv[1]) != 10 || argv[1][0] != '0' || (argv[1][1] != 'x' && argv[1][1] != 'X')) { callid = 0; } else { callid = atoh((u8 *)argv[1], 10); } conplat_syscall(MODULEID_ADN_LLB, LLB_SHOW_INTERF, &callid, sizeof(u32), &sys_result); return ERROR_FAIL; }
int setdebug(void * pio) { #ifdef NPDEBUG char * cp; /* get an optional parameter */ cp = nextarg(((GEN_IO)pio)->inbuf); /* if no parameter was entered */ if (!*cp) { if (NDEBUG) { NDEBUG &= UPCTRACE; ns_printf(pio,"IP stack debug tracing off\n"); } else { NDEBUG |= INFOMSG|IPTRACE|PROTERR|TPTRACE; ns_printf(pio,"IP stack debug tracing on\n"); } } else { /* '?' means display NDEBUG value, else set NDEBUG flag to parameter value */ if (*cp != '?') { #ifdef IN_MENUS NDEBUG = atoh(cp); #endif } ns_printf(pio,"NDEBUG is now 0x%x\n",NDEBUG); } #else ns_printf(pio,"not a DEBUG compile.\n"); #endif return 0; }
int main() { int i,j; int round=0; //加密单位数(从低位加密计算,以word(2个Byte)为单位) int key_input=0; char text[2048]; //输入原文缓冲区 int KEY[4]; //输入密钥4组4bit int padNum=0; //填充位数(4bit为1个单位) int charNum=0; //输入原文位数(4bit为1个单位) int totalNum=0; //填充后原文位数(4bit一个单位) int plain[2048]; //输入带加密原文 int Z[2048]; int code[2048]; //生成的密文 //输入明文 printf("please input the plain text(16bit,in terms of hex):\n"); printf("example:if u want to encrypt \"0x12345\", please input 12345 \n"); //原文输入读作字符串后进行转换 fgets (text, 256, stdin); i=0; while(text[i]!='\0') { i++; } charNum=i-1; printf("charNum = %d\n", charNum); printf("text: %s\n", text); //输入密钥 printf("please input the key(16bit, in terms of hex):\n"); printf("example:if u want to using key \"0x1234\", please input 1234 \n"); scanf("%x", &key_input); key_input= 0x1234; printf("key: %x\n", key_input); //将16bit的key_input分成四组4bit数据,然后赋值给KEY[i] for(i=0; i<4; i++) { KEY[i]=( key_input>>(4*i) )& 0x0f; //printf("key[%d] = %x \n", i, KEY[i]); } //输入加密轮数 printf("\nplease input the number of encrypt words(integer,if enter 0 means encypte all words): "); scanf("%d",&round); printf("encrypt the last %d words\n", round); if(charNum %4) { padNum = 4- charNum%4; } else { padNum=0; } totalNum = charNum + padNum; printf("padNum %d, totalNum %d\n", padNum, totalNum); //将16进制输入的text字符串分成四组4bit数据(两个word), //如果不够,高位需补足添零。然后赋值给plain[i] //清零初始化 for(i=0; i<2048; i++) { plain[i]=0; code[i]=0; } //高位补零操作 j=0; for(i=charNum-1; i>=0; i--) { plain[i]= atoh(text[j]); j++; } for(j= charNum; j< totalNum; j++) { plain[j]=0; } #if 0 for(i=0; i< totalNum; i++) { printf("plain[%d] = %x \n", i, plain[i]); } #endif if(round==0 || round>totalNum/4) { round = totalNum/4; } word_encrypt(round, KEY, plain, code, Z); printf("test:\n"); for(i=totalNum-1; i>=0; i--) { printf("%x", code[i]); } return 0; }
//$GPRMC,225446.000,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68\r\n // 0 1 2 3 4 5 6 7 // 0123456789012345678901234567890123456789012345678901234567890123456789012 // 0 1 2 3 4 5 6 7 8 9 10 11 12 void parseGPSdata(char *gpsBuffer) { time_t tNow; tmElements_t tm; uint8_t gpsCheck1, gpsCheck2; // checksums // char gpsTime[10]; // time including fraction hhmmss.fff char gpsFixStat; // fix status // char gpsLat[7]; // ddmm.ff (with decimal point) // char gpsLatH; // hemisphere // char gpsLong[8]; // dddmm.ff (with decimal point) // char gpsLongH; // hemisphere // char gpsSpeed[5]; // speed over ground // char gpsCourse[5]; // Course // char gpsDate[6]; // Date // char gpsMagV[5]; // Magnetic variation // char gpsMagD; // Mag var E/W // char gpsCKS[2]; // Checksum without asterisk char *ptr; uint32_t tmp; if ( strncmp( gpsBuffer, "$GPRMC,", 7 ) == 0 ) { //Serial.println("parseGPSData"); //Serial.println(gpsBuffer); //beep(1000, 1); //Calculate checksum from the received data ptr = &gpsBuffer[1]; // start at the "G" gpsCheck1 = 0; // init collector /* Loop through entire string, XORing each character to the next */ while (*ptr != '*') // count all the bytes up to the asterisk { gpsCheck1 ^= *ptr; ptr++; if (ptr>(gpsBuffer+GPSBUFFERSIZE)) goto GPSerror1; // extra sanity check, can't hurt... } // now get the checksum from the string itself, which is in hex gpsCheck2 = atoh(*(ptr+1)) * 16 + atoh(*(ptr+2)); if (gpsCheck1 == gpsCheck2) { // if checksums match, process the data //beep(1000, 1); ptr = strtok(gpsBuffer, ",*\r"); // parse $GPRMC if (ptr == NULL) goto GPSerror1; ptr = strtok(NULL, ",*\r"); // Time including fraction hhmmss.fff if (ptr == NULL) goto GPSerror1; if ((strlen(ptr) < 6) || (strlen(ptr) > 10)) goto GPSerror1; // check time length // strncpy(gpsTime, ptr, 10); // copy time string hhmmss tmp = parsedecimal(ptr); // parse integer portion tm.Hour = tmp / 10000; tm.Minute = (tmp / 100) % 100; tm.Second = tmp % 100; ptr = strtok(NULL, ",*\r"); // Status if (ptr == NULL) goto GPSerror1; gpsFixStat = ptr[0]; if (gpsFixStat == 'A') { // if data valid, parse time & date gpsTimeout = 0; // reset gps timeout counter ptr = strtok(NULL, ",*\r"); // Latitude including fraction if (ptr == NULL) goto GPSerror1; // strncpy(gpsLat, ptr, 7); // copy Latitude ddmm.ff ptr = strtok(NULL, ",*\r"); // Latitude N/S if (ptr == NULL) goto GPSerror1; // gpsLatH = ptr[0]; ptr = strtok(NULL, ",*\r"); // Longitude including fraction hhmm.ff if (ptr == NULL) goto GPSerror1; // strncpy(gpsLong, ptr, 7); ptr = strtok(NULL, ",*\r"); // Longitude Hemisphere if (ptr == NULL) goto GPSerror1; // gpsLongH = ptr[0]; ptr = strtok(NULL, ",*\r"); // Ground speed 000.5 if (ptr == NULL) goto GPSerror1; // strncpy(gpsSpeed, ptr, 5); ptr = strtok(NULL, ",*\r"); // Track angle (course) 054.7 if (ptr == NULL) goto GPSerror1; // strncpy(gpsCourse, ptr, 5); ptr = strtok(NULL, ",*\r"); // Date ddmmyy if (ptr == NULL) goto GPSerror1; // strncpy(gpsDate, ptr, 6); if (strlen(ptr) != 6) goto GPSerror1; // check date length tmp = parsedecimal(ptr); tm.Day = tmp / 10000; tm.Month = (tmp / 100) % 100; tm.Year = tmp % 100; ptr = strtok(NULL, "*\r"); // magnetic variation & dir if (ptr == NULL) goto GPSerror1; if (ptr == NULL) goto GPSerror1; ptr = strtok(NULL, ",*\r"); // Checksum if (ptr == NULL) goto GPSerror1; // strncpy(gpsCKS, ptr, 2); // save checksum chars tm.Year = y2kYearToTm(tm.Year); // convert yy year to (yyyy-1970) (add 30) tNow = makeTime(&tm); // convert to time_t if ((tGPSupdate>0) && (abs(tNow-tGPSupdate)>SECS_PER_DAY)) goto GPSerror2; // GPS time jumped more than 1 day if ((tm.Second == 0) || ((tNow - tGPSupdate)>=60)) { // update RTC once/minute or if it's been 60 seconds //beep(1000, 1); // debugging g_gps_updating = true; tGPSupdate = tNow; // remember time of this update tNow = tNow + (long)(g_TZ_hour + g_DST_offset) * SECS_PER_HOUR; // add time zone hour offset & DST offset if (g_TZ_hour < 0) // add or subtract time zone minute offset tNow = tNow - (long)g_TZ_minute * SECS_PER_HOUR; else tNow = tNow + (long)g_TZ_minute * SECS_PER_HOUR; setRTCTime(tNow); // set RTC from adjusted GPS time & date } else g_gps_updating = false; } // if fix status is A } // if checksums match else // checksums do not match g_gps_cks_errors++; // increment error count return; GPSerror1: g_gps_parse_errors++; // increment error count goto GPSerror2a; GPSerror2: g_gps_time_errors++; // increment error count GPSerror2a: //beep(2093,1); // error signal - I'm leaving this in for now /wm //flash_display(200); // flash display to show GPS error strcpy(gpsBuffer, ""); // wipe GPS buffer } // if "$GPRMC" }
void doirq(void) { #if RTCDIS==1 char time[7]; char buf[32], *p[9]; int i; #endif switch(get_intoffset()) { case 5: #if EINT==1 if(get_eintpend(11)) { beeper_off(); #if TIME==1 timer_stop(); #endif clear_eintpend(11); } clear_srcpnd(5); #endif break; case 14: beeper_on_off(); clear_srcpnd(14); break; case 28: #if RTCDIS==1 if(get_subsrcpend(0)) { gets(buf); buf[strlen(buf)-2] = '\0'; p[0] = strtok(buf, " "); for(i=1; p[i-1]!=NULL; i++) { p[i] = strtok(NULL, " "); } #if RTCSET==1 if(strcmp(p[0], "timeset") == 0) { time[0] = atoh(p[1]); time[1] = atoh(p[2]); time[2] = atoh(p[3]); time[3] = atoh(p[4]); time[4] = atoh(p[5]); time[5] = atoh(p[6]); time[6] = atoh(p[7]); rtc_init(time); } #endif if(strcmp(p[0], "alarmset") == 0) { time[0] = atoh(p[1]); time[1] = atoh(p[2]); time[2] = atoh(p[3]); time[3] = atoh(p[4]); time[4] = atoh(p[5]); time[5] = atoh(p[6]); #if ALARM==1 alarm_init(time); #endif } clear_subsrcpend(0); } clear_srcpnd(28); #endif break; case 30: #if ALARM==1 beeper_on(); #if TIME==1 timer_update(); #endif clear_srcpnd(28); #endif break; } clear_intpnd(); }
int inet_pton(int af, const char * src, void * dst) { /* * Altera modification: * Conditionally declare variables to remove build warning */ #if defined(IP_V6) const char * cp; /* char after previous colon */ unshort * dest; /* word pointer to dst */ int colons; /* number of colons in src */ int words; /* count of words written to dest */ #endif #if defined(IP_V4) || defined(MINI_IP) /* RFC 2133 wants us to support both types of address */ if(af == AF_INET) /* wants a v4 address */ { u_long ip4addr; unsigned sbits; char * err; err = parse_ipad(&ip4addr, &sbits, (char *) src); if(err == NULL) { /* copy the parsed address into caller's buffer, and * return success */ MEMCPY(dst, &ip4addr, sizeof (u_long)); return 0; } else { /* return failure */ pton_error = "IPv4 address parse failure"; return 1; } } #endif /* IP_V4 */ #ifdef IP_V6 if(af != AF_INET6) { pton_error = "bad domain"; return -1; } /* count the number of colons in the address */ cp = src; colons = 0; while(*cp) if(*cp++ == ':') colons++; if(colons < 2 || colons > 7) { pton_error = "must have 2-7 colons"; return 1; } /* loop through address text, parseing 16-bit chunks */ cp = src; dest = dst; words = 0; if(*cp == ':') /* leading colon has implied zero, e.g. "::1" */ { *dest++ = 0; words++; cp++; /* bump past leading colon, eg ":!" */ } while(*cp > ' ') { if(words >= 8) { /* !!!??? */ dprintf("*** inet_pton: logic error?\n"); dtrap(); /* logic error? */ pton_error = "internal"; return 1; } if(*cp == ':') /* found a double-colon? */ { int i; for(i = (8 - colons); i > 0; i--) { *dest++ = 0; /* add zeros to dest address */ words++; /* count total words */ } cp++; /* bump past double colon */ if(*cp <= ' ') /* last colon was last char? */ { *dest++ = 0; /* add one final zero */ words++; /* count total words */ } } else { unshort wordval; wordval = htons(atoh(cp)); /* get next 16 bit word */ if((wordval == 0) && (*cp != '0')) /* check format */ { pton_error = "must be hex numbers or colons"; return 1; } *dest++ = wordval; words++; /* count total words set in dest */ cp = strchr((char *)cp, ':'); /* find next colon */ if(cp) /* bump past colon */ cp++; else /* no more colons? */ break; /* done with parsing */ } } if(words != 8) { pton_error = "too short - missing colon?"; return 1; } #endif /* IP_V6 */ return 0; }
/**************************************************************************** Function : hexWrite Description : Writes (and optionally verifies) currently-open hex file to UBW32 device. Parameters : char Verify (1) vs. write (0). Returns : ErrorCode ERR_NONE on success, else various other values as defined in ubw32.h. Notes : UBW32 device and hex file are both assumed already open and valid; no checks performed here. ****************************************************************************/ ErrorCode hexWrite(const char verify) { char *ptr,pass; ErrorCode status; int checksum,i,end,offset; short bufLen; unsigned int len,type,addrHi,addrLo,addr32,addrSave; for(pass=0;pass<=verify;pass++) { offset = 0; /* Start at beginning of hex file */ bufLen = 0; /* Hex buffer initially empty */ addrHi = 0; /* Initial address high bits */ addrSave = 0; /* PIC start addr for hex buffer contents */ addr32 = 0; if(pass) (void)printf("\nVerifying:"); for(;;) { /* Each line in file */ /* Line start contains length, 16-bit address and type */ if(3 != sscanf(&hexFileData[offset],":%02x%04x%02x", &len,&addrLo,&type)) return ERR_HEX_SYNTAX; /* Position of %02x checksum at end of line */ end = offset + 9 + len * 2; /* Verify checksum on first (write) pass */ if(!pass) { for(checksum = 0,i = offset + 1;i < end; checksum = (checksum + (0x100 - atoh(i))) & 0xff,i += 2); if(atoh(end) != checksum) return ERR_HEX_CHECKSUM; } /* Process different hex record types. Using if/else rather than a switch in order to better handle EOF cases (allows simple 'break' rather than goto or other nasties). */ if(0 == type) { /* Data record */ /* If new record address is not contiguous with prior record, issue accumulated hex data (if any) and start anew. */ if((addrHi + addrLo) != addr32) { addr32 = addrHi + addrLo; if(bufLen) { if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass))) return status; bufLen = 0; } addrSave = addr32; } /* Parse bytes from line into hexBuf */ for(i = offset + 9;i < end;i += 2) { hexBuf[bufLen++] = atoh(i); /* Add to hex buffer */ /* If buffer is full, issue block and start anew */ if(sizeof(hexBuf) == bufLen) { if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass))) return status; bufLen = 0; } /* Increment address, wraparound as per hexfile spec */ if(0xffffffff == addr32) { /* Wraparound. If any hex data, issue and start anew. */ if(bufLen) { if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass))) return status; bufLen = 0; } addr32 = 0; } else { addr32++; } /* If issueBlock() used, save new address for next block */ if(!bufLen) addrSave = addr32; } } else if(1 == type) { /* EOF record */ break; } else if(4 == type) { /* Extended linear address record */ if(1 != sscanf(&hexFileData[offset+9],"%04x",&addrHi)) return ERR_HEX_SYNTAX; addrHi <<= 16; addr32 = addrHi + addrLo; /* Assume this means a noncontiguous address jump; issue block and start anew. The prior noncontiguous address code should already have this covered, but in the freak case of an extended address record with no subsequent data, make sure the last of the data is issued. */ if(bufLen) { if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass))) return status; bufLen = 0; addrSave = addr32; } } else { /* Unsupported record type */ return ERR_HEX_RECORD; } /* Advance to start of next line (skip CR/LF/etc.), unless EOF */ if(NULL == (ptr = strchr(&hexFileData[end+2],':'))) break; offset = ptr - hexFileData; } /* At end of file, issue any residual data (counters reset at top) */ if(bufLen && (ERR_NONE != (status = issueBlock(addrSave,bufLen,pass)))) return status; /* Make sure last data is flushed (issueBlock() does this automatically if less than 56 bytes...but if the last packet is exactly this size, an explicit flush is done here). */ if(!pass && (bufLen == 56)) { DEBUGMSG("Completing"); usbBuf[0] = PROGRAM_COMPLETE; if(ERR_NONE != (status = usbWrite(1,0))) return status; } #ifdef DEBUG (void)printf("PASS %d of %d COMPLETE\n",pass,verify); #endif } return ERR_NONE; }
int evb_resource_dump_write(struct file *file, const char *buffer, unsigned long count, void *data) { /* Reading / Writing from system controller internal registers */ if (!strncmp(buffer, "register", 8)) { if (buffer[10] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = MV_REG_READ(evb_resource_dump_request); } if (buffer[10] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 12 + 8 + 1), 8); MV_REG_WRITE(evb_resource_dump_request, evb_resource_dump_result); } } /* Reading / Writing from 32bit address - mostly usable for memory */ if (!strncmp(buffer, "memory ", 8)) { if (buffer[10] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = *(unsigned int *)evb_resource_dump_request; } if (buffer[10] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 12 + 8 + 1), 8); *(unsigned int *)evb_resource_dump_request = evb_resource_dump_result; } } /* Reading / Writing from a rgister via SMI */ if (!strncmp(buffer, "smi", 3)) { unsigned short regVal; unsigned int dev_addr = atoh((char *)((unsigned int)buffer + 7), 8); if (buffer[5] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8); regVal = 0; mvEthPhyRegRead(dev_addr, evb_resource_dump_request, ®Val); evb_resource_dump_result = (u32) regVal; } if (buffer[5] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8); evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 7 + 8 + 8 + 2), 8); mvEthPhyRegWrite(dev_addr, evb_resource_dump_request, (u16) evb_resource_dump_result); } } #ifdef CONFIG_MV_CPU_PERF_CNTRS if (!strncmp(buffer, "start_cc", 8)) { int cc0, cc1, cc2, cc3; sscanf((char *)((unsigned int)buffer + 8), "%d %d %d %d", &cc0, &cc1, &cc2, &cc3); mv_proc_start_cntrs(cc0, cc1, cc2, cc3); } if (!strncmp(buffer, "show__cc", 8)) mv_proc_show_cntrs(); #endif /* */ #ifdef CONFIG_MV_CPU_L2_PERF_CNTRS if (!strncmp(buffer, "start_l2", 8)) { int l20, l21; sscanf((char *)((unsigned int)buffer + 8), "%d %d", &l20, &l21); mv_proc_start_l2_cntrs(l20, l21); } if (!strncmp(buffer, "show__l2", 8)) mv_proc_show_l2_cntrs(); #endif /* */ #ifdef CONFIG_MV_DRAM_STATS_CNTRS if (!strncmp(buffer, "start_dram_stats", strlen("start_dram_stats"))) { int mode0, mode1; sscanf((char *)((unsigned int)buffer + strlen("start_dram_stats")), "%d %d", &mode0, &mode1); mv_proc_start_dram_stats_cntrs(mode0, mode1); } if (!strncmp(buffer, "stop_dram_stats", strlen("stop_dram_stats"))) mvDramStatStop(); if (!strncmp(buffer, "show_dram_stats", strlen("show_dram_stats"))) mv_proc_show_dram_stats_cntrs(); #endif /* */ if (!strncmp(buffer, "idle_wfi", strlen("idle_wfi"))) { int en; sscanf((char *)((unsigned int)buffer + strlen("idle_wfi")), "%d", &en); support_wait_for_interrupt = en; } if (!strncmp(buffer, "show__ua", 8)) { if (kernel_align == 1) kernel_align = 0; else kernel_align = 1; printk(KERN_INFO "debug kernel align %d\n", kernel_align); } if (!strncmp(buffer, "cpu_freq", strlen("cpu_freq"))) { buffer += strlen("cpu_freq") + 1; if (!strncmp(buffer, "normal", strlen("normal"))) { printk(KERN_INFO "Entering fast mode.\n"); mvCtrlPwrSaveOff(); } else if (!strncmp(buffer, "ddr", strlen("ddr"))) { printk(KERN_INFO "Entering slow mode.\n"); mvCtrlPwrSaveOn(); } } #if 0 if (!strncmp(buffer, "ddd", 3)) { unsigned int ii[10]; int ip, sum = 0; volatile unsigned int *tt = (unsigned int *)((unsigned int)ii + 2); MV_CPU_CNTRS_EVENT *hal_rx_event = NULL; /* 0 - instruction counters */ mvCpuCntrsProgram(0, MV_CPU_CNTRS_INSTRUCTIONS, "Instr", 25); /* 1 - ICache misses counter */ mvCpuCntrsProgram(1, MV_CPU_CNTRS_ICACHE_READ_MISS, "IcMiss", 0); /* 2 - cycles counter */ mvCpuCntrsProgram(2, MV_CPU_CNTRS_CYCLES, "Cycles", 21); /* 3 - DCache read misses counter */ mvCpuCntrsProgram(3, MV_CPU_CNTRS_DCACHE_READ_MISS, "DcRdMiss", 0); hal_rx_event = mvCpuCntrsEventCreate("HAL_RX", 1); MV_CPU_CNTRS_START(hal_rx_event); for (ip = 0; ip < 1000; ip++) sum += *tt; MV_CPU_CNTRS_STOP(hal_rx_event); MV_CPU_CNTRS_SHOW(hal_rx_event); } #endif /* */ return count; }
int Inet6Pton(char * src, void * dst) { char * cp; /* char after previous colon */ A_UINT16 * dest; /* word pointer to dst */ int colons; /* number of colons in src */ int words; /* count of words written to dest */ /* count the number of colons in the address */ cp = src; colons = 0; while(*cp) { if(*cp++ == ':') colons++; } if(colons < 2 || colons > 7) { /* printf("must have 2-7 colons");*/ return 1; } /* loop through address text, parseing 16-bit chunks */ cp = src; dest = dst; words = 0; if(*cp == ':') /* leading colon has implied zero, e.g. "::1" */ { *dest++ = 0; words++; cp++; /* bump past leading colon, eg ":!" */ } while(*cp > ' ') { if(words >= 8) { printf("*** inet_pton: logic error?\n"); return 1; } if(*cp == ':') /* found a double-colon? */ { int i; for(i = (8 - colons); i > 0; i--) { *dest++ = 0; /* add zeros to dest address */ words++; /* count total words */ } cp++; /* bump past double colon */ if(*cp <= ' ') /* last colon was last char? */ { *dest++ = 0; /* add one final zero */ words++; /* count total words */ } } else { A_UINT16 wordval; A_UINT16 temp; wordval = atoh(cp); temp = wordval; wordval = htons(temp); /* get next 16 bit word */ if((wordval == 0) && (*cp != '0')) /* check format */ { printf("must be hex numbers or colons \n"); return 1; } *dest++ = wordval; words++; /* count total words set in dest */ cp = swat_strchr((char *)cp, ':'); /* find next colon */ if(cp) /* bump past colon */ cp++; else /* no more colons? */ break; /* done with parsing */ } } if(words != 8) { printf("too short - missing colon?\n"); return 1; } return 0; }
int evb_resource_dump_write (struct file *file, const char *buffer, unsigned long count, void *data) { /* Reading / Writing from system controller internal registers */ if (!strncmp (buffer , "register" , 8)) { if (buffer[10] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12),8); evb_resource_dump_result = MV_REG_READ(evb_resource_dump_request); } if (buffer[10] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 12 + 8 + 1) , 8); MV_REG_WRITE (evb_resource_dump_request , evb_resource_dump_result); } } /* Reading / Writing from 32bit address - mostly usable for memory */ if (!strncmp (buffer , "memory " , 8)) { if (buffer[10] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12),8); evb_resource_dump_result = *(unsigned int *)evb_resource_dump_request; } if (buffer[10] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8); evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 12 + 8 + 1) , 8); * (unsigned int *) evb_resource_dump_request = evb_resource_dump_result; } } #if (defined (CONFIG_MV_ETHERNET) || defined (CONFIG_MV_GATEWAY)) && !defined(CONFIG_GTW_LOADABLE_DRV) /* Reading / Writing from a rgister via SMI */ if (!strncmp (buffer , "smi" , 3)) { unsigned int dev_addr = atoh((char *)((unsigned int)buffer + 7),8); if (buffer[5] == 'r') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1),8); evb_resource_dump_result = 0; #if defined (CONFIG_MV_ETHERNET) mv_eth_read_mii(dev_addr, evb_resource_dump_request, &evb_resource_dump_result); #elif defined (CONFIG_MV_GATEWAY) mv_gtw_read_mii(NULL, dev_addr, evb_resource_dump_request, &evb_resource_dump_result); #endif } if (buffer[5] == 'w') { evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8); evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 7 + 8 + 8 + 2) , 8); #if defined (CONFIG_MV_ETHERNET) mv_eth_write_mii(dev_addr, evb_resource_dump_request , evb_resource_dump_result); #elif defined (CONFIG_MV_GATEWAY) mv_gtw_write_mii(NULL, dev_addr, evb_resource_dump_request , evb_resource_dump_result); #endif } } #endif #ifdef CONFIG_MV_CPU_PERF_CNTRS if (!strncmp (buffer , "start_cc" , 8)) { int cc0, cc1, cc2, cc3; sscanf( (char *)((unsigned int)buffer + 8),"%d %d %d %d",&cc0, &cc1, &cc2, &cc3 ); mv_proc_start_cntrs(cc0, cc1, cc2, cc3); } if (!strncmp (buffer , "show__cc" , 8)) { mv_proc_show_cntrs(); } #endif #ifdef CONFIG_MV_CPU_L2_PERF_CNTRS if (!strncmp (buffer , "start_l2" , 8)) { int l20, l21; sscanf( (char *)((unsigned int)buffer + 8),"%d %d",&l20, &l21); mv_proc_start_l2_cntrs(l20, l21); } if (!strncmp (buffer , "show__l2" , 8)) { mv_proc_show_l2_cntrs(); } #endif if(!strncmp (buffer , "show__ua" , 8)) { if (kernel_align == 1) kernel_align = 0; else kernel_align =1; printk("debug kernel align %d\n",kernel_align); } #if 0 if(!strncmp (buffer , "ddd", 3)) { unsigned int ii[10]; int ip, sum = 0; volatile unsigned int *tt = (unsigned int*)((unsigned int)ii + 2); MV_CPU_CNTRS_EVENT* hal_rx_event = NULL; /* 0 - instruction counters */ mvCpuCntrsProgram(0, MV_CPU_CNTRS_INSTRUCTIONS, "Instr", 25); /* 1 - ICache misses counter */ mvCpuCntrsProgram(1, MV_CPU_CNTRS_ICACHE_READ_MISS, "IcMiss", 0); /* 2 - cycles counter */ mvCpuCntrsProgram(2, MV_CPU_CNTRS_CYCLES, "Cycles", 21); /* 3 - DCache read misses counter */ mvCpuCntrsProgram(3, MV_CPU_CNTRS_DCACHE_READ_MISS, "DcRdMiss", 0); hal_rx_event = mvCpuCntrsEventCreate("HAL_RX", 1); MV_CPU_CNTRS_START(hal_rx_event); for(ip = 0; ip < 1000; ip++) sum += *tt; MV_CPU_CNTRS_STOP(hal_rx_event); MV_CPU_CNTRS_SHOW(hal_rx_event); } #endif return count; }
int main(int argc, char* argv[]){ FILE* pfo; FILE* pfi; int nCnt, address; int shift_bit = 1; int shift_cnt = 0; char* s; char str[100]; char buf[BUF_SIZE]; char c; strcpy(input_file, default_input_file); strcpy(output_file, default_output_file); //コマンドライン入力を解析 for(nCnt = 1 ; nCnt < argc ; nCnt++){ s = argv[nCnt]; if(*s++ == '-'){ c = *s; while(*s != 0){ if(*s == ':') break; s++; } if(*s++ == ':'){ switch(c){ //output file name case 'O': case 'o': strcpy(output_file, s); break; //input file name case 'R': case 'r': strcpy(input_file, s); break; default: printf("tlcs900offset -R:input_file -O:output_file\n"); break; } } } } //input, outputファイル名の標準出力 printf("input file = %s\n", input_file); printf("output file = %s\n", output_file); if((pfi = fopen(input_file, "r")) == NULL){ fprintf(stderr, "can't open input file!"); exit(1); } if((pfo = fopen(output_file, "w")) == NULL){ fclose(pfi); fprintf(stderr, "can't open output file!"); exit(1); } //inputファイルの取り込み for(;;){ if((fgets(buf, BUF_SIZE, pfi)) == NULL) break; s = buf; switch(offset_state){ //; BEGIN TCB_texptnの範囲の解析 case TEXPTN_STATE: if(test_string(&s, "; END")){ offset_state = NORMAL_STATE; continue; } if(test_string(&s, "line") || test_string(&s, "call")) continue; if(skip_char(&s, 'x')){ continue; } get_num(s); address = atoh(s); printf("TCB_texptn\tequ\t%d\n",address); fputs("TCB_texptn\t\tequ\t", pfo); sprintf(str,"%d",address); fputs(str, pfo); fputs(lf, pfo); break; case SP_STATE: //; BEGIN TCB_spの範囲の解析 if(test_string(&s, "; END")){ offset_state = NORMAL_STATE; continue; } if(test_string(&s, "line") || test_string(&s, "call") ) continue; if(skip_space(&s)) continue; if(skip_char(&s, '(')){ continue; } if(skip_char(&s, 'x')){ continue; } get_num(s); address = atoh(s); printf("TCB_sp\t\tequ\t%d\n",address); fputs("TCB_sp\t\t\tequ\t", pfo); sprintf(str,"%d",address); fputs(str, pfo); fputs(lf, pfo); break; case PC_STATE: //; BEGIN TCB_pcの範囲の解析 if(test_string(&s, "; END")){ offset_state = NORMAL_STATE; continue; } if(test_string(&s, "line") || test_string(&s, "call")) continue; if(skip_char(&s, 'x')){ continue; } get_num(s); address = atoh(s); printf("TCB_pc\tequ\t%d\n",address); fputs("TCB_pc\t\t\tequ\t", pfo); sprintf(str,"%d",address); fputs(str, pfo); fputs(lf, pfo); break; case ENATEX_STATE: //; BEGIN TCB_pcの範囲の解析 if(test_string(&s, "; END")){ offset_state = NORMAL_STATE; continue; } if(test_string(&s, "line") || test_string(&s, "call")) continue; if(skip_char(&s, 'x')){ continue; } get_num(s); address = atoh(s); printf("TCB_enatex\tequ\t%d\n",address); fputs("TCB_enatex\t\tequ\t", pfo); sprintf(str,"%d",address); fputs(str, pfo); fputs(lf, pfo); get_num_undo(s); if(skip_char(&s, ',')){ continue; } *(s + BIT_SIZE) = '\0'; printf("TCB_enatex_mask\tequ\t%s\n",s); fputs("TCB_enatex_mask\tequ\t", pfo); fputs(s, pfo); fputs(lf, pfo); if(skip_char(&s, 'x')){ continue; } address = atoh(s); for(shift_cnt=0;shift_cnt<=16;shift_cnt++){ if(address == shift_bit){ printf("TCB_enatex_bit\tequ\t%d\n",shift_cnt); fputs("TCB_enatex_bit\tequ\t", pfo); sprintf(str,"%d",shift_cnt); fputs(str, pfo); fputs(lf, pfo); } shift_bit<<=1; } break; default: if(test_string(&s, "; BEGIN TCB_texptn")){ offset_state = TEXPTN_STATE; continue; }else if(test_string(&s, "; BEGIN TCB_sp")){ offset_state = SP_STATE; continue; }else if(test_string(&s, "; BEGIN TCB_pc")){ offset_state = PC_STATE; continue; }else if(test_string(&s, "; BEGIN TCB_enatex")){ offset_state = ENATEX_STATE; continue; } break; } } return 0; }