//* This function changes hex char[4] to uint16_t. void HexToByte_4(char *hexstring_4, uint16_t *byte) { char tempp[2]; uint8_t right_dec = 0; uint8_t left_dec = 0; uint16_t right_dec16 = 0; uint16_t left_dec16 = 0; tempp[0] = hexstring_4[0]; tempp[1] = hexstring_4[1]; HexToByte(tempp,&left_dec); tempp[0] = hexstring_4[2]; tempp[1] = hexstring_4[3]; HexToByte(tempp,&right_dec); left_dec16 = left_dec16 | left_dec; right_dec16 = right_dec16 | right_dec; *byte = (left_dec16 << 8) | right_dec16; }
char* Decrypt(const char* szSource, const char* szPassWord) // 解密,返回解密结果 { if(szSource == NULL || (strlen(szSource)%2 != 0) || szPassWord == NULL) return NULL; unsigned char* src = HexToByte(szSource); unsigned char* ret = new unsigned char[strlen(szSource) / 2 + 1]; int ret_len = 0; memset(ret, (int)strlen(szSource) / 2 + 1,0); if(RC4(src, (int)strlen(szSource) / 2, (unsigned char*)szPassWord, (int)strlen(szPassWord), ret, &ret_len) != 0) return NULL; ret[ret_len] = '\0'; return (char*)ret; }
static bool ParseSha1(const CXmlItem &item, const char *name, Byte *digest) { int index = item.FindSubTag(name); if (index < 0) return false; const CXmlItem &checkItem = item.SubItems[index]; AString style = checkItem.GetPropertyValue("style"); if (style == "SHA1") { AString s = checkItem.GetSubString(); if (s.Length() != 40) return false; for (int i = 0; i < s.Length(); i += 2) { Byte b0, b1; if (!HexToByte(s[i], b0) || !HexToByte(s[i + 1], b1)) return false; digest[i / 2] = (b0 << 4) | b1; } return true; } return false; }
uint8_t GetLRC(char *frame) { uint8_t LRCsum = 0; char temp[2]; uint8_t TempSum; frame++; while(*frame) { temp[0] = *frame++; temp[1] = *frame++; HexToByte(temp, &TempSum); LRCsum += TempSum; } LRCsum = (~(LRCsum)+1); return LRCsum; }
//Illegal value in querry frame void ErrorMessage(uint8_t ErrorCode) { char OutputFrame[OFS]; // output frame char temp[2]; uint8_t FunC; uint8_t ErrFuncCode; uint8_t k; //Clears table for(k = 0; k<OFS; k++){OutputFrame[k] = '\0';} //Rewrite first chars RewritingChars(OutputFrame,0,2); //Read Function Code from message temp[0] = word[3]; temp[1] = word[4]; HexToByte(temp, &FunC); //Calculate Function Code for Message with Error ErrFuncCode = FunC + 80; ByteToHex(temp,ErrFuncCode); OutputFrame[3] = temp[0]; OutputFrame[4] = temp[1]; //Fill Data field with ILLEGAL FUNCTION CODE ByteToHex(temp,ErrorCode); OutputFrame[5] = temp[0]; OutputFrame[6] = temp[1]; //* Writes LRC. ByteToHex(temp,GetLRC(OutputFrame)); OutputFrame[7] = temp[0]; OutputFrame[8] = temp[1]; OutputFrame[9] = 0x0D; OutputFrame[10] = 0x0A; OutputFrame[11] = 0x0A; //sending frame UART_SendStr(OutputFrame); }
UnicodeString TCopyParamType::RestoreChars(const UnicodeString & AFileName) const { UnicodeString FileName = AFileName; if (GetInvalidCharsReplacement() == TokenReplacement) { wchar_t * InvalidChar = const_cast<wchar_t *>(FileName.c_str()); while ((InvalidChar = wcschr(InvalidChar, TokenPrefix)) != nullptr) { intptr_t Index = InvalidChar - FileName.c_str() + 1; if (FileName.Length() >= Index + 2) { UnicodeString Hex = FileName.SubString(Index + 1, 2); wchar_t Char = static_cast<wchar_t>(HexToByte(Hex)); if ((Char != L'\0') && ((FTokenizibleChars.Pos(Char) > 0) || (((Char == L' ') || (Char == L'.')) && (Index == FileName.Length() - 2)))) { FileName[Index] = Char; FileName.Delete(Index + 1, 2); InvalidChar = const_cast<wchar_t *>(FileName.c_str() + Index); } else if ((Hex == L"00") && ((Index == FileName.Length() - 2) || (FileName[Index + 3] == L'.')) && IsReservedName(FileName.SubString(1, Index - 1) + FileName.SubString(Index + 3, FileName.Length() - Index - 3 + 1))) { FileName.Delete(Index, 3); InvalidChar = const_cast<wchar_t *>(FileName.c_str() + Index - 1); } else { InvalidChar++; } } else { InvalidChar++; } } } return FileName; }
//* If LRC in frame[] is correct returns 1, else 0. bool CheckLRC(char *frame) { uint8_t a = 0; uint8_t Sum; char tempByte[2]; uint8_t tempSum = 0; char temp[4]; uint8_t LRC_calculated = 0; uint8_t LRC_dec_from_frame = 0; //* counts chars in frame while(word[a] != '\r') { a++; } temp[1] = frame[a-1]; temp[0] = frame[a-2]; HexToByte(temp,&LRC_dec_from_frame); frame[a-1] = '\0'; frame[a-2] = '\0'; //* calculates LRC LRC_calculated = GetLRC(frame); if (LRC_calculated == LRC_dec_from_frame) { return 1; } else { return 0; } }
UCVarValue FBaseCVar::FromString (const char *value, ECVarType type) { UCVarValue ret; int i; switch (type) { case CVAR_Bool: if (stricmp (value, "true") == 0) ret.Bool = true; else if (stricmp (value, "false") == 0) ret.Bool = false; else ret.Bool = strtol (value, NULL, 0) != 0; break; case CVAR_Int: if (stricmp (value, "true") == 0) ret.Int = 1; else if (stricmp (value, "false") == 0) ret.Int = 0; else ret.Int = strtol (value, NULL, 0); break; case CVAR_Float: ret.Float = (float)strtod (value, NULL); break; case CVAR_String: ret.String = const_cast<char *>(value); break; case CVAR_GUID: // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} // 01234567890123456789012345678901234567 // 0 1 2 3 ret.pGUID = NULL; for (i = 0; i < 38; ++i) { if (value[i] == 0) { break; } bool goodv = true; switch (i) { case 0: if (value[i] != '{') goodv = false; break; case 9: case 14: case 19: case 24: if (value[i] != '-') goodv = false; break; case 37: if (value[i] != '}') goodv = false; break; default: if (value[i] < '0' && value[i] > '9' && value[i] < 'A' && value[i] > 'F' && value[i] < 'a' && value[i] > 'f') { goodv = false; } break; } } if (i == 38 && value[i] == 0) { cGUID.Data1 = strtoul (value + 1, NULL, 16); cGUID.Data2 = (WORD)strtoul (value + 10, NULL, 16); cGUID.Data3 = (WORD)strtoul (value + 15, NULL, 16); cGUID.Data4[0] = HexToByte (value + 20); cGUID.Data4[1] = HexToByte (value + 22); cGUID.Data4[2] = HexToByte (value + 25); cGUID.Data4[3] = HexToByte (value + 27); cGUID.Data4[4] = HexToByte (value + 29); cGUID.Data4[5] = HexToByte (value + 31); cGUID.Data4[6] = HexToByte (value + 33); cGUID.Data4[7] = HexToByte (value + 35); ret.pGUID = &cGUID; } break; default: break; } return ret; }
//* FC16 This command writes the contents of analog output holding registers void ForceMultipleRegisters() { char OutputFrame[OFS]; uint8_t counter = 0; uint16_t Value=0; uint16_t FirstRegister; uint16_t NumberOfRegs; uint16_t Coil; uint8_t NumberOfDataBytes; char temp[2]; char temp4[4]; uint16_t n = 0; //Clears table for(n = 0; n<OFS; n++){OutputFrame[n] = '\0';} // rewrites slave's address & number of function RewritingChars(OutputFrame,0,12); //gets number of first coil temp4[0] = word[5]; temp4[1] = word[6]; temp4[2] = word[7]; temp4[3] = word[8]; HexToByte_4(temp4, &FirstRegister); //gets number of coils to written temp4[0] = word[9]; temp4[1] = word[10]; temp4[2] = word[11]; temp4[3] = word[12]; HexToByte_4(temp4, &NumberOfRegs); //gets the number of data bytes to follow temp[0] = word[13]; temp[1] = word[14]; HexToByte(temp, &NumberOfDataBytes); if(Check_DataAddr_F03_F04(FirstRegister, NumberOfRegs) & Check_DataVal_F16(NumberOfDataBytes)) { counter=15; for(n=0; n<(NumberOfDataBytes/2); n++) { temp4[0] = word[counter]; counter++; temp4[1] = word[counter]; counter++; temp4[2] = word[counter]; counter++; temp4[3] = word[counter]; counter++; HexToByte_4(temp4, &Value); Output_Registers[FirstRegister+n] = Value; } //* Writes LRC. counter = 13; ByteToHex(temp,GetLRC(OutputFrame)); OutputFrame[counter] = temp[0]; counter++; OutputFrame[counter] = temp[1]; counter++; OutputFrame[counter] = 0x0D; counter++; OutputFrame[counter] = 0x0A; counter++; OutputFrame[counter] = 0x0A; counter++; //sending frame UART_SendStr(OutputFrame); } }
static int Parse(const Byte *p) { int c1 = HexToByte(p[0]); if (c1 < 0) return -1; int c2 = HexToByte(p[1]); if (c2 < 0) return -1; return (c1 << 4) | c2; }
//----------------------------------------------------------------// void MOAITextFrame::Parse () { float xScaleAdvance = this->mRightToLeft ? -1.0f : 1.0f; this->mLineBottom = 0; this->mLineTop = 0; this->mLineCount = 0; this->mLineXMax = 0.0f; this->mTokenXMin = 0.0f; this->mTokenXMax = 0.0f; float points = this->mPoints; float lineHeight = this->mFont->GetLineSpacing () * this->mPoints * this->mLineSpacing; this->mTotalLines = ( u32 )floorf ( this->mFrame.Height () / lineHeight ); if ( !this->mTotalLines ) return; this->mPen.Init ( 0.0f, this->mFrame.mYMin ); u32 colorSize = 0; u8 color [ COLOR_MAX ]; u32 c = 0; this->mGlyph = 0; bool inToken = false; int resetIdx = 0; u32 state = META_START; while ( state != META_FINISH ) { switch ( state ) { //================================================================// // META //----------------------------------------------------------------// //----------------------------------------------------------------// // check to see if we've encountered a style escape case META_START: { resetIdx = this->mIdx; c = this->DecodeChar (); if ( c == 0 ) { this->FlushToken (); if ( this->mLineCount >= this->mTotalLines ) { TRANSITION ( META_FINISH ); } // save the cursor just before the EOF this->mCursor->mIndex = resetIdx; this->mCursor->mRGBA = this->mRGBA; this->FlushLine (); TRANSITION ( META_FINISH ); } TRANSITION_ON_MATCH ( '<', STYLE_START ); TRANSITION ( TEXT_START ); } //================================================================// // TEXT //----------------------------------------------------------------// //----------------------------------------------------------------// // process a single char as text (ignore style escape) case TEXT_START: { if ( c == '\n' ) { this->FlushToken (); inToken = false; if ( this->mLineCount >= this->mTotalLines ) { TRANSITION ( META_FINISH ); } this->mCursor->mIndex = resetIdx; this->mCursor->mRGBA = this->mRGBA; this->FlushLine (); this->mPen.mX = 0.0f; this->mTokenXMax = 0.0f; this->mTokenXMin = 0.0f; this->mGlyph = 0; TRANSITION ( META_START ); } const MOAIGlyph* prevGlyph = this->mGlyph; const MOAIGlyph* glyph = &this->mFont->GetGlyphForChar ( c ); this->mGlyph = glyph; assert ( glyph ); bool hasWidth = ( glyph->mWidth > 0.0f ); // apply kerning if ( prevGlyph ) { MOAIKernVec kernVec = prevGlyph->GetKerning ( glyph->mCode ); this->mPen.mX += kernVec.mX * points * xScaleAdvance; } if ( hasWidth ) { if ( inToken == false ) { // save the cursor just before the new token this->mCursor->mIndex = resetIdx; this->mCursor->mRGBA = this->mRGBA; this->mTokenXMin = this->mPen.mX; this->mTokenXMax = this->mPen.mX; inToken = true; } // push the glyph float penX = this->mPen.mX + (( glyph->mWidth + glyph->mBearingX ) * points * xScaleAdvance ); float glyphX = this->mRightToLeft ? penX : this->mPen.mX; this->mLayout->PushGlyph ( glyph, resetIdx, glyphX, 0.0f, points, this->mRGBA ); this->mTokenXMax = penX; } else if ( inToken ) { this->FlushToken (); // bail if line count overflow if ( this->mLineCount >= this->mTotalLines ) { TRANSITION ( META_FINISH ); } inToken = false; } // advance the pen this->mPen.mX += glyph->mAdvanceX * points * xScaleAdvance; // back to start TRANSITION ( META_START ); } //================================================================// // STYLE //----------------------------------------------------------------// //----------------------------------------------------------------// // see which style we're parsing case STYLE_START: { c = this->DecodeChar (); TRANSITION_ON_MATCH ( 'c', COLOR_START ); TRANSITION ( STYLE_ABORT ); } // reset the cursor and go directly to text mode case STYLE_ABORT: { this->mIdx = resetIdx; c = this->DecodeChar (); TRANSITION ( TEXT_START ); } //================================================================// // COLOR //----------------------------------------------------------------// //----------------------------------------------------------------// case COLOR_START: { colorSize = 0; c = this->DecodeChar (); if ( IsWhitespace ( c )) continue; if ( c == ':' ) { state = COLOR_BODY; break; } TRANSITION_ON_MATCH ( ':', COLOR_BODY ); TRANSITION_ON_MATCH ( '>', COLOR_FINISH ); TRANSITION ( STYLE_ABORT ); } //----------------------------------------------------------------// case COLOR_BODY: { c = this->DecodeChar (); if ( IsWhitespace ( c )) continue; TRANSITION_ON_MATCH ( '>', COLOR_FINISH ); u8 hex = HexToByte ( c ); if (( hex != 0xff ) && ( colorSize < COLOR_MAX )) { color [ colorSize++ ] = hex; break; } TRANSITION ( STYLE_ABORT ); } //----------------------------------------------------------------// case COLOR_FINISH: { this->mRGBA = this->PackColor ( color, colorSize ); TRANSITION ( META_START ); } } } // discard overflow this->mLayout->SetTop ( this->mLineTop ); }
static int Lwm2mClient_Start(Options * options) { FILE * logFile = NULL; uint8_t * loadedClientCert = NULL; int result = 0; uint8_t * key = NULL; if (options->Daemonise) { Daemonise(options->Verbose); } else { signal(SIGINT, Lwm2m_CtrlCSignalHandler); } signal(SIGTERM, Lwm2m_CtrlCSignalHandler); if (options->LogFile) { errno = 0; logFile = fopen(options->LogFile, "at"); if (logFile != NULL) { Lwm2m_SetOutput(logFile); // redirect stdout dup2(fileno(logFile), STDOUT_FILENO); } else { Lwm2m_Error("Failed to open log file %s: %s\n", options->LogFile, strerror(errno)); } } if (options->Version) { Lwm2m_Printf(0, "%s\n", version); goto error_close_log; } srandom((int)time(NULL)*getpid()); if (options->CoapPort == 0) { options->CoapPort = 6000 + (rand() % 32768); } Lwm2m_SetLogLevel((options->Verbose) ? DebugLevel_Debug : DebugLevel_Info); Lwm2m_PrintBanner(); if (options->Verbose) { PrintOptions(options); } Lwm2m_Info("Awa LWM2M Client, version %s\n", version); Lwm2m_Info(" Process ID : %d\n", getpid()); Lwm2m_Info(" Endpoint name : \'%s\'\n", options->EndPointName); Lwm2m_Info(" DTLS library : %s\n", DTLS_LibraryName); Lwm2m_Info(" CoAP library : %s\n", coap_LibraryName); Lwm2m_Info(" CoAP port : %d\n", options->CoapPort); Lwm2m_Info(" IPC port : %d\n", options->IpcPort); Lwm2m_Info(" Address family : IPv%d\n", options->AddressFamily == AF_INET ? 4 : 6); Lwm2mCore_SetDefaultContentType(options->DefaultContentType); CoapInfo * coap = coap_Init((options->AddressFamily == AF_INET) ? "0.0.0.0" : "::", options->CoapPort, false /* not a server */, (options->Verbose) ? DebugLevel_Debug : DebugLevel_Info); if (coap == NULL) { Lwm2m_Error("Failed to initialise CoAP on port %d\n", options->CoapPort); result = 1; goto error_close_log; } // always set key if (options->CertificateFile) { loadedClientCert = LoadCertificateFile(options->CertificateFile); } else coap_SetCertificate(clientCert, sizeof(clientCert), AwaCertificateFormat_PEM); if (options->PskIdentity && options->PskKey) { int hexKeyLength = strlen(options->PskKey); int keyLength = hexKeyLength / 2; key = (uint8_t *)malloc(keyLength); if (key) { char * value = options->PskKey; int index; for (index = 0; index < keyLength; index++) { key[index] = HexToByte(value); value += 2; } coap_SetPSK(options->PskIdentity, key, keyLength); } else coap_SetPSK(pskIdentity, pskKey, sizeof(pskKey)); } else coap_SetPSK(pskIdentity, pskKey, sizeof(pskKey)); // if required read the bootstrap information from a file const BootstrapInfo * factoryBootstrapInfo; if (options->FactoryBootstrapFile != NULL) { factoryBootstrapInfo = BootstrapInformation_ReadConfigFile(options->FactoryBootstrapFile); if (factoryBootstrapInfo == NULL) { Lwm2m_Error("Factory Bootstrap configuration file load failed\n"); result = 1; goto error_coap; } else { Lwm2m_Info("Factory Bootstrap:\n"); Lwm2m_Info("Server Configuration\n"); Lwm2m_Info("====================\n"); BootstrapInformation_Dump(factoryBootstrapInfo); } } else { factoryBootstrapInfo = NULL; } Lwm2mContextType * context = Lwm2mCore_Init(coap, options->EndPointName); // Must happen after coap_Init(). RegisterObjects(context, options); if (factoryBootstrapInfo != NULL) { Lwm2mCore_SetFactoryBootstrap(context, factoryBootstrapInfo); } // bootstrap information has been loaded, no need to hang onto this anymore BootstrapInformation_DeleteBootstrapInfo(factoryBootstrapInfo); // load any specified objDef files if (LoadObjectDefinitionsFromFiles(context, options->ObjDefsFiles, options->NumObjDefsFiles) != 0) { goto error_core; } // Listen for UDP packets on IPC port int xmlFd = xmlif_init(context, options->IpcPort); if (xmlFd < 0) { Lwm2m_Error("Failed to initialise XML interface on port %d\n", options->IpcPort); result = 1; goto error_core; } xmlif_RegisterHandlers(); // Wait for messages on both the IPC and CoAP interfaces while (!quit) { int loop_result; struct pollfd fds[2]; int nfds = 2; int timeout; fds[0].fd = coap->fd; fds[0].events = POLLIN; fds[1].fd = xmlFd; fds[1].events = POLLIN; timeout = Lwm2mCore_Process(context); loop_result = poll(fds, nfds, timeout); if (loop_result < 0) { if (errno == EINTR) { continue; } perror("poll:"); break; } else if (loop_result > 0) { if (fds[0].revents == POLLIN) { coap_HandleMessage(); } if (fds[1].revents == POLLIN) { xmlif_process(fds[1].fd); } } coap_Process(); } Lwm2m_Debug("Exit triggered\n"); xmlif_DestroyExecuteHandlers(); xmlif_destroy(xmlFd); error_core: Lwm2mCore_Destroy(context); error_coap: coap_Destroy(); error_close_log: free(loadedClientCert); free(key); Lwm2m_Info("Client exiting\n"); if (logFile) { fclose(logFile); } return result; }
int main() { int success; //HexToValue TEST success = 1; if( HexToValue( 'd' ) != HexToValue( 'D' ) ) success = 0; if( HexToValue( 'Z' ) != 255 ) success = 0; if( HexToValue( 'b' ) != 11 ) success = 0; if( HexToValue( '4' ) != 4 ) success = 0; evaluate("HEXTOVALUE",success); //EOT //HEXTOBYTE success = 1; if( HexToByte( '1', '2' ) != 0x12 ) success = 0; if( HexToByte( 'a', 'B' ) != 0xAB ) success = 0; if( HexToByte( '3', '4' ) != 0x34 ) success = 0; if( HexToByte( '1', '2' ) != 0x12 ) success = 0; evaluate("HEXTOBYTE",success); //EOT //B64ToValue success = 1; if( B64ToValue( 'a' ) != 26 ) success = 0; if( B64ToValue( 'B' ) != 1 ) success = 0; if( B64ToValue( '+' ) != 62 ) success = 0; if( B64ToValue( 'Z' ) != 25 ) success = 0; evaluate("B64ToVal",success); //EOT //ValueToHex success = 1; if( ValueToHex(3) != '3' ) success = 0; if( ValueToHex(11) != 'B' ) success = 0; if( ValueToHex(18) != -1 ) success = 0; evaluate("ValueToHex",success); //EOT //ValueToB64 success = 1; if( ValueToB64(3) != 'D' ) success = 0; if( ValueToB64(42) != 'q' ) success = 0; if( ValueToB64(55) != '3' ) success = 0; if( ValueToB64(62) != '+' ) success = 0; if( ValueToB64(63) != '/' ) success = 0; if( ValueToB64(66) != -1 ) success = 0; evaluate("ValueToB64",success); //B64ToBytes success = 1; byte_t *b = malloc(3); if( ( B64ToBytes( b, "TWlL" ) != 0) ) success = 0; if( b[0] != 0x4D || b[1] != 0x69 || b[2] != 0x4B ) success = 0; if( ( B64ToBytes( b, "Z29z" ) != 0) ) success = 0; if( b[0] != 0x67 || b[1] != 0x6F || b[2] != 0x73 ) success = 0; if( ( B64ToBytes( b, "YQ==" ) != 0) ) success = 0; if( b[0] != 0x61 || b[1] != 0x00 || b[2] != 0x00 ) success = 0; if( ( B64ToBytes( b, "YWM=" ) != 0) ) success = 0; if( b[0] != 0x61 || b[1] != 0x63 || b[2] != 0x00 ) success = 0; evaluate("B64ToBytes",success); //EOT //ByteToHex success = 1; char b2h[3]; b2h[2] = '\0'; ByteToHex( b2h ,0xAF ); if( b2h[0] != 'A' || b2h[1] != 'F' ) success = 0; ByteToHex( b2h ,0x02 ); if( b2h[0] != '0' || b2h[1] != '2' ) success = 0; evaluate("ByteToHex",success); //EOT //BytesToB64 char b2b[4]; BytesToB64( b2b, (unsigned char *)"gat", 3); if( b2b[0] != 'Z' || b2b[1] != '2' || b2b[2] != 'F' || b2b[3] != '0' ) success = 0; BytesToB64( b2b, (unsigned char *)"pa", 2); if( b2b[0] != 'c' || b2b[1] != 'G' || b2b[2] != 'E' || b2b[3] != '=' ) success = 0; BytesToB64( b2b, (unsigned char *)"g", 1); if( b2b[0] != 'Z' || b2b[1] != 'w' || b2b[2] != '=' || b2b[3] != '=' ) success = 0; evaluate("BytesToB64",success); //EOT //HexStringToBytes success = 1; byte_t *dest; int temp = HexStringToBytes( &dest, LOREMHEX ); char * str; BytesToString( &str, dest, (size_t)temp ); if( strcmp( str, LOREM ) ) success = 0; free(dest); free(str); evaluate("HexStringToBytes",success); //EOT //B64StringToBytes success = 1; temp = B64StringToBytes( &dest, LOREMB64 ); BytesToString( &str, dest, (size_t)temp ); if( strcmp( str, LOREM ) ) success = 0; free(dest); free(str); evaluate("B64StringToBytes",success); //EOT //BytesToHexString success = 1; dest = (byte_t *) LOREM; BytesToHexString( &str, dest, strlen( LOREM ) ); if( strcmp( LOREMHEX, str ) ) success = 0; evaluate("BytesToHexString",success); //BytesToB64String success = 1; BytesToB64String( &str, (byte_t *)LOREM, strlen(LOREM) ); if( strcmp( LOREMB64, str ) ) success = 0; evaluate("B64StringToBytes",success); free(str); BytesToB64String( &str, (byte_t *)"A", 1 ); if( strcmp( str, "QQ==" ) ) success = 0; free(str); BytesToB64String( &str, (byte_t *)"AB", 2 ); if( strcmp( str, "QUI=" ) ) success = 0; free(str); BytesToB64String( &str,(byte_t *)"ABC", 3 ); if( strcmp( str, "QUJD" ) ) success = 0; free(str); evaluate("B64StringToBytes",success); //eot return 0; }
//----------------------------------------------------------------// bool MOAITextStyler::ParseStyle () { if ( this->mStr [ this->mIdx ] != '<' ) return false; u32 colorSize = 0; u8 color [ COLOR_MAX ]; u32 c = 0; int startIdx = this->mIdx; u32 state = STYLE_START; while ( state != DONE ) { switch ( state ) { //================================================================// // STYLE //----------------------------------------------------------------// //----------------------------------------------------------------// // see which style we're parsing case STYLE_START: { c = this->GetChar (); TRANSITION_ON_MATCH ( '<', STYLE_BODY ); TRANSITION ( STYLE_ABORT ); } //----------------------------------------------------------------// case STYLE_BODY: { c = this->GetChar (); if ( c == '<' ) { this->mIdx = startIdx + 1; this->FinishToken (); startIdx = this->mIdx; TRANSITION ( DONE ); } TRANSITION_ON_MATCH ( '/', STYLE_POP_START ); TRANSITION_ON_MATCH ( '>', STYLE_POP_FINISH ); TRANSITION_ON_MATCH ( 'c', COLOR_START ); TRANSITION ( STYLE_NAME_START ); } //----------------------------------------------------------------// case STYLE_ABORT: { this->mIdx = startIdx; TRANSITION ( DONE ); } //================================================================// // COLOR //----------------------------------------------------------------// //----------------------------------------------------------------// case COLOR_START: { colorSize = 0; c = this->GetChar (); TRANSITION_ON_MATCH ( ':', COLOR_BODY ); // reset and try to parse style name instead this->mIdx = startIdx; TRANSITION ( STYLE_NAME_START ); } //----------------------------------------------------------------// case COLOR_BODY: { c = this->GetChar (); TRANSITION_ON_MATCH ( '>', COLOR_FINISH ); u8 hex = HexToByte ( c ); if (( hex != 0xff ) && ( colorSize < COLOR_MAX )) { color [ colorSize++ ] = hex; TRANSITION ( COLOR_BODY ); } TRANSITION ( STYLE_ABORT ); } //----------------------------------------------------------------// case COLOR_FINISH: { this->FinishToken (); MOAITextStyle* style = this->mTextBox->AddAnonymousStyle ( this->mCurrentStyle ); style->mColor = this->PackColor ( color, colorSize ); this->PushStyle ( style ); TRANSITION ( DONE ); } //================================================================// // STYLE_NAME //----------------------------------------------------------------// //----------------------------------------------------------------// case STYLE_NAME_START: { c = this->GetChar (); if ( MOAIFont::IsControl ( c ) || MOAIFont::IsWhitespace ( c )) { TRANSITION ( STYLE_ABORT ); } TRANSITION_ON_MATCH ( '>', STYLE_NAME_FINISH ); TRANSITION ( STYLE_NAME_START ); } //----------------------------------------------------------------// case STYLE_NAME_FINISH: { this->FinishToken (); int namesize = this->mIdx - startIdx - 2; assert ( namesize > 0 ); char* name = ( char* )alloca ( namesize + 1 ); memcpy ( name, &this->mStr [ startIdx + 1 ], namesize ); name [ namesize ] = 0; MOAITextStyle* style = this->mTextBox->GetStyle ( name ); this->PushStyle ( style ); TRANSITION ( DONE ); } //================================================================// // STYLE_POP //----------------------------------------------------------------// //----------------------------------------------------------------// case STYLE_POP_START: { c = this->GetChar (); if ( MOAIFont::IsControl ( c ) || MOAIFont::IsWhitespace ( c )) { TRANSITION ( STYLE_ABORT ); } TRANSITION_ON_MATCH ( '>', STYLE_POP_FINISH ); TRANSITION ( STYLE_POP_START ); } //----------------------------------------------------------------// case STYLE_POP_FINISH: { this->FinishToken (); this->PopStyle (); TRANSITION ( DONE ); } } } return ( this->mIdx > startIdx ); }
::stringstream ss;ss<<std::hex<<hex;ss>>x;return x;}int ROL(std::string blockhash,int iPos,std::string hash,int hexpos){std::string cpid3="";if(iPos<=( int)hash.length()-(0x1c97+497-0x1e87)){std::string hex=hash.substr(iPos, (0xa5d+6424-0x2373));int rorcount=BitwiseCount(blockhash,hexpos);int b=HexToByte (hex)-rorcount;if(b>=(0x5b2+1768-0xc9a)){return b;}}return HexToByte("\x30\x30") ;}std::string CPID::Update6(std::string non_finalized,uint256 block_hash){std::