bool PLSParser::TryMagic(const QByteArray& data) const {
return data.toLower().contains("[playlist]");
}
/* calculate request-digest/response-digest as per HTTP Digest spec */
static QByteArray digestMd5ResponseHelper(
const QByteArray &alg,
const QByteArray &userName,
const QByteArray &realm,
const QByteArray &password,
const QByteArray &nonce, /* nonce from server */
const QByteArray &nonceCount, /* 8 hex digits */
const QByteArray &cNonce, /* client nonce */
const QByteArray &qop, /* qop-value: "", "auth", "auth-int" */
const QByteArray &method, /* method from the request */
const QByteArray &digestUri, /* requested URL */
const QByteArray &hEntity /* H(entity body) if qop="auth-int" */
)
{
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData(userName);
hash.addData(":", 1);
hash.addData(realm);
hash.addData(":", 1);
hash.addData(password);
QByteArray ha1 = hash.result();
if (alg.toLower() == "md5-sess") {
hash.reset();
// RFC 2617 contains an error, it was:
// hash.addData(ha1);
// but according to the errata page at http://www.rfc-editor.org/errata_list.php, ID 1649, it
// must be the following line:
hash.addData(ha1.toHex());
hash.addData(":", 1);
hash.addData(nonce);
hash.addData(":", 1);
hash.addData(cNonce);
ha1 = hash.result();
};
ha1 = ha1.toHex();
// calculate H(A2)
hash.reset();
hash.addData(method);
hash.addData(":", 1);
hash.addData(digestUri);
if (qop.toLower() == "auth-int") {
hash.addData(":", 1);
hash.addData(hEntity);
}
QByteArray ha2hex = hash.result().toHex();
// calculate response
hash.reset();
hash.addData(ha1);
hash.addData(":", 1);
hash.addData(nonce);
hash.addData(":", 1);
if (!qop.isNull()) {
hash.addData(nonceCount);
hash.addData(":", 1);
hash.addData(cNonce);
hash.addData(":", 1);
hash.addData(qop);
hash.addData(":", 1);
}
hash.addData(ha2hex);
return hash.result().toHex();
}
QList<QNetworkCookie> QNetworkCookiePrivate::parseSetCookieHeaderLine(const QByteArray &cookieString)
{
// According to http://wp.netscape.com/newsref/std/cookie_spec.html,<
// the Set-Cookie response header is of the format:
//
// Set-Cookie: NAME=VALUE; expires=DATE; path=PATH; domain=DOMAIN_NAME; secure
//
// where only the NAME=VALUE part is mandatory
//
// We do not support RFC 2965 Set-Cookie2-style cookies
QList<QNetworkCookie> result;
QDateTime now = QDateTime::currentDateTime().toUTC();
int position = 0;
const int length = cookieString.length();
while (position < length) {
QNetworkCookie cookie;
// The first part is always the "NAME=VALUE" part
QPair<QByteArray,QByteArray> field = nextField(cookieString, position);
if (field.first.isEmpty() || field.second.isNull())
// parsing error
break;
cookie.setName(field.first);
cookie.setValue(field.second);
position = nextNonWhitespace(cookieString, position);
bool endOfCookie = false;
while (!endOfCookie && position < length) {
switch (cookieString.at(position++)) {
case ',':
// end of the cookie
endOfCookie = true;
break;
case ';':
// new field in the cookie
field = nextField(cookieString, position);
field.first = field.first.toLower(); // everything but the NAME=VALUE is case-insensitive
if (field.first == "expires") {
position -= field.second.length();
int end;
for (end = position; end < length; ++end)
if (isValueSeparator(cookieString.at(end)))
break;
QByteArray dateString = cookieString.mid(position, end - position).trimmed();
position = end;
QDateTime dt = parseDateString(dateString.toLower());
if (!dt.isValid()) {
return result;
}
cookie.setExpirationDate(dt);
} else if (field.first == "domain") {
QByteArray rawDomain = field.second;
QString maybeLeadingDot;
if (rawDomain.startsWith('.')) {
maybeLeadingDot = QLatin1Char('.');
rawDomain = rawDomain.mid(1);
}
QString normalizedDomain = QUrl::fromAce(QUrl::toAce(QString::fromUtf8(rawDomain)));
if (normalizedDomain.isEmpty() && !rawDomain.isEmpty())
return result;
cookie.setDomain(maybeLeadingDot + normalizedDomain);
} else if (field.first == "max-age") {
bool ok = false;
int secs = field.second.toInt(&ok);
if (!ok)
return result;
cookie.setExpirationDate(now.addSecs(secs));
} else if (field.first == "path") {
QString path = QUrl::fromPercentEncoding(field.second);
cookie.setPath(path);
} else if (field.first == "secure") {
cookie.setSecure(true);
} else if (field.first == "httponly") {
cookie.setHttpOnly(true);
} else if (field.first == "comment") {
//cookie.setComment(QString::fromUtf8(field.second));
} else if (field.first == "version") {
if (field.second != "1") {
// oops, we don't know how to handle this cookie
return result;
}
} else {
// got an unknown field in the cookie
// what do we do?
}
position = nextNonWhitespace(cookieString, position);
}
}
if (!cookie.name().isEmpty())
result += cookie;
}
return result;
}
qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
{
if (fragment.isEmpty()) {
// according to http://dev.opera.com/articles/view/mama-http-headers/ the average size of the header
// block is 381 bytes.
// reserve bytes. This is better than always append() which reallocs the byte array.
fragment.reserve(512);
}
qint64 bytes = 0;
char c = 0;
bool allHeaders = false;
qint64 haveRead = 0;
do {
haveRead = socket->read(&c, 1);
if (haveRead == 0) {
// read more later
break;
} else if (haveRead == -1) {
// connection broke down
return -1;
} else {
fragment.append(c);
bytes++;
if (c == '\n') {
// check for possible header endings. As per HTTP rfc,
// the header endings will be marked by CRLFCRLF. But
// we will allow CRLFCRLF, CRLFLF, LFLF
if (fragment.endsWith("\r\n\r\n")
|| fragment.endsWith("\r\n\n")
|| fragment.endsWith("\n\n"))
allHeaders = true;
// there is another case: We have no headers. Then the fragment equals just the line ending
if ((fragment.length() == 2 && fragment.endsWith("\r\n"))
|| (fragment.length() == 1 && fragment.endsWith("\n")))
allHeaders = true;
}
}
} while (!allHeaders && haveRead > 0);
// we received all headers now parse them
if (allHeaders) {
parseHeader(fragment);
state = ReadingDataState;
fragment.clear(); // next fragment
bodyLength = contentLength(); // cache the length
// cache isChunked() since it is called often
chunkedTransferEncoding = headerField("transfer-encoding").toLower().contains("chunked");
// cache isConnectionCloseEnabled since it is called often
QByteArray connectionHeaderField = headerField("connection");
// check for explicit indication of close or the implicit connection close of HTTP/1.0
connectionCloseEnabled = (connectionHeaderField.toLower().contains("close") ||
headerField("proxy-connection").toLower().contains("close")) ||
(majorVersion == 1 && minorVersion == 0 &&
(connectionHeaderField.isEmpty() && !headerField("proxy-connection").toLower().contains("keep-alive")));
}
return bytes;
}
bool IqAuthFeature::xmppStanzaIn(IXmppStream *AXmppStream, Stanza &AStanza, int AOrder)
{
if (AXmppStream==FXmppStream && AOrder==XSHO_XMPP_FEATURE)
{
if (AStanza.id() == "getIqAuth")
{
if (AStanza.type() == "result")
{
Stanza auth("iq");
auth.setType("set").setTo(FXmppStream->streamJid().domain()).setId("setIqAuth");
QDomElement query = auth.addElement("query",NS_JABBER_IQ_AUTH);
query.appendChild(auth.createElement("username")).appendChild(auth.createTextNode(FXmppStream->streamJid().pNode()));
query.appendChild(auth.createElement("resource")).appendChild(auth.createTextNode(FXmppStream->streamJid().resource()));
QDomElement reqElem = AStanza.firstElement("query",NS_JABBER_IQ_AUTH);
if (!reqElem.firstChildElement("digest").isNull())
{
QByteArray shaData = FXmppStream->streamId().toUtf8()+FXmppStream->password().toUtf8();
QByteArray shaDigest = QCryptographicHash::hash(shaData,QCryptographicHash::Sha1).toHex();
query.appendChild(auth.createElement("digest")).appendChild(auth.createTextNode(shaDigest.toLower().trimmed()));
FXmppStream->sendStanza(auth);
LOG_STRM_INFO(AXmppStream->streamJid(),"Username and encrypted password sent");
}
else if (!reqElem.firstChildElement("password").isNull())
{
if (FXmppStream->connection()->isEncrypted())
{
query.appendChild(auth.createElement("password")).appendChild(auth.createTextNode(FXmppStream->password()));
FXmppStream->sendStanza(auth);
LOG_STRM_INFO(AXmppStream->streamJid(),"Username and plain text password sent");
}
else
{
LOG_STRM_ERROR(AXmppStream->streamJid(),"Failed to send username and plain text password: Connection not encrypted");
emit error(XmppError(IERR_XMPPSTREAM_NOT_SECURE));
}
}
}
else
{
XmppStanzaError err(AStanza);
LOG_STRM_ERROR(AXmppStream->streamJid(),QString("Failed to receive authentication initialization: %1").arg(err.condition()));
emit error(err);
}
return true;
}
else if (AStanza.id() == "setIqAuth")
{
FXmppStream->removeXmppStanzaHandler(XSHO_XMPP_FEATURE,this);
if (AStanza.type() == "result")
{
LOG_STRM_INFO(AXmppStream->streamJid(),"Username and password accepted");
deleteLater();
emit finished(false);
}
else
{
XmppStanzaError err(AStanza);
LOG_STRM_WARNING(AXmppStream->streamJid(),QString("Username and password rejected: %1").arg(err.condition()));
emit error(XmppStanzaError(AStanza));
}
return true;
}
}
return false;
}
static QFontEngine::FaceId fontFile(const QByteArray &_xname, QFreetypeFace **freetype, int *synth)
{
*freetype = 0;
*synth = 0;
QByteArray xname = _xname.toLower();
int pos = 0;
int minus = 0;
while (minus < 5 && (pos = xname.indexOf('-', pos + 1)))
++minus;
QByteArray searchname = xname.left(pos);
while (minus < 12 && (pos = xname.indexOf('-', pos + 1)))
++minus;
QByteArray encoding = xname.mid(pos + 1);
//qDebug("xname='%s', searchname='%s', encoding='%s'", xname.data(), searchname.data(), encoding.data());
QStringList fontpath = fontPath();
QFontEngine::FaceId face_id;
face_id.index = 0;
QByteArray best_mapping;
for (QStringList::ConstIterator it = fontpath.constBegin(); it != fontpath.constEnd(); ++it) {
if (!(*it).startsWith(QLatin1Char('/')))
continue; // not a path name, a font server
QString fontmapname;
int num = 0;
// search font.dir and font.scale for the right file
while (num < 2) {
if (num == 0)
fontmapname = (*it) + QLatin1String("/fonts.scale");
else
fontmapname = (*it) + QLatin1String("/fonts.dir");
++num;
//qWarning(fontmapname);
QFile fontmap(fontmapname);
if (!fontmap.open(QIODevice::ReadOnly))
continue;
while (!fontmap.atEnd()) {
QByteArray mapping = fontmap.readLine();
QByteArray lmapping = mapping.toLower();
//qWarning(xfontname);
//qWarning(mapping);
if (!lmapping.contains(searchname))
continue;
int index = mapping.indexOf(' ');
QByteArray ffn = mapping.mid(0,index);
// remove bitmap formats freetype can't handle
if (ffn.contains(".spd") || ffn.contains(".phont"))
continue;
bool best_match = false;
if (!best_mapping.isEmpty()) {
if (lmapping.contains("-0-0-0-0-")) { // scalable font
best_match = true;
goto found;
}
if (lmapping.contains(encoding) && !best_mapping.toLower().contains(encoding))
goto found;
continue;
}
found:
int colon = ffn.lastIndexOf(':');
if (colon != -1) {
QByteArray s = ffn.left(colon);
ffn = ffn.mid(colon + 1);
if (s.contains("ds="))
*synth |= QFontEngine::SynthesizedBold;
if (s.contains("ai="))
*synth |= QFontEngine::SynthesizedItalic;
}
face_id.filename = (*it).toLocal8Bit() + '/' + ffn;
best_mapping = mapping;
if (best_match)
goto end;
}
}
}
end:
// qDebug("fontfile for %s is from '%s'\n got %s synth=%d", xname.data(),
// best_mapping.data(), face_id.filename.data(), *synth);
*freetype = QFreetypeFace::getFace(face_id);
if (!*freetype) {
face_id.index = 0;
face_id.filename = QByteArray();
}
return face_id;
}
void QNetworkAccessDataBackend::open()
{
QUrl uri = request().url();
if (operation() != QNetworkAccessManager::GetOperation &&
operation() != QNetworkAccessManager::HeadOperation) {
// data: doesn't support anything but GET
QString msg = QObject::tr("Operation not supported on %1")
.arg(uri.toString());
error(QNetworkReply::ContentOperationNotPermittedError, msg);
finished();
return;
}
if (uri.host().isEmpty()) {
setHeader(QNetworkRequest::ContentTypeHeader, QLatin1String("text/plain;charset=US-ASCII"));
// the following would have been the correct thing, but
// reality often differs from the specification. People have
// data: URIs with ? and #
//QByteArray data = QByteArray::fromPercentEncoding(uri.encodedPath());
QByteArray data = QByteArray::fromPercentEncoding(uri.toEncoded());
// remove the data: scheme
data.remove(0, 5);
// parse it:
int pos = data.indexOf(',');
if (pos != -1) {
QByteArray payload = data.mid(pos + 1);
data.truncate(pos);
data = data.trimmed();
// find out if the payload is encoded in Base64
if (data.endsWith(";base64")) {
payload = QByteArray::fromBase64(payload);
data.chop(7);
}
if (data.toLower().startsWith("charset")) {
int i = 7; // strlen("charset")
while (data.at(i) == ' ')
++i;
if (data.at(i) == '=')
data.prepend("text/plain;");
}
if (!data.isEmpty())
setHeader(QNetworkRequest::ContentTypeHeader, data.trimmed());
setHeader(QNetworkRequest::ContentLengthHeader, payload.size());
emit metaDataChanged();
writeDownstreamData(payload);
finished();
return;
}
}
// something wrong with this URI
QString msg = QObject::tr("Invalid URI: %1").arg(uri.toString());
error(QNetworkReply::ProtocolFailure, msg);
finished();
}
QList<QNetworkCookie> QNetworkCookiePrivate::parseSetCookieHeaderLine(const QByteArray &cookieString)
{
// According to http://wp.netscape.com/newsref/std/cookie_spec.html,<
// the Set-Cookie response header is of the format:
//
// Set-Cookie: NAME=VALUE; expires=DATE; path=PATH; domain=DOMAIN_NAME; secure
//
// where only the NAME=VALUE part is mandatory
//
// We do not support RFC 2965 Set-Cookie2-style cookies
QList<QNetworkCookie> result;
const QDateTime now = QDateTime::currentDateTimeUtc();
int position = 0;
const int length = cookieString.length();
while (position < length) {
QNetworkCookie cookie;
// The first part is always the "NAME=VALUE" part
QPair<QByteArray,QByteArray> field = nextField(cookieString, position, true);
if (field.first.isEmpty())
// parsing error
break;
cookie.setName(field.first);
cookie.setValue(field.second);
position = nextNonWhitespace(cookieString, position);
while (position < length) {
switch (cookieString.at(position++)) {
case ';':
// new field in the cookie
field = nextField(cookieString, position, false);
field.first = field.first.toLower(); // everything but the NAME=VALUE is case-insensitive
if (field.first == "expires") {
position -= field.second.length();
int end;
for (end = position; end < length; ++end)
if (isValueSeparator(cookieString.at(end)))
break;
QByteArray dateString = cookieString.mid(position, end - position).trimmed();
position = end;
QDateTime dt = parseDateString(dateString.toLower());
if (dt.isValid())
cookie.setExpirationDate(dt);
//if unparsed, ignore the attribute but not the whole cookie (RFC6265 section 5.2.1)
} else if (field.first == "domain") {
QByteArray rawDomain = field.second;
//empty domain should be ignored (RFC6265 section 5.2.3)
if (!rawDomain.isEmpty()) {
QString maybeLeadingDot;
if (rawDomain.startsWith('.')) {
maybeLeadingDot = QLatin1Char('.');
rawDomain = rawDomain.mid(1);
}
//IDN domains are required by RFC6265, accepting utf8 as well doesn't break any test cases.
QString normalizedDomain = QUrl::fromAce(QUrl::toAce(QString::fromUtf8(rawDomain)));
if (!normalizedDomain.isEmpty()) {
cookie.setDomain(maybeLeadingDot + normalizedDomain);
} else {
//Normalization fails for malformed domains, e.g. "..example.org", reject the cookie now
//rather than accepting it but never sending it due to domain match failure, as the
//strict reading of RFC6265 would indicate.
return result;
}
}
} else if (field.first == "max-age") {
bool ok = false;
int secs = field.second.toInt(&ok);
if (ok) {
if (secs <= 0) {
//earliest representable time (RFC6265 section 5.2.2)
cookie.setExpirationDate(QDateTime::fromSecsSinceEpoch(0));
} else {
cookie.setExpirationDate(now.addSecs(secs));
}
}
//if unparsed, ignore the attribute but not the whole cookie (RFC6265 section 5.2.2)
} else if (field.first == "path") {
if (field.second.startsWith('/')) {
// ### we should treat cookie paths as an octet sequence internally
// However RFC6265 says we should assume UTF-8 for presentation as a string
cookie.setPath(QString::fromUtf8(field.second));
} else {
// if the path doesn't start with '/' then set the default path (RFC6265 section 5.2.4)
// and also IETF test case path0030 which has valid and empty path in the same cookie
cookie.setPath(QString());
}
} else if (field.first == "secure") {
cookie.setSecure(true);
} else if (field.first == "httponly") {
cookie.setHttpOnly(true);
} else {
// ignore unknown fields in the cookie (RFC6265 section 5.2, rule 6)
}
position = nextNonWhitespace(cookieString, position);
}
}
if (!cookie.name().isEmpty())
result += cookie;
}
return result;
}
void QHttpSocketEngine::slotSocketReadNotification()
{
Q_D(QHttpSocketEngine);
if (d->state != Connected && d->socket->bytesAvailable() == 0)
return;
if (d->state == Connected) {
// Forward as a read notification.
if (d->readNotificationEnabled)
emitReadNotification();
return;
}
if (d->state == ConnectSent) {
d->reply->d_func()->state = QHttpNetworkReplyPrivate::NothingDoneState;
d->state = ReadResponseHeader;
}
if (d->state == ReadResponseHeader) {
bool ok = readHttpHeader();
if (!ok) {
// protocol error, this isn't HTTP
d->socket->close();
setState(QAbstractSocket::UnconnectedState);
setError(QAbstractSocket::ProxyProtocolError, tr("Did not receive HTTP response from proxy"));
emitConnectionNotification();
return;
}
if (d->state == ReadResponseHeader)
return; // readHttpHeader() was not done yet, need to wait for more header data
}
if (d->state == ReadResponseContent) {
char dummybuffer[4096];
while (d->pendingResponseData) {
int read = d->socket->read(dummybuffer, qMin(sizeof(dummybuffer), (size_t)d->pendingResponseData));
if (read == 0)
return;
if (read == -1) {
d->socket->disconnectFromHost();
emitWriteNotification();
return;
}
d->pendingResponseData -= read;
}
if (d->pendingResponseData > 0)
return;
if (d->reply->d_func()->statusCode == 407)
d->state = SendAuthentication;
}
int statusCode = d->reply->statusCode();
QAuthenticatorPrivate *priv = 0;
if (statusCode == 200) {
d->state = Connected;
setLocalAddress(d->socket->localAddress());
setLocalPort(d->socket->localPort());
setState(QAbstractSocket::ConnectedState);
d->authenticator.detach();
priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
priv->hasFailed = false;
} else if (statusCode == 407) {
if (d->authenticator.isNull())
d->authenticator.detach();
priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
if (d->credentialsSent && priv->phase != QAuthenticatorPrivate::Phase2) {
// Remember that (e.g.) NTLM is two-phase, so only reset when the authentication is not currently in progress.
//407 response again means the provided username/password were invalid.
d->authenticator = QAuthenticator(); //this is needed otherwise parseHttpResponse won't set the state, and then signal isn't emitted.
d->authenticator.detach();
priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
priv->hasFailed = true;
}
priv->parseHttpResponse(d->reply->header(), true);
if (priv->phase == QAuthenticatorPrivate::Invalid) {
// problem parsing the reply
d->socket->close();
setState(QAbstractSocket::UnconnectedState);
setError(QAbstractSocket::ProxyProtocolError, tr("Error parsing authentication request from proxy"));
emitConnectionNotification();
return;
}
bool willClose;
QByteArray proxyConnectionHeader = d->reply->headerField("Proxy-Connection");
// Although most proxies use the unofficial Proxy-Connection header, the Connection header
// from http spec is also allowed.
if (proxyConnectionHeader.isEmpty())
proxyConnectionHeader = d->reply->headerField("Connection");
proxyConnectionHeader = proxyConnectionHeader.toLower();
if (proxyConnectionHeader == "close") {
willClose = true;
} else if (proxyConnectionHeader == "keep-alive") {
willClose = false;
} else {
// no Proxy-Connection header, so use the default
// HTTP 1.1's default behaviour is to keep persistent connections
// HTTP 1.0 or earlier, so we expect the server to close
willClose = (d->reply->majorVersion() * 0x100 + d->reply->minorVersion()) <= 0x0100;
}
if (willClose) {
// the server will disconnect, so let's avoid receiving an error
// especially since the signal below may trigger a new event loop
d->socket->disconnectFromHost();
d->socket->readAll();
//We're done with the reply and need to reset it for the next connection
delete d->reply;
d->reply = new QHttpNetworkReply;
}
if (priv->phase == QAuthenticatorPrivate::Done)
emit proxyAuthenticationRequired(d->proxy, &d->authenticator);
// priv->phase will get reset to QAuthenticatorPrivate::Start if the authenticator got modified in the signal above.
if (priv->phase == QAuthenticatorPrivate::Done) {
setError(QAbstractSocket::ProxyAuthenticationRequiredError, tr("Authentication required"));
d->socket->disconnectFromHost();
} else {
// close the connection if it isn't already and reconnect using the chosen authentication method
d->state = SendAuthentication;
if (willClose) {
d->socket->connectToHost(d->proxy.hostName(), d->proxy.port());
} else {
// send the HTTP CONNECT again
slotSocketConnected();
}
return;
}
} else {
d->socket->close();
setState(QAbstractSocket::UnconnectedState);
if (statusCode == 403 || statusCode == 405) {
// 403 Forbidden
// 405 Method Not Allowed
setError(QAbstractSocket::SocketAccessError, tr("Proxy denied connection"));
} else if (statusCode == 404) {
// 404 Not Found: host lookup error
setError(QAbstractSocket::HostNotFoundError, QAbstractSocket::tr("Host not found"));
} else if (statusCode == 503) {
// 503 Service Unavailable: Connection Refused
setError(QAbstractSocket::ConnectionRefusedError, QAbstractSocket::tr("Connection refused"));
} else {
// Some other reply
//qWarning("UNEXPECTED RESPONSE: [%s]", responseHeader.toString().toLatin1().data());
setError(QAbstractSocket::ProxyProtocolError, tr("Error communicating with HTTP proxy"));
}
}
// The handshake is done; notify that we're connected (or failed to connect)
emitConnectionNotification();
}
QString Driver::propertyCaption(const QByteArray& propName) const
{
return d->propertyCaptions.value(propName.toLower());
}
QVariant Driver::propertyValue(const QByteArray& propName) const
{
return d->properties.value(propName.toLower());
}
const QList<PlastiQCandidateMethod> PlastiQMetaObject::candidates(const QByteArray &name, int argc, PlastiQMethod::Type type, PlastiQMethod::Access filter, bool ignoreCase) const
{
#ifdef PQDEBUG
PQDBG_LVL_START(__FUNCTION__);
PQDBGLPUP(QString("PlastiQMetaObject::d.className = %1").arg(d.className));
PQDBGLPUP(QString("find candidates for `%1`").arg(name.constData()));
#endif
QList<PlastiQCandidateMethod> candidateList;
const PlastiQMetaObject *m = this;
int offset = 0;
bool maxArgs = argc == -1;
QByteArray lowerName = name.toLower();
do {
QHashIterator<QByteArray, PlastiQMethod> *i;
const QHash<QByteArray, PlastiQMethod> *hash;
switch(type) {
case PlastiQMethod::Method:
i = new QHashIterator<QByteArray, PlastiQMethod>(*(m->d.pq_methods));
hash = m->d.pq_methods;
break;
case PlastiQMethod::Constructor:
i = new QHashIterator<QByteArray, PlastiQMethod>(*(m->d.pq_constructors));
hash = m->d.pq_constructors;
break;
case PlastiQMethod::Signal:
i = new QHashIterator<QByteArray, PlastiQMethod>(*(m->d.pq_signals));
hash = m->d.pq_signals;
break;
default:
PQDBG_LVL_DONE();
return candidateList;
}
while(i->hasNext()) {
i->next();
if(ignoreCase) {
if(i->value().name.toLower() != lowerName) continue;
}
else {
if(i->value().name != name) continue;
}
int idx = i->key().indexOf("(");
QString methodSignature = i->key().mid(idx + 1, i->key().size() - idx - 2);
QStringList argTypes = methodSignature.split(",");
int candidateArgc = methodSignature.length() ? argTypes.size() : 0;
if(type == PlastiQMethod::Signal && maxArgs) {
if(argc < candidateArgc) {
argc = candidateArgc;
candidateList.clear();
candidateList.append({ i->value().name, argc, argTypes, i->value().index + offset });
continue;
}
}
else {
if(!maxArgs && candidateArgc != argc) {
continue;
}
}
if(filter == PlastiQMethod::None || filter == i->value().access) {
if(maxArgs) {
if(argc < candidateArgc) {
PQDBGLPUP(QString("reappend candidate: %1(%2)").arg(name.constData()).arg(methodSignature));
argc = candidateArgc;
candidateList.clear();
candidateList.append({ i->value().name, argc, argTypes, i->value().index + offset });
continue;
}
}
else {
PQDBGLPUP(QString("append candidate: %1(%2)").arg(name.constData()).arg(methodSignature));
candidateList.append({ i->value().name, argc, argTypes, i->value().index + offset });
}
}
}
if(type == PlastiQMethod::Constructor) {
delete i;
break;
}
else {
offset += hash->size();
delete i;
}
} while(m = m->d.superdata);
PQDBG_LVL_DONE();
return candidateList;
}
/*!
Converts the log \a log to its textual representation and returns
a QByteArray containing the data.
*/
QByteArray TLogger::logToByteArray(const TLog &log, const QByteArray &layout, const QByteArray &dateTimeFormat, QTextCodec *codec)
{
QByteArray message;
message.reserve(layout.length() + log.message.length() + 100);
int pos = 0;
while (pos < layout.length()) {
char c = layout.at(pos++);
if (c != '%') {
message.append(c);
continue;
}
QByteArray dig;
for (;;) {
if (pos >= layout.length()) {
message.append('%').append(dig);
break;
}
c = layout.at(pos++);
if (c >= '0' && c <= '9') {
dig += c;
continue;
}
if (c == 'd') { // %d : timestamp
if (!dateTimeFormat.isEmpty()) {
message.append(log.timestamp.toString(dateTimeFormat).toLatin1());
} else {
message.append(log.timestamp.toString(Qt::ISODate).toLatin1());
}
} else if (c == 'p' || c == 'P') { // %p or %P : priority
QByteArray pri = priorityToString((TLogger::Priority)log.priority);
if (c == 'p') {
pri = pri.toLower();
}
if (!pri.isEmpty()) {
message.append(pri);
int d = dig.toInt() - pri.length();
if (d > 0) {
message.append(QByteArray(d, ' '));
}
}
} else if (c == 't' || c == 'T') { // %t or %T : thread ID (dec or hex)
QChar fillChar = (dig.length() > 0 && dig[0] == '0') ? QLatin1Char('0') : QLatin1Char(' ');
message.append(QString("%1").arg((qulonglong)log.threadId, dig.toInt(), ((c == 't') ? 10 : 16), fillChar).toLatin1());
} else if (c == 'i' || c == 'I') { // %i or %I : PID (dec or hex)
QChar fillChar = (dig.length() > 0 && dig[0] == '0') ? QLatin1Char('0') : QLatin1Char(' ');
message.append(QString("%1").arg(log.pid, dig.toInt(), ((c == 'i') ? 10 : 16), fillChar).toLatin1());
} else if (c == 'n') { // %n : newline
message.append('\n');
} else if (c == 'm') { // %m : message
message.append(log.message);
} else if (c == '%') {
message.append('%').append(dig);
dig.clear();
continue;
} else {
message.append('%').append(dig).append(c);
}
break;
}
}
return (codec) ? codec->fromUnicode(QString::fromLocal8Bit(message.data(), message.length())) : message;
}