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); }