Ejemplo n.º 1
0
QString GpxFileParser::parseGpxFile(QIODevice &file) {
    QXmlStreamReader xml(&file);
    parseRoot(xml, m_cacheList);

    /* Error handling. */
    if(xml.hasError())
        return QObject::tr("Parse error at line %1, column %2:\n%3")
               .arg(xml.lineNumber()).arg(xml.columnNumber()).arg(xml.errorString());

    xml.clear();

    qDebug() << __FUNCTION__ << "Parser finished";

    return NULL;
}
Ejemplo n.º 2
0
	api_return ShareRootApi::handleUpdateRoot(ApiRequest& aRequest) {
		const auto& reqJson = aRequest.getRequestBody();

		auto path = JsonUtil::getField<string>("path", reqJson, false);

		auto info = ShareManager::getInstance()->getRootInfo(path);
		if (!info) {
			aRequest.setResponseErrorStr("Path not found");
			return websocketpp::http::status_code::not_found;
		}

		parseRoot(info, reqJson, false);

		ShareManager::getInstance()->updateRootDirectory(info);
		return websocketpp::http::status_code::ok;
	}
Ejemplo n.º 3
0
	api_return ShareRootApi::handleAddRoot(ApiRequest& aRequest) {
		const auto& reqJson = aRequest.getRequestBody();

		auto path = Util::validatePath(JsonUtil::getField<string>("path", reqJson, false), true);

		// Validate the path
		try {
			ShareManager::getInstance()->validateRootPath(path);
		} catch (ShareException& e) {
			JsonUtil::throwError("path", JsonUtil::ERROR_INVALID, e.what());
		}

		auto info = std::make_shared<ShareDirectoryInfo>(path);

		parseRoot(info, reqJson, true);

		ShareManager::getInstance()->addRootDirectory(info);
		return websocketpp::http::status_code::ok;
	}
Ejemplo n.º 4
0
static int
devicePulse( tr_upnp_device_t * dev, tr_fd_t * fdlimit, int port )
{
    const char * body;
    int          len, code;
    uint8_t      laststate;

    switch( dev->state )
    {
        case UPNPDEV_STATE_READY:
            if( 0 < port )
            {
                tr_dbg( "upnp device %s: want mapping, state ready -> get",
                        dev->host );
                dev->mappedport = port;
                dev->state = UPNPDEV_STATE_GET;
                break;
            }
            return 1;
        case UPNPDEV_STATE_MAPPED:
            if( port != dev->mappedport )
            {
                tr_dbg( "upnp device %s: change mapping, "
                        "state mapped -> delete", dev->host );
                dev->state = UPNPDEV_STATE_DEL;
                break;
            }
            if( tr_date() > dev->lastcheck + MAPPING_CHECK_INTERVAL )
            {
                tr_dbg( "upnp device %s: check mapping, "
                        "state mapped -> get", dev->host );
                dev->state = UPNPDEV_STATE_GET;
            }
            return 1;
        case UPNPDEV_STATE_ERROR:
            return 0;
    }

    code = devicePulseHttp( dev, fdlimit, &body, &len );
    if( 0 > code )
    {
        return 1;
    }

    if( LOOP_DETECT_THRESHOLD <= dev->looping )
    {
        tr_dbg( "upnp device %s: loop detected, state %hhu -> error",
                dev->host, dev->state );
        dev->state = UPNPDEV_STATE_ERROR;
        dev->looping = 0;
        killHttp( fdlimit, &dev->http );
        return 1;
    }

    laststate = dev->state;
    dev->state = UPNPDEV_STATE_ERROR;
    switch( laststate ) 
    {
        case UPNPDEV_STATE_ROOT:
            if( !TR_HTTP_STATUS_OK( code ) )
            {
                tr_dbg( "upnp device %s: fetch root failed with http code %i",
                        dev->host, code );
            }
            else if( parseRoot( body, len, &dev->soap, &dev->scpd ) )
            {
                tr_dbg( "upnp device %s: parse root failed", dev->host );
            }
            else
            {
                tr_dbg( "upnp device %s: found scpd \"%s\" and soap \"%s\"",
                        dev->root, dev->scpd, dev->soap );
                tr_dbg( "upnp device %s: parsed root, state root -> scpd",
                        dev->host );
                dev->state = UPNPDEV_STATE_SCPD;
            }
            break;

        case UPNPDEV_STATE_SCPD:
            if( !TR_HTTP_STATUS_OK( code ) )
            {
                tr_dbg( "upnp device %s: fetch scpd failed with http code %i",
                        dev->host, code );
            }
            else if( parseScpd( body, len, &dev->getcmd,
                                &dev->addcmd, &dev->delcmd ) )
            {
                tr_dbg( "upnp device %s: parse scpd failed", dev->host );
            }
            else
            {
                tr_dbg( "upnp device %s: parsed scpd, state scpd -> ready",
                        dev->host );
                dev->state = UPNPDEV_STATE_READY;
                dev->looping = 0;
            }
            break;

        case UPNPDEV_STATE_ADD:
            dev->looping++;
            if( IGD_ADD_CONFLICT == code )
            {
                tr_dbg( "upnp device %s: add conflict, state add -> delete",
                        dev->host );
                dev->state = UPNPDEV_STATE_DEL;
            }
            else if( TR_HTTP_STATUS_OK( code ) ||
                     IGD_GENERIC_ERROR == code || IGD_GENERIC_FAILED == code )
            {
                tr_dbg( "upnp device %s: add attempt, state add -> get",
                        dev->host );
                dev->state = UPNPDEV_STATE_GET;
            }
            else
            {
                tr_dbg( "upnp device %s: add failed with http code %i",
                        dev->host, code );
            }
            break;

        case UPNPDEV_STATE_GET:
            dev->looping++;
            if( TR_HTTP_STATUS_OK( code ) )
            {
                switch( parseMapping( dev, body, len ) )
                {
                    case -1:
                        break;
                    case 0:
                        tr_dbg( "upnp device %s: invalid mapping, "
                                "state get -> delete", dev->host );
                        dev->state = UPNPDEV_STATE_DEL;
                        break;
                    case 1:
                        tr_dbg( "upnp device %s: good mapping, "
                                "state get -> mapped", dev->host );
                        dev->state = UPNPDEV_STATE_MAPPED;
                        dev->looping = 0;
                        dev->lastcheck = tr_date();
                        tr_inf( "upnp successful for port %i",
                                dev->mappedport );
                        break;
                    default:
                        assert( 0 );
                        break;
                }
            }
            else if( IGD_NO_MAPPING_EXISTS == code ||
                     IGD_GENERIC_ERROR == code || IGD_GENERIC_FAILED == code )
            {
                tr_dbg( "upnp device %s: no mapping, state get -> add",
                        dev->host );
                dev->state = UPNPDEV_STATE_ADD;
            }
            else
            {
                tr_dbg( "upnp device %s: get failed with http code %i",
                        dev->host, code );
            }
            break;

        case UPNPDEV_STATE_DEL:
            dev->looping++;
            if( TR_HTTP_STATUS_OK( code ) || IGD_NO_MAPPING_EXISTS == code ||
                IGD_GENERIC_ERROR == code || IGD_GENERIC_FAILED == code )
            {
                tr_dbg( "upnp device %s: deleted, state delete -> ready",
                        dev->host );
                dev->state = UPNPDEV_STATE_READY;
                dev->looping = 0;
            }
            else
            {
                tr_dbg( "upnp device %s: del failed with http code %i",
                        dev->host, code );
            }
            break;

        default:
            assert( 0 );
            break;
    }

    dev->lastrequest = tr_date();
    killHttp( fdlimit, &dev->http );

    if( UPNPDEV_STATE_ERROR == dev->state )
    {
        tr_dbg( "upnp device %s: error, state %hhu -> error",
                dev->host, laststate );
        return 0;
    }

    return 1;
}
Ejemplo n.º 5
0
bool Lvk::Clue::ScriptParser::parse(const QString &filename, Clue::Script &script,
                                    Clue::ScriptFormat format)
{
    qDebug() << "ScriptParser: parsing filename" << filename;

    m_errMsg.clear();
    script.clear();
    script.filename = QFileInfo(filename).fileName();

    QFile f(filename);

    if (!f.exists()) {
        m_errMsg = QObject::tr("File not found: '%1'").arg(filename);
        m_error = Clue::FileNotFoundError;
        return false;
    }

    QIODevice::OpenMode flags = (format == XmlObfuscated) ? QFile::ReadOnly
                                                          : QFile::ReadOnly | QFile::Text;

    if (!f.open(flags)) {
        m_errMsg = QObject::tr("Cannot read file: '%1'").arg(filename);
        m_error = Clue::ReadError;
        return false;
    }

    QByteArray data = f.readAll();

    if (format == XmlObfuscated) {
        if (!deobfuscate(data)) {
            m_errMsg = QObject::tr("Cannot deobfuscate: '%1'").arg(filename);
            m_error = Clue::InvalidFormatError;
            return false;
        }
    }

    QString xml = QString::fromUtf8(data);
    QDomDocument doc;
    QString err;
    int line = 0;
    int col = 0;
    bool parsingOk = false;

    removeComments(xml);

    if (doc.setContent(xml, &err, &line, &col)) {
        QDomElement root = doc.documentElement();

        if (requireTagName("script", root)) {
            parsingOk = parseRoot(root, script);
        }
    } else {
        m_errMsg = QObject::tr("Ill-formed XML in line %1:%2").arg(line).arg(col);
        // More details:
        //m_errMsg = QObject::tr("Ill-formed XML in line %1:%2 %3").arg(line).arg(col).arg(xml);
    }

    if (!parsingOk) {
        m_errMsg = QObject::tr("Invalid format in file '%1'.\n%2").arg(filename, m_errMsg);
        m_error = Clue::InvalidFormatError;
        return false;
    }

    return true;
}
Ejemplo n.º 6
0
KoFilter::ConversionStatus KWord13Import::convert( const QByteArray& from, const QByteArray& to )
{
    if ( to != "application/vnd.oasis.opendocument.text"
        || from != "application/x-kword" )
    {
        return KoFilter::NotImplemented;
    }

    // We need KimageIO's help in OOWriterWorker::convertUnknownImage


    KWord13Document kwordDocument;

    const QString fileName( m_chain->inputFile() );
    if ( fileName.isEmpty() )
    {
        kError(30520) << "No input file name!";
        return KoFilter::StupidError;
    }

    KoStore* store = KoStore::createStore( fileName, KoStore::Read );
    if ( store && store->hasFile( "maindoc.xml" ) )
    {
        kDebug(30520) <<"Maindoc.xml found in KoStore!";

        // We do not really care about errors while reading/parsing documentinfo
        store->open( "documentinfo.xml" );
        KoStoreDevice ioInfo( store );
        ioInfo.open( QIODevice::ReadOnly );
        kDebug (30520) <<"Processing document info...";
        if ( ! parseInfo ( &ioInfo, kwordDocument ) )
        {
            kWarning(30520) << "Parsing documentinfo.xml has failed. Ignoring!";
        }
        ioInfo.close();
        store->close();

        // ### TODO: error return values
        if ( ! store->open( "maindoc.xml" ) )
        {
            kError(30520) << "Opening root has failed";
            delete store;
            return KoFilter::StupidError;
        }
        KoStoreDevice ioMain( store );
        ioMain.open( QIODevice::ReadOnly );
        kDebug (30520) <<"Processing root...";
        if ( ! parseRoot ( &ioMain, kwordDocument ) )
        {
            kWarning(30520) << "Parsing maindoc.xml has failed! Aborting!";
            delete store;
            return KoFilter::StupidError;
        }
        ioMain.close();
        store->close();

        if ( store->open( "preview.png" ) )
        {

            kDebug(30520) <<"Preview found!";
            KoStoreDevice ioPreview( store );
            ioPreview.open( QIODevice::ReadOnly );
            const QByteArray image ( ioPreview.readAll() );
            if ( image.isNull() )
            {
                kWarning(30520) << "Loading of preview failed! Ignoring!";
            }
            else
            {
                kwordDocument.m_previewFile = new KTemporaryFile();
                kwordDocument.m_previewFile->setSuffix(".png");
                kwordDocument.m_previewFile->open(); // ### TODO check KTemporaryFile
                // ### TODO: check if file is correctly written
                kwordDocument.m_previewFile->write( image );
                kwordDocument.m_previewFile->close();
            }
            ioPreview.close();
            store->close();
        }
        else
        {
            kDebug(30520) <<"No preview found!";
        }
    }
    else
    {
        kWarning(30520) << "Opening store has failed. Trying raw XML file!";
        // Be sure to undefine store
        delete store;
        store = 0;

        QFile file( fileName );
        file.open( QIODevice::ReadOnly );
        if ( ! parseRoot( &file, kwordDocument ) )
        {
            kError(30520) << "Could not process document! Aborting!";
            file.close();
            return KoFilter::StupidError;
        }
        file.close();
    }

    if ( store && ! postParse( store, kwordDocument ) )
    {
        kError(30520) << "Error during post-parsing! Aborting!";
        return  KoFilter::StupidError;
    }

    // We have finished with the input store/file, so close the store (already done for a raw XML file)
    kDebug(30520) <<"Deleting input store...";
    delete store;
    store = 0;
    kDebug(30520) <<"Input store deleted!";

    KWord13OasisGenerator generator;

    kDebug(30520) << __FILE__ <<":" << __LINE__;

    if ( ! generator.prepare( kwordDocument ) )
    {
        kError(30520) << "Could not prepare the OASIS document! Aborting!";
        return KoFilter::StupidError;
    }

    const QString filenameOut ( m_chain->outputFile() );

    if ( filenameOut.isEmpty() )
    {
        kError(30520) << "Empty file name for saving as OASIS! Aborting!";
        return KoFilter::StupidError;
    }

    if ( ! generator.generate( filenameOut, kwordDocument ) )
    {
        kError(30520) << "Could not save as OASIS! Aborting!";
        return KoFilter::StupidError;
    }

    kDebug(30520) <<"Filter has finished!";

    return KoFilter::OK;
}