NS_IMETHODIMP nsAbDirectoryQuery::DoQuery(nsIAbDirectory *aDirectory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirSearchListener* listener,
PRInt32 resultLimit, PRInt32 timeOut,
PRInt32* _retval)
{
NS_ENSURE_ARG_POINTER(aDirectory);
nsCOMPtr<nsISupports> supportsExpression;
nsresult rv = arguments->GetExpression(getter_AddRefs(supportsExpression));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbBooleanExpression> expression(do_QueryInterface(supportsExpression, &rv));
NS_ENSURE_SUCCESS(rv, rv);
bool doSubDirectories;
rv = arguments->GetQuerySubDirectories(&doSubDirectories);
NS_ENSURE_SUCCESS(rv, rv);
rv = query(aDirectory, expression, listener, doSubDirectories, &resultLimit);
rv = NS_FAILED(rv) ? queryError(listener) : queryFinished(listener);
*_retval = 0;
return rv;
}
void MsgAudioSelectionEngine::HandleQueryCompletedL(CMdEQuery& aQuery,
TInt aError)
{
iNameList.clear();
iUriList.clear();
if (aError == KErrCancel)
{
emit queryError(aError);
return;
}
else
{
QMap<QString,QString> nameUriList;
CMdEObjectQuery* query = static_cast<CMdEObjectQuery*> (&aQuery);
TInt count = query->Count();
for (TInt i = 0; i < count; ++i)
{
CMdEObject* object =
(CMdEObject*) query->TakeOwnershipOfResult(i);
CleanupStack::PushL(object);
CMdEPropertyDef& propDef = MsgAudioSelectionEngine::PropertyDefL(
iSession, MsgAudioSelectionEngine::EAttrFileName);
CMdEProperty* property = 0;
TInt err = object->Property(propDef, property, 0);
if (err != KErrNotFound && property)
{
QString songName(XQConversions::s60DescToQString(
property->TextValueL()));
QString uriValue(XQConversions::s60DescToQString(
object->Uri()));
//insert into the map
nameUriList.insertMulti(uriValue, songName);
}
CleanupStack::PopAndDestroy(object);
}
//now get all the song names and sort them
iNameList = nameUriList.values();
iNameList.sort();
// go through the song list and get the associated uri
// insert into the uri list
int nameListTotal = iNameList.count();
for(int nameListCount = 0;
nameListCount<nameListTotal;
nameListCount++)
{
QString key = nameUriList.key(iNameList.at(nameListCount));
iUriList.append(key);
nameUriList.remove(key);
}
// emit the list to the model
emit queryComplete(iNameList, iUriList);
}
}
Instance MemoryDump::queryInstance(const int queryId, KnowledgeSources src) const
{
// The very first component must be a variable
Variable* v = _factory->findVarById(queryId);
if (!v)
queryError(QString("Variable with ID 0x%1 does not exist")
.arg(queryId, 0, 16));
return v->toInstance(_vmem, BaseType::trLexicalAndPointers, src);
}
Instance MemoryDump::queryInstance(const QString& queryString,
KnowledgeSources src) const
{
QStringList components = queryString.split('.', QString::SkipEmptyParts);
if (components.isEmpty())
queryError("Empty query string given");
Instance result, prev;
while (!components.isEmpty()) {
result = getNextInstance(components.first(), result, src);
if (!result.isValid()) {
QString s(prev.fullName());
if (!s.isEmpty())
s += ".";
s += components.first();
if (result.origin() == Instance::orCandidate)
queryError(QString("The selected member candidate for \"%1\" is invalid")
.arg(s));
else if (result.origin() == Instance::orRuleEngine)
queryError(QString("The instance \"%1\" returned by the rule engine is invalid.")
.arg(s));
else
queryError(QString("The instance \"%1\" is invalid (origin: %2)")
.arg(s)
.arg(Instance::originToString(result.origin())));
}
prev = result;
components.pop_front();
}
return result;
}
void QParseQuery::onQueryReply( QParseReply* reply ) {
if ( reply->getHasError() ) {
emit queryError( reply->getErrorMessage() );
return;
}
// elaborate the result and create objects
QParse* parse = QParse::instance();
QJsonArray results = reply->getJson()["results"].toArray();
QList<QParseObject*> parseObjects;
for( int i=0; i<results.count(); i++ ) {
QJsonObject object = results.at(i).toObject();
// call the constructor passing the json object data
QParseObject* parseObject = qobject_cast<QParseObject*>(metaParseObject.newInstance( Q_ARG(QJsonObject, object), Q_ARG(QObject*, parse) ));
parseObjects << parseObject;
}
emit queryResults( parseObjects );
reply->deleteLater();
}
void LLQueryResponder::queryResult(const char *buf, size_t len)
{
const char *pos = buf;
int qdcount = DNS_HEADER_QDCOUNT(pos);
int ancount = DNS_HEADER_ANCOUNT(pos);
int nscount = DNS_HEADER_NSCOUNT(pos);
int arcount = DNS_HEADER_ARCOUNT(pos);
int ret;
if (qdcount == 0 || ancount + nscount + arcount == 0)
{
ret = ARES_ENODATA;
goto bail;
}
pos += NS_HFIXEDSZ;
for (int i = 0; i < qdcount; i++)
{
std::string ignore;
size_t enclen;
ret = LLAres::expandName(pos, buf, len, i == 0 ? mQuery : ignore,
enclen);
if (ret != ARES_SUCCESS)
{
goto bail;
}
pos += enclen;
if (i == 0)
{
int t = DNS_QUESTION_TYPE(pos);
switch (t)
{
case RES_A:
case RES_NS:
case RES_CNAME:
case RES_PTR:
case RES_AAAA:
case RES_SRV:
mType = (LLResType) t;
break;
default:
LL_INFOS() << "Cannot grok query type " << t << LL_ENDL;
ret = ARES_EBADQUERY;
goto bail;
}
}
pos += NS_QFIXEDSZ;
if (pos > buf + len)
{
ret = ARES_EBADRESP;
goto bail;
}
}
ret = parseSection(buf, len, ancount, pos, mAnswers);
if (ret != ARES_SUCCESS)
{
goto bail;
}
ret = parseSection(buf, len, nscount, pos, mAuthorities);
if (ret != ARES_SUCCESS)
{
goto bail;
}
ret = parseSection(buf, len, arcount, pos, mAdditional);
bail:
mResult = ret;
if (mResult == ARES_SUCCESS)
{
querySuccess();
} else {
queryError(mResult);
}
}
QString MemoryDump::dump(const QString& type, quint64 address, int length,
const ColorPalette& col) const
{
if (type == "char") {
char c;
if (_vmem->readAtomic(address, &c, sizeof(char)) != sizeof(char))
queryError(QString("Cannot read memory from address 0x%1")
.arg(address, (_specs.sizeofPointer << 1), 16, QChar('0')));
return QString("%1 (0x%2)").arg(c).arg(c, (sizeof(c) << 1), 16, QChar('0'));
}
if (type == "int") {
qint32 i;
if (_vmem->readAtomic(address, (char*)&i, sizeof(qint32)) != sizeof(qint32))
queryError(QString("Cannot read memory from address 0x%1")
.arg(address, (_specs.sizeofPointer << 1), 16, QChar('0')));
return QString("%1 (0x%2)").arg(i).arg((quint32)i, (sizeof(i) << 1), 16, QChar('0'));
}
if (type == "long") {
qint64 l;
if (_vmem->readAtomic(address, (char*)&l, sizeof(qint64)) != sizeof(qint64))
queryError(QString("Cannot read memory from address 0x%1")
.arg(address, (_specs.sizeofPointer << 1), 16, QChar('0')));
return QString("%1 (0x%2)").arg(l).arg((quint64)l, (sizeof(l) << 1), 16, QChar('0'));
}
if (type == "raw" || type == "hex") {
QString ret;
const int buflen = 256, linelen = 16;
char buf[buflen];
char bufstr[linelen + 1] = {0};
// Make sure we got a valid length
if (length < 0)
queryError(QString("No valid length given for dumping raw memory"));
int totalBytesRead = 0, col = 0;
while (length > 0) {
int bytesRead = _vmem->readAtomic(address, buf, qMin(buflen, length));
length -= bytesRead;
int i = 0;
while (i < bytesRead) {
// New line every 16 bytes begins with address
if (totalBytesRead % 16 == 0) {
if (totalBytesRead > 0) {
ret += QString(" |%0|\n").arg(bufstr, -linelen);
memset(bufstr, 0, linelen + 1);
col = 0;
}
ret += QString("%1 ").arg(address, _specs.sizeofPointer << 1, 16, QChar('0'));
}
// Wider column after 8 bytes
if (totalBytesRead % 8 == 0)
ret += ' ';
// Write the character as hex string
if ((unsigned char)buf[i] < 16)
ret += '0';
ret += QString::number((unsigned char)buf[i], 16) + ' ';
// Add character to string buffer, if it's an ASCII char
if ( ((unsigned char)buf[i] >= 32) && ((unsigned char)buf[i] < 127) )
bufstr[col] = buf[i];
else
bufstr[col] = '.';
++col;
++totalBytesRead;
++address;
++i;
}
}
// Finish it up
if (col > 0) {
while (col < linelen) {
ret += " ";
if (col % 8 == 0)
ret += ' ';
++col;
}
ret += QString(" |%0|").arg(bufstr, -linelen);
}
return ret;
}
QStringList components = type.split('.', QString::SkipEmptyParts);
Instance result;
if (!components.isEmpty()) {
// Get first instance
result = getInstanceAt(components.first(), address, QStringList("user"));
components.pop_front();
while (!components.isEmpty()) {
result = getNextInstance(components.first(), result, ksNone);
components.pop_front();
}
return QString("%1%2%3 (ID%4 0x%5%6) @%7 0x%8%9\n")
.arg(col.color(ctType))
.arg(result.typeName())
.arg(col.color(ctReset))
.arg(col.color(ctTypeId))
.arg((uint)result.type()->id(), 0, 16)
.arg(col.color(ctReset))
.arg(col.color(ctAddress))
.arg(result.address(), 0, 16)
.arg(col.color(ctReset)) + result.toString(&col);
}
queryError3("Unknown type: " + type,
QueryException::ecUnresolvedType, type);
return QString();
}
Instance MemoryDump::getNextInstance(const QString& component,
const Instance& instance,
KnowledgeSources src) const
{
Instance result;
QString typeString, symbol, offsetString, candidate, arrayIndexString;
bool okay;
// quint32 compatibleCnt = 0;
// A component should have the form (symbol(-offset)?)?symbol(<candidate>)?([index])?
#define SYMBOL "[A-Za-z0-9_]+"
#define NUMBER "\\d+"
QRegExp re(
"^\\s*(?:"
"\\(\\s*"
"(" SYMBOL ")"
"(?:"
"\\s*-\\s*(" SYMBOL ")"
")?"
"\\s*\\)"
")?"
"\\s*(" SYMBOL ")\\s*"
"(?:<\\s*(" NUMBER ")\\s*>\\s*)?"
"((?:\\[\\s*" NUMBER "\\s*\\]\\s*)*)\\s*");
if (!re.exactMatch(component)) {
queryError(QString("Could not parse a part of the query string: %1")
.arg(component));
}
// Set variables according to the matching
typeString = re.cap(1);
offsetString = re.cap(2).trimmed();
symbol = re.cap(3);
candidate = re.cap(4);
arrayIndexString = re.cap(5).trimmed();
int candidateIndex = candidate.isEmpty() ? -1 : candidate.toInt();
// debugmsg(QString("1: %1, 2: %2, 3: %3, 4: %4, 5: %5")
// .arg(re.cap(1))
// .arg(re.cap(2))
// .arg(re.cap(3))
// .arg(re.cap(4))
// .arg(re.cap(5)));
// A candidate index of 0 means to ignore the alternative types
if (candidateIndex == 0)
src = static_cast<KnowledgeSources>(src|ksNoAltTypes);
// If the given instance is Null, we interpret this as the first component
// in the query string and will therefore try to resolve the variable.
if (!instance.isValid()) {
Variable* v = _factory->findVarByName(symbol);
if (!v)
queryError(QString("Variable does not exist: %1").arg(symbol));
if (candidateIndex > 0) {
if (v->altRefTypeCount() < candidateIndex)
queryError(QString("Variable \"%1\" does not have a candidate "
"with index %2")
.arg(symbol)
.arg(candidateIndex));
result = v->altRefTypeInstance(_vmem, candidateIndex - 1);
}
else {
result = v->toInstance(_vmem, BaseType::trLexical, src);
}
}
else {
// Dereference any pointers/arrays first
result = instance.dereference(BaseType::trAnyNonNull);
// Did we get a null instance?
if (!(result.type()->type() & StructOrUnion) &&
(result.isNull() || !result.toPointer()))
queryError(QString("Member \"%1\" is null")
.arg(result.fullName()));
// We have a instance therefore we resolve the member
if (!(result.type()->type() & StructOrUnion))
queryError(QString("Member \"%1\" is not a struct or union")
.arg(result.fullName()));
if (!result.memberExists(symbol))
queryError(QString("Struct \"%1\" has no member named \"%2\"")
.arg(result.typeName())
.arg(symbol));
// Do we have a candidate index?
if (candidateIndex > 0) {
if (result.memberCandidatesCount(symbol) < candidateIndex)
queryError(QString("Member \"%1\" does not have a candidate "
"with index %2")
.arg(symbol)
.arg(candidateIndex));
result = result.memberCandidate(symbol, candidateIndex - 1);
}
else {
result = result.member(symbol, BaseType::trLexical, 0, src);
}
}
if (!result.isValid())
return result;
// Cast the instance if necessary
if (!typeString.isEmpty()) {
quint32 offset = 0;
// Is a offset given?
if (!offsetString.isEmpty()) {
// Is the offset given as string or as int?
offset = offsetString.toUInt(&okay, 10);
if (!okay) {
// String.
BaseType* type = getType(typeString);
if (!type ||
!(type->type() & StructOrUnion))
queryError(QString("The given type \"%1\" is not a struct "
"or union and therefore has no offset")
.arg(typeString));
Structured* structd = dynamic_cast<Structured *>(type);
if (!structd->memberExists(offsetString)) {
queryError(QString("Struct of type \"%1\" has no member "
"named \"%2\"")
.arg(typeString)
.arg(offsetString));
}
else {
StructuredMember* structdMember =
structd->member(offsetString);
offset = structdMember->offset();
}
}
}
// Get address
size_t address;
if (result.type()->type() & (rtPointer))
address = (size_t)result.toPointer() - offset;
else
address = result.address() - offset;
result = getInstanceAt(typeString, address, result.fullNameComponents());
}
// Add array index
if (!arrayIndexString.isEmpty()) {
QRegExp reArrayIndex("\\[\\s*(" NUMBER ")\\s*\\]\\s*");
QStringList matches;
int strpos = 0;
while (strpos < arrayIndexString.size() &&
(strpos = arrayIndexString.indexOf(reArrayIndex, strpos)) >= 0)
{
matches.append(reArrayIndex.cap(1));
strpos += reArrayIndex.cap(0).size();
}
for (int i = 0; i < matches.count(); ++i) {
quint32 arrayIndex = matches[i].toUInt(&okay, 10);
if (okay) {
// Is the result already an instance list?
if (result.isList()) {
InstanceList list(result.toList());
if (arrayIndex < (quint32)list.size())
result = list[arrayIndex];
else
queryError(QString("Given array index %1 is out of bounds.")
.arg(arrayIndex));
}
else {
// Is this a pointer or an array type?
Instance tmp = result.arrayElem(arrayIndex);
if (!tmp.isNull())
result = tmp.dereference(BaseType::trLexical);
// Manually update the address
else {
result.addToAddress(arrayIndex * result.type()->size());
result.setName(QString("%1[%2]").arg(result.name()).arg(arrayIndex));
}
}
}
else {
queryError(QString("Given array index %1 could not be converted "
"to a number.")
.arg(matches[i]));
}
}
}
// Try to dereference this instance as deep as possible
return result.dereference(BaseType::trLexicalAndPointers);
}
