bool ServerObject::HandleImageData (Entity& e, const QVariantMap& hints)
{
const auto& dataVar = hints.value ("image-data", hints.value ("image_data"));
if (dataVar.isNull ())
return false;
const auto& arg = dataVar.value<QDBusArgument> ();
int width = 0, height = 0, rowstride = 0;
bool hasAlpha = false;
int bps = 0, channels = 0;
QByteArray data;
arg.beginStructure ();
arg >> width >> height >> rowstride >> hasAlpha >> bps >> channels >> data;
arg.endStructure ();
const QImage img (reinterpret_cast<const uchar*> (data.constBegin ()),
width, height, QImage::Format_ARGB32);
if (img.isNull ())
return false;
e.Additional_ ["NotificationPixmap"] = QPixmap::fromImage (img.rgbSwapped ());
return true;
}
QByteArray QCSP::reverse( const QByteArray &data ) const
{
QByteArray reverse;
for( QByteArray::const_iterator i = data.constEnd(); i != data.constBegin(); )
{
--i;
reverse += *i;
}
return reverse;
}
void CPU::loadRom(const std::string& h, const std::string& g, const std::string& f, const std::string& e)
{
QFile file_h(QString::fromStdString(h));
if(!file_h.open(QIODevice::ReadOnly))
{
error("Cannot open rom 1 : " + file_h.errorString().toStdString() + " : " +
std::to_string(file_h.error()));
}
QFile file_g(QString::fromStdString(g));
if(!file_g.open(QIODevice::ReadOnly))
{
error("Cannot open rom 2 : " + file_g.errorString().toStdString() + " : " +
std::to_string(file_h.error()));
}
QFile file_f(QString::fromStdString(f));
if(!file_f.open(QIODevice::ReadOnly))
{
error("Cannot open rom 3 : " + file_f.errorString().toStdString() + " : " +
std::to_string(file_h.error()));
}
QFile file_e(QString::fromStdString(e));
if(!file_e.open(QIODevice::ReadOnly))
{
error("Cannot open rom 4 : " + file_e.errorString().toStdString() + " : " +
std::to_string(file_h.error()));
}
QByteArray hContents = file_h.readAll();
std::copy(hContents.constBegin(), hContents.constEnd(),
m_state.mem.begin());
QByteArray gContents = file_g.readAll();
std::copy(gContents.constBegin(), gContents.constEnd(),
m_state.mem.begin() + 0x800);
QByteArray fContents = file_f.readAll();
std::copy(fContents.constBegin(), fContents.constEnd(),
m_state.mem.begin() + 0x1000);
QByteArray eContents = file_e.readAll();
std::copy(eContents.constBegin(), eContents.constEnd(),
m_state.mem.begin() + 0x1800);
}
QByteArray QCSP::decrypt( const QByteArray &data )
{
HCRYPTKEY key = 0;
if( !CryptGetUserKey( d->h, AT_KEYEXCHANGE, &key ) )
return QByteArray();
QByteArray reverse;
for( QByteArray::const_iterator i = data.constEnd(); i != data.constBegin(); )
{
--i;
reverse += *i;
}
DWORD size = reverse.size();
bool result = CryptDecrypt( key, 0, true, 0, (BYTE*)reverse.data(), &size );
CryptDestroyKey( key );
return result ? reverse : QByteArray();
}
static QList<QPointF> parsePoints(const QByteArray &line)
{
QList<QPointF> res;
QByteArray::const_iterator it = line.constBegin();
if (*it == ',')
++it;
QList<qreal> nums = parseNumbersList(it);
QList<qreal>::const_iterator nitr;
for (nitr = nums.begin(); nitr != nums.end(); ++nitr) {
qreal x = *nitr; ++nitr;
Q_ASSERT(nitr != nums.end());
qreal y = *nitr;
res.append(QPointF(x, y));
}
return res;
}
QByteArray QCSP::sign( int method, const QByteArray &digest )
{
ALG_ID alg = 0;
switch( method )
{
case NID_sha1: alg = CALG_SHA1; break;
case NID_sha256: alg = CALG_SHA_256; break;
case NID_sha384: alg = CALG_SHA_384; break;
case NID_sha512: alg = CALG_SHA_512; break;
case NID_sha224:
default: return QByteArray();
}
HCRYPTHASH hash = 0;
if( !CryptCreateHash( d->h, alg, 0, 0, &hash ) )
return QByteArray();
if( !CryptSetHashParam( hash, HP_HASHVAL, (BYTE*)digest.constData(), 0 ) )
{
CryptDestroyHash( hash );
return QByteArray();
}
DWORD size = 256;
QByteArray sig;
sig.resize( size );
if( !CryptSignHashW( hash, AT_SIGNATURE, 0, 0, (BYTE*)sig.data(), &size ) )
sig.clear();
CryptDestroyHash( hash );
QByteArray reverse;
for( QByteArray::const_iterator i = sig.constEnd(); i != sig.constBegin(); )
{
--i;
reverse += *i;
}
return reverse;
}
QString CGI::encodeURL(const QString &rawText)
{
QByteArray utf = rawText.toUtf8();
QString enc;
enc.reserve(utf.length()); // Make sure we at least have space for a normal US-ASCII URL
QByteArray::const_iterator it = utf.constBegin();
while (it != utf.constEnd()) {
const char ch = *it;
if (('A' <= ch && ch <= 'Z')
|| ('a' <= ch && ch <= 'z')
|| ('0' <= ch && ch <= '9')) {
enc.append(QLatin1Char(ch));
} else if (ch == ' ') {
enc.append(QLatin1Char('+'));
} else {
switch (ch) {
case '-': case '_':
case '(': case ')':
case '.': case '!':
case '~': case '*':
case '\'':
enc.append(QLatin1Char(ch));
break;
default:
ushort c1 = (*it & 0xF0) >> 4;
ushort c2 = (*it & 0x0F);
enc.append(QLatin1Char('%'));
enc.append(QLatin1Char(*(cgi_chars + c1)));
enc.append(QLatin1Char(*(cgi_chars + c2)));
break;
}
}
++it;
}
return enc;
}
const char *MacroExpander::expand(const char *__first, const char *__last,
QByteArray *__result)
{
const char *start = __first;
__first = skip_blanks (__first, __last);
lines = skip_blanks.lines;
while (__first != __last)
{
if (*__first == '\n')
{
__result->append("\n# ");
__result->append(QByteArray::number(env->currentLine));
__result->append(' ');
__result->append('"');
__result->append(env->currentFile.toUtf8());
__result->append('"');
__result->append('\n');
++lines;
__first = skip_blanks (++__first, __last);
lines += skip_blanks.lines;
if (__first != __last && *__first == '#')
break;
}
else if (*__first == '#')
{
__first = skip_blanks (++__first, __last);
lines += skip_blanks.lines;
const char *end_id = skip_identifier (__first, __last);
const QByteArray fast_name(__first, end_id - __first);
__first = end_id;
if (const QByteArray *actual = resolve_formal (fast_name))
{
__result->append('\"');
const char *actual_begin = actual->constData ();
const char *actual_end = actual_begin + actual->size ();
for (const char *it = skip_whitespaces (actual_begin, actual_end);
it != actual_end; ++it)
{
if (*it == '"' || *it == '\\')
{
__result->append('\\');
__result->append(*it);
}
else if (*it == '\n')
{
__result->append('"');
__result->append('\n');
__result->append('"');
}
else
__result->append(*it);
}
__result->append('\"');
}
else
__result->append('#'); // ### warning message?
}
else if (*__first == '\"')
{
const char *next_pos = skip_string_literal (__first, __last);
lines += skip_string_literal.lines;
__result->append(__first, next_pos - __first);
__first = next_pos;
}
else if (*__first == '\'')
{
const char *next_pos = skip_char_literal (__first, __last);
lines += skip_char_literal.lines;
__result->append(__first, next_pos - __first);
__first = next_pos;
}
else if (comment_p (__first, __last))
{
__first = skip_comment_or_divop (__first, __last);
int n = skip_comment_or_divop.lines;
lines += n;
while (n-- > 0)
__result->append('\n');
}
else if (pp_isspace (*__first))
{
for (; __first != __last; ++__first)
{
if (*__first == '\n' || !pp_isspace (*__first))
break;
}
__result->append(' ');
}
else if (pp_isdigit (*__first))
{
const char *next_pos = skip_number (__first, __last);
lines += skip_number.lines;
__result->append(__first, next_pos - __first);
__first = next_pos;
}
else if (pp_isalpha (*__first) || *__first == '_')
{
const char *name_begin = __first;
const char *name_end = skip_identifier (__first, __last);
__first = name_end; // advance
// search for the paste token
const char *next = skip_blanks (__first, __last);
bool paste = false;
if (next != __last && *next == '#')
{
paste = true;
++next;
if (next != __last && *next == '#')
__first = skip_blanks(++next, __last);
}
const QByteArray fast_name(name_begin, name_end - name_begin);
if (const QByteArray *actual = resolve_formal (fast_name))
{
const char *begin = actual->constData ();
const char *end = begin + actual->size ();
if (paste) {
for (--end; end != begin - 1; --end) {
if (! pp_isspace(*end))
break;
}
++end;
}
__result->append(begin, end - begin);
continue;
}
Macro *macro = env->resolve (fast_name);
if (! macro || macro->isHidden() || env->hideNext)
{
if (fast_name.size () == 7 && fast_name [0] == 'd' && fast_name == "defined")
env->hideNext = true;
else
env->hideNext = false;
if (fast_name.size () == 8 && fast_name [0] == '_' && fast_name [1] == '_')
{
if (fast_name == "__LINE__")
{
__result->append(QByteArray::number(env->currentLine + lines));
continue;
}
else if (fast_name == "__FILE__")
{
__result->append('"');
__result->append(env->currentFile.toUtf8());
__result->append('"');
continue;
}
else if (fast_name == "__DATE__")
{
__result->append('"');
__result->append(QDate::currentDate().toString().toUtf8());
__result->append('"');
continue;
}
else if (fast_name == "__TIME__")
{
__result->append('"');
__result->append(QTime::currentTime().toString().toUtf8());
__result->append('"');
continue;
}
}
__result->append(name_begin, name_end - name_begin);
continue;
}
if (! macro->isFunctionLike())
{
Macro *m = 0;
if (! macro->definition().isEmpty())
{
macro->setHidden(true);
QByteArray __tmp;
__tmp.reserve (256);
MacroExpander expand_macro (env);
expand_macro(macro->definition(), &__tmp);
if (! __tmp.isEmpty ())
{
const char *__tmp_begin = __tmp.constBegin();
const char *__tmp_end = __tmp.constEnd();
const char *__begin_id = skip_whitespaces (__tmp_begin, __tmp_end);
const char *__end_id = skip_identifier (__begin_id, __tmp_end);
if (__end_id == __tmp_end)
{
const QByteArray __id (__begin_id, __end_id - __begin_id);
m = env->resolve (__id);
}
if (! m)
*__result += __tmp;
}
macro->setHidden(false);
}
if (! m)
continue;
macro = m;
}
// function like macro
const char *arg_it = skip_whitespaces (__first, __last);
if (arg_it == __last || *arg_it != '(')
{
__result->append(name_begin, name_end - name_begin);
lines += skip_whitespaces.lines;
__first = arg_it;
continue;
}
QVector<QByteArray> actuals;
QVector<MacroArgumentReference> actuals_ref;
actuals.reserve (5);
++arg_it; // skip '('
MacroExpander expand_actual (env, frame);
const char *arg_end = skip_argument_variadics (actuals, macro, arg_it, __last);
if (arg_it != arg_end)
{
actuals_ref.append(MacroArgumentReference(start_offset + (arg_it-start), arg_end - arg_it));
const QByteArray actual (arg_it, arg_end - arg_it);
QByteArray expanded;
expand_actual (actual.constBegin (), actual.constEnd (), &expanded);
actuals.push_back (expanded);
arg_it = arg_end;
}
while (arg_it != __last && *arg_end == ',')
{
++arg_it; // skip ','
arg_end = skip_argument_variadics (actuals, macro, arg_it, __last);
actuals_ref.append(MacroArgumentReference(start_offset + (arg_it-start), arg_end - arg_it));
const QByteArray actual (arg_it, arg_end - arg_it);
QByteArray expanded;
expand_actual (actual.constBegin (), actual.constEnd (), &expanded);
actuals.push_back (expanded);
arg_it = arg_end;
}
if (! (arg_it != __last && *arg_it == ')'))
return __last;
++arg_it; // skip ')'
__first = arg_it;
pp_frame frame (macro, actuals);
MacroExpander expand_macro (env, &frame);
macro->setHidden(true);
expand_macro (macro->definition(), __result);
macro->setHidden(false);
}
else
__result->append(*__first++);
}
return __first;
}
