static void processCookie(QString &line)
{
QString policy;
popArg(policy, line);
KCookieAdvice expectedAdvice = KCookieJar::strToAdvice(policy);
if (expectedAdvice == KCookieDunno)
FAIL(QString("Unknown accept policy '%1'").arg(policy));
QString urlStr;
popArg(urlStr, line);
KUrl url(urlStr);
if (!url.isValid())
FAIL(QString("Invalid URL '%1'").arg(urlStr));
if (url.isEmpty())
FAIL(QString("Missing URL"));
line.replace("%LASTYEAR%", *lastYear);
line.replace("%NEXTYEAR%", *nextYear);
KHttpCookieList list = jar->makeCookies(urlStr, line.toUtf8(), windowId);
if (list.isEmpty())
FAIL(QString("Failed to make cookies from: '%1'").arg(line));
for(KHttpCookieList::iterator cookieIterator = list.begin();
cookieIterator != list.end(); ++cookieIterator) {
KHttpCookie& cookie = *cookieIterator;
const KCookieAdvice cookieAdvice = jar->cookieAdvice(cookie);
if (cookieAdvice != expectedAdvice)
FAIL(urlStr+QString("\n'%2'\nGot advice '%3' expected '%4'").arg(line)
.arg(KCookieJar::adviceToStr(cookieAdvice))
.arg(KCookieJar::adviceToStr(expectedAdvice)));
jar->addCookie(cookie);
}
}
Version Popt::getVersion(const Package &p, VersionFlag vf, bool versionMustExist) {
if(_args.empty()) {
switch(vf) {
case NO_DEFAULT:
// No default, skip to the popArg call below which
// will trigger the appropriate error.
break;
case INSTALLED:
if(p.isInstalled()) {
return p.getInstalledVersion(); // exists per definition
}
break; // Fall through to popArg
case INSTALLED_OR_CURRENT:
if(p.isInstalled()) {
return p.getInstalledVersion(); // exists per definition
}
// fall through to next case
case CURRENT:
if(p.hasVersions()) {
return p.getRecentVersion(); // Exists per definition
}
break; // Fall through to popArg
case NONE_NEEDED:
// Ignores versionMustExist, caller has to handle this,
// but at least we do not return an invalid version just an empty
// one, the caller can easily distinct them.
return Version::EMPTY_VERSION;
}
}
const Version v(popArg("missing version"));
if(v.isEmptyVersion() || versionMustExist) {
p.checkVersionExists(v);
}
return v;
}
static void processLine(QString line)
{
if (line.isEmpty())
return;
if (line[0] == '#')
{
if (line[1] == '#')
qDebug("%s", line.toLatin1().constData());
return;
}
QString command;
popArg(command, line);
if (command.isEmpty())
return;
if (command == "COOKIE")
processCookie(line);
else if (command == "CHECK")
processCheck(line);
else if (command == "CLEAR")
processClear(line);
else if (command == "CONFIG")
processConfig(line);
else if (command == "SAVE")
saveCookies();
else
FAIL(QString("Unknown command '%1'").arg(command));
}
static void processConfig(QString &line)
{
QString key;
popArg(key, line);
if (key.isEmpty())
FAIL(QString("Missing Key"));
KConfigGroup cg(config, "Cookie Policy");
cg.writeEntry(key, line);
jar->loadConfig(config, false);
}
static void processCheck(QString &line)
{
QString urlStr;
popArg(urlStr, line);
KUrl url(urlStr);
if (!url.isValid())
FAIL(QString("Invalid URL '%1'").arg(urlStr));
if (url.isEmpty())
FAIL(QString("Missing URL"));
QString expectedCookies = line;
QString cookies = jar->findCookies(urlStr, false, windowId, 0).trimmed();
if (cookies != expectedCookies)
FAIL(urlStr+QString("\nGot '%1' expected '%2'")
.arg(cookies, expectedCookies));
}
// Extract package and version, both may be in on argument as
// <pkg>:<version> or they may be in two arguments.
// @param versionMustExist If true, the function checks that the version supplied
// actually exists, otherwise it throws an exception.
Package &Popt::getPackage(Version &v, VersionFlags vf, bool versionMustExist) {
if(_args.empty()) {
const std::string defaultPName = getDefaultPackageName();
if(!defaultPName.empty()) {
Package &p = _tp.getPackage(defaultPName);
if(vf != NONE_NEEDED) {
v = getVersion(p, vf, versionMustExist); // extract with default or throw
}
return p;
}
}
std::string pname = popArg("missing package name");
if(extractPackageAndVersionFromString(pname, v)) {
Package &p = _tp.getPackage(pname);
if(versionMustExist) {
p.checkVersionExists(v);
}
return p;
}
if(!_tp.hasPackage(pname)) {
if(pname.compare(0, 3, "lib") == 0) {
// package name is something like "libfoo"
// Check if the package name is actually only "foo" or "foolib"
Package::Name oname = pname.substr(3);
warnIfPackageExists(pname, oname);
warnIfPackageExists(pname, oname + "lib");
} else if(pname.length() > 3 && pname.compare(pname.length() - 3, 3, "lib") == 0) {
// Same as above, but package name is "foolib"
Package::Name oname = pname.substr(0, pname.length() - 3);
warnIfPackageExists(pname, oname);
warnIfPackageExists(pname, "lib" + oname);
} else {
warnIfPackageExists(pname, pname + "lib");
warnIfPackageExists(pname, "lib" + pname);
}
}
Package &p = _tp.getPackage(pname);
if(vf != NONE_NEEDED) {
v = getVersion(p, vf, versionMustExist);
}
return p;
}
Package &Popt::getPackage2(Version &v) {
if(_args.size() == 1) {
// Only one argument, assume this to be the version
std::string pname = popArg();
if(extractPackageAndVersionFromString(pname, v)) {
// pname had a package name _and_ a version, that's all we need, v is already written.
return _tp.getPackage(pname);
}
// Now we have either a package name and no version string
// or only a version string and no package name.
// See if we have a default package name.
const std::string defaultPName = getDefaultPackageName();
if(!defaultPName.empty()) {
// OK, we have a default package name, assume the argument to be the version
v = pname;
return _tp.getPackage(defaultPName);
}
// Initialy there was only one argument, it had been removed at the call to popArg
// above, now the getPackage will fail with a more or less meaningfull message.
assert(_args.empty());
}
// At least two arguments, use the normal algorithm
return getPackage(v, NO_DEFAULT, false);
}
std::string Popt::popArg() {
return popArg("missing argument(s)");
}
