BOOST_FIXTURE_TEST_CASE(TestListDir, FileOpenFixture)
{
std::string parentPath = tmpPath.string();
std::vector<std::string> files = ListDir(parentPath, "txt");
BOOST_TEST_REQUIRE(files.size() == 3u);
for(const std::string& file : files)
{
BOOST_REQUIRE(bfs::exists(file));
BOOST_REQUIRE(bfs::path(file).is_absolute());
// Filepath must be utf8 encoded
BOOST_REQUIRE(isValidUTF8(file));
bfs::path filePath(file);
// String result must still be utf8
BOOST_REQUIRE(isValidUTF8(filePath.string()));
// Scopes for auto-close
{
// path input
bnw::ifstream sFile(filePath);
BOOST_REQUIRE(sFile);
std::string content;
BOOST_REQUIRE(sFile >> content);
BOOST_TEST_REQUIRE(content == "OK");
}
{
// string input
bnw::ifstream sFile(file);
BOOST_REQUIRE(sFile);
std::string content;
BOOST_REQUIRE(sFile >> content);
BOOST_TEST_REQUIRE(content == "OK");
}
{
// Memory mapped file
boost::iostreams::mapped_file_source mmapFile;
mmapFile.open(bfs::path(file));
BOOST_TEST_REQUIRE(mmapFile.is_open());
using MMStream = boost::iostreams::stream<boost::iostreams::mapped_file_source>;
MMStream map(mmapFile);
std::string content;
BOOST_REQUIRE(map >> content);
BOOST_TEST_REQUIRE(content == "OK");
}
}
}
char *
Helpers::GnunetFsDubiousMetaToUtf8 (enum EXTRACTOR_MetaFormat format,
const char *data, size_t data_len)
{
switch (format)
{
case EXTRACTOR_METAFORMAT_UTF8:
/* data must not contain NULLs (hence the -1) */
if (isValidUTF8 (data))
return GNUNET_strdup (data);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Failed to validate supposedly utf-8 string `%s' of length %u, assuming it to be a C string\n"),
data,
(unsigned int) data_len);
format = EXTRACTOR_METAFORMAT_C_STRING;
/* fall-through */
case EXTRACTOR_METAFORMAT_C_STRING:
if (data_len > 0)
{
/* There are no guarantees that data is NULL-terminated, AFAIU,
* so let's play it safe, shall we?
*/
char data_copy[data_len + 1];
memcpy (data_copy, data, data_len);
data_copy[data_len] = '\0';
return "Implement me !";//GNUNET_GTK_from_loc_to_utf8 (data_copy);
}
break;
default:
break;
}
return NULL;
}
void TranslateString(char *src, size_t size)
{
char *fptr = src;
size_t src_len = strlen(src);
char *tptr_start = alloca(src_len * 4 + 1);
char *tptr = tptr_start;
if (isValidUTF8(src))
strncpy(tptr_start, fptr, src_len + 1);
else {
while (*fptr) {
int i;
for (i = 0; tc[i] && (tc[i] != *fptr); i++);
if (tc[i]) {
*tptr++ = 0xC3;
*tptr++ = su[i];
fptr++;
} else if (*fptr & 0x80)
fptr++;
else
*tptr++ = *fptr++;
}
*tptr = 0;
}
fptr = tptr_start;
tptr = src;
char *tptr_end = src + size - 4;
while (*fptr && tptr < tptr_end) {
if (*fptr == '~') {
fptr++;
int i;
for (i = 0; sc[i] && (sc[i] != *fptr); i++);
if (sc[i]) {
*tptr++ = 0xC3;
*tptr++ = su[i];
fptr++;
} else if (*fptr == 'd') {
*tptr++ = 0xC2;
*tptr++ = 0xb0;
fptr++;
} else
*tptr++ = '~';
} else
CopyUTF8Char(&tptr, &fptr);
}
*tptr = 0;
}
/**
* @brief
*/
std::vector<std::string> glArchivItem_Font::WrapInfo::CreateSingleStrings(const std::string& text)
{
RTTR_Assert(isValidUTF8(text)); // Can only handle UTF-8 strings!
std::vector<std::string> destStrings;
if(positions.empty())
return destStrings;
destStrings.reserve(positions.size());
unsigned curStart = positions.front();
for(auto it = positions.begin() + 1; it != positions.end(); ++it)
{
RTTR_Assert(*it >= curStart);
std::string curLine = text.substr(curStart, *it - curStart);
boost::algorithm::trim_right(curLine);
destStrings.push_back(curLine);
curStart = *it;
}
/* Push last part */
destStrings.push_back(text.substr(curStart));
return destStrings;
}
/**
* This is a fallback method. It should never be called.
* If UTF8 support is desired, then a UTF8 StringMgr needs
* to be used.
*
* Here we just do our best.
*
* Converts the param to an upper case UTF8 string
* @param t - The text encoded in utf8 which should be turned into an upper case string
*
*/
char *StringMgr::upperUTF8(char *t, unsigned int maxlen) const {
// try to decide if it's worth trying to toupper. Do we have more
// characters which are probably lower latin than not?
// we still don't use isValidUTF8 optimally. what if we have 1 unicode
// character in the string? should we not try to upper any of the string?
// dunno. Best solution is to upper all other characters. Don't have
// time to write that before release.
long performOp = 0;
if (!isValidUTF8((unsigned char *)t)) {
performOp = 1;
}
else {
for (const char *ch = t; *ch; ch++) {
performOp += (*ch > 0) ? 1 : -1;
}
}
if (performOp > 0) {
return upperLatin1(t);
}
return t;
}
zmsg_t* PrimeWorker::ReceiveRequest(proto::Request& req, void* socket) {
zmsg_t* msg = zmsg_recv(socket);
zframe_t* frame = zmsg_last(msg);
zmsg_remove(msg, frame);
size_t fsize = zframe_size(frame);
const byte* fbytes = zframe_data(frame);
bool ok = req.ParseFromArray(fbytes, fsize);
zframe_destroy(&frame);
bool valid = false;
while(ok){
if(!proto::Request::Type_IsValid(req.type()))
break;
if(!req.has_reqnonce())
break;
if(CheckVersion(req.version()) <= 0)
break;
uint256 reqnonce;
{
const std::string& nonce = req.reqnonce();
if(nonce.length() != sizeof(uint256))
break;
memcpy(reqnonce.begin(), nonce.c_str(), sizeof(uint256));
}
if(!CheckReqNonce(reqnonce) || !mReqNonces.insert(reqnonce).second)
break;
if(req.has_stats()){
const proto::ClientStats& stats = req.stats();
if(!isValidUTF8(stats.addr()))
break;
if(!isValidUTF8(stats.name()))
break;
if(stats.cpd() < 0 || stats.cpd() > 150. || stats.cpd() != stats.cpd())
break;
}
if(req.has_share()){
const proto::Share& share = req.share();
if(!isValidUTF8(share.addr()))
break;
if(!isValidUTF8(share.name()))
break;
if(!isValidUTF8(share.hash()))
break;
if(!isValidUTF8(share.merkle()))
break;
if(!isValidUTF8(share.multi()))
break;
if(share.has_blockhash() && !isValidUTF8(share.blockhash()))
break;
}
valid = true;
break;
}
if(valid)
return msg;
else{
mInvCount++;
zmsg_destroy(&msg);
return 0;
}
}
bool isValidUTF8(const std::string& s) {
return isValidUTF8(s.c_str());
}
bool isValidUTF8(string s) {
return isValidUTF8(s.c_str());
}
/**
* Gibt Infos, über die Unterbrechungspunkte in einem Text
*
* @param[in] text Text, der auf Zeilen verteilt werden soll
* @param[in] primary_width Maximale Breite der ersten Zeile
* @param[in] secondary_width Maximale Breite der weiteren Zeilen
*/
glArchivItem_Font::WrapInfo glArchivItem_Font::GetWrapInfo(const std::string& text, const unsigned short primary_width,
const unsigned short secondary_width)
{
if(!fontNoOutline)
initFont();
RTTR_Assert(isValidUTF8(text)); // Can only handle UTF-8 strings!
// Current line width
unsigned line_width = 0;
// Width of current word
unsigned word_width = 0;
unsigned curMaxLineWidth = primary_width;
WrapInfo wi;
// We start the first line at the first char (so wi.positions.size() == numLines)
wi.positions.push_back(0);
utf8Iterator it(text.begin(), text.begin(), text.end());
utf8Iterator itEnd(text.end(), text.begin(), text.end());
utf8Iterator itWordStart = it;
const unsigned spaceWidth = CharWidth(' ');
for(;; ++it)
{
uint32_t curChar = (it != itEnd) ? *it : 0;
// Word ended
if(curChar == 0 || curChar == '\n' || curChar == ' ')
{
// Is the current word to long for the current line
if(word_width + line_width > curMaxLineWidth)
{
// Word does not fit -> Start new line
// Can we fit the word in one line?
if(word_width <= secondary_width)
{
// New line starts at index of word start
wi.positions.push_back(static_cast<unsigned>(itWordStart.base() - text.begin()));
line_width = 0;
} else
{
// Word does not even fit on one line -> Put as many letters in one line as possible
for(utf8Iterator itWord = itWordStart; itWord != it; ++itWord)
{
unsigned letter_width = CharWidth(*itWord);
// Can we fit the letter onto current line?
if(line_width + letter_width <= curMaxLineWidth)
line_width += letter_width; // Add it
else
{
// Create new line at this letter
wi.positions.push_back(static_cast<unsigned>(itWord.base() - text.begin()));
line_width = letter_width;
itWordStart = nextIt(itWord);
}
}
// Restart word
word_width = 0;
}
curMaxLineWidth = secondary_width;
}
if(curChar == 0)
break;
else if(curChar == ' ')
{
// Set up this line if we are going to continue it (not at line break or text end)
// Line contains word and whitespace
line_width += word_width + spaceWidth;
word_width = 0;
itWordStart = nextIt(it);
} else
{
// If line break add new line (after all the word-breaking above)
itWordStart = nextIt(it);
if(itWordStart == itEnd)
break; // Reached end
word_width = 0;
line_width = 0;
wi.positions.push_back(static_cast<unsigned>(itWordStart.base() - text.begin()));
}
} else
{
// Some char -> Add its width
word_width += CharWidth(curChar);
}
}
// Ignore trailing newline
if(wi.positions.back() + 1 >= text.length() && wi.positions.size() > 1)
wi.positions.pop_back();
return wi;
}
/**
* Zeichnet einen Text.
*
* @param[in] x X-Koordinate
* @param[in] y Y-Koordinate
* @param[in] text Der Text
* @param[in] format Format des Textes (verodern)
* @p FontStyle::LEFT - Text links ( standard )
* @p FontStyle::CENTER - Text mittig
* @p FontStyle::RIGHT - Text rechts
* @p FontStyle::TOP - Text oben ( standard )
* @p FontStyle::VCENTER - Text vertikal zentriert
* @p FontStyle::BOTTOM - Text unten
* @param[in] color Farbe des Textes
* @param[in] length Länge des Textes
* @param[in] max maximale Länge
* @param end Suffix for displaying a truncation of the text (...)
*/
void glArchivItem_Font::Draw(DrawPoint pos, const std::string& text, FontStyle format, unsigned color, unsigned short length,
unsigned short maxWidth, const std::string& end)
{
if(!fontNoOutline)
initFont();
RTTR_Assert(isValidUTF8(text));
// Breite bestimmen
if(length == 0)
length = (unsigned short)text.length();
unsigned maxNumChars;
unsigned short textWidth;
bool drawEnd;
if(maxWidth == 0xFFFF)
{
maxNumChars = length;
textWidth = getWidth(text, length);
drawEnd = false;
} else
{
RTTR_Assert(isValidUTF8(end));
textWidth = getWidth(text, length, maxWidth, &maxNumChars);
if(!end.empty() && maxNumChars < length)
{
unsigned short endWidth = getWidth(end);
// If "end" does not fit, draw nothing
if(textWidth < endWidth)
return;
// Wieviele Buchstaben gehen in den "Rest" (ohne "end")
textWidth = getWidth(text, length, textWidth - endWidth, &maxNumChars) + endWidth;
drawEnd = true;
} else
drawEnd = false;
}
if(maxNumChars == 0)
return;
auto itEnd = text.cbegin();
std::advance(itEnd, maxNumChars);
// Vertical alignment (assumes 1 line only!)
if(format.is(FontStyle::BOTTOM))
pos.y -= dy;
else if(format.is(FontStyle::VCENTER))
pos.y -= dy / 2;
// Horizontal center must change current line only. Everything else changes the start point
DrawPoint curPos(pos);
// Horizontal alignment
if(format.is(FontStyle::RIGHT))
curPos.x = pos.x -= textWidth;
else if(format.is(FontStyle::CENTER))
{
unsigned short line_width;
const auto itNl = std::find(text.cbegin(), itEnd, '\n');
if(itNl != itEnd)
line_width = getWidthInternal(text.cbegin(), itNl);
else
line_width = textWidth;
curPos.x = pos.x - line_width / 2;
}
texList.texCoords.clear();
texList.vertices.clear();
for(auto it = text.begin(); it != itEnd;)
{
const uint32_t curChar = utf8::next(it, itEnd);
if(curChar == '\n')
{
if(format.is(FontStyle::CENTER))
{
unsigned short line_width;
const auto itNl = std::find(it, itEnd, '\n');
line_width = getWidthInternal(it, itNl);
curPos.x = pos.x - line_width / 2;
} else
curPos.x = pos.x;
curPos.y += dy;
} else
DrawChar(curChar, texList, curPos);
}
if(drawEnd)
{
for(auto it = end.begin(); it != end.end();)
{
const uint32_t curChar = utf8::next(it, end.end());
if(curChar == '\n')
{
curPos.x = pos.x;
curPos.y += dy;
} else
DrawChar(curChar, texList, curPos);
}
}
if(texList.vertices.empty())
return;
// Get texture first as it might need to be created
glArchivItem_Bitmap& usedFont = format.is(FontStyle::NO_OUTLINE) ? *fontNoOutline : *fontWithOutline;
unsigned texture = usedFont.GetTexture();
if(!texture)
return;
const GlPoint texSize(usedFont.GetTexSize());
RTTR_Assert(texList.texCoords.size() == texList.vertices.size());
RTTR_Assert(texList.texCoords.size() % 4u == 0);
// Vectorizable loop
for(unsigned i = 0; i < texList.texCoords.size(); i += 4)
{
for(int j = 0; j < 4; j++)
texList.texCoords[i + j] /= texSize;
}
glVertexPointer(2, GL_FLOAT, 0, &texList.vertices[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &texList.texCoords[0]);
VIDEODRIVER.BindTexture(texture);
glColor4ub(GetRed(color), GetGreen(color), GetBlue(color), GetAlpha(color));
glDrawArrays(GL_QUADS, 0, texList.vertices.size());
}