void NovellVpnSettingWidget::readSecrets()
{
    QStringMap secrets = d->setting->vpnSecrets();
    kDebug() << "Value of" << NM_NOVELLVPN_KEY_CERT_PWD << secrets.value(QLatin1String(NM_NOVELLVPN_KEY_CERT_PWD));
    d->ui.x509CertPass->setText(secrets.value(QLatin1String(NM_NOVELLVPN_KEY_CERT_PWD)));
    d->ui.leUserPass->setText(secrets.value(QLatin1String(NM_NOVELLVPN_KEY_USER_PWD)));
    d->ui.leGroupPass->setText(secrets.value(QLatin1String(NM_NOVELLVPN_KEY_GRP_PWD)));
}
Beispiel #2
0
QString SSDP::GetHeaderValue( const QStringMap &headers,
                              const QString    &sKey, const QString &sDefault )
{
    QStringMap::const_iterator it = headers.find( sKey.toLower() );

    if ( it == headers.end())
        return( sDefault );

    return *it;
}
/**
* This controller needs the parameter 'machine' with the name of the machine
*
* \param[in] params The parameter map
*/
void InfoController::setParams(const QStringMap& params)
{
	if( !params.contains("machine") || !params.contains("machine"))
	{
		std::cerr << "InfoController: Required parameter not found" << std::endl;
		return;
	}

	_machine = params["machine"];
	_model.setDatabaseFile( params["db"] );
}
uint VpncSettingWidget::handleOnePasswordType(const QComboBox * combo, const QString & key, QStringMap & data)
{
    uint type = combo->currentIndex();
    switch (type) {
    case VpncSettingWidgetPrivate::EnumPasswordStorage::AlwaysAsk:
        data.insert(key, QString::number(Knm::Setting::NotSaved));
        break;
    case VpncSettingWidgetPrivate::EnumPasswordStorage::Save:
        data.insert(key, QString::number(Knm::Setting::AgentOwned));
        break;
    case VpncSettingWidgetPrivate::EnumPasswordStorage::NotRequired:
        data.insert(key, QString::number(Knm::Setting::NotRequired));
        break;
    }
    return type;
}
QVariantMap convertToVariant(const QStringMap &val)
{
  QVariantMap ret;
  for(const QString &k : val.keys())
  {
    ret[k] = val[k];
  }
  return ret;
}
QStringMap AbstractWebApplication::parseCookie(const Http::Request &request) const
{
    // [rfc6265] 4.2.1. Syntax
    QStringMap ret;
    const QString cookieStr = request.headers.value(QLatin1String("cookie"));
    const QVector<QStringRef> cookies = cookieStr.splitRef(';', QString::SkipEmptyParts);

    for (const auto &cookie : cookies) {
        const int idx = cookie.indexOf('=');
        if (idx < 0)
            continue;

        const QString name = cookie.left(idx).trimmed().toString();
        const QString value = Utils::String::unquote(cookie.mid(idx + 1).trimmed())
                                  .toString();
        ret.insert(name, value);
    }
    return ret;
}
void VpncSettingWidget::readSecrets()
{
    Q_D(VpncSettingWidget);
    QStringMap secrets = d->setting->vpnSecrets();
    Knm::Setting::secretsTypes userType;
    Knm::Setting::secretsTypes groupType;

    userType = (Knm::Setting::secretsTypes)d->setting->data().value(NM_VPNC_KEY_XAUTH_PASSWORD"-flags").toInt();

    if (userType & Knm::Setting::AgentOwned || userType & Knm::Setting::None || !userType) {
        d->ui.leUserPassword->setText(secrets.value(QLatin1String(NM_VPNC_KEY_XAUTH_PASSWORD)));
    }
    fillOnePasswordCombo(d->ui.cboUserPassOptions, userType);

    groupType = (Knm::Setting::secretsTypes)d->setting->data().value(NM_VPNC_KEY_SECRET"-flags").toInt();

    if (groupType & Knm::Setting::AgentOwned || groupType & Knm::Setting::None || !groupType) {
        d->ui.leGroupPassword->setText(secrets.value(QLatin1String(NM_VPNC_KEY_SECRET)));
    }
    fillOnePasswordCombo(d->ui.cboGroupPassOptions, groupType);
}
Beispiel #8
0
void MythFEXML::SendAction(HTTPRequest *pRequest)
{
    QStringMap* map = &pRequest->m_mapParams;
    pRequest->m_eResponseType = ResponseTypeHTML;
    QString sText = map->value("action");
    uint pcount   = map->size();

    VERBOSE(VB_UPNP, QString("UPNP Action: %1 (total %2 params)")
        .arg(sText).arg(pcount));

    if (!IsValidAction(sText))
        return;

    if (pcount > 1)
    {
        bool valid = false;
        QStringList args;
        if (ACTION_SCREENSHOT == sText && 3 == pcount)
        {
            args << map->value("width");
            args << map->value("height");
            valid = true;
        }
        else if (ACTION_HANDLEMEDIA == sText && 2 == pcount)
        {
            args << map->value("file");
            valid = true;
        }

        if (valid)
        {
            MythEvent* me = new MythEvent(sText, args);
            qApp->postEvent(GetMythMainWindow(), me);
            return;
        }

        VERBOSE(VB_UPNP, QString("Failed to validate extra paramaters - ignoring"));
    }

    QKeyEvent* ke = new QKeyEvent(QEvent::KeyPress, 0, Qt::NoModifier, sText);
    qApp->postEvent(GetMythMainWindow(), (QEvent*)ke);
}
Beispiel #9
0
void SSDP::ProcessData( MSocketDevice *pSocket )
{
    long nBytes = 0;
    long nRead  = 0;

    while ((nBytes = pSocket->bytesAvailable()) > 0)
    {
        QByteArray buffer;
        buffer.resize(nBytes);

        nRead = pSocket->readBlock( buffer.data(), nBytes );

        QHostAddress  peerAddress = pSocket->peerAddress();
        quint16       peerPort    = pSocket->peerPort   ();

        // ------------------------------------------------------------------
        QString     str          = QString(buffer.constData());
        QStringList lines        = str.split("\r\n", QString::SkipEmptyParts);
        QString     sRequestLine = lines.size() ? lines[0] : "";

        lines.pop_front();

        // ------------------------------------------------------------------
        // Parse request Type
        // ------------------------------------------------------------------

        VERBOSE(VB_UPNP+VB_EXTRA,
                QString( "SSDP::ProcessData - requestLine: %1" )
                .arg( sRequestLine ));

        SSDPRequestType eType = ProcessRequestLine( sRequestLine );

        // ------------------------------------------------------------------
        // Read Headers into map
        // ------------------------------------------------------------------

        QStringMap  headers;

        for ( QStringList::Iterator it = lines.begin();
                                    it != lines.end(); ++it ) 
        {
            QString sLine  = *it;
            QString sName  = sLine.section( ':', 0, 0 ).trimmed();
            QString sValue = sLine.section( ':', 1 );

            sValue.truncate( sValue.length() );  //-2

            if ((sName.length() != 0) && (sValue.length() !=0))
                headers.insert( sName.toLower(), sValue.trimmed() );
        }

//        pSocket->SetDestAddress( peerAddress, peerPort );

        // --------------------------------------------------------------
        // See if this is a valid request
        // --------------------------------------------------------------

        switch( eType )
        {
            case SSDP_MSearch:
            {
                // ----------------------------------------------------------
                // If we haven't enabled notifications yet, then we don't 
                // want to answer search requests.
                // ----------------------------------------------------------

                if (m_pNotifyTask != NULL)
                    ProcessSearchRequest( headers, peerAddress, peerPort ); 

                break;
            }

            case SSDP_MSearchResp:
                ProcessSearchResponse( headers); 
                break;

            case SSDP_Notify:
                ProcessNotify( headers ); 
                break;

            case SSDP_Unknown:
            default:
                VERBOSE(VB_UPNP, "SSPD::ProcessData - Unknown request Type.");
                break;
        }
    }

}
void NovellVpnSettingWidget::writeX509Auth(QStringMap & data, QStringMap & secretData)
{
    data.insert(QLatin1String(NM_NOVELLVPN_KEY_AUTHTYPE), QLatin1String(NM_NOVELLVPN_CONTYPE_X509_STRING));
    data.insert(NM_NOVELLVPN_KEY_CERTIFICATE, d->ui.x509Cert->url().path());
    secretData.insert(QLatin1String(NM_NOVELLVPN_KEY_CERT_PWD), d->ui.x509CertPass->text());
}
Beispiel #11
0
bool ServerSideScripting::EvaluatePage( QTextStream *pOutStream, const QString &sFileName,
                                        HTTPRequest *pRequest)
{
    try
    {

        ScriptInfo *pInfo = NULL;

        // ------------------------------------------------------------------
        // See if page has already been loaded
        // ------------------------------------------------------------------

        pInfo = GetLoadedScript( sFileName );

        // ------------------------------------------------------------------
        // Load Script File and Create Function
        // ------------------------------------------------------------------

        QFileInfo  fileInfo ( sFileName );
        QDateTime  dtLastModified = fileInfo.lastModified();

        Lock();
        if ((pInfo == NULL) || (pInfo->m_dtTimeStamp != dtLastModified ))
        {
            QString      sCode = CreateMethodFromFile( sFileName );

            QScriptValue func  = m_engine.evaluate( sCode, sFileName );

            if ( m_engine.hasUncaughtException() )
            {
                LOG(VB_GENERAL, LOG_ERR,
                    QString("Error Loading QSP File: %1 - (line %2) %3")
                        .arg(sFileName)
                        .arg(m_engine.uncaughtExceptionLineNumber())
                        .arg(m_engine.uncaughtException().toString()));

                Unlock();
                return false;
            }

            if (pInfo != NULL)
            {
                pInfo->m_oFunc       = func;
                pInfo->m_dtTimeStamp = dtLastModified;
            }
            else
            {
                pInfo = new ScriptInfo( func, dtLastModified );
                m_mapScripts[ sFileName ] = pInfo;
            }
        }

        // ------------------------------------------------------------------
        // Build array of arguments passed to script
        // ------------------------------------------------------------------

        QStringMap mapParams = pRequest->m_mapParams;

        // Valid characters for object property names must contain only
        // word characters and numbers, _ and $
        // They must not start with a number - to simplify the regexp, we
        // restrict the first character to the English alphabet
        QRegExp validChars = QRegExp("^([a-zA-Z]|_|\\$)(\\w|\\$)+$");

        QVariantMap params;
        QMap<QString, QString>::const_iterator it = mapParams.begin();
        QString prevArrayName = "";
        QVariantMap array;
        for (; it != mapParams.end(); ++it)
        {
            QString key = it.key();
            QVariant value = QVariant(it.value());

            // PHP Style parameter array
            if (key.contains("["))
            {
                QString arrayName = key.section('[',0,0);
                QString arrayKey = key.section('[',1,1);
                arrayKey.chop(1); // Remove trailing ]
                if (prevArrayName != arrayName) // New or different array
                {
                    if (!array.isEmpty())
                    {
                        params.insert(prevArrayName, QVariant(array));
                        array.clear();
                    }
                    prevArrayName = arrayName;
                }

                if (!validChars.exactMatch(arrayKey)) // Discard anything that isn't valid for now
                    continue;

                array.insert(arrayKey, value);

                if ((it + 1) != mapParams.end())
                    continue;
            }

            if (!array.isEmpty())
            {
                params.insert(prevArrayName, QVariant(array));
                array.clear();
            }
            // End Array handling

            if (!validChars.exactMatch(key)) // Discard anything that isn't valid for now
                continue;

            params.insert(key, value);

        }

        // ------------------------------------------------------------------
        // Build array of request headers
        // ------------------------------------------------------------------

        QStringMap mapHeaders = pRequest->m_mapHeaders;

        QVariantMap requestHeaders;
        for (it = mapHeaders.begin(); it != mapHeaders.end(); ++it)
        {
            QString key = it.key();
            key = key.replace('-', '_'); // May be other valid chars in a request header that we need to replace
            QVariant value = QVariant(it.value());

            if (!validChars.exactMatch(key)) // Discard anything that isn't valid for now
                continue;

            requestHeaders.insert(key, value);
        }

        // ------------------------------------------------------------------
        // Build array of information from the server e.g. client IP
        // See RFC 3875 - The Common Gateway Interface
        // ------------------------------------------------------------------

        QVariantMap serverVars;
        serverVars.insert("REMOTE_ADDR", QVariant(pRequest->GetPeerAddress()));
        serverVars.insert("SERVER_ADDR", QVariant(pRequest->GetHostAddress()));
        serverVars.insert("SERVER_PROTOCOL", QVariant(pRequest->GetRequestProtocol()));
        serverVars.insert("SERVER_SOFTWARE", QVariant(HttpServer::GetServerVersion()));

        QHostAddress clientIP = QHostAddress(pRequest->GetPeerAddress());
        QHostAddress serverIP = QHostAddress(pRequest->GetHostAddress());
        if (clientIP.protocol() == QAbstractSocket::IPv4Protocol)
        {
            serverVars.insert("IP_PROTOCOL", "IPv4");
        }
        else if (clientIP.protocol() == QAbstractSocket::IPv6Protocol)
        {
            serverVars.insert("IP_PROTOCOL", "IPv6");
        }

        if (((clientIP.protocol() == QAbstractSocket::IPv4Protocol) &&
             (clientIP.isInSubnet(QHostAddress("172.16.0.0"), 12) ||
              clientIP.isInSubnet(QHostAddress("192.168.0.0"), 16) ||
              clientIP.isInSubnet(QHostAddress("10.0.0.0"), 8))) ||
            ((clientIP.protocol() == QAbstractSocket::IPv6Protocol) &&
              clientIP.isInSubnet(serverIP, 64))) // default subnet size is assumed to be /64
        {
            serverVars.insert("CLIENT_NETWORK", "local");
        }
        else
        {
            serverVars.insert("CLIENT_NETWORK", "remote");
        }

        // ------------------------------------------------------------------
        // Add the arrays (objects) we've just created to the global scope
        // They may be accessed as 'Server.REMOTE_ADDR'
        // ------------------------------------------------------------------

        m_engine.globalObject().setProperty("Parameters",
                                            m_engine.toScriptValue(params));
        m_engine.globalObject().setProperty("RequestHeaders",
                                            m_engine.toScriptValue(requestHeaders));
        m_engine.globalObject().setProperty("Server",
                                            m_engine.toScriptValue(serverVars));

        // ------------------------------------------------------------------
        // Execute function to render output
        // ------------------------------------------------------------------

        OutputStream outStream( pOutStream );

        QScriptValueList args;
        args << m_engine.newQObject( &outStream );
        args << m_engine.toScriptValue(params);

        QScriptValue ret = pInfo->m_oFunc.call( QScriptValue(), args );

        if (ret.isError())
        {
            QScriptValue lineNo = ret.property( "lineNumber" );

            LOG(VB_GENERAL, LOG_ERR,
                QString("Error calling QSP File: %1(%2) - %3")
                    .arg(sFileName)
                    .arg( lineNo.toInt32 () )
                    .arg( ret   .toString() ));
            Unlock();
            return false;

        }

        if (m_engine.hasUncaughtException())
        {
            LOG(VB_GENERAL, LOG_ERR,
                QString("Error calling QSP File: %1(%2) - %3")
                    .arg(sFileName)
                    .arg(m_engine.uncaughtExceptionLineNumber() )
                    .arg(m_engine.uncaughtException().toString()));
            Unlock();
            return false;
        }
        Unlock();
    }
    catch(...)
    {
        LOG(VB_GENERAL, LOG_ERR,
            QString("Exception while evaluating QSP File: %1") .arg(sFileName));

        Unlock();
        return false;
    }

    return true;
}
Beispiel #12
0
QDomDocument SOAPClient::SendSOAPRequest(const QString &sMethod,
                                         QStringMap    &list,
                                         int           &nErrCode,
                                         QString       &sErrDesc)
{
    QUrl url(m_url);

    url.setPath(m_sControlPath);

    nErrCode = UPnPResult_Success;
    sErrDesc = "";

    QDomDocument xmlResult;
    if (m_sNamespace.isEmpty())
    {
        nErrCode = UPnPResult_MythTV_NoNamespaceGiven;
        sErrDesc = "No namespace given";
        return xmlResult;
    }

    // --------------------------------------------------------------
    // Add appropriate headers
    // --------------------------------------------------------------
    QHash<QByteArray, QByteArray> headers;

    headers.insert("Content-Type", "text/xml; charset=\"utf-8\"");
    QString soapHeader = QString("\"%1#%2\"").arg(m_sNamespace).arg(sMethod);
	headers.insert("SOAPACTION", soapHeader.toUtf8());
    headers.insert("User-Agent", "Mozilla/9.876 (X11; U; Linux 2.2.12-20 i686, en) "
                                 "Gecko/25250101 Netscape/5.432b1");
    // --------------------------------------------------------------
    // Build request payload
    // --------------------------------------------------------------

    QByteArray  aBuffer;
    QTextStream os( &aBuffer );

    os.setCodec("UTF-8");

    os << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"; 
    os << "<s:Envelope "
        " s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\""
        " xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">\r\n";
    os << " <s:Body>\r\n";
    os << "  <u:" << sMethod << " xmlns:u=\"" << m_sNamespace << "\">\r\n";

    // --------------------------------------------------------------
    // Add parameters from list
    // --------------------------------------------------------------

    for (QStringMap::iterator it = list.begin(); it != list.end(); ++it)
    {                                                               
        os << "   <" << it.key() << ">";
        os << HTTPRequest::Encode( *it );
        os << "</"   << it.key() << ">\r\n";
    }

    os << "  </u:" << sMethod << ">\r\n";
    os << " </s:Body>\r\n";
    os << "</s:Envelope>\r\n";

    os.flush();

    // --------------------------------------------------------------
    // Perform Request
    // --------------------------------------------------------------

    LOG(VB_UPNP, LOG_DEBUG,
        QString("SOAPClient(%1) sending:\n %2").arg(url.toString()).arg(aBuffer.constData()));

    QString sXml;

    if (!GetMythDownloadManager()->postAuth(url.toString(), &aBuffer, NULL, NULL, &headers))
    {
        LOG(VB_GENERAL, LOG_ERR, QString("SOAPClient::SendSOAPRequest: request failed: %1")
                                         .arg(url.toString()));
    }
    else
        sXml = QString(aBuffer);

    // --------------------------------------------------------------
    // Parse response
    // --------------------------------------------------------------

    LOG(VB_UPNP, LOG_DEBUG, "SOAPClient response:\n" +
                            QString("%1\n").arg(sXml));

    // TODO handle timeout without response correctly.

    list.clear();

    QDomDocument doc;

    if (!doc.setContent(sXml, true, &sErrDesc, &nErrCode))
    {
        LOG(VB_UPNP, LOG_ERR,
            QString("SendSOAPRequest( %1 ) - Invalid response from %2")
                .arg(sMethod).arg(url.toString()) + 
            QString("%1: %2").arg(nErrCode).arg(sErrDesc));

        return xmlResult;
    }

    // --------------------------------------------------------------
    // Is this a valid response?
    // --------------------------------------------------------------

    QString      sResponseName = sMethod + "Response";
    QDomNodeList oNodeList     =
        doc.elementsByTagNameNS(m_sNamespace, sResponseName);

    if (oNodeList.count() == 0)
    {
        // --------------------------------------------------------------
        // Must be a fault... parse it to return reason
        // --------------------------------------------------------------

        nErrCode = GetNodeValue(
            doc, "Envelope/Body/Fault/detail/UPnPError/errorCode", 500);
        sErrDesc = GetNodeValue(
            doc, "Envelope/Body/Fault/detail/UPnPError/errorDescription", "");
        if (sErrDesc.isEmpty())
            sErrDesc = QString("Unknown #%1").arg(nErrCode);

        QDomNode oNode  = FindNode( "Envelope/Body/Fault", doc );

        oNode = xmlResult.importNode( oNode, true );
        xmlResult.appendChild( oNode );

        return xmlResult;
    }

    QDomNode oMethod = oNodeList.item(0);
    if (oMethod.isNull())
        return xmlResult;

    QDomNode oNode = oMethod.firstChild(); 
    for (; !oNode.isNull(); oNode = oNode.nextSibling())
    {
        QDomElement e = oNode.toElement();
        if (e.isNull())
            continue;

        QString sName  = e.tagName();
        QString sValue = "";
    
        QDomText  oText = oNode.firstChild().toText();
    
        if (!oText.isNull())
            sValue = oText.nodeValue();

        list.insert(QUrl::fromPercentEncoding(sName.toUtf8()),
                    QUrl::fromPercentEncoding(sValue.toUtf8()));
    }

    // Create copy of oMethod that can be used with xmlResult.

    oMethod = xmlResult.importNode( oMethod.firstChild(), true  );

    // importNode does not attach the new nodes to the document,
    // do it here.

    xmlResult.appendChild( oMethod );

    return xmlResult;
}
void NovellVpnSettingWidget::writeConfig()
{
    kDebug();

    d->setting->setServiceType(QLatin1String(NM_DBUS_SERVICE_NOVELLVPN));

    QStringMap data;
    QStringMap secretData;

    // required settings
    data.insert(NM_NOVELLVPN_KEY_GATEWAY, d->ui.leGateway->text());

    if (d->ui.cmbGwType->currentIndex() == 0) {
        data.insert(QLatin1String(NM_NOVELLVPN_KEY_GWTYPE), QLatin1String(NM_NOVELLVPN_GWTYPE_NORTEL_STRING));

        if (d->ui.cmbAuthType->currentIndex() == 0) {
            data.insert(QLatin1String(NM_NOVELLVPN_KEY_AUTHTYPE), QLatin1String(NM_NOVELLVPN_CONTYPE_GROUPAUTH_STRING));

            data.insert(QLatin1String(NM_NOVELLVPN_KEY_USER_NAME), d->ui.leUserName->text());
            data.insert(QLatin1String(NM_NOVELLVPN_KEY_GROUP_NAME), d->ui.leGroupName->text());
            secretData.insert(QLatin1String(NM_NOVELLVPN_KEY_USER_PWD), d->ui.leUserPass->text());
            secretData.insert(QLatin1String(NM_NOVELLVPN_KEY_GRP_PWD), d->ui.leGroupPass->text());
        } else {
            writeX509Auth(data, secretData);
        }
    } else {
        data.insert(QLatin1String(NM_NOVELLVPN_KEY_GWTYPE), QLatin1String(NM_NOVELLVPN_GWTYPE_STDGW_STRING));
        writeX509Auth(data, secretData);
    }

    // advanced dialog
    data.insert(QLatin1String(NM_NOVELLVPN_KEY_DHGROUP),
            (d->advUi.rbDh1->isChecked()
             ? QString::number(DHGROUP_DH1)
             : QString::number(DHGROUP_DH2)));

    if (d->advUi.rbPfOff->isChecked()) {
        data.insert(QLatin1String(NM_NOVELLVPN_KEY_PFSGROUP), QString::number(PFSGROUP_OFF));
    } else if (d->advUi.rbPf1->isChecked()) {
        data.insert(QLatin1String(NM_NOVELLVPN_KEY_PFSGROUP), QString::number(PFSGROUP_PFS1));
    } else {
        data.insert(QLatin1String(NM_NOVELLVPN_KEY_PFSGROUP), QString::number(PFSGROUP_PFS2));
    }

    data.insert(QLatin1String(NM_NOVELLVPN_KEY_NOSPLITTUNNEL), d->advUi.cbDisableSplit->isChecked() ? QLatin1String("yes") : QLatin1String("no"));

    d->setting->setData(data);
    d->setting->setVpnSecrets(secretData);
}
Beispiel #14
0
UPnPResultCode MythXMLClient::GetConnectionInfo( const QString &sPin, DatabaseParams *pParams, QString &sMsg )
{
    if (pParams == NULL)
        return UPnPResult_InvalidArgs;

    int           nErrCode = 0;
    QString       sErrDesc;
    QStringMap    list;

    sMsg.clear();

    list.insert( "Pin", sPin );

    QDomDocument xmlResults = SendSOAPRequest(
        "GetConnectionInfo", list, nErrCode, sErrDesc, m_bInQtThread);

    // --------------------------------------------------------------
    // Is this a valid response?
    // --------------------------------------------------------------

    QDomNode oNode = xmlResults.namedItem( "GetConnectionInfoResult" );

    if (UPnPResult_Success == nErrCode && !oNode.isNull())
    {
        QDomNode dbNode = oNode.namedItem( "Database" );

        pParams->dbHostName   = GetNodeValue( dbNode, "Host"     , QString());
        pParams->dbPort       = GetNodeValue( dbNode, "Port"     , 0        );
        pParams->dbUserName   = GetNodeValue( dbNode, "UserName" , QString());
        pParams->dbPassword   = GetNodeValue( dbNode, "Password" , QString());
        pParams->dbName       = GetNodeValue( dbNode, "Name"     , QString());
        pParams->dbType       = GetNodeValue( dbNode, "Type"     , QString());

        QDomNode wolNode = oNode.namedItem( "WOL" );

        pParams->wolEnabled   = GetNodeValue( wolNode, "Enabled"  , false    );
        pParams->wolReconnect = GetNodeValue( wolNode, "Reconnect", 0        );
        pParams->wolRetry     = GetNodeValue( wolNode, "Retry"    , 0        );
        pParams->wolCommand   = GetNodeValue( wolNode, "Command"  , QString());

        return UPnPResult_Success;
    }
    else
    {
        sMsg = sErrDesc;

        LOG(VB_GENERAL, LOG_ERR,
            QString("MythXMLClient::GetConnectionInfo Failed - (%1) %2")
                .arg(nErrCode) .arg(sErrDesc));
    }

    if (( nErrCode == UPnPResult_HumanInterventionRequired ) || 
        ( nErrCode == UPnPResult_ActionNotAuthorized       ) ||
        ( nErrCode == 501                                  ))
    {
        // Service calls no longer return UPnPResult codes, 
        // convert standard 501 to UPnPResult code for now.
        return UPnPResult_ActionNotAuthorized;
    }

    return UPnPResult_ActionFailed;
}
void OpenconnectSettingWidget::writeConfig()
{
    Q_D(OpenconnectSettingWidget);

    d->setting->setServiceType(QLatin1String(NM_DBUS_SERVICE_OPENCONNECT));

    QStringMap data;
    QStringMap secretData;

    data.insert(QLatin1String(NM_OPENCONNECT_KEY_GATEWAY), d->ui.leGateway->text().toUtf8());
    if (!d->ui.leCaCertificate->url().isEmpty())
        data.insert(QLatin1String(NM_OPENCONNECT_KEY_CACERT), d->ui.leCaCertificate->url().path());
    if (!d->ui.leProxy->text().isEmpty())
        data.insert(QLatin1String(NM_OPENCONNECT_KEY_PROXY), d->ui.leProxy->text().toUtf8());
    data.insert(QLatin1String(NM_OPENCONNECT_KEY_CSD_ENABLE), d->ui.chkAllowTrojan->isChecked() ? "yes" : "no");
    if (!d->ui.leCsdWrapperScript->url().isEmpty())
        data.insert(QLatin1String(NM_OPENCONNECT_KEY_CSD_WRAPPER), d->ui.leCsdWrapperScript->url().path());
    if (!d->ui.leUserCert->url().isEmpty())
        data.insert(QLatin1String(NM_OPENCONNECT_KEY_USERCERT), d->ui.leUserCert->url().path());
    if (!d->ui.leUserPrivateKey->url().isEmpty())
        data.insert(QLatin1String(NM_OPENCONNECT_KEY_PRIVKEY), d->ui.leUserPrivateKey->url().path());
    data.insert(QLatin1String(NM_OPENCONNECT_KEY_PEM_PASSPHRASE_FSID), d->ui.chkUseFsid->isChecked() ? "yes" : "no");

    /* These are different for every login session, and should not be stored */
    data.insert(QLatin1String(NM_OPENCONNECT_KEY_COOKIE"-flags"), QString::number(Knm::Setting::NotSaved));
    data.insert(QLatin1String(NM_OPENCONNECT_KEY_GWCERT"-flags"), QString::number(Knm::Setting::NotSaved));
    data.insert(QLatin1String(NM_OPENCONNECT_KEY_GATEWAY"-flags"), QString::number(Knm::Setting::NotSaved));

    d->setting->setData(data);

    //VpnSecrets empty so far, they will be acquired by the auth dialog
    d->setting->setVpnSecrets(secretData);
}
Beispiel #16
0
UPnPResultCode MythXMLClient::GetConnectionInfo( const QString &sPin, DatabaseParams *pParams, QString &sMsg )
{
    if (pParams == NULL)
        return UPnPResult_InvalidArgs;

    int           nErrCode = 0;
    QString       sErrDesc;
    QStringMap    list;

    sMsg.clear();

    list.insert( "Pin", sPin );

    if (SendSOAPRequest( "GetConnectionInfo", list, nErrCode, sErrDesc, m_bInQtThread ))
    {
        QString sXml = "<Info>" + list[ "Info" ] + "</Info>";

        sMsg = sErrDesc;

        QDomDocument doc;

        if ( !doc.setContent( sXml, false, &sErrDesc, &nErrCode ))
        {
            sMsg = QObject::tr("Error Requesting Connection Info");

            VERBOSE( VB_UPNP, QString( "Error Requesting Connection Info : (%1) - %2" )
                                 .arg( nErrCode )
                                 .arg( sErrDesc ) );

            return UPnPResult_ActionFailed;
        }

        // --------------------------------------------------------------
        // Is this a valid response?
        // --------------------------------------------------------------

        QDomNode infoNode = doc.namedItem( "Info" );

        if (!infoNode.isNull())
        {
            QDomNode dbNode = infoNode.namedItem( "Database" );

            pParams->dbHostName     = GetNodeValue( dbNode, "Host"     , QString( ));
            pParams->dbPort         = GetNodeValue( dbNode, "Port"     , 0         );
            pParams->dbUserName     = GetNodeValue( dbNode, "UserName" , QString( ));
            pParams->dbPassword     = GetNodeValue( dbNode, "Password" , QString( ));
            pParams->dbName         = GetNodeValue( dbNode, "Name"     , QString( ));
            pParams->dbType         = GetNodeValue( dbNode, "Type"     , QString( ));

            QDomNode wolNode = infoNode.namedItem( "WOL" );

            pParams->wolEnabled     = GetNodeValue( wolNode, "Enabled"  , false     );
            pParams->wolReconnect   = GetNodeValue( wolNode, "Reconnect", 0         );
            pParams->wolRetry       = GetNodeValue( wolNode, "Retry"    , 0         );
            pParams->wolCommand     = GetNodeValue( wolNode, "Command"  , QString( ));

            return UPnPResult_Success;
        }
        else
        {
            if (sMsg.isEmpty())
                sMsg = QObject::tr("Unexpected Response");

            VERBOSE( VB_IMPORTANT, QString( "MythXMLClient::GetConnectionInfo Failed : Unexpected Response - %1" )
                                      .arg( sXml   ));
        }
    }
    else
    {
        sMsg = sErrDesc;

        if (sMsg.isEmpty())
            sMsg = QObject::tr("Access Denied");

        VERBOSE( VB_IMPORTANT, QString( "MythXMLClient::GetConnectionInfo Failed - (%1) %2" )
                             .arg( nErrCode )
                             .arg( sErrDesc ));
    }

    if (UPnPResult_HumanInterventionRequired == nErrCode
           || UPnPResult_ActionNotAuthorized == nErrCode)
        return (UPnPResultCode)nErrCode;

    return UPnPResult_ActionFailed;
}
Beispiel #17
0
bool SOAPClient::SendSOAPRequest( const QString    &sMethod, 
                                        QStringMap &list, 
                                        int        &nErrCode, 
                                        QString    &sErrDesc,
                                        bool        bInQtThread )
{
    QUrl url( m_url );

    url.setPath( m_sControlPath );

    // --------------------------------------------------------------
    // Add appropriate headers
    // --------------------------------------------------------------

    QHttpRequestHeader header;

    header.setValue("CONTENT-TYPE", "text/xml; charset=\"utf-8\"" );
    header.setValue("SOAPACTION"  , QString( "\"%1#GetConnectionInfo\"" )
                                       .arg( m_sNamespace ));

    // --------------------------------------------------------------
    // Build request payload
    // --------------------------------------------------------------

    QByteArray  aBuffer;
    QTextStream os( &aBuffer );

    os << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"; 
    os << "<s:Envelope s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\" xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">\r\n";
    os << " <s:Body>\r\n";
    os << "  <u:" << sMethod << " xmlns:u=\"" << m_sNamespace << "\">\r\n";

    // --------------------------------------------------------------
    // Add parameters from list
    // --------------------------------------------------------------

    for ( QStringMap::iterator it  = list.begin(); 
                               it != list.end(); 
                             ++it ) 
    {                                                               
        os << "   <" << it.key() << ">";
        os << HTTPRequest::Encode( *it );
        os << "</"   << it.key() << ">\r\n";
    }

    os << "  </u:" << sMethod << ">\r\n";
    os << " </s:Body>\r\n";
    os << "</s:Envelope>\r\n";

    os.flush();

    // --------------------------------------------------------------
    // Perform Request
    // --------------------------------------------------------------

    QBuffer     buff( &aBuffer );

    QString sXml = HttpComms::postHttp( url, 
                                        &header,
                                        (QIODevice *)&buff,
                                        10000, // ms
                                        3,     // retries
                                        0,     // redirects
                                        false, // allow gzip
                                        NULL,  // login
                                        bInQtThread );

    // --------------------------------------------------------------
    // Parse response
    // --------------------------------------------------------------

    list.clear();

    QDomDocument doc;

    if ( !doc.setContent( sXml, true, &sErrDesc, &nErrCode ))
    {
        VERBOSE( VB_UPNP, QString( "MythXMLClient::SendSOAPRequest( %1 ) - Invalid response from %2" )
                             .arg( sMethod   )
                             .arg( url.toString() ));
        return false;
    }

    // --------------------------------------------------------------
    // Is this a valid response?
    // --------------------------------------------------------------

    QString      sResponseName = sMethod + "Response";
    QDomNodeList oNodeList     = doc.elementsByTagNameNS( m_sNamespace, sResponseName );

    if (oNodeList.count() > 0)
    {
        QDomNode oMethod = oNodeList.item(0);

        if (!oMethod.isNull())
        {

            for ( QDomNode oNode = oMethod.firstChild(); !oNode.isNull(); 
                           oNode = oNode.nextSibling() )
            {
                QDomElement e = oNode.toElement();

                if (!e.isNull())
                {
                    QString sName  = e.tagName();
                    QString sValue = "";
    
                    QDomText  oText = oNode.firstChild().toText();
    
                    if (!oText.isNull())
                        sValue = oText.nodeValue();

                    list.insert(QUrl::fromPercentEncoding(sName.toUtf8()),
                                QUrl::fromPercentEncoding(sValue.toUtf8()));
                }
            }
        }

        return true;
    }

    // --------------------------------------------------------------
    // Must be a fault... parse it to return reason
    // --------------------------------------------------------------

    nErrCode = GetNodeValue( doc, "Envelope/Body/Fault/detail/UPnPResult/errorCode"       , 500 );
    sErrDesc = GetNodeValue( doc, "Envelope/Body/Fault/detail/UPnPResult/errorDescription", QString( "Unknown" ));

    return false;
}
Beispiel #18
0
void TabletServer::mainScreen(QTcpSocket *socket, const QStringList &path, const QStringMap &query)
{
    Document * doc = mw->currentDocument();
    if(!doc)
    {
        generic404(socket,path,query);
        return;
    }

    QStringList pathCopy = path;
    pathCopy.takeFirst(); // should be "tablet", but could be anything - /tablet/ is canonized for use in the tablet cache manifest for sfari
    QString control = pathCopy.isEmpty() ? "" : pathCopy.takeFirst().toLower();
    //bool flag = pathCopy.isEmpty() ? 0 : pathCopy.takeFirst().toInt();

    //qDebug() << "TabletServer::mainScreen(): control: "<<control;

    HttpUser *user = HttpUserUtil::instance()->currentUser();

    if(control != "login")
    {
        if(!user)
        {
            QString from = QUrl::toPercentEncoding(toPathString(path,query).toAscii()).replace(" ", "+");
            redirect(socket, "/tablet/login?from=" + from);
            return;
        }

        // I've decided to allow guests "view-only" access

// 		else
// 		if(user->level() == HttpUser::Guest)
// 		{
// 			Http_Send_Ok(socket) << "<html><head><title>Not Allowed</title></head><body><h1>Not Allowed</h1>Sorry, you're not allowed to access this site. (<a href='/tablet/login'>Login again</a>)</body></html";
// 			return;
// 		}
    }

    if(control.isEmpty())
    {

        SimpleTemplate tmpl("data/http/tablet.tmpl");
        tmpl.param("user_name", user->user());
        tmpl.param("user_level", (int)user->level());
        tmpl.param("is_admin", user->level() == HttpUser::Admin);
        tmpl.param("is_user",  user->level() == HttpUser::User);
        tmpl.param("is_guest", user->level() == HttpUser::Guest);

// 		tmpl.param("list",outputGroupList);
//
// 		OutputControl * outputControl = mw->outputControl(liveId);
// 		tmpl.param("black_toggled", outputControl->isBlackToggled());
// 		tmpl.param("clear_toggled", outputControl->isClearToggled());
//
// 		SlideGroupViewControl *viewControl = mw->viewControl(liveId);
// 		tmpl.param("qslide_toggled", viewControl->isQuickSlideToggled());
//
// 		if(doc->filename().isEmpty())
// 			tmpl.param("docfile",tr("New File"));
// 		else
// 			tmpl.param("docfile",QFileInfo(doc->filename()).baseName());

        // 	Http_Send_Ok(socket) <<
        // 		"Content-Type: text/html\n\n" <<
        // 		tmpl.toString();

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "text/html");

        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << tmpl.toString();
    }
    else if(control == "login")
    {
        loginPage(socket, path, query, "/tablet/login");
    }
    else if(control == "list")
    {
        QString filter = query["filter"]; // Can be empty

        // Don't allow non-admins to search because it would interfere with the main UI
        if(!filter.isEmpty() &&
                user->level() < HttpUser::Admin)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        QString mode   = query["mode"]; // Either "db" or "file"

        bool pollingFlag  = query["poll"] == "true";
        QString clientMD5 = query["md5"]; // the md5 of the list contents to use to check for changes if pollingFlag == true

        // Compile list of results matching mode (from db or from current sched) and the filter, and return as json string

        // TODO add button to search online

        //qDebug() << "TabletServer::mainScreen(): list: mode: "<<mode<<", filter: "<<filter;

        QVariantMap result;
        QVariantList resultList;

        bool moreResults = false;
        int listCutoffLimit = 10; // included in results even though only relevant to 'db' mode

        // Buffer for compiling MD5 hash
        QStringList md5sigList;

        if(mode == "db")
        {
            bool isChanged = true;
            if(pollingFlag)
            {
                int currentChangeSequence = m_songListModel->currentChangeSequence();
                QString seqString = QString::number(currentChangeSequence);

                // md5sigList is used to generate the md5 to send back to the client
                md5sigList << seqString;

                QString seqMd5 = MD5::md5sum(md5sigList.join(""));

                isChanged = false;

                if(seqMd5 != clientMD5)
                    isChanged = true;
            }

            // Only regen list if 'isChanged' - and isChanged is only set to 'false' if:
            //  - Client is in polling mode
            //  - Client MD5 matches the MD5 of current sequence number
            // We do this because generating the list makes a call to filter()
            // which can cause trouble if the filter string is empty and the user
            // in the DViz main UI is trying to search for something (which would NOT change
            // the sequence number above, but would change the filter)
            if(isChanged)
            {
                // List cutoff limit only relevant when searching/quering database.
                // Cutoff not honored or implemented for file schedule
                QString maxResults = query["max"];
                if(!maxResults.isEmpty())
                    listCutoffLimit = maxResults.toInt();
                if(listCutoffLimit < 1)
                    listCutoffLimit = 1;

                m_songListModel->filter(filter);

                moreResults = m_songListModel->rowCount() > listCutoffLimit;
                int resultCount = qMin(listCutoffLimit, m_songListModel->rowCount());

                for(int i=0; i<resultCount; i++)
                {
                    SongRecord *song = m_songListModel->songAt(i);
                    if(!song)
                    {
                        qDebug() << "TabletServer::mainScreen(): list: db: No song at index: "<<i;
                        continue;
                    }

                    QVariantMap line;
                    line["id"]    = song->songId();
                    line["title"] = song->title();
                    line["text"]  = song->text();
                    line["arr"]   = song->defaultArrangement()->arrangement().join(", ");

                    resultList << line;

                    // We use the sequence md5 (above) for the md5 sig instead of the list contents now
// 					md5sigList.append(QString::number(song->songId()));
// 					md5sigList.append(song->title());
// 					md5sigList.append(song->text());
                }
            }
        }
        else
        {
// 			int liveId = AppSettings::taggedOutput("live")->id();
// 			SlideGroup *liveGroup = mw->outputInst(liveId)->slideGroup();

            DocumentListModel * model = mw->documentListModel();

            //uint secs = QDateTime::currentDateTime().toTime_t();

            QString lowerFilter = filter.toLower();

            for(int idx = 0; idx < model->rowCount(); idx++)
            {
                SlideGroup * group = model->groupAt(idx);

                SongSlideGroup *songGroup = dynamic_cast<SongSlideGroup*>(group);

                if(songGroup && (
                            songGroup->groupTitle().toLower().contains(lowerFilter) ||
                            songGroup->text().toLower().contains(lowerFilter)))
                {
                    QVariantMap row;

                    QVariant tooltip = model->data(model->index(group->groupNumber(),0), Qt::ToolTipRole);
                    QString viewText = group->assumedName();

                    if(tooltip.isValid())
                        viewText = tooltip.toString();

                    row["id"]        = idx; //songGroup->groupId();
                    row["title"]     = viewText;
                    row["text"]	 = songGroup->text();
                    row["arr"]	 = songGroup->arrangement().join(", ");
                    row["mapping"]	 = genArrMapping(songGroup->text(), songGroup->arrangement());

                    resultList << row;

                    md5sigList.append(QString::number(songGroup->groupId()));
                    md5sigList.append(viewText);
                    md5sigList.append(songGroup->text());
                }

                // We don't limit the number of results in the document results
                moreResults = false;
            }
        }

        QString currentMD5 = MD5::md5sum(md5sigList.join(""));

        bool isChanged = true;
        if(pollingFlag &&
                currentMD5 == clientMD5)
            isChanged = false;

        if(isChanged)
        {
            result["num"]    = resultList.size();
            result["list"]   = QVariant(resultList);
            result["more"]   = moreResults;
            result["cutoff"] = listCutoffLimit;
        }
        else
            result["nochange"] = true;

        result["md5"] = currentMD5;


        QString jsonString = m_toJson.serialize(result);

        //qDebug() << "TabletServer::mainScreen(): list: result: "<<result;
        //qDebug() << "TabletServer::mainScreen(): list: json:   "<<jsonString;

// 		Http_Send_Ok(socket) <<
// 			"Content-Type: application/json\n\n" <<
// 			jsonString;

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "application/json");
        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << jsonString;
    }
    else if(control == "save_song")
    {
        if(user->level() < HttpUser::Admin)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        QString mode   = query["mode"]; // Either "db" or "file"
        int itemid     = query["itemid"].toInt(); // If mode is db, itemid is a songid, otherwise, it's a group index

        QString title  = query["title"];
        QString text   = query["text"];
        QString arrTxt = query["arr"];

        QStringList newArrList = arrTxt.split(QRegExp("\\s*,\\s*"));

        SongRecord *song;

        if(mode == "file")
        {
            DocumentListModel * model = mw->documentListModel();
            SlideGroup * group = model->groupAt(itemid);
            SongSlideGroup *songGroup = dynamic_cast<SongSlideGroup*>(group);

            // Update the document model
            songGroup->setArrangement(newArrList);
            songGroup->setGroupTitle(title);
            songGroup->setText(text); // automatically regenerates slides in document

            song = songGroup->song();
        }
        else
        {
            song = SongRecord::retrieve(itemid);
        }

        if(!song)
        {
            Http_Send_404(socket)
                    << "Invalid songid";
        }

        song->setTitle(title);
        song->setText(text);

        SongArrangement *arr = song->defaultArrangement();
        arr->setArrangement(newArrList);

        // Changes automatically committed to database

        QVariantMap result;
        result["mapping"] = genArrMapping(song->text(), arr->arrangement());

        QString jsonString = m_toJson.serialize(result);

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "application/json");
        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << jsonString;
    }
    else if(control == "add_song")
    {
        if(user->level() < HttpUser::Admin)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        int songid = query["songid"].toInt();

        QVariantMap result;

        SongRecord *song = SongRecord::retrieve(songid);
        if(!song)
        {
            Http_Send_404(socket)
                    << "Invalid songid";
        }
        else
        {
            SlideGroup *group = mw->songBrowser()->createSlideGroup(song);

            group->setGroupNumber(mw->currentDocument()->numGroups());
            mw->currentDocument()->addGroup(group);

            result["groupnum"] = group->groupNumber();
        }

        QString jsonString = m_toJson.serialize(result);

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "application/json");
        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << jsonString;
    }
    else if(control == "del_song")
    {
        if(user->level() < HttpUser::Admin)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        QString mode   = query["mode"]; // Either "db" or "file"

        int itemid = query["itemid"].toInt();

        if(mode == "file")
        {
            DocumentListModel * model = mw->documentListModel();
            SlideGroup * group = model->groupAt(itemid);
            SongSlideGroup *songGroup = dynamic_cast<SongSlideGroup*>(group);

            if(!songGroup)
            {
                Http_Send_404(socket)
                        << "Invalid songid";
            }

            mw->currentDocument()->removeGroup(songGroup);
        }
        else
        {
            SongRecord *song = SongRecord::retrieve(itemid);
            if(!song)
            {
                Http_Send_404(socket)
                        << "Invalid songid";
            }

            SongRecord::deleteSong(song);
        }

        QVariantMap result;

        // Nothing to see here, move along.

        QString jsonString = m_toJson.serialize(result);

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "application/json");
        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << jsonString;
    }
    else if(control == "show_slide")
    {
        if(user->level() < HttpUser::User)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        int groupIdx = query["group"].toInt();

        Document * doc = mw->currentDocument();
        if(!doc)
        {
            generic404(socket,path,query);
            return;
        }

        if(groupIdx < 0 || groupIdx >= doc->numGroups())
        {
            generic404(socket,path,query);
            return;
        }

        DocumentListModel * docModel = mw->documentListModel();
        SlideGroup *group = docModel->groupAt(groupIdx);
        if(!group)
        {
            generic404(socket,path,query);
            return;
        }

        int liveId = AppSettings::taggedOutput("live")->id();
        SlideGroup *liveGroup = mw->outputInst(liveId)->slideGroup();
        Slide * liveSlide = mw->outputInst(liveId)->slide();

        //SlideGroupViewControl *viewControl = mw->viewControl(liveId);
        //Slide * liveSlide = viewControl->selectedSlide();

        int idx = query.value("slide").toInt();
        if(idx < 0 || idx > group->numSlides())
        {
            generic404(socket,path,query);
            return;
        }

        Slide *slide = group->at(idx);


        if(liveGroup != group ||
                liveSlide != slide)
            mw->setLiveGroup(group,
                             ! slide ? liveSlide : slide); // prevent changing slides when loading the group page if group already live on different slide

        if(liveGroup == group &&
                liveSlide != slide/* &&
		   nextPathElement != "icon"*/)
        {
            // this is JUST a change slide request
            mw->setLiveGroup(liveGroup,slide);

            // 204 = HTTP No Content, ("...[the browser] SHOULD NOT change its document view...")
            Http_Send_Response(socket,"HTTP/1.0 204 Changed Slide") << "";

            // BlackBerry Internet Browser doesnt honor HTTP 204, so we have to use javascript to make it not change the current document

            return;
        }
        else
            Http_Send_Response(socket,"HTTP/1.0 204 No Change") << "";
    }
    else if(control == "poll_live_slide")
    {
        if(user->level() < HttpUser::Guest)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        DocumentListModel * docModel = mw->documentListModel();

        QVariantMap result;
        bool ok = true;

        int liveId = AppSettings::taggedOutput("live")->id();
        SlideGroup *liveGroup = mw->outputInst(liveId)->slideGroup();
        Slide *liveSlide = mw->outputInst(liveId)->slide();
        if(!liveGroup)
        {
            ok = false;
            result["error"] = "NLG";
        }

// 		SlideGroupViewControl *viewControl = mw->viewControl(liveId);
// 		Slide * liveSlide = viewControl->selectedSlide();

        if(!liveSlide && ok)
        {
            ok = false;
            result["error"] = "NLS";
        }

        if(ok)
        {
            int groupIdx = docModel->indexForGroup(liveGroup).row();
            int slideIdx = liveGroup->indexOf(liveSlide);

            result["groupIdx"] = groupIdx;
            result["slideIdx"] = slideIdx;
        }

        QString jsonString = m_toJson.serialize(result);

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "application/json");
        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << jsonString;

    }
    else
    {
        generic404(socket,path,query);
    }
}
Beispiel #19
0
/** Actually sends the sMethod action to the command URL specified
 *  in the constructor (url+[/]+sControlPath).
 *
 * \param sMethod method to be invoked. e.g. "SetChannel",
 *                "GetConnectionInfoResult"
 *
 * \param list Parsed as a series of key value pairs for the input params
 *             and then cleared and used for the output params.
 *
 * \param nErrCode set to zero on success, non-zero in case of error.
 *
 * \param sErrCode returns error description from device, when applicable.
 *
 * \param bInQtThread May be set to true if this is run from within
 *                    a QThread with a running an event loop.
 *
 * \return Returns a QDomDocument containing output parameters on success.
 */
QDomDocument SOAPClient::SendSOAPRequest(const QString &sMethod,
                                         QStringMap    &list,
                                         int           &nErrCode,
                                         QString       &sErrDesc,
                                         bool           bInQtThread)
{
    QUrl url(m_url);

    url.setPath(m_sControlPath);

    nErrCode = UPnPResult_Success;
    sErrDesc = "";

    QDomDocument xmlResult;
    if (m_sNamespace.isEmpty())
    {
        nErrCode = UPnPResult_MythTV_NoNamespaceGiven;
        sErrDesc = "No namespace given";
        return xmlResult;
    }

    // --------------------------------------------------------------
    // Add appropriate headers
    // --------------------------------------------------------------

    QHttpRequestHeader header("POST", sMethod, 1, 0);

    header.setValue("CONTENT-TYPE", "text/xml; charset=\"utf-8\"" );
    header.setValue("SOAPACTION",
                    QString("\"%1#%2\"").arg(m_sNamespace).arg(sMethod));

    // --------------------------------------------------------------
    // Build request payload
    // --------------------------------------------------------------

    QByteArray  aBuffer;
    QTextStream os( &aBuffer );

    os.setCodec("UTF-8");

    os << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"; 
    os << "<s:Envelope "
        " s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\""
        " xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">\r\n";
    os << " <s:Body>\r\n";
    os << "  <u:" << sMethod << " xmlns:u=\"" << m_sNamespace << "\">\r\n";

    // --------------------------------------------------------------
    // Add parameters from list
    // --------------------------------------------------------------

    for (QStringMap::iterator it = list.begin(); it != list.end(); ++it)
    {                                                               
        os << "   <" << it.key() << ">";
        os << HTTPRequest::Encode( *it );
        os << "</"   << it.key() << ">\r\n";
    }

    os << "  </u:" << sMethod << ">\r\n";
    os << " </s:Body>\r\n";
    os << "</s:Envelope>\r\n";

    os.flush();

    // --------------------------------------------------------------
    // Perform Request
    // --------------------------------------------------------------

    QBuffer buff(&aBuffer);

    LOG(VB_UPNP, LOG_DEBUG,
        QString("SOAPClient(%1) sending:\n").arg(url.toString()) +
        header.toString() + QString("\n%1\n").arg(aBuffer.constData()));

    QString sXml =
        HttpComms::postHttp(url,
                            &header,
                            &buff, // QIODevice*
                            10000, // ms -- Technically should be 30ms per spec
                            3,     // retries
                            0,     // redirects
                            false, // allow gzip
                            NULL,  // login
                            bInQtThread,
                            QString() // userAgent, UPnP/1.0 very strict on
                                      // format if set
        );

    // --------------------------------------------------------------
    // Parse response
    // --------------------------------------------------------------

    LOG(VB_UPNP, LOG_DEBUG, "SOAPClient response:\n" +
                            QString("%1\n").arg(sXml));

    // TODO handle timeout without response correctly.

    list.clear();

    QDomDocument doc;

    if (!doc.setContent(sXml, true, &sErrDesc, &nErrCode))
    {
        LOG(VB_UPNP, LOG_ERR,
            QString("SendSOAPRequest( %1 ) - Invalid response from %2")
                .arg(sMethod).arg(url.toString()) + 
            QString("%1: %2").arg(nErrCode).arg(sErrDesc));

        return xmlResult;
    }

    // --------------------------------------------------------------
    // Is this a valid response?
    // --------------------------------------------------------------

    QString      sResponseName = sMethod + "Response";
    QDomNodeList oNodeList     =
        doc.elementsByTagNameNS(m_sNamespace, sResponseName);

    if (oNodeList.count() == 0)
    {
        // --------------------------------------------------------------
        // Must be a fault... parse it to return reason
        // --------------------------------------------------------------

        nErrCode = GetNodeValue(
            doc, "Envelope/Body/Fault/detail/UPnPError/errorCode", 500);
        sErrDesc = GetNodeValue(
            doc, "Envelope/Body/Fault/detail/UPnPError/errorDescription", "");
        if (sErrDesc.isEmpty())
            sErrDesc = QString("Unknown #%1").arg(nErrCode);

        QDomNode oNode  = FindNode( "Envelope/Body/Fault", doc );

        oNode = xmlResult.importNode( oNode, true );
        xmlResult.appendChild( oNode );

        return xmlResult;
    }

    QDomNode oMethod = oNodeList.item(0);
    if (oMethod.isNull())
        return xmlResult;

    QDomNode oNode = oMethod.firstChild(); 
    for (; !oNode.isNull(); oNode = oNode.nextSibling())
    {
        QDomElement e = oNode.toElement();
        if (e.isNull())
            continue;

        QString sName  = e.tagName();
        QString sValue = "";
    
        QDomText  oText = oNode.firstChild().toText();
    
        if (!oText.isNull())
            sValue = oText.nodeValue();

        list.insert(QUrl::fromPercentEncoding(sName.toUtf8()),
                    QUrl::fromPercentEncoding(sValue.toUtf8()));
    }

    // Create copy of oMethod that can be used with xmlResult.

    oMethod = xmlResult.importNode( oMethod.firstChild(), true  );

    // importNode does not attach the new nodes to the document,
    // do it here.

    xmlResult.appendChild( oMethod );

    return xmlResult;
}
Beispiel #20
0
QVariant MethodInfo::Invoke( Service *pService, const QStringMap &reqParams )
{
    HttpRedirectException exception;
    bool                  bExceptionThrown = false;
    QStringMap            lowerParams;

    if (!pService)
        throw;

     // Change params to lower case for case-insensitive comparison
    QStringMap::const_iterator it = reqParams.begin();
    for (; it != reqParams.end(); ++it)
    {
        lowerParams[it.key().toLower()] = *it;
    }

    // --------------------------------------------------------------
    // Provide actual parameters received to method
    // --------------------------------------------------------------

    pService->m_parsedParams = lowerParams.keys();


    QList<QByteArray> paramNames = m_oMethod.parameterNames();
    QList<QByteArray> paramTypes = m_oMethod.parameterTypes();

    // ----------------------------------------------------------------------
    // Create Parameter array (Can't have more than _MAX_PARAMS parameters)....
    // switched to static array for performance.
    // ----------------------------------------------------------------------

    void *param[ _MAX_PARAMS ];
    int   types[ _MAX_PARAMS ];

    memset( param, 0, _MAX_PARAMS * sizeof(void *));
    memset( types, 0, _MAX_PARAMS * sizeof(int));

    try
    {
        // --------------------------------------------------------------
        // Add a place for the Return value
        // --------------------------------------------------------------

        int nRetIdx = QMetaType::type( m_oMethod.typeName() ); 

        if (nRetIdx != 0)
        {
            param[ 0 ] = QMetaType::create( nRetIdx );
            types[ 0 ] = nRetIdx;
        }
        else
        {
            param[ 0 ] = nullptr;
            types[ 0 ] = 0;
        }

        // --------------------------------------------------------------
        // Fill in parameters from request values
        // --------------------------------------------------------------

        for( int nIdx = 0; nIdx < paramNames.length(); nIdx++ )
        {
            QString sValue     = lowerParams[ paramNames[ nIdx ].toLower() ];
            QString sParamType = paramTypes[ nIdx ];

            int     nId        = QMetaType::type( paramTypes[ nIdx ] );
            void   *pParam     = nullptr;

            if (nId != 0)
            {
                pParam = QMetaType::create( nId );
            }
            else
            {
                LOG(VB_GENERAL, LOG_ERR,
                    QString("MethodInfo::Invoke - Type unknown '%1'")
                        .arg(sParamType));
            }

            types[nIdx+1] = nId;
            param[nIdx+1] = pService->ConvertToParameterPtr( nId, sParamType,
                                                             pParam, sValue );
        }

#if 0
        QThread *currentThread = QThread::currentThread();
        QThread *objectThread  = pService->thread();

        if (currentThread == objectThread)
            LOG(VB_HTTP, LOG_DEBUG, "*** Threads are same ***");
        else
            LOG(VB_HTTP, LOG_DEBUG, "*** Threads are Different!!! ***");
#endif

        pService->qt_metacall( QMetaObject::InvokeMetaMethod, 
                               m_nMethodIndex, 
                               param );

        // --------------------------------------------------------------
        // Delete param array, skip return parameter since not dynamically
        // created.
        // --------------------------------------------------------------

        for (int nIdx=1; nIdx < paramNames.length()+1; nIdx++)
        {
            if ((types[ nIdx ] != 0) && (param[ nIdx ] != nullptr))
                QMetaType::destroy( types[ nIdx ], param[ nIdx ] );
        }
    }
    catch (QString &sMsg)
    {
        LOG(VB_GENERAL, LOG_ERR,
            QString("MethodInfo::Invoke - An Exception Occurred: %1")
                 .arg(sMsg));

        if  ((types[ 0 ] != 0) && (param[ 0 ] != nullptr ))
            QMetaType::destroy( types[ 0 ], param[ 0 ] );

        throw;
    }
    catch (HttpRedirectException &ex)
    {
        bExceptionThrown = true;
        exception = ex;
    }
    catch (...)
    {
        LOG(VB_GENERAL, LOG_INFO,
            "MethodInfo::Invoke - An Exception Occurred" );
    }

    // --------------------------------------------------------------
    // return the result after converting to a QVariant
    // --------------------------------------------------------------

    QVariant vReturn;
  
    if ( param[ 0 ] != nullptr)
    {
        vReturn = pService->ConvertToVariant( types[ 0 ], param[ 0 ] );

        if  (types[ 0 ] != 0)
            QMetaType::destroy( types[ 0 ], param[ 0 ] );
    }

    // --------------------------------------------------------------
    // Re-throw exception if needed.
    // --------------------------------------------------------------

    if (bExceptionThrown)
        throw exception;

    return vReturn;
}
Beispiel #21
0
void SSDP::ProcessData( MSocketDevice *pSocket )
{
    QByteArray buffer;
    long nBytes = 0;

    while ((nBytes = pSocket->bytesAvailable()) > 0)
    {
        buffer.resize(nBytes);

        long nRead = 0;
        do
        {
            long ret = pSocket->readBlock( buffer.data() + nRead, nBytes - nRead );
            if (ret < 0)
            {
                LOG(VB_GENERAL, LOG_ERR, QString("Socket readBlock error %1")
                    .arg(pSocket->error()));
                buffer.clear();
                break;
            }

            nRead += ret;

            if (0 == ret)
            {
                LOG(VB_SOCKET, LOG_WARNING,
                    QString("%1 bytes reported available, "
                            "but only %2 bytes read.")
                    .arg(nBytes).arg(nRead));
                nBytes = nRead;
                buffer.resize(nBytes);
                break;
            }
        }
        while (nRead < nBytes);

        if (buffer.isEmpty())
            continue;

        QHostAddress  peerAddress = pSocket->peerAddress();
        quint16       peerPort    = pSocket->peerPort   ();

        // ------------------------------------------------------------------
        QString     str          = QString(buffer.constData());
        QStringList lines        = str.split("\r\n", QString::SkipEmptyParts);
        QString     sRequestLine = lines.size() ? lines[0] : "";

        lines.pop_front();

        // ------------------------------------------------------------------
        // Parse request Type
        // ------------------------------------------------------------------

        LOG(VB_UPNP, LOG_DEBUG, QString("SSDP::ProcessData - requestLine: %1")
                .arg(sRequestLine));

        SSDPRequestType eType = ProcessRequestLine( sRequestLine );

        // ------------------------------------------------------------------
        // Read Headers into map
        // ------------------------------------------------------------------

        QStringMap  headers;

        for ( QStringList::Iterator it = lines.begin();
                                    it != lines.end(); ++it ) 
        {
            QString sLine  = *it;
            QString sName  = sLine.section( ':', 0, 0 ).trimmed();
            QString sValue = sLine.section( ':', 1 );

            sValue.truncate( sValue.length() );  //-2

            if ((sName.length() != 0) && (sValue.length() !=0))
                headers.insert( sName.toLower(), sValue.trimmed() );
        }

#if 0
        pSocket->SetDestAddress( peerAddress, peerPort );
#endif

        // --------------------------------------------------------------
        // See if this is a valid request
        // --------------------------------------------------------------

        switch( eType )
        {
            case SSDP_MSearch:
            {
                // ----------------------------------------------------------
                // If we haven't enabled notifications yet, then we don't 
                // want to answer search requests.
                // ----------------------------------------------------------

                if (m_pNotifyTask != NULL)
                    ProcessSearchRequest( headers, peerAddress, peerPort ); 

                break;
            }

            case SSDP_MSearchResp:
                ProcessSearchResponse( headers); 
                break;

            case SSDP_Notify:
                ProcessNotify( headers ); 
                break;

            case SSDP_Unknown:
            default:
                LOG(VB_UPNP, LOG_ERR,
                    "SSPD::ProcessData - Unknown request Type.");
                break;
        }
    }
}
void VpncSettingWidget::readConfig()
{
    Q_D(VpncSettingWidget);
    // General settings
    QStringMap dataMap = d->setting->data();
    //   gateway
    QString gateway = dataMap[NM_VPNC_KEY_GATEWAY];
    if (!gateway.isEmpty()) {
        d->ui.leGateway->setText(gateway);
    }
    //   username
    QString user = dataMap[NM_VPNC_KEY_XAUTH_USER];
    if (!user.isEmpty()) {
        d->ui.leUserName->setText(user);
    }
    //   group name
    QString group = dataMap[NM_VPNC_KEY_ID];
    if (!group.isEmpty()) {
        d->ui.leGroupName->setText(group);
    }
    // hybrid auth
    if (dataMap[NM_VPNC_KEY_AUTHMODE] == QLatin1String("hybrid")) {
        d->ui.cbUseHybridAuth->setChecked(true);
        d->ui.leCaCertPath->setUrl(KUrl(dataMap[NM_VPNC_KEY_CA_FILE]));
    }
    // password storage type is set in readSecrets

    // Optional settings
    //   domain
    QString domain = dataMap[NM_VPNC_KEY_DOMAIN];
    if (!domain.isEmpty()) {
        d->ui.leDomain->setText(domain);
    }

    //   encryption
    if (dataMap[NM_VPNC_KEY_SINGLE_DES] == QLatin1String("yes")) {
        d->ui.cboEncryptionMethod->setCurrentIndex(VpncSettingWidgetPrivate::EnumEncryptionMethod::Weak);
    } else if (dataMap[NM_VPNC_KEY_NO_ENCRYPTION] == QLatin1String("yes")) {
        d->ui.cboEncryptionMethod->setCurrentIndex(VpncSettingWidgetPrivate::EnumEncryptionMethod::None);
    }

    //   nat traversal
    if (dataMap[NM_VPNC_KEY_NAT_TRAVERSAL_MODE] == NM_VPNC_NATT_MODE_NATT)
        d->ui.cboNatTraversal->setCurrentIndex(VpncSettingWidgetPrivate::EnumNatt::NattIfAvail);
    else if (dataMap[NM_VPNC_KEY_NAT_TRAVERSAL_MODE] == NM_VPNC_NATT_MODE_NATT_ALWAYS)
        d->ui.cboNatTraversal->setCurrentIndex(VpncSettingWidgetPrivate::EnumNatt::Force);
    else if (dataMap[NM_VPNC_KEY_NAT_TRAVERSAL_MODE] == NM_VPNC_NATT_MODE_CISCO)
        d->ui.cboNatTraversal->setCurrentIndex(VpncSettingWidgetPrivate::EnumNatt::CiscoUdp);
    else if (dataMap[NM_VPNC_KEY_NAT_TRAVERSAL_MODE] == NM_VPNC_NATT_MODE_NONE)
        d->ui.cboNatTraversal->setCurrentIndex(VpncSettingWidgetPrivate::EnumNatt::Disabled);

    //   dead peer detection
    if (dataMap.contains(NM_VPNC_KEY_DPD_IDLE_TIMEOUT)) {
        uint dpdTimeout = dataMap.value(NM_VPNC_KEY_DPD_IDLE_TIMEOUT).toUInt();
        if (dpdTimeout == 0) {
            d->ui.chkDeadPeerDetection->setChecked(false);
            d->dpdTimeout = dpdTimeout;
        }
    }
    //   dh group
    if (dataMap.contains(NM_VPNC_KEY_DHGROUP)) {
        QString dhGroup = dataMap.value(NM_VPNC_KEY_DHGROUP);
        if (dhGroup == NM_VPNC_DHGROUP_DH1) {
            // DH Group 1
            d->ui.cboDHGroup->setCurrentIndex(VpncSettingWidgetPrivate::EnumDh::Dh1);
        } else if (dhGroup == NM_VPNC_DHGROUP_DH2) {
            // DH Group 2
            d->ui.cboDHGroup->setCurrentIndex(VpncSettingWidgetPrivate::EnumDh::Dh2);
        } else if (dhGroup == NM_VPNC_DHGROUP_DH5) {
            // DH Group 5
            d->ui.cboDHGroup->setCurrentIndex(VpncSettingWidgetPrivate::EnumDh::Dh5);
        }
    }

    // Perfect Forward Secrecy
    if (dataMap.contains(NM_VPNC_KEY_PERFECT_FORWARD)) {
        QString forwardSecrecy = dataMap.value(NM_VPNC_KEY_PERFECT_FORWARD);
        if (forwardSecrecy == QLatin1String("nopfs")) {
            d->ui.cboPerfectForwardSecrecy->setCurrentIndex(VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::NoPfs);
        } else if (forwardSecrecy == QLatin1String("server")) {
            d->ui.cboPerfectForwardSecrecy->setCurrentIndex(VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Server);
        } else if (forwardSecrecy == QLatin1String("dh1")) {
            d->ui.cboPerfectForwardSecrecy->setCurrentIndex(VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh1);
        } else if (forwardSecrecy == QLatin1String("dh2")) {
            d->ui.cboPerfectForwardSecrecy->setCurrentIndex(VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh2);
        } else if (forwardSecrecy == QLatin1String("dh5")) {
            d->ui.cboPerfectForwardSecrecy->setCurrentIndex(VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh5);
        }
    }

    // Vendor
    if (dataMap.contains(NM_VPNC_KEY_VENDOR)) {
        QString vendor = dataMap.value(NM_VPNC_KEY_VENDOR);
        if (vendor == QLatin1String("cisco")) {
            d->ui.cboVendor->setCurrentIndex(VpncSettingWidgetPrivate::EnumVendor::Cisco);
        } else if (vendor == QLatin1String("netscreen")) {
            d->ui.cboVendor->setCurrentIndex(VpncSettingWidgetPrivate::EnumVendor::Netscreen);
        }
    }

    // Application Version
    if (dataMap.contains(NM_VPNC_KEY_APP_VERSION)) {
        d->ui.leApplicationVersion->setText(dataMap.value(NM_VPNC_KEY_APP_VERSION));
    }

    // Local Port
    if (dataMap.contains(NM_VPNC_KEY_LOCAL_PORT)) {
        d->ui.spbLocalPort->setValue(dataMap.value(NM_VPNC_KEY_LOCAL_PORT).toInt());
    }

    // Cisco UDP Encapsulation Port
    if (dataMap.contains(NM_VPNC_KEY_CISCO_UDP_ENCAPS_PORT)) {
        d->ui.spbCiscoUdpEncPort->setValue(dataMap.value(NM_VPNC_KEY_CISCO_UDP_ENCAPS_PORT).toInt());
    }
}
void VpncSettingWidget::writeConfig()
{
    Q_D(VpncSettingWidget);
    kDebug();

    d->setting->setServiceType(QLatin1String(NM_DBUS_SERVICE_VPNC));

    QStringMap data;
    QStringMap secretData;

    // General settings
    //   gateway
    if (!d->ui.leGateway->text().isEmpty()) {
        data.insert(NM_VPNC_KEY_GATEWAY, d->ui.leGateway->text());
    }

    //   group name
    if (!d->ui.leGroupName->text().isEmpty()) {
        data.insert(NM_VPNC_KEY_ID, d->ui.leGroupName->text());
    }

    //   user password
    if (!d->ui.leUserPassword->text().isEmpty() && d->ui.cboUserPassOptions->currentIndex() == VpncSettingWidgetPrivate::EnumPasswordStorage::Save) {
        secretData.insert(NM_VPNC_KEY_XAUTH_PASSWORD, d->ui.leUserPassword->text());
    }
    //   group password
    if (!d->ui.leGroupPassword->text().isEmpty() && d->ui.cboGroupPassOptions->currentIndex() == VpncSettingWidgetPrivate::EnumPasswordStorage::Save) {
        secretData.insert(NM_VPNC_KEY_SECRET, d->ui.leGroupPassword->text());
    }
    handleOnePasswordType(d->ui.cboUserPassOptions, NM_VPNC_KEY_XAUTH_PASSWORD"-flags", data);
    handleOnePasswordType(d->ui.cboGroupPassOptions, NM_VPNC_KEY_SECRET"-flags", data);

    // hybrid auth
    if (d->ui.cbUseHybridAuth->isChecked()) {
        data.insert(NM_VPNC_KEY_AUTHMODE, QLatin1String("hybrid"));
        data.insert(NM_VPNC_KEY_CA_FILE, d->ui.leCaCertPath->url().path());
    }

    // Optional settings
    //   username
    if (!d->ui.leUserName->text().isEmpty()) {
        data.insert(NM_VPNC_KEY_XAUTH_USER, d->ui.leUserName->text());
    }

    //   domain
    if (!d->ui.leDomain->text().isEmpty()) {
        data.insert(NM_VPNC_KEY_DOMAIN, d->ui.leDomain->text());
    }

    //   encryption
    switch (d->ui.cboEncryptionMethod->currentIndex()) {
    case VpncSettingWidgetPrivate::EnumEncryptionMethod::Weak:
        data.insert(NM_VPNC_KEY_SINGLE_DES, QLatin1String("yes"));
        break;
    case VpncSettingWidgetPrivate::EnumEncryptionMethod::None:
        data.insert(NM_VPNC_KEY_NO_ENCRYPTION, QLatin1String("yes"));
        break;
    default:
        break;
    }

    // nat traversal
    switch (d->ui.cboNatTraversal->currentIndex()) {
    case VpncSettingWidgetPrivate::EnumNatt::Force:
        data.insert(NM_VPNC_KEY_NAT_TRAVERSAL_MODE, QLatin1String(NM_VPNC_NATT_MODE_NATT_ALWAYS));
        break;
    case VpncSettingWidgetPrivate::EnumNatt::CiscoUdp:
        data.insert(NM_VPNC_KEY_NAT_TRAVERSAL_MODE, QLatin1String(NM_VPNC_NATT_MODE_CISCO));
        break;
    case VpncSettingWidgetPrivate::EnumNatt::Disabled:
        data.insert(NM_VPNC_KEY_NAT_TRAVERSAL_MODE, QLatin1String(NM_VPNC_NATT_MODE_NONE));
        break;
    case VpncSettingWidgetPrivate::EnumNatt::NattIfAvail:
    default:
        data.insert(NM_VPNC_KEY_NAT_TRAVERSAL_MODE, QLatin1String(NM_VPNC_NATT_MODE_NATT));
        break;
    }

    // dead peer detection
    if (d->ui.chkDeadPeerDetection->isChecked()) {
        if (d->dpdTimeout > 0) {
            data.insert(NM_VPNC_KEY_DPD_IDLE_TIMEOUT, QString::number(d->dpdTimeout));
        }
    } else {
        data.insert(NM_VPNC_KEY_DPD_IDLE_TIMEOUT, QString::number(0));
    }

    // dh group
    switch (d->ui.cboDHGroup->currentIndex()) {
    case VpncSettingWidgetPrivate::EnumDh::Dh1:	// DH Group 1
        data.insert(NM_VPNC_KEY_DHGROUP, NM_VPNC_DHGROUP_DH1);
        break;
    case VpncSettingWidgetPrivate::EnumDh::Dh2:	// DH Group 2
        data.insert(NM_VPNC_KEY_DHGROUP, NM_VPNC_DHGROUP_DH2);
        break;
    case VpncSettingWidgetPrivate::EnumDh::Dh5:	// DH Group 5
        data.insert(NM_VPNC_KEY_DHGROUP, NM_VPNC_DHGROUP_DH5);
        break;
    }

    // Perfect Forward Secrecy
    switch (d->ui.cboPerfectForwardSecrecy->currentIndex()) {
    case VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::NoPfs:
        data.insert(NM_VPNC_KEY_PERFECT_FORWARD, QLatin1String("nopfs"));
        break;
    case VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Server:
        data.insert(NM_VPNC_KEY_PERFECT_FORWARD, QLatin1String("server"));
        break;
    case VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh1:
        data.insert(NM_VPNC_KEY_PERFECT_FORWARD, QLatin1String("dh1"));
        break;
    case VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh2:
        data.insert(NM_VPNC_KEY_PERFECT_FORWARD, QLatin1String("dh2"));
        break;
    case VpncSettingWidgetPrivate::EnumPerfectForwardSecrecy::Dh5:
        data.insert(NM_VPNC_KEY_PERFECT_FORWARD, QLatin1String("dh5"));
        break;
    }

    // Vendor
    switch (d->ui.cboVendor->currentIndex()) {
    case VpncSettingWidgetPrivate::EnumVendor::Cisco:
        data.insert(NM_VPNC_KEY_VENDOR, QLatin1String("cisco"));
        break;
    case VpncSettingWidgetPrivate::EnumVendor::Netscreen:
        data.insert(NM_VPNC_KEY_VENDOR, QLatin1String("netscreen"));
        break;
    }

    // Application Version
    if (!d->ui.leApplicationVersion->text().isEmpty()) {
        data.insert(NM_VPNC_KEY_APP_VERSION, d->ui.leApplicationVersion->text());
    }

    // Local Port
    data.insert(NM_VPNC_KEY_LOCAL_PORT, QString::number(d->ui.spbLocalPort->value()));

    // Cisco UDP Encapsulation Port
    data.insert(NM_VPNC_KEY_CISCO_UDP_ENCAPS_PORT, QString::number(d->ui.spbCiscoUdpEncPort->value()));

    d->setting->setData(data);
    d->setting->setVpnSecrets(secretData);
}
Beispiel #24
0
UPnPResultCode MythXMLClient::GetConnectionInfo( const QString &sPin, DatabaseParams *pParams, QString &sMsg )
{
    if (pParams == NULL)
        return UPnPResult_InvalidArgs;

    int           nErrCode = 0;
    QString       sErrDesc;
    QStringMap    list;

    sMsg.clear();

    list.insert( "Pin", sPin );

    QDomDocument xmlResults = SendSOAPRequest(
        "GetConnectionInfo", list, nErrCode, sErrDesc, m_bInQtThread);

    // --------------------------------------------------------------
    // Is this a valid response?
    // --------------------------------------------------------------

    QDomNode oNode = xmlResults.namedItem( "GetConnectionInfoResult" );

    if (UPnPResult_Success == nErrCode && !oNode.isNull())
    {
        QDomNode dbNode = oNode.namedItem( "Database" );

        pParams->dbHostName   = GetNodeValue( dbNode, "Host"     , QString());
        pParams->dbPort       = GetNodeValue( dbNode, "Port"     , 0        );
        pParams->dbUserName   = GetNodeValue( dbNode, "UserName" , QString());
        pParams->dbPassword   = GetNodeValue( dbNode, "Password" , QString());
        pParams->dbName       = GetNodeValue( dbNode, "Name"     , QString());
        pParams->dbType       = GetNodeValue( dbNode, "Type"     , QString());

        QDomNode wolNode = oNode.namedItem( "WOL" );

        pParams->wolEnabled   = GetNodeValue( wolNode, "Enabled"  , false    );
        pParams->wolReconnect = GetNodeValue( wolNode, "Reconnect", 0        );
        pParams->wolRetry     = GetNodeValue( wolNode, "Retry"    , 0        );
        pParams->wolCommand   = GetNodeValue( wolNode, "Command"  , QString());

        QDomNode verNode = oNode.namedItem( "Version" );

        pParams->verVersion   = GetNodeValue( verNode, "Version"  , ""       );
        pParams->verBranch    = GetNodeValue( verNode, "Branch"   , ""       );
        pParams->verProtocol  = GetNodeValue( verNode, "Protocol" , ""       );
        pParams->verBinary    = GetNodeValue( verNode, "Binary"   , ""       );
        pParams->verSchema    = GetNodeValue( verNode, "Schema"   , ""       );

        if ((pParams->verProtocol != MYTH_PROTO_VERSION) ||
            (pParams->verSchema   != MYTH_DATABASE_VERSION))
            // incompatible version, we cannot use this backend
        {
            LOG(VB_GENERAL, LOG_ERR,
                QString("MythXMLClient::GetConnectionInfo Failed - "
                        "Version Mismatch (%1,%2) != (%3,%4)")
                .arg(pParams->verProtocol)
                .arg(pParams->verSchema)
                .arg(MYTH_PROTO_VERSION)
                .arg(MYTH_DATABASE_VERSION));
            sMsg = QObject::tr("Version Mismatch", "UPNP Errors");
            return UPnPResult_ActionFailed;
        }

        return UPnPResult_Success;
    }
    else
    {
        sMsg = sErrDesc;

        LOG(VB_GENERAL, LOG_ERR,
            QString("MythXMLClient::GetConnectionInfo Failed - (%1) %2")
                .arg(nErrCode) .arg(sErrDesc));
    }

    if (( nErrCode == UPnPResult_HumanInterventionRequired ) || 
        ( nErrCode == UPnPResult_ActionNotAuthorized       ) ||
        ( nErrCode == 501                                  ))
    {
        // Service calls no longer return UPnPResult codes, 
        // convert standard 501 to UPnPResult code for now.
        sMsg = QObject::tr("Not Authorized", "UPNP Errors");
        return UPnPResult_ActionNotAuthorized;
    }

    sMsg = QObject::tr("Unknown Error", "UPNP Errors");
    return UPnPResult_ActionFailed;
}