C++ QNetworkCookie::setExpirationDate方法代码示例

QNetworkReply* KVNetworkAccessManager::createRequest(Operation op, const QNetworkRequest &req, QIODevice *outgoingData)
{
	QNetworkRequest request = req;
	request.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:28.0) Gecko/20100101 Firefox/28.0");

	if(op == PostOperation) {
		//qDebug() << "POST" << request.url().path();
		// If the request addressed to API - translate this request
		if(request.url().host() != "localhost" && request.url().host() != "127.0.0.1" && !request.url().host().contains(".dmm.com")) {
			QNetworkReply *r = QNetworkAccessManager::createRequest(op, request, outgoingData);
			KVNetworkReply *reply = new KVNetworkReply(r->parent(), r, this, translation);
			return reply;
		}
	}
	else if(op == GetOperation)
	{
		// If the request addressed to DMM - create hacked cookies
		if(request.url().host().contains(".dmm.com"))
		{
			QNetworkCookie languageCookie;
			languageCookie.setDomain(".dmm.com");
			languageCookie.setPath("/");
			languageCookie.setName("cklg");
			languageCookie.setValue("ja");
			languageCookie.setExpirationDate(QDateTime::currentDateTime().addYears(1));

			QNetworkCookie locationCookie;
			locationCookie.setDomain(".dmm.com");
			locationCookie.setPath("/");
			locationCookie.setName("ckcy");
			locationCookie.setValue("1");
			locationCookie.setExpirationDate(QDateTime::currentDateTime().addYears(1));

			if(cookieHack)
			{
				cookieJar()->insertCookie(languageCookie);
				cookieJar()->insertCookie(locationCookie);
			}
			else
			{
				cookieJar()->deleteCookie(languageCookie);
				cookieJar()->deleteCookie(locationCookie);
			}
		}
	}

	QNetworkReply *reply = QNetworkAccessManager::createRequest(op, request, outgoingData);

	// If the request if for an SWF or MP3 file, track it and report progress
	if(req.url().path().endsWith(".swf") || req.url().path().endsWith(".mp3"))
	{
		connect(reply, SIGNAL(metaDataChanged()), this, SLOT(trackedGETMetaDataChanged()));
		connect(reply, SIGNAL(readyRead()), this, SLOT(trackedGETReadyRead()));
		connect(reply, SIGNAL(finished()), this, SLOT(trackedGETFinished()));
	}

	return reply;
}

QNetworkCookie CookieDialog::cookie()
{
    QNetworkCookie cookie;
    cookie.setDomain(m_domainLineEdit->text());
    cookie.setName(m_nameLineEdit->text().toLatin1());
    cookie.setValue(m_valueLineEdit->text().toLatin1());
    cookie.setExpirationDate(QDateTime(m_dateEdit->date()));
    cookie.setPath(m_pathLineEdit->text());
    cookie.setSecure(m_isSecureComboBox->currentText() == tr("yes"));
    cookie.setHttpOnly(m_isHttpOnlyComboBox->currentText() == tr("yes"));
    return cookie;
}

void CookieJar::setCookies(const QVariantList &cookies)
{
    QList<QNetworkCookie> newCookies;
    for (int i = 0; i < cookies.size(); ++i) {
        QNetworkCookie nc;
        QVariantMap cookie = cookies.at(i).toMap();

        //
        // The field of domain and cookie name/value MUST be set, otherwise skip it.
        //
        if (cookie["domain"].isNull() || cookie["domain"].toString().isEmpty()
                || cookie["name"].isNull() || cookie["name"].toString().isEmpty()
                || cookie["value"].isNull()
           ) {
            continue;
        } else {
            nc.setDomain(cookie["domain"].toString());
            nc.setName(cookie["name"].toByteArray());
            nc.setValue(cookie["value"].toByteArray());
        }

        if (cookie["path"].isNull() || cookie["path"].toString().isEmpty()) {
            nc.setPath("/");
        } else {
            nc.setPath(cookie["path"].toString());
        }

        if (cookie["httponly"].isNull()) {
            nc.setHttpOnly(false);
        } else {
            nc.setHttpOnly(cookie["httponly"].toBool());
        }

        if (cookie["secure"].isNull()) {
            nc.setSecure(false);
        } else {
            nc.setSecure(cookie["secure"].toBool());
        }

        if (!cookie["expires"].isNull()) {
            QString datetime = cookie["expires"].toString().replace(" GMT", "");
            QDateTime expires = QDateTime::fromString(datetime, "ddd, dd MMM yyyy hh:mm:ss");
            if (expires.isValid()) {
                nc.setExpirationDate(expires);
            }
        }

        newCookies.append(nc);
    }

    this->setAllCookies(newCookies);
}

void HttpWriterTest::writeSetCookieValue_data () {
	QTest::addColumn< QNetworkCookie > ("input");
	QTest::addColumn< QString > ("result");
	
	QNetworkCookie normal ("foo", "bar");
	QNetworkCookie encoded ("foo", "b a;r");
	QNetworkCookie maxAge ("foo", "bar");
	QNetworkCookie maxAgePast ("foo", "bar");
	QNetworkCookie domain ("foo", "bar");
	QNetworkCookie path ("foo", "bar");
	QNetworkCookie secure ("foo", "bar");
	QNetworkCookie httpOnly ("foo", "bar");
	QNetworkCookie complex ("foo", "b a;r");
	
	maxAge.setExpirationDate (QDateTime::currentDateTime ().addSecs (123));
	maxAgePast.setExpirationDate (QDateTime::currentDateTime ().addSecs (-100));
	domain.setDomain ("nuriaproject.org");
	path.setPath ("/foo/bar");
	secure.setSecure (true);
	httpOnly.setHttpOnly (true);
	
	complex.setExpirationDate (QDateTime::currentDateTime ().addSecs (123));
	complex.setDomain ("nuriaproject.org");
	complex.setPath ("/foo/bar");
	complex.setSecure (true);
	complex.setHttpOnly (true);
	
	QTest::newRow ("normal") << normal << "foo=bar";
	QTest::newRow ("encoded") << encoded << "foo=b%20a%3Br";
	QTest::newRow ("maxAge") << maxAge << "foo=bar; Max-Age=123";
	QTest::newRow ("maxAge in past") << maxAgePast << "foo=bar; Max-Age=0";
	QTest::newRow ("domain") << domain << "foo=bar; Domain=nuriaproject.org";
	QTest::newRow ("path") << path << "foo=bar; Path=/foo/bar";
	QTest::newRow ("secure") << secure << "foo=bar; Secure";
	QTest::newRow ("httpOnly") << httpOnly << "foo=bar; HttpOnly";
	QTest::newRow ("complex") << complex << "foo=b%20a%3Br; Domain=nuriaproject.org; "
				     "Path=/foo/bar; Max-Age=123; Secure; HttpOnly";
	
}

bool CookiesModel::insertRows(int row, int count, const QModelIndex &parent)
{
    if ((row < 0) || (row > m_cookies.size())) return false;

    QNetworkCookie newCookie;
    newCookie.setExpirationDate(QDateTime::currentDateTime().addYears(99));

    beginInsertRows(parent, row, row + count - 1);
    while (count-- > 0)
        m_cookies.insert(row, newCookie);
    endInsertRows();

    return true;
}

void CookieJar::read()
{
    qDebug() << Q_FUNC_INFO;
    qDebug() << COOKIE_PATH;
    QFile f(COOKIE);

    if(!f.exists())
    {
        return;
    }

    if (!f.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return;
    }

    QList<QNetworkCookie> list;

    while(!f.atEnd())
    {
        QList<QByteArray> spl = f.readLine().split(';');
        QList<QByteArray> cookie = spl[0].split('=');

        if(cookie.length() < 2 || cookie[0].isEmpty() || cookie[1].isEmpty())
        {
            continue;
        }

        QMap<QByteArray, QByteArray> add;
        for(int cnt = 1; spl.length() > cnt; cnt++)
        {
            QList<QByteArray> t = spl[cnt].split('=');
            if(t.count() > 1)
            {
                add[t[0].trimmed()] = t[1].trimmed();
            }
        }

        QNetworkCookie c;
        c.setName(cookie[0]);
        c.setValue(cookie[1]);
        c.setPath(add["path"]);
        c.setDomain(add["domain"]);
        c.setExpirationDate(QDateTime::fromString(add["expires"]));
        list.append(c);
    }
    setAllCookies(list);
}

void connectWindowClass::checkThisCookie(QNetworkCookie cookie)
{
    if(cookie.name() == "dlrowolleh" || cookie.name() == "coniunctio")
    {
        for(int j = 0; j < cookieList.size(); ++j)
        {
            if(cookieList.at(j).name() == cookie.name())
            {
                cookieList.removeAt(j);
                break;
            }
        }
        cookie.setExpirationDate(QDateTime::currentDateTime().addYears(8));
        cookieList.append(cookie);
    }

    adjustSize();
}

PostMonster::HttpResponse Common::deserializeResponse(const QJsonObject &jsonResponse)
{
    PostMonster::HttpResponse response;

    response.mimeType = jsonResponse["mimeType"].toString().toLatin1();
    response.status = jsonResponse["status"].toInt();

    QByteArray body;
    body.append(jsonResponse["body"].toString());
    response.body.append(QByteArray::fromBase64(body));

    foreach (const QJsonValue &jsonHeader, jsonResponse["headers"].toArray()) {
        QNetworkReply::RawHeaderPair header;
        header.first.append(jsonHeader.toObject()["name"].toString());
        header.second.append(jsonHeader.toObject()["value"].toString());

        response.headers << header;
    }

    foreach (const QJsonValue &value, jsonResponse["cookies"].toArray()) {
        const QJsonObject &jsonCookie = value.toObject();
        QNetworkCookie cookie;

        if (jsonCookie.contains("expire"))
            cookie.setExpirationDate(QDateTime::fromString(jsonCookie["expire"].toString(),
                                                           Qt::ISODate));
        if (jsonCookie["httpOnly"].toBool())
            cookie.setHttpOnly(true);
        if (jsonCookie["secure"].toBool())
            cookie.setSecure(true);
        if (jsonCookie.contains("path"))
            cookie.setPath(jsonCookie["path"].toString());

        cookie.setName(jsonCookie["name"].toString().toLatin1());
        cookie.setValue(jsonCookie["value"].toString().toLatin1());

        response.cookies << cookie;
    }

    return response;
}

PostMonster::HttpRequest Common::deserializeRequest(const QJsonObject &jsonRequest)
{
    PostMonster::HttpRequest request;

    request.url = jsonRequest["url"].toString();
    request.method = jsonRequest["method"].toString().toLatin1();
    request.encoding = jsonRequest["encoding"].toString().toLatin1();
    request.body = QByteArray::fromBase64(jsonRequest["body"].toString().toLatin1());

    foreach (const QJsonValue &value, jsonRequest["headers"].toArray()) {
        const QJsonObject &jsonHeader = value.toObject();
        QNetworkReply::RawHeaderPair header;

        header.first = jsonHeader["name"].toString().toLatin1();
        header.second = jsonHeader["value"].toString().toLatin1();

        request.headers << header;
    }

    foreach (const QJsonValue &value, jsonRequest["cookies"].toArray()) {
        const QJsonObject &jsonCookie = value.toObject();
        QNetworkCookie cookie;

        if (jsonCookie.contains("expire"))
            cookie.setExpirationDate(QDateTime::fromString(jsonCookie["expire"].toString(),
                                                           Qt::ISODate));
        if (jsonCookie["httpOnly"].toBool())
            cookie.setHttpOnly(true);
        if (jsonCookie["secure"].toBool())
            cookie.setSecure(true);
        if (jsonCookie.contains("path"))
            cookie.setPath(jsonCookie["path"].toString());

        cookie.setName(jsonCookie["name"].toString().toLatin1());
        cookie.setValue(jsonCookie["value"].toString().toLatin1());

        request.cookies << cookie;
    }

    return request;
}

void HttpWriterTest::writeSetCookies () {
	HttpWriter writer;
	
	// Data
	QByteArray expected = "Set-Cookie: expires=b%20a%3Br; Max-Age=0; Secure; HttpOnly\r\n"
			      "Set-Cookie: session=foo\r\n";
	
	QNetworkCookie expires ("expires", "b a;r");
	expires.setExpirationDate (QDateTime::fromMSecsSinceEpoch (123));
	expires.setSecure (true);
	expires.setHttpOnly (true);
	
	HttpClient::Cookies cookies {
		{ "session", QNetworkCookie ("session", "foo") },
		{ "expires", expires }
	};
	
	// 
	QByteArray result = writer.writeSetCookies (cookies);
	QCOMPARE(result, expected);
}

bool CookieJar::setCookie(const QString& cookieName, const QString& value, int maxAge, const QString& path, const QString& domain, bool isSecure)
{
	QNetworkCookie cookie;
	QUrl url = QString(isSecure ? "https://" : "http://" + QString(domain.startsWith('.') ? "www" : "") + domain + (path.isEmpty() ? "/" : path));
#ifdef U_CJ_DEBUG
	qDebug() << Q_FUNC_INFO << allCookies().count() << url;
#endif
	cookie.setName(cookieName.toUtf8());
	cookie.setValue(value.toUtf8());
	cookie.setDomain(domain);
	cookie.setPath(path);
	cookie.setSecure(isSecure);

	if(maxAge != 0) {
		QDateTime expireDate = QDateTime::currentDateTimeUtc().addSecs(maxAge);
		cookie.setExpirationDate(expireDate);
	}
#ifdef U_CJ_DEBUG
	qDebug() << Q_FUNC_INFO << cookie;
#endif
	return setCookiesFromUrl(QList<QNetworkCookie>() << cookie, url);
}

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, true);
        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, 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()) {
                        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;
    }

//.........这里部分代码省略.........

void AddFeedWizard::addFeed()
{
  // Set URL-schema for URL-address "http://" or leave it "https://"
  feedUrlString_ = urlFeedEdit_->text().simplified();
  if (feedUrlString_.contains("feed:", Qt::CaseInsensitive)) {
    if (feedUrlString_.contains("https://", Qt::CaseInsensitive)) {
      feedUrlString_.remove(0, 5);
      urlFeedEdit_->setText(feedUrlString_);
    } else {
      feedUrlString_.remove(0, 7);
      urlFeedEdit_->setText("http://" + feedUrlString_);
    }
  }
  QUrl feedUrl(urlFeedEdit_->text().simplified());
  if (feedUrl.scheme().isEmpty()) {
    feedUrl.setUrl("http://" % urlFeedEdit_->text().simplified());
  }
  feedUrlString_ = feedUrl.toString();
  urlFeedEdit_->setText(feedUrlString_);

#if QT_VERSION >= 0x040800
  if (feedUrl.host().isEmpty() && !feedUrl.isLocalFile()) {
#else
  if (feedUrl.host().isEmpty() && (feedUrl.scheme() != "file")) {
#endif
    textWarning->setText(tr("URL error!"));
    warningWidget_->setVisible(true);
    return;
  }

  QSqlQuery q;
  int duplicateFoundId = -1;
  q.prepare("SELECT id FROM feeds WHERE xmlUrl LIKE :xmlUrl");
  q.bindValue(":xmlUrl", feedUrlString_);
  q.exec();
  if (q.first())
    duplicateFoundId = q.value(0).toInt();

  if (0 <= duplicateFoundId) {
    textWarning->setText(tr("Duplicate feed!"));
    warningWidget_->setVisible(true);
  } else {
    button(QWizard::NextButton)->setEnabled(false);
    button(QWizard::CancelButton)->setEnabled(false);
    button(QWizard::FinishButton)->setEnabled(false);
    page(0)->setEnabled(false);
    showProgressBar();

    // Calculate row's number to insert new feed
    int rowToParent = 0;
    q.exec("SELECT count(id) FROM feeds WHERE parentId=0");
    if (q.next()) rowToParent = q.value(0).toInt();

    int auth = 0;
    QString userInfo;
    if (authentication_->isChecked()) {
      auth = 1;
      userInfo = QString("%1:%2").arg(user_->text()).arg(pass_->text());
    }

    // Insert feed
    q.prepare("INSERT INTO feeds(xmlUrl, created, rowToParent, authentication) "
              "VALUES (:feedUrl, :feedCreateTime, :rowToParent, :authentication)");
    q.bindValue(":feedUrl", feedUrlString_);
    q.bindValue(":feedCreateTime",
        QLocale::c().toString(QDateTime::currentDateTimeUtc(), "yyyy-MM-ddTHH:mm:ss"));
    q.bindValue(":rowToParent", rowToParent);
    q.bindValue(":authentication", auth);
    q.exec();

    feedId_ = q.lastInsertId().toInt();
    q.finish();

    if (feedUrlString_.contains(":COOKIE:", Qt::CaseInsensitive)) {
      int index = feedUrlString_.lastIndexOf(":COOKIE:", -1, Qt::CaseInsensitive);
      QString cookieStr = feedUrlString_.right(feedUrlString_.length() - index - 8);
      QStringList cookieStrList = cookieStr.split(";");

      QList<QNetworkCookie> loadedCookies;
      foreach (QString cookieStr, cookieStrList) {
        const QList<QNetworkCookie> &cookieList = QNetworkCookie::parseCookies(cookieStr.toUtf8());
        if (cookieList.isEmpty()) {
          continue;
        }
        QNetworkCookie cookie = cookieList.at(0);
        QDateTime date = QDateTime::currentDateTime();
        date = date.addYears(35);
        cookie.setExpirationDate(date);
        loadedCookies.append(cookie);
      }
      mainApp->cookieJar()->setCookiesFromUrl(loadedCookies, feedUrlString_);
    }

    emit signalRequestUrl(feedId_, feedUrlString_, QDateTime(), userInfo);
  }
}