C++ KUrl::query方法代码示例

 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( 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] == '~' )