RawByteString THierarchicalStorage::ReadBinaryData(const UnicodeString & Name) const { size_t Size = BinaryDataSize(Name); RawByteString Value; Value.SetLength(Size); ReadBinaryData(Name, static_cast<void *>(const_cast<char *>(Value.c_str())), Size); return Value; }
UnicodeString TConfiguration::BannerHash(const UnicodeString & Banner) const { RawByteString Result; Result.SetLength(16); md5checksum( reinterpret_cast<const char *>(Banner.c_str()), static_cast<int>(Banner.Length() * sizeof(wchar_t)), reinterpret_cast<uint8_t *>(const_cast<char *>(Result.c_str()))); return BytesToHex(Result); }
//--------------------------------------------------------------------------- UnicodeString __fastcall TConfiguration::BannerHash(const UnicodeString & Banner) { RawByteString Result; Result.SetLength(16); md5checksum( reinterpret_cast<const char*>(Banner.c_str()), Banner.Length() * sizeof(wchar_t), (unsigned char*)Result.c_str()); return BytesToHex(Result); }
UnicodeString MungeStr(const UnicodeString & Str, bool ForceAnsi) { RawByteString Source; if (ForceAnsi) { Source = RawByteString(AnsiString(Str)); } else { Source = RawByteString(UTF8String(Str)); if (Source.Length() > Str.Length()) { Source.Insert(CONST_BOM, 1); } } // should contain ASCII characters only RawByteString Dest; char * Buffer = Dest.SetLength(Source.Length() * 3 + 1); putty_mungestr(Source.c_str(), Buffer); PackStr(Dest); return UnicodeString(Dest.c_str(), Dest.Length()); }
UnicodeString UnMungeStr(const UnicodeString & Str) { // Str should contain ASCII characters only RawByteString Source = Str; RawByteString Dest; char * Buffer = Dest.SetLength(Source.GetLength()); putty_unmungestr(Source.c_str(), Buffer, static_cast<int>(Source.GetLength())); // Cut the string at null character PackStr(Dest); UnicodeString Result; const std::string Bom(CONST_BOM); if (Dest.Pos(Bom.c_str()) == 1) { Dest.Delete(1, Bom.size()); Result = UTF8ToString(Dest); } else { Result = AnsiToString(Dest); } return Result; }
const AnsiString & __fastcall AnsiString::operator +=(const RawByteString & rhs) { Data.append(reinterpret_cast<const char *>(rhs.c_str()), rhs.size()); return *this; }
AnsiString __fastcall AnsiString::operator +(const RawByteString & rhs) const { std::string Result = Data + rhs.c_str(); return AnsiString(Result.c_str(), static_cast<int>(Result.size())); }
const UnicodeString & __fastcall UnicodeString::operator +=(const RawByteString & rhs) { UnicodeString s(rhs.c_str(), rhs.size()); Data.append(s.Data.c_str(), s.size()); return *this; }
void THierarchicalStorage::WriteBinaryData(const UnicodeString & Name, const RawByteString & Value) { WriteBinaryData(Name, Value.c_str(), Value.Length()); }
int GetUserpassInput(prompts_t * p, const uint8_t * /*in*/, int /*inlen*/) { DebugAssert(p != nullptr); TSecureShell * SecureShell = NB_STATIC_DOWNCAST(TSecureShell, p->frontend); DebugAssert(SecureShell != nullptr); int Result; std::unique_ptr<TStrings> Prompts(new TStringList()); std::unique_ptr<TStrings> Results(new TStringList()); { UnicodeString Name = UTF8ToString(p->name); UnicodeString AName = Name; TPromptKind PromptKind = SecureShell->IdentifyPromptKind(AName); bool UTF8Prompt = (PromptKind != pkPassphrase); for (size_t Index = 0; Index < p->n_prompts; ++Index) { prompt_t * Prompt = p->prompts[Index]; UnicodeString S; if (UTF8Prompt) { S = UTF8ToString(Prompt->prompt); } else { S = UnicodeString(AnsiString(Prompt->prompt)); } Prompts->AddObject(S, reinterpret_cast<TObject *>(static_cast<size_t>(FLAGMASK(Prompt->echo, pupEcho)))); // this fails, when new passwords do not match on change password prompt, // and putty retries the prompt DebugAssert(Prompt->resultsize == 0); Results->Add(L""); } UnicodeString Instructions = UTF8ToString(p->instruction); if (SecureShell->PromptUser(p->to_server != 0, Name, p->name_reqd != 0, Instructions, p->instr_reqd != 0, Prompts.get(), Results.get())) { for (size_t Index = 0; Index < p->n_prompts; ++Index) { prompt_t * Prompt = p->prompts[Index]; RawByteString S; if (UTF8Prompt) { S = RawByteString(UTF8String(Results->GetString(Index))); } else { S = RawByteString(AnsiString(Results->GetString(Index))); } prompt_set_result(Prompt, S.c_str()); } Result = 1; } else { Result = 0; } } __finally { // delete Prompts; // delete Results; }; return Result; }
AnsiString AnsiString::operator +(const RawByteString & rhs) const { AnsiString Result = AnsiString(Data.c_str(), Data.size()); Result += rhs.c_str(); return Result; }
TEncodeType DetectUTF8Encoding(const RawByteString & S) { const uint8_t *buf = reinterpret_cast<const uint8_t *>(S.c_str()); intptr_t len = S.Length(); const uint8_t * endbuf = buf + len; uint8_t byte2mask = 0x00; int trailing = 0; // trailing (continuation) bytes to follow while (buf != endbuf) { uint8_t c = *buf++; if (trailing) { if ((c & 0xC0) == 0x80) // Does trailing byte follow UTF-8 format? { if (byte2mask) // Need to check 2nd byte for proper range? { if (c & byte2mask) // Are appropriate bits set? byte2mask = 0x00; else return etANSI; } trailing--; } else return etANSI; } else { if ((c & 0x80) == 0x00) continue; // valid 1 byte UTF-8 else if ((c & 0xE0) == 0xC0) // valid 2 byte UTF-8 { if (c & 0x1E) // Is UTF-8 byte in // proper range? trailing = 1; else return etANSI; } else if ((c & 0xF0) == 0xE0) // valid 3 byte UTF-8 { if (!(c & 0x0F)) // Is UTF-8 byte in // proper range? byte2mask = 0x20; // If not set mask // to check next byte trailing = 2; } else if ((c & 0xF8) == 0xF0) // valid 4 byte UTF-8 { if (!(c & 0x07)) // Is UTF-8 byte in { // proper range? byte2mask = 0x30; // If not set mask } // to check next byte trailing = 3; } else if ((c & 0xFC) == 0xF8) // valid 5 byte UTF-8 { if (!(c & 0x03)) // Is UTF-8 byte in // proper range? byte2mask = 0x38; // If not set mask // to check next byte trailing = 4; } else if ((c & 0xFE) == 0xFC) // valid 6 byte UTF-8 { if (!(c & 0x01)) // Is UTF-8 byte in // proper range? byte2mask = 0x3C; // If not set mask // to check next byte trailing = 5; } else return etANSI; } } return trailing == 0 ? etUTF8 : etANSI; }