TestLaunchConfiguration(KUrl script) { c = new KConfig(); cfg = c->group("launch"); cfg.writeEntry("Server", script.host()); cfg.writeEntry("Path", script.path()); cfg.writeEntry("Arguments", script.query()); KConfigGroup pmCfg = cfg.group("Path Mappings").group("0"); pmCfg.writeEntry("Remote", KUrl(buildBaseUrl)); pmCfg.writeEntry("Local", KUrl(QDir::currentPath())); }
void SieveJob::schedule( Command command ) { switch ( command ) { case Get: kDebug() << "get(" << mUrl.prettyUrl() << ")"; mJob = KIO::get( mUrl ); connect( mJob, SIGNAL(data(KIO::Job*,const QByteArray&)), SLOT(slotData(KIO::Job*,const QByteArray&)) ); break; case Put: kDebug() << "put(" << mUrl.prettyUrl() << ")"; mJob = KIO::put( mUrl, 0600, KIO::Overwrite ); connect( mJob, SIGNAL(dataReq(KIO::Job*,QByteArray&)), SLOT(slotDataReq(KIO::Job*,QByteArray&)) ); break; case Activate: kDebug() << "chmod(" << mUrl.prettyUrl() <<", 0700 )"; mJob = KIO::chmod( mUrl, 0700 ); break; case Deactivate: kDebug() << "chmod(" << mUrl.prettyUrl() <<", 0600 )"; mJob = KIO::chmod( mUrl, 0600 ); break; case SearchActive: kDebug() << "listDir(" << mUrl.prettyUrl() << ")"; { KUrl url = mUrl; QString query = url.query(); //save query part, because KUrl::cd() erases it if ( !url.fileName().isEmpty() ) url.cd(".."); url.setQuery( query ); kDebug() << "listDir's real URL:" << url.prettyUrl(); mJob = KIO::listDir( url ); connect( mJob, SIGNAL(entries(KIO::Job*,const KIO::UDSEntryList&)), SLOT(slotEntries(KIO::Job*,const KIO::UDSEntryList&)) ); break; } case List: kDebug() << "listDir(" << mUrl.prettyUrl() << ")"; { mJob = KIO::listDir( mUrl ); connect( mJob, SIGNAL( entries(KIO::Job *, const KIO::UDSEntryList & ) ), SLOT( slotEntries( KIO::Job *, const KIO::UDSEntryList & ) ) ); break; } case Delete: kDebug() << "delete(" << mUrl.prettyUrl() << ")"; mJob = KIO::del( mUrl ); break; default: assert( 0 ); } // common to all jobs: connect( mJob, SIGNAL(result(KJob*)), SLOT(slotResult(KJob*)) ); }
// The opposite of parseURL static QString splitURL( int mRealArgType, const KUrl& url ) { if ( mRealArgType == 33 ) { // LDAP server // The format is HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN Q_ASSERT( url.protocol() == "ldap" ); return urlpart_encode( url.host() ) + ':' + ( url.port() != -1 ? QString::number( url.port() ) : QString() ) + ':' + // -1 is used for default ports, omit urlpart_encode( url.user() ) + ':' + urlpart_encode( url.pass() ) + ':' + // KUrl automatically encoded the query (e.g. for spaces inside it), // so decode it before writing it out to gpgconf (issue119) urlpart_encode( KUrl::fromPercentEncoding( url.query().mid(1).toLatin1() ) ); } return url.path(); }
Request Request::fromURL( const KUrl & url ) { Request request; const QStringList query = url.query().mid(1).split( QLatin1Char('&') ); #ifndef NDEBUG kDebug(7112) << "Parsing request from query:\n" << query.join( QLatin1String("\n") ); #endif for ( QStringList::const_iterator it = query.begin() ; it != query.end() ; ++it ) { int equalsPos = (*it).indexOf( QLatin1Char('=') ); if ( equalsPos <= 0 ) continue; const QString key = (*it).left( equalsPos ).toLower(); const QString value = QUrl::fromPercentEncoding( (*it).mid( equalsPos + 1 ).toLatin1() ); //krazy:exclude=qclasses if ( key == QLatin1String("to") ) request.addTo( value ); else if ( key == QLatin1String("cc") ) request.addCc( value ); else if ( key == QLatin1String("bcc") ) request.addBcc( value ); else if ( key == QLatin1String("headers") ) { request.setEmitHeaders( value == QLatin1String("0") ); request.setEmitHeaders( false ); // ### ??? } else if ( key == QLatin1String("subject") ) request.setSubject( value ); else if ( key == QLatin1String("from") ) request.setFromAddress( value ); else if ( key == QLatin1String("profile") ) request.setProfileName( value ); else if ( key == QLatin1String("hostname") ) request.setHeloHostname( value ); else if ( key == QLatin1String("body") ) request.set8BitBody( value.toUpper() == QLatin1String("8BIT") ); else if ( key == QLatin1String("size") ) request.setSize( value.toUInt() ); else kWarning(7112) << "while parsing query: unknown query item \"" << key << "\" with value \"" << value << "\"" << endl; } return request; }
/** * List the contents of a directory. */ void LDAPProtocol::listDir( const KUrl &_url ) { int ret, ret2, id, id2; unsigned long total=0; QStringList att,saveatt; LdapUrl usrc(_url),usrc2; bool critical = true; bool isSub = ( usrc.extension( "x-dir", critical ) == "sub" ); kDebug(7125) << "listDir(" << _url << ")"; changeCheck( usrc ); if ( !mConnected ) { finished(); return; } usrc2 = usrc; saveatt = usrc.attributes(); // look up the entries if ( isSub ) { att.append("dn"); usrc.setAttributes(att); } if ( _url.query().isEmpty() ) usrc.setScope( LdapUrl::One ); if ( (id = mOp.search( usrc.dn(), usrc.scope(), usrc.filter(), usrc.attributes() )) == -1 ) { LDAPErr(); return; } usrc.setAttributes( QStringList() << "" ); usrc.setExtension( "x-dir", "base" ); // publish the results UDSEntry uds; while( true ) { ret = mOp.waitForResult( id, -1 ); if ( ret == -1 || mConn.ldapErrorCode() != KLDAP_SUCCESS ) { LDAPErr(); return; } if ( ret == LdapOperation::RES_SEARCH_RESULT ) break; if ( ret != LdapOperation::RES_SEARCH_ENTRY ) continue; kDebug(7125) << " ldap_result: " << ret; total++; uds.clear(); LDAPEntry2UDSEntry( mOp.object().dn(), uds, usrc ); listEntry( uds, false ); // processedSize( total ); kDebug(7125) << " total: " << total << " " << usrc.prettyUrl(); // publish the sub-directories (if dirmode==sub) if ( isSub ) { LdapDN dn = mOp.object().dn(); usrc2.setDn( dn ); usrc2.setScope( LdapUrl::One ); usrc2.setAttributes( saveatt ); usrc2.setFilter( usrc.filter() ); kDebug(7125) << "search2 " << dn.toString(); if ( (id2 = mOp.search( dn, LdapUrl::One, QString(), att )) != -1 ) { while ( true ) { kDebug(7125) << " next result "; ret2 = mOp.waitForResult( id2, -1 ); if ( ret2 == -1 || ret2 == LdapOperation::RES_SEARCH_RESULT ) break; if ( ret2 == LdapOperation::RES_SEARCH_ENTRY ) { LDAPEntry2UDSEntry( dn, uds, usrc2, true ); listEntry( uds, false ); total++; mOp.abandon( id2 ); break; } } } } } // totalSize( total ); uds.clear(); listEntry( uds, true ); // we are done finished(); }
void CgiProtocol::get( const KUrl& url ) { kDebug(7124) << "CgiProtocol::get()"; kDebug(7124) << " URL: " << url.url(); #if 0 kDebug(7124) << " Path: " << url.path(); kDebug(7124) << " Query: " << url.query(); kDebug(7124) << " Protocol: " << url.protocol(); kDebug(7124) << " Filename: " << url.filename(); #endif QByteArray protocol = "SERVER_PROTOCOL=HTTP"; putenv( protocol.data() ); QByteArray requestMethod = "REQUEST_METHOD=GET"; putenv( requestMethod.data() ); QByteArray query = url.query().mid( 1 ).toLocal8Bit(); query.prepend( "QUERY_STRING=" ); putenv( query.data() ); QString path = url.path(); QString file; int pos = path.lastIndexOf('/'); if ( pos >= 0 ) file = path.mid( pos + 1 ); else file = path; QString cmd; bool stripHeader = false; bool forwardFile = true; QStringList::ConstIterator it; for( it = mCgiPaths.constBegin(); it != mCgiPaths.constEnd(); ++it ) { cmd = *it; if ( !(*it).endsWith('/') ) cmd += '/'; cmd += file; if ( KStandardDirs::exists( cmd ) ) { forwardFile = false; stripHeader = true; break; } } FILE *fd; if ( forwardFile ) { kDebug(7124) << "Forwarding to '" << path << "'"; QByteArray filepath = QFile::encodeName( path ); fd = fopen( filepath.data(), "r" ); if ( !fd ) { kDebug(7124) << "Error opening '" << filepath << "'"; error(KIO::ERR_CANNOT_OPEN_FOR_READING, path); return; } } else { kDebug(7124) << "Cmd: " << cmd; fd = popen( QFile::encodeName(KShell::quoteArg( cmd )).data(), "r" ); if ( !fd ) { kDebug(7124) << "Error running '" << cmd << "'"; error( KIO::ERR_CANNOT_OPEN_FOR_READING, cmd ); return; } } char buffer[ 4090 ]; while ( !feof( fd ) ) { int n = fread( buffer, 1, 2048, fd ); if ( n == -1 ) { // ERROR if ( forwardFile ) { fclose( fd ); } else { pclose( fd ); } return; } buffer[n] = 0; if ( stripHeader ) { QByteArray output = buffer; // this assumes buffer is text and not binary int colon = output.indexOf( ':' ); int newline = output.indexOf( '\n' ); int semicolon = output.lastIndexOf( ';', newline ); int end; if ( semicolon < 0 ) end = newline; else end = semicolon; #if 0 kDebug(7124) << " colon: " << colon; kDebug(7124) << " newline: " << newline; kDebug(7124) << " semicolon: " << semicolon; kDebug(7124) << " end: " << end; #endif // Set the charset meta data if one exists (BR# 241364). if (end == semicolon) { const int assignOp = output.indexOf('=', semicolon + 1); if (assignOp != -1) { const QByteArray charset (output.mid(assignOp+1, newline- assignOp -1).trimmed()); kDebug(7124) << "Charset:" << charset; setMetaData(QLatin1String("charset"), charset.toLower()); } } QByteArray contentType = output.mid( colon + 1, end - colon - 1 ); contentType = contentType.trimmed().toLower(); kDebug(7124) << "ContentType: '" << contentType << "'"; mimeType( contentType ); int start = output.indexOf( "\r\n\r\n" ); if ( start >= 0 ) start += 4; else { start = output.indexOf( "\n\n" ); if ( start >= 0 ) start += 2; } if ( start >= 0 ) output = output.mid( start ); stripHeader = false; data( output ); } else { data( QByteArray::fromRawData( buffer, n ) ); } } if ( forwardFile ) { fclose( fd ); } else { pclose( fd ); } finished(); kDebug(7124) << "CgiProtocol::get - done"; }
bool KShortUriFilter::filterUri( KUriFilterData& data ) const { /* * Here is a description of how the shortURI deals with the supplied * data. First it expands any environment variable settings and then * deals with special shortURI cases. These special cases are the "smb:" * URL scheme which is very specific to KDE, "#" and "##" which are * shortcuts for man:/ and info:/ protocols respectively. It then handles * local files. Then it checks to see if the URL is valid and one that is * supported by KDE's IO system. If all the above checks fails, it simply * lookups the URL in the user-defined list and returns without filtering * if it is not found. TODO: the user-defined table is currently only manually * hackable and is missing a config dialog. */ KUrl url = data.uri(); QString cmd = data.typedString(); // WORKAROUND: Allow the use of '@' in the username component of a URL since // other browsers such as firefox in their infinite wisdom allow such blatant // violations of RFC 3986. BR# 69326/118413. if (cmd.count(QLatin1Char('@')) > 1) { const int lastIndex = cmd.lastIndexOf(QLatin1Char('@')); // Percent encode all but the last '@'. QString encodedCmd = QUrl::toPercentEncoding(cmd.left(lastIndex), ":/"); encodedCmd += cmd.mid(lastIndex); KUrl u (encodedCmd); if (u.isValid()) { cmd = encodedCmd; url = u; } } const bool isMalformed = !url.isValid(); QString protocol = url.protocol(); kDebug(7023) << cmd; // Fix misparsing of "foo:80", QUrl thinks "foo" is the protocol and "80" is the path. // However, be careful not to do that for valid hostless URLs, e.g. file:///foo! if (!protocol.isEmpty() && url.host().isEmpty() && !url.path().isEmpty() && cmd.contains(':') && !KProtocolInfo::protocols().contains(protocol)) { protocol.clear(); } //kDebug(7023) << "url=" << url << "cmd=" << cmd << "isMalformed=" << isMalformed; if (!isMalformed && (protocol.length() == 4) && (protocol != QLatin1String("http")) && (protocol[0]=='h') && (protocol[1]==protocol[2]) && (protocol[3]=='p')) { // Handle "encrypted" URLs like: h++p://www.kde.org url.setProtocol( QLatin1String("http")); setFilteredUri( data, url); setUriType( data, KUriFilterData::NetProtocol ); return true; } // TODO: Make this a bit more intelligent for Minicli! There // is no need to make comparisons if the supplied data is a local // executable and only the argument part, if any, changed! (Dawit) // You mean caching the last filtering, to try and reuse it, to save stat()s? (David) const QString starthere_proto = QL1S("start-here:"); if (cmd.indexOf(starthere_proto) == 0 ) { setFilteredUri( data, KUrl("system:/") ); setUriType( data, KUriFilterData::LocalDir ); return true; } // Handle MAN & INFO pages shortcuts... const QString man_proto = QL1S("man:"); const QString info_proto = QL1S("info:"); if( cmd[0] == '#' || cmd.indexOf( man_proto ) == 0 || cmd.indexOf( info_proto ) == 0 ) { if( cmd.left(2) == QL1S("##") ) cmd = QL1S("info:/") + cmd.mid(2); else if ( cmd[0] == '#' ) cmd = QL1S("man:/") + cmd.mid(1); else if ((cmd==info_proto) || (cmd==man_proto)) cmd+='/'; setFilteredUri( data, KUrl( cmd )); setUriType( data, KUriFilterData::Help ); return true; } // Detect UNC style (aka windows SMB) URLs if ( cmd.startsWith( QLatin1String( "\\\\") ) ) { // make sure path is unix style cmd.replace('\\', '/'); cmd.prepend( QLatin1String( "smb:" ) ); setFilteredUri( data, KUrl( cmd )); setUriType( data, KUriFilterData::NetProtocol ); return true; } bool expanded = false; // Expanding shortcut to HOME URL... QString path; QString ref; QString query; QString nameFilter; if (KUrl::isRelativeUrl(cmd) && QDir::isRelativePath(cmd)) { path = cmd; //kDebug(7023) << "path=cmd=" << path; } else { if (url.isLocalFile()) { //kDebug(7023) << "hasRef=" << url.hasRef(); // Split path from ref/query // but not for "/tmp/a#b", if "a#b" is an existing file, // or for "/tmp/a?b" (#58990) if( ( url.hasRef() || !url.query().isEmpty() ) && !url.path().endsWith(QL1S("/")) ) // /tmp/?foo is a namefilter, not a query { path = url.path(); ref = url.ref(); //kDebug(7023) << "isLocalFile set path to " << stringDetails( path ); //kDebug(7023) << "isLocalFile set ref to " << stringDetails( ref ); query = url.query(); if (path.isEmpty() && url.hasHost()) path = '/'; } else { path = cmd; //kDebug(7023) << "(2) path=cmd=" << path; } } } if( path[0] == '~' ) { int slashPos = path.indexOf('/'); if( slashPos == -1 ) slashPos = path.length(); if( slashPos == 1 ) // ~/ { path.replace ( 0, 1, QDir::homePath() ); } else // ~username/ { const QString userName (path.mid( 1, slashPos-1 )); KUser user (userName); if( user.isValid() && !user.homeDir().isEmpty()) { path.replace (0, slashPos, user.homeDir()); } else { if (user.isValid()) { setErrorMsg(data, i18n("<qt><b>%1</b> does not have a home folder.</qt>", userName)); } else { setErrorMsg(data, i18n("<qt>There is no user called <b>%1</b>.</qt>", userName)); } setUriType( data, KUriFilterData::Error ); // Always return true for error conditions so // that other filters will not be invoked !! return true; } } expanded = true; } else if ( path[0] == '$' ) { // Environment variable expansion. if ( sEnvVarExp.indexIn( path ) == 0 ) { QByteArray exp = qgetenv( path.mid( 1, sEnvVarExp.matchedLength() - 1 ).toLocal8Bit().data() ); if(! exp.isNull()) { path.replace( 0, sEnvVarExp.matchedLength(), QString::fromLocal8Bit(exp.constData()) ); expanded = true; } } } if ( expanded || cmd.startsWith( '/' ) ) { // Look for #ref again, after $ and ~ expansion (testcase: $QTDIR/doc/html/functions.html#s) // Can't use KUrl here, setPath would escape it... const int pos = path.indexOf('#'); if ( pos > -1 ) { const QString newPath = path.left( pos ); if ( QFile::exists( newPath ) ) { ref = path.mid( pos + 1 ); path = newPath; //kDebug(7023) << "Extracted ref: path=" << path << " ref=" << ref; } } } bool isLocalFullPath = (!path.isEmpty() && path[0] == '/'); // Checking for local resource match... // Determine if "uri" is an absolute path to a local resource OR // A local resource with a supplied absolute path in KUriFilterData const QString abs_path = data.absolutePath(); const bool canBeAbsolute = (protocol.isEmpty() && !abs_path.isEmpty()); const bool canBeLocalAbsolute = (canBeAbsolute && abs_path[0] =='/' && !isMalformed); bool exists = false; /*kDebug(7023) << "abs_path=" << abs_path << "protocol=" << protocol << "canBeAbsolute=" << canBeAbsolute << "canBeLocalAbsolute=" << canBeLocalAbsolute << "isLocalFullPath=" << isLocalFullPath;*/ KDE_struct_stat buff; if ( canBeLocalAbsolute ) { QString abs = QDir::cleanPath( abs_path ); // combine absolute path (abs_path) and relative path (cmd) into abs_path int len = path.length(); if( (len==1 && path[0]=='.') || (len==2 && path[0]=='.' && path[1]=='.') ) path += '/'; //kDebug(7023) << "adding " << abs << " and " << path; abs = QDir::cleanPath(abs + '/' + path); //kDebug(7023) << "checking whether " << abs << " exists."; // Check if it exists if( KDE::stat( abs, &buff ) == 0 ) { path = abs; // yes -> store as the new cmd exists = true; isLocalFullPath = true; } } if (isLocalFullPath && !exists && !isMalformed) { exists = ( KDE::stat( path, &buff ) == 0 ); if ( !exists ) { // Support for name filter (/foo/*.txt), see also KonqMainWindow::detectNameFilter // If the app using this filter doesn't support it, well, it'll simply error out itself int lastSlash = path.lastIndexOf( '/' ); if ( lastSlash > -1 && path.indexOf( ' ', lastSlash ) == -1 ) // no space after last slash, otherwise it's more likely command-line arguments { QString fileName = path.mid( lastSlash + 1 ); QString testPath = path.left( lastSlash + 1 ); if ( ( fileName.indexOf( '*' ) != -1 || fileName.indexOf( '[' ) != -1 || fileName.indexOf( '?' ) != -1 ) && KDE::stat( testPath, &buff ) == 0 ) { nameFilter = fileName; //kDebug(7023) << "Setting nameFilter to " << nameFilter; path = testPath; exists = true; } } } } //kDebug(7023) << "path =" << path << " isLocalFullPath=" << isLocalFullPath << " exists=" << exists; if( exists ) { KUrl u; u.setPath(path); //kDebug(7023) << "ref=" << stringDetails(ref) << " query=" << stringDetails(query); u.setRef(ref); u.setQuery(query); if (!KAuthorized::authorizeUrlAction( QLatin1String("open"), KUrl(), u)) { // No authorization, we pretend it's a file will get // an access denied error later on. setFilteredUri( data, u ); setUriType( data, KUriFilterData::LocalFile ); return true; } // Can be abs path to file or directory, or to executable with args bool isDir = S_ISDIR( buff.st_mode ); if( !isDir && access ( QFile::encodeName(path).data(), X_OK) == 0 ) { //kDebug(7023) << "Abs path to EXECUTABLE"; setFilteredUri( data, u ); setUriType( data, KUriFilterData::Executable ); return true; } // Open "uri" as file:/xxx if it is a non-executable local resource. if( isDir || S_ISREG( buff.st_mode ) ) { //kDebug(7023) << "Abs path as local file or directory"; if ( !nameFilter.isEmpty() ) u.setFileName( nameFilter ); setFilteredUri( data, u ); setUriType( data, ( isDir ) ? KUriFilterData::LocalDir : KUriFilterData::LocalFile ); return true; } // Should we return LOCAL_FILE for non-regular files too? kDebug(7023) << "File found, but not a regular file nor dir... socket?"; } if( data.checkForExecutables()) { // Let us deal with possible relative URLs to see // if it is executable under the user's $PATH variable. // We try hard to avoid parsing any possible command // line arguments or options that might have been supplied. QString exe = removeArgs( cmd ); //kDebug(7023) << "findExe with" << exe; if (!KStandardDirs::findExe( exe ).isNull() ) { //kDebug(7023) << "EXECUTABLE exe=" << exe; setFilteredUri( data, KUrl::fromPath( exe )); // check if we have command line arguments if( exe != cmd ) setArguments(data, cmd.right(cmd.length() - exe.length())); setUriType( data, KUriFilterData::Executable ); return true; } } // Process URLs of known and supported protocols so we don't have // to resort to the pattern matching scheme below which can possibly // slow things down... if ( !isMalformed && !isLocalFullPath && !protocol.isEmpty() ) { //kDebug(7023) << "looking for protocol " << protocol; if ( KProtocolInfo::isKnownProtocol( protocol ) ) { setFilteredUri( data, url ); if ( protocol == QL1S("man") || protocol == QL1S("help") ) setUriType( data, KUriFilterData::Help ); else setUriType( data, KUriFilterData::NetProtocol ); return true; } } // Short url matches if ( !cmd.contains( ' ' ) ) { // Okay this is the code that allows users to supply custom matches for // specific URLs using Qt's regexp class. This is hard-coded for now. // TODO: Make configurable at some point... Q_FOREACH(const URLHint& hint, m_urlHints) { if (hint.regexp.indexIn(cmd) == 0) { //kDebug(7023) << "match - prepending" << (*it).prepend; const QString cmdStr = hint.prepend + cmd; KUrl url(cmdStr); if (KProtocolInfo::isKnownProtocol(url)) { setFilteredUri( data, url ); setUriType( data, hint.type ); return true; } } } // No protocol and not malformed means a valid short URL such as kde.org or // [email protected]. However, it might also be valid only because it lacks // the scheme component, e.g. www.kde,org (illegal ',' before 'org'). The // check below properly deciphers the difference between the two and sends // back the proper result. if (protocol.isEmpty() && isPotentialShortURL(cmd)) { QString urlStr = data.defaultUrlScheme(); if (urlStr.isEmpty()) urlStr = m_strDefaultUrlScheme; const int index = urlStr.indexOf(QL1C(':')); if (index == -1 || !KProtocolInfo::isKnownProtocol(urlStr.left(index))) urlStr += QL1S("://"); urlStr += cmd; KUrl url (urlStr); if (url.isValid()) { setFilteredUri(data, url); setUriType(data, KUriFilterData::NetProtocol); } else if (KProtocolInfo::isKnownProtocol(url.protocol())) { setFilteredUri(data, data.uri()); setUriType(data, KUriFilterData::Error); } return true; } }