/** * \brief muParser callback for registering user-defined variables * * When encountering an unknown variable within an expression, this function gets called. * Memory for the variable is allocated in m_variables and a pointer to the memory location * is returned to muParser. New variables are initialized with NaN. */ double *MuParserScript::variableFactory(const char *name, void *self) { MuParserScript *me = static_cast<MuParserScript *>(self); return me->m_variables.insert(QByteArray(name), NAN).operator->(); }
QByteArray JsonValue::parseCString(const char *&from, const char *to) { QByteArray result; JDEBUG("parseCString: " << QByteArray(from, to - from)); if (*from != '"') { qDebug() << "JSON Parse Error, double quote expected"; ++from; // So we don't hang return QByteArray(); } const char *ptr = from; ++ptr; while (ptr < to) { if (*ptr == '"') { ++ptr; result = QByteArray(from + 1, ptr - from - 2); break; } if (*ptr == '\\') { ++ptr; if (ptr == to) { qDebug() << "JSON Parse Error, unterminated backslash escape"; from = ptr; // So we don't hang return QByteArray(); } } ++ptr; } from = ptr; int idx = result.indexOf('\\'); if (idx >= 0) { char *dst = result.data() + idx; const char *src = dst + 1, *end = result.data() + result.length(); do { char c = *src++; switch (c) { case 'a': *dst++ = '\a'; break; case 'b': *dst++ = '\b'; break; case 'f': *dst++ = '\f'; break; case 'n': *dst++ = '\n'; break; case 'r': *dst++ = '\r'; break; case 't': *dst++ = '\t'; break; case 'v': *dst++ = '\v'; break; case '"': *dst++ = '"'; break; case '\\': *dst++ = '\\'; break; default: { int chars = 0; uchar prod = 0; forever { if (c < '0' || c > '7') { --src; break; } prod = prod * 8 + c - '0'; if (++chars == 3 || src == end) break; c = *src++; } if (!chars) { qDebug() << "JSON Parse Error, unrecognized backslash escape"; return QByteArray(); } *dst++ = prod; } } while (src != end) { char c = *src++; if (c == '\\') break; *dst++ = c; } } while (src != end); *dst = 0; result.truncate(dst - result.data()); }
void SoundEditWidget::deleteSound() { mHasSound = false; mSound = QByteArray(); updateView(); }
QByteArray Null::encodeData() const { return QByteArray(); }
static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt) { ATSFontContainerRef handle; OSStatus e = noErr; if(fnt->data.isEmpty()) { #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5) if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) { extern OSErr qt_mac_create_fsref(const QString &, FSRef *); // qglobal.cpp FSRef ref; if(qt_mac_create_fsref(fnt->fileName, &ref) != noErr) return; ATSFontActivateFromFileReference(&ref, kATSFontContextLocal, kATSFontFormatUnspecified, 0, kATSOptionFlagsDefault, &handle); } else #endif { #ifndef Q_WS_MAC64 extern Q_CORE_EXPORT OSErr qt_mac_create_fsspec(const QString &, FSSpec *); // global.cpp FSSpec spec; if(qt_mac_create_fsspec(fnt->fileName, &spec) != noErr) return; e = ATSFontActivateFromFileSpecification(&spec, kATSFontContextLocal, kATSFontFormatUnspecified, 0, kATSOptionFlagsDefault, &handle); #endif } } else { e = ATSFontActivateFromMemory((void *)fnt->data.constData(), fnt->data.size(), kATSFontContextLocal, kATSFontFormatUnspecified, 0, kATSOptionFlagsDefault, &handle); fnt->data = QByteArray(); } if(e != noErr) return; ItemCount fontCount = 0; e = ATSFontFindFromContainer(handle, kATSOptionFlagsDefault, 0, 0, &fontCount); if(e != noErr) return; QVarLengthArray<ATSFontRef> containedFonts(fontCount); e = ATSFontFindFromContainer(handle, kATSOptionFlagsDefault, fontCount, containedFonts.data(), &fontCount); if(e != noErr) return; fnt->families.clear(); #if defined(QT_MAC_USE_COCOA) // Make sure that the family name set on the font matches what // kCTFontFamilyNameAttribute returns in initializeDb(). // So far the best solution seems find the installed font // using CoreText and get the family name from it. // (ATSFontFamilyGetName appears to be the correct API, but also // returns the font display name.) for(int i = 0; i < containedFonts.size(); ++i) { QCFString fontPostScriptName; ATSFontGetPostScriptName(containedFonts[i], kATSOptionFlagsDefault, &fontPostScriptName); QCFType<CTFontDescriptorRef> font = CTFontDescriptorCreateWithNameAndSize(fontPostScriptName, 14); QCFString familyName = (CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontFamilyNameAttribute); fnt->families.append(familyName); } #else for(int i = 0; i < containedFonts.size(); ++i) { QCFString family; ATSFontGetName(containedFonts[i], kATSOptionFlagsDefault, &family); fnt->families.append(family); } #endif fnt->handle = handle; }
void Server::initializeCert() { QByteArray crt, key, pass, dhparams; crt = getConf("certificate", QString()).toByteArray(); key = getConf("key", QString()).toByteArray(); pass = getConf("passphrase", QByteArray()).toByteArray(); dhparams = getConf("sslDHParams", Meta::mp.qbaDHParams).toByteArray(); QList<QSslCertificate> ql; // Attempt to load key as an RSA key or a DSA key if (! key.isEmpty()) { qskKey = QSslKey(key, QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey, pass); if (qskKey.isNull()) qskKey = QSslKey(key, QSsl::Dsa, QSsl::Pem, QSsl::PrivateKey, pass); } // If we still can't load the key, try loading any keys from the certificate if (qskKey.isNull() && ! crt.isEmpty()) { qskKey = QSslKey(crt, QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey, pass); if (qskKey.isNull()) qskKey = QSslKey(crt, QSsl::Dsa, QSsl::Pem, QSsl::PrivateKey, pass); } // If have a key, walk the list of certs, find the one for our key, // remove any certs for our key from the list, what's left is part of // the CA certificate chain. if (! qskKey.isNull()) { ql << QSslCertificate::fromData(crt); ql << QSslCertificate::fromData(key); for (int i=0;i<ql.size();++i) { const QSslCertificate &c = ql.at(i); if (isKeyForCert(qskKey, c)) { qscCert = c; ql.removeAt(i); } } qlCA = ql; } #if defined(USE_QSSLDIFFIEHELLMANPARAMETERS) if (! dhparams.isEmpty()) { QSslDiffieHellmanParameters qdhp = QSslDiffieHellmanParameters(dhparams); if (qdhp.isValid()) { qsdhpDHParams = qdhp; } else { log(QString::fromLatin1("Unable to use specified Diffie-Hellman parameters (sslDHParams): %1").arg(qdhp.errorString())); } } #else if (! dhparams.isEmpty()) { log("Diffie-Hellman parameters (sslDHParams) were specified, but will not be used. This version of Murmur does not support Diffie-Hellman parameters."); } #endif QString issuer; #if QT_VERSION >= 0x050000 QStringList issuerNames = qscCert.issuerInfo(QSslCertificate::CommonName); if (! issuerNames.isEmpty()) { issuer = issuerNames.first(); } #else issuer = qscCert.issuerInfo(QSslCertificate::CommonName); #endif // Really old certs/keys are no good, throw them away so we can // generate a new one below. if (issuer == QString::fromUtf8("Murmur Autogenerated Certificate")) { log("Old autogenerated certificate is unusable for registration, invalidating it"); qscCert = QSslCertificate(); qskKey = QSslKey(); } // If we have a cert, and it's a self-signed one, but we're binding to // all the same addresses as the Meta server is, use it's cert instead. // This allows a self-signed certificate generated by Murmur to be // replaced by a CA-signed certificate in the .ini file. if (!qscCert.isNull() && issuer == QString::fromUtf8("Murmur Autogenerated Certificate v2") && ! Meta::mp.qscCert.isNull() && ! Meta::mp.qskKey.isNull() && (Meta::mp.qlBind == qlBind)) { qscCert = Meta::mp.qscCert; qskKey = Meta::mp.qskKey; } // If we still don't have a certificate by now, try to load the one from Meta if (qscCert.isNull() || qskKey.isNull()) { if (! key.isEmpty() || ! crt.isEmpty()) { log("Certificate specified, but failed to load."); } qskKey = Meta::mp.qskKey; qscCert = Meta::mp.qscCert; // If loading from Meta doesn't work, build+sign a new one if (qscCert.isNull() || qskKey.isNull()) { log("Generating new server certificate."); CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); X509 *x509 = X509_new(); EVP_PKEY *pkey = EVP_PKEY_new(); RSA *rsa = RSA_generate_key(2048,RSA_F4,NULL,NULL); EVP_PKEY_assign_RSA(pkey, rsa); X509_set_version(x509, 2); ASN1_INTEGER_set(X509_get_serialNumber(x509),1); X509_gmtime_adj(X509_get_notBefore(x509),0); X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365*20); X509_set_pubkey(x509, pkey); X509_NAME *name=X509_get_subject_name(x509); X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, reinterpret_cast<unsigned char *>(const_cast<char *>("Murmur Autogenerated Certificate v2")), -1, -1, 0); X509_set_issuer_name(x509, name); add_ext(x509, NID_basic_constraints, SSL_STRING("critical,CA:FALSE")); add_ext(x509, NID_ext_key_usage, SSL_STRING("serverAuth,clientAuth")); add_ext(x509, NID_subject_key_identifier, SSL_STRING("hash")); add_ext(x509, NID_netscape_comment, SSL_STRING("Generated from murmur")); X509_sign(x509, pkey, EVP_sha1()); crt.resize(i2d_X509(x509, NULL)); unsigned char *dptr=reinterpret_cast<unsigned char *>(crt.data()); i2d_X509(x509, &dptr); qscCert = QSslCertificate(crt, QSsl::Der); if (qscCert.isNull()) log("Certificate generation failed"); key.resize(i2d_PrivateKey(pkey, NULL)); dptr=reinterpret_cast<unsigned char *>(key.data()); i2d_PrivateKey(pkey, &dptr); qskKey = QSslKey(key, QSsl::Rsa, QSsl::Der); if (qskKey.isNull()) log("Key generation failed"); setConf("certificate", qscCert.toPem()); setConf("key", qskKey.toPem()); } } #if defined(USE_QSSLDIFFIEHELLMANPARAMETERS) if (qsdhpDHParams.isEmpty()) { log("Generating new server 2048-bit Diffie-Hellman parameters. This could take a while..."); DH *dh = DH_new(); if (dh == NULL) { qFatal("DH_new failed: unable to generate Diffie-Hellman parameters for virtual server"); } // Generate DH params. // We register a status callback in order to update the UI // for Murmur on Windows. We don't show the actual status, // but we do it to keep Murmur on Windows responsive while // generating the parameters. BN_GENCB cb; memset(&cb, 0, sizeof(BN_GENCB)); BN_GENCB_set(&cb, dh_progress, NULL); if (DH_generate_parameters_ex(dh, 2048, 2, &cb) == 0) { qFatal("DH_generate_parameters_ex failed: unable to generate Diffie-Hellman parameters for virtual server"); } BIO *mem = BIO_new(BIO_s_mem()); if (PEM_write_bio_DHparams(mem, dh) == 0) { qFatal("PEM_write_bio_DHparams failed: unable to write generated Diffie-Hellman parameters to memory"); } char *pem = NULL; long len = BIO_get_mem_data(mem, &pem); if (len <= 0) { qFatal("BIO_get_mem_data returned an empty or invalid buffer"); } QByteArray pemdh(pem, len); QSslDiffieHellmanParameters qdhp(pemdh); if (!qdhp.isValid()) { qFatal("QSslDiffieHellmanParameters: unable to import generated Diffie-HellmanParameters: %s", qdhp.errorString().toStdString().c_str()); } qsdhpDHParams = qdhp; setConf("sslDHParams", pemdh); BIO_free(mem); DH_free(dh); } #endif // Drain OpenSSL's per-thread error queue // to ensure that errors from the operations // we've done in here do not leak out into // Qt's SSL module. // // If an error leaks, it can break all connections // to the server because each invocation of Qt's SSL // read callback checks OpenSSL's per-thread error // queue (albeit indirectly, via SSL_get_error()). // Qt expects any errors returned from SSL_get_error() // to be related to the QSslSocket it is currently // processing -- which is the obvious thing to expect: // SSL_get_error() takes a pointer to an SSL object // and the return code of the failed operation. // However, it is also documented as: // // "In addition to ssl and ret, SSL_get_error() // inspects the current thread's OpenSSL error // queue." // // So, if any OpenSSL operation on the main thread // forgets to clear the error queue, those errors // *will* leak into other things that *do* error // checking. In our case, into Qt's SSL read callback, // resulting in all clients being disconnected. ERR_clear_error(); }
Frame::Frame(quint8 header) : _header(header) , _data(QByteArray()) { }
void FeedbackDialog::GenerateSpecs() { // Gather some information about the system and embed it into the report QDesktopWidget* screen = QApplication::desktop(); QString os_version = "Operating system: "; QString qt_version = QString("Qt version: ") + QT_VERSION_STR + QString("\n"); QString total_ram = "Total RAM: "; QString number_of_cores = "Number of cores: "; QString compiler_bits = "Compiler architecture: "; QString compiler_version = "Compiler version: "; QString kernel_line = "Kernel: "; QString screen_size = "Size of the screen(s): " + QString::number(screen->width()) + "x" + QString::number(screen->height()) + "\n"; QString number_of_screens = "Number of screens: " + QString::number(screen->screenCount()) + "\n"; QString processor_name = "Processor: "; // platform specific code #ifdef Q_OS_MACX number_of_cores += QString::number(sysconf(_SC_NPROCESSORS_ONLN)) + "\n"; uint64_t memsize; size_t len = sizeof(memsize); static int mib_s[2] = { CTL_HW, HW_MEMSIZE }; if (sysctl (mib_s, 2, &memsize, &len, NULL, 0) == 0) total_ram += QString::number(memsize/1024/1024) + " MB\n"; else total_ram += "Error getting total RAM information\n"; int mib[] = {CTL_KERN, KERN_OSRELEASE}; sysctl(mib, sizeof mib / sizeof(int), NULL, &len, NULL, 0); char *kernelVersion = (char *)malloc(sizeof(char)*len); sysctl(mib, sizeof mib / sizeof(int), kernelVersion, &len, NULL, 0); QString kernelVersionStr = QString(kernelVersion); free(kernelVersion); int major_version = kernelVersionStr.split(".").first().toUInt() - 4; int minor_version = kernelVersionStr.split(".").at(1).toUInt(); os_version += QString("Mac OS X 10.%1.%2").arg(major_version).arg(minor_version) + " "; switch(major_version) { case 4: os_version += "\"Tiger\"\n"; break; case 5: os_version += "\"Leopard\"\n"; break; case 6: os_version += "\"Snow Leopard\"\n"; break; case 7: os_version += "\"Lion\"\n"; break; case 8: os_version += "\"Mountain Lion\"\n"; break; default: os_version += "\"Unknown version\"\n"; break; } #endif #ifdef Q_OS_WIN SYSTEM_INFO sysinfo; GetSystemInfo(&sysinfo); number_of_cores += QString::number(sysinfo.dwNumberOfProcessors) + "\n"; MEMORYSTATUSEX status; status.dwLength = sizeof(status); GlobalMemoryStatusEx(&status); total_ram += QString::number(status.ullTotalPhys/1024/1024) + " MB\n"; switch(QSysInfo::windowsVersion()) { case QSysInfo::WV_NT: os_version += "Windows NT\n"; break; case QSysInfo::WV_2000: os_version += "Windows 2000\n"; break; case QSysInfo::WV_XP: os_version += "Windows XP\n"; break; case QSysInfo::WV_2003: os_version += "Windows Server 2003\n"; break; case QSysInfo::WV_VISTA: os_version += "Windows Vista\n"; break; case QSysInfo::WV_WINDOWS7: os_version += "Windows 7\n"; break; #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) case QSysInfo::WV_WINDOWS8: os_version += "Windows 8\n"; break; #endif default: os_version += "Windows (Unknown version)\n"; break; } kernel_line += "Windows kernel\n"; #endif #ifdef Q_OS_LINUX number_of_cores += QString::number(sysconf(_SC_NPROCESSORS_ONLN)) + "\n"; quint32 pages = sysconf(_SC_PHYS_PAGES); quint32 page_size = sysconf(_SC_PAGE_SIZE); quint64 total = (quint64)pages * page_size / 1024 / 1024; total_ram += QString::number(total) + " MB\n"; os_version += "GNU/Linux or BSD\n"; #endif // uname -a #if defined(Q_OS_LINUX) || defined(Q_OS_MAC) QProcess *process = new QProcess(); QStringList arguments = QStringList("-a"); process->start("uname", arguments); if (process->waitForFinished()) kernel_line += QString(process->readAll()); delete process; #endif #if (defined(Q_OS_WIN) && defined(__i386__)) || defined(__x86_64__) // cpu info quint32 registers[4]; quint32 i; i = 0x80000002; asm volatile ("cpuid" : "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]) : "a" (i), "c" (0)); processor_name += QByteArray(reinterpret_cast<char*>(®isters[0]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[1]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[2]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[3]), 4); i = 0x80000003; asm volatile ("cpuid" : "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]) : "a" (i), "c" (0)); processor_name += QByteArray(reinterpret_cast<char*>(®isters[0]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[1]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[2]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[3]), 4); i = 0x80000004; asm volatile ("cpuid" : "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]) : "a" (i), "c" (0)); processor_name += QByteArray(reinterpret_cast<char*>(®isters[0]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[1]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[2]), 4); processor_name += QByteArray(reinterpret_cast<char*>(®isters[3]), 4); processor_name += "\n"; #else processor_name += "Unknown"; #endif // compiler #ifdef __GNUC__ compiler_version += "GCC " + QString(__VERSION__) + "\n"; #else compiler_version += "Unknown\n"; #endif if(sizeof(void*) == 4) compiler_bits += "i386\n"; else if(sizeof(void*) == 8) compiler_bits += "x86_64\n"; // concat system info specs = qt_version + os_version + total_ram + screen_size + number_of_screens + processor_name + number_of_cores + compiler_version + compiler_bits + kernel_line; }
ParametersRecord::ParametersRecord(const RecordHeader& header, const QByteArray& _data) { const UnsignedByteArray data(_data); Q_ASSERT(header.type() == RecordHeader::ParametersRecord); Q_ASSERT(data.length() >= header.contentLength()); int i = 0; quint16 bytesToRead = header.contentLength(); const quint8 highBitMask = 1 << 7; QByteArray name, value; while(i < bytesToRead) { quint32 nameLength; quint32 valueLength; // See "Name-Value pairs" in the spec // work out name length if(data[i] & highBitMask) { // Four bytes of name length nameLength = ((data[i] & ~highBitMask) << 24) + (data[i+1] << 16) + (data[i+2] << 8) + data[i+3] ; i+= 4; } else { // 1 byte of name length nameLength = data[i++]; } // ditto for value if(data[i] & highBitMask) { // Four bytes of value length valueLength = ((data[i] & ~highBitMask) << 24) + (data[i+1] << 16) + (data[i+2] << 8) + data[i+3] ; i+= 4; } else { // 1 byte of name length valueLength = data[i++]; } name = QByteArray(&data.constData()[i], nameLength); i += nameLength; value = QByteArray(&data.constData()[i], valueLength); i += valueLength; m_parameters.insert(name, value); name.clear(); value.clear(); } }
// XXX: documentation!!! QByteArray QWSWindowSurface::transientState() const { return QByteArray(); }
QByteArray QWSWindowSurface::permanentState() const { return QByteArray(); }
void FF10Node::process( qint64 pTimeStamp ) { fugio::Performance Perf( mNode, __FUNCTION__, pTimeStamp ); FF_Main_FuncPtr MainFunc = mLibrary->func(); if( !MainFunc ) { return; } fugio::Image DstImg = mValOutput->variant().value<fugio::Image>(); if( DstImg.format() == fugio::ImageFormat::UNKNOWN ) { /* if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_32BIT ) ) { DstImg.setFormat( fugio::ImageFormat::RGBA8 ); // mBitDepth = FF_CAP_32BITVIDEO; } else */if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_24BIT ) ) { #if defined( Q_OS_WIN ) DstImg.setFormat( fugio::ImageFormat::BGR8 ); #else DstImg.setFormat( fugio::ImageFormat::RGB8 ); #endif mBitDepth = FF_CAP_24BITVIDEO; } else if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_16BIT ) ) { DstImg.setFormat( fugio::ImageFormat::RGB_565 ); mBitDepth = FF_CAP_16BITVIDEO; } } if( DstImg.format() == fugio::ImageFormat::UNKNOWN ) { return; } //------------------------------------------------------------------------- // Calculate the input size QSize SrcSze; for( int i = 0 ; i < mInputs.size() ; i++ ) { fugio::Image SrcImg = variant<fugio::Image>( mInputs.at( i ) ); if( !SrcImg.isValid() ) { continue; } if( SrcImg.width() > SrcSze.width() ) { SrcSze.setWidth( SrcImg.width() ); } if( SrcImg.height() > SrcSze.height() ) { SrcSze.setHeight( SrcImg.height() ); } if( SrcImg.format() != DstImg.format() ) { continue; } } if( !SrcSze.isValid() ) { return; } //------------------------------------------------------------------------- // Initialise the instance FFMixed PMU; if( DstImg.size() != SrcSze ) { if( mInstanceId ) { PMU.UIntValue = 0; PMU = MainFunc( FF_DEINSTANTIATE, PMU, mInstanceId ); mInstanceId = 0; } DstImg.setSize( SrcSze ); if( mBitDepth == FF_CAP_16BITVIDEO ) { DstImg.setLineSize( 0, 2 * SrcSze.width() ); } else if( mBitDepth == FF_CAP_24BITVIDEO ) { DstImg.setLineSize( 0, 3 * SrcSze.width() ); } else if( mBitDepth == FF_CAP_32BITVIDEO ) { DstImg.setLineSize( 0, 4 * SrcSze.width() ); } mDstBuf.resize( 1024 + DstImg.bufferSize( 0 ) + 1024 ); DstImg.setBuffer( 0, &mDstBuf[ 1024 ] ); VideoInfoStruct VIS; VIS.BitDepth = mBitDepth; VIS.FrameWidth = SrcSze.width(); VIS.FrameHeight = SrcSze.height(); VIS.Orientation = FF_ORIENTATION_TL; PMU.PointerValue = &VIS; PMU = MainFunc( FF_INSTANTIATE, PMU, 0 ); if( PMU.UIntValue == FF_FAIL ) { return; } mInstanceId = PMU.PointerValue; } if( !mInstanceId ) { return; } //------------------------------------------------------------------------- // Prepare the source frames QVector<void *> SrcPtr; for( int i = 0 ; i < mInputs.size() ; i++ ) { fugio::Image SrcImg = variant<fugio::Image>( mInputs.at( i ) ); if( !SrcImg.isValid() ) { continue; } if( SrcImg.size() != SrcSze || SrcImg.lineSize( 0 ) != DstImg.lineSize( 0 ) ) { continue; } SrcPtr << SrcImg.buffer( 0 ); } //------------------------------------------------------------------------- // Update the parameters SetParameterStructTag PrmSet; for( int i = 0 ; i < mParams.size() ; i++ ) { QSharedPointer<fugio::PinInterface> PrmPin = mParams.at( i ); FreeframeLibrary::ParamEntry PrmEnt = mLibrary->params().at( i ); QVariant PrmVal = variant( PrmPin ); PrmSet.ParameterNumber = i; if( PrmEnt.mType == FF_TYPE_STANDARD ) { PrmSet.NewParameterValue.FloatValue = qBound( 0.0f, PrmVal.value<float>(), 1.0f ); PMU.PointerValue = &PrmSet; MainFunc( FF_SETPARAMETER, PMU, mInstanceId ); } else if( PrmEnt.mType == FF_TYPE_BOOLEAN ) { PrmSet.NewParameterValue.UIntValue = PrmVal.value<bool>() ? FF_TRUE : FF_FALSE; PMU.PointerValue = &PrmSet; MainFunc( FF_SETPARAMETER, PMU, mInstanceId ); } PMU.UIntValue = i; PMU = MainFunc( FF_GETPARAMETERDISPLAY, PMU, mInstanceId ); if( PMU.UIntValue != FF_FAIL ) { PrmPin->setDisplayLabel( QString::fromLatin1( QByteArray( (const char *)PMU.PointerValue, 16 ) ) ); } } //------------------------------------------------------------------------- // Call the plugin if( SrcPtr.size() >= mLibrary->minInputFrames() ) { if( mLibrary->hasProcessFrameCopy() ) { ProcessFrameCopyStruct PFC; PFC.numInputFrames = SrcPtr.size(); PFC.pOutputFrame = DstImg.buffer( 0 ); PFC.ppInputFrames = SrcPtr.data(); PMU.PointerValue = &PFC; PMU = MainFunc( FF_PROCESSFRAMECOPY, PMU, mInstanceId ); } else { if( !SrcPtr.isEmpty() ) { memcpy( DstImg.buffer( 0 ), SrcPtr.first(), DstImg.bufferSize( 0 ) ); } PMU.PointerValue = DstImg.buffer( 0 ); PMU = MainFunc( FF_PROCESSFRAME, PMU, mInstanceId ); } } //------------------------------------------------------------------------- // Update the pin if we succeed if( PMU.UIntValue == FF_SUCCESS ) { pinUpdated( mPinOutput ); } }
/** * @brief Clears contents of the movie based on a list * @param infos List of infos which should be cleared */ void Movie::clear(QList<int> infos) { if (infos.contains(MovieScraperInfos::Actors)) m_actors.clear(); if (infos.contains(MovieScraperInfos::Backdrop)) { m_backdrops.clear(); m_images.insert(ImageType::MovieBackdrop, QByteArray()); m_hasImageChanged.insert(ImageType::MovieBackdrop, false); m_imagesToRemove.removeOne(ImageType::MovieBackdrop); } if (infos.contains(MovieScraperInfos::CdArt)) { m_discArts.clear(); m_images.insert(ImageType::MovieCdArt, QByteArray()); m_hasImageChanged.insert(ImageType::MovieCdArt, false); m_imagesToRemove.removeOne(ImageType::MovieCdArt); } if (infos.contains(MovieScraperInfos::ClearArt)) { m_clearArts.clear(); m_images.insert(ImageType::MovieClearArt, QByteArray()); m_hasImageChanged.insert(ImageType::MovieClearArt, false); m_imagesToRemove.removeOne(ImageType::MovieClearArt); } if (infos.contains(MovieScraperInfos::Logo)) { m_logos.clear(); m_images.insert(ImageType::MovieLogo, QByteArray()); m_hasImageChanged.insert(ImageType::MovieLogo, false); m_imagesToRemove.removeOne(ImageType::MovieLogo); } if (infos.contains(MovieScraperInfos::Countries)) m_countries.clear(); if (infos.contains(MovieScraperInfos::Genres)) m_genres.clear(); if (infos.contains(MovieScraperInfos::Poster)){ m_posters.clear(); m_images.insert(ImageType::MoviePoster, QByteArray()); m_hasImageChanged.insert(ImageType::MoviePoster, false); m_numPrimaryLangPosters = 0; m_imagesToRemove.removeOne(ImageType::MoviePoster); } if (infos.contains(MovieScraperInfos::Studios)) m_studios.clear(); if (infos.contains(MovieScraperInfos::Title)) m_originalName = ""; if (infos.contains(MovieScraperInfos::Set)) m_set = ""; if (infos.contains(MovieScraperInfos::Overview)) { m_overview = ""; m_outline = ""; } if (infos.contains(MovieScraperInfos::Rating)) { m_rating = 0; m_votes = 0; } if (infos.contains(MovieScraperInfos::Released)) m_released = QDate(2000, 02, 30); // invalid date if (infos.contains(MovieScraperInfos::Tagline)) m_tagline = ""; if (infos.contains(MovieScraperInfos::Runtime)) m_runtime = 0; if (infos.contains(MovieScraperInfos::Trailer)) m_trailer = ""; if (infos.contains(MovieScraperInfos::Certification)) m_certification = ""; if (infos.contains(MovieScraperInfos::Writer)) m_writer = ""; if (infos.contains(MovieScraperInfos::Director)) m_director = ""; if (infos.contains(MovieScraperInfos::Tags)) m_tags.clear(); if (infos.contains(MovieScraperInfos::Banner)) { m_images.insert(ImageType::MovieBanner, QByteArray()); m_hasImageChanged.insert(ImageType::MovieBanner, false); m_imagesToRemove.removeOne(ImageType::MovieBanner); } if (infos.contains(MovieScraperInfos::Thumb)) { m_images.insert(ImageType::MovieThumb, QByteArray()); m_hasImageChanged.insert(ImageType::MovieThumb, false); m_imagesToRemove.removeOne(ImageType::MovieThumb); } if (infos.contains(MovieScraperInfos::ExtraFanarts)) { m_extraFanartsToRemove.clear(); m_extraFanartImagesToAdd.clear(); m_extraFanarts.clear(); } }
void ImageScalingTest::shouldHaveChangeMimetype_data() { QTest::addColumn<QByteArray>("initialmimetype"); QTest::addColumn<QByteArray>("newmimetype"); QTest::addColumn<QString>("format"); QTest::newRow("no change mimetype when empty") << QByteArray() << QByteArray() << QStringLiteral("PNG"); QTest::newRow("no change mimetype when empty jpeg") << QByteArray() << QByteArray() << QStringLiteral("JPG"); QTest::newRow("no change mimetype when jpeg (same)") << QByteArray("image/jpeg") << QByteArray("image/jpeg") << QStringLiteral("JPG"); QTest::newRow("no change mimetype when jpeg") << QByteArray("image/jpeg") << QByteArray("image/jpeg") << QStringLiteral("PNG"); QTest::newRow("no change mimetype when png (same)") << QByteArray("image/png") << QByteArray("image/png") << QStringLiteral("JPG"); QTest::newRow("no change mimetype when png") << QByteArray("image/png") << QByteArray("image/png") << QStringLiteral("PNG"); QTest::newRow("change mimetype when png") << QByteArray("image/mng") << QByteArray("image/png") << QStringLiteral("PNG"); QTest::newRow("change mimetype when jpeg") << QByteArray("image/mng") << QByteArray("image/jpeg") << QStringLiteral("JPG"); QTest::newRow("When format is not defined but png") << QByteArray("image/png") << QByteArray("image/png") << QString(); QTest::newRow("When format is not defined but jpeg") << QByteArray("image/jpeg") << QByteArray("image/jpeg") << QString(); QTest::newRow("When format is not defined but other mimetype (return png)") << QByteArray("image/mng") << QByteArray("image/png") << QString(); }
QVariant SettingsHandlerBase::handleReadItemValue(const XQSettingsKey& key, XQSettingsManager::Type type, TInt& error) { const TInt KRBufDefaultLength = 32; switch(type) { case XQSettingsManager::TypeVariant: { //Try to read TInt TInt intValue; error = getValue(key.key(), intValue); if (error == KErrNone) { return QVariant(intValue); } //Try to read TReal TReal realValue; error = getValue(key.key(), realValue); if (error == KErrNone) { return QVariant(realValue); } //Try to read RBuf8 QVariant byteArrayVariant; TRAP(error, RBuf8 tdes8Value; tdes8Value.CreateL(KRBufDefaultLength); CleanupClosePushL(tdes8Value); getValueL(key.key(), tdes8Value); byteArrayVariant.setValue(QByteArray((const char*)tdes8Value.Ptr(), tdes8Value.Length())); CleanupStack::PopAndDestroy(&tdes8Value); ) if (error == KErrNone) { return byteArrayVariant; } break; } case XQSettingsManager::TypeInt: { //Try to read TInt TInt intValue; error = getValue(key.key(), intValue); if (error == KErrNone) { return QVariant(intValue); } break; } case XQSettingsManager::TypeDouble: { //Try to read TReal TReal realValue; error = getValue(key.key(), realValue); if (error == KErrNone) { return QVariant(realValue); } break; } case XQSettingsManager::TypeString: { //Try to read RBuf8 QVariant stringVariant; TRAP(error, RBuf16 tdes16Value; tdes16Value.CreateL(KRBufDefaultLength); CleanupClosePushL(tdes16Value); getValueL(key.key(), tdes16Value); stringVariant.setValue(QString::fromUtf16(tdes16Value.Ptr(), tdes16Value.Length())); CleanupStack::PopAndDestroy(&tdes16Value); ) if (error == KErrNone) { return stringVariant; } break; }
void SshOutgoingPacket::generateChannelOpenFailurePacket(quint32 remoteChannel, quint32 reason, const QByteArray &reasonString) { init(SSH_MSG_CHANNEL_OPEN_FAILURE).appendInt(remoteChannel).appendInt(reason) .appendString(reasonString).appendString(QByteArray()).finalize(); }
void FGFSIoTelnetChannel::collectIncomingData (const char* s, int n) { DEBUGP(LOGBULK, "collect bs" << n); emit sigRcvd(QByteArray(s)); };
void SshOutgoingPacket::generateDisconnectPacket(SshErrorCode reason, const QByteArray &reasonString) { init(SSH_MSG_DISCONNECT).appendInt(reason).appendString(reasonString) .appendString(QByteArray()).finalize(); }
Frame::Frame() : _header(0) , _data(QByteArray()) { }
/** * \brief Parse \a argv into a name,value map. * \param terminalArgs stop parsing when one of these options is found (it will be included in result) * \param safeArgs if not NULL, will be used to pass number of arguments before terminal argument (or argc if there was no terminal argument) * * Supported options syntax: --switch; --param=value; --param value; -switch; -param=value; -param value. * Additionally on Windows: /switch; /param:value; /param value. * * When creating the map, alias names are converted to original option names. * * Use \a terminalArgs if you want need to stop parsing after certain options for security reasons, etc. */ QHash<QByteArray, QByteArray> SimpleCli::parse(int argc, char* argv[], const QList<QByteArray>& terminalArgs, int* safeArgc) { #ifdef Q_OS_WIN const bool winmode = true; #else const bool winmode = false; #endif QHash<QByteArray, QByteArray> map; int safe = 1; int n = 1; for (; n < argc; ++n) { QByteArray str = QByteArray(argv[n]); QByteArray left, right; int sep = str.indexOf('='); if (sep == -1) { left = str; } else { left = str.mid(0, sep); right = str.mid(sep + 1); } bool unnamedArgument = true; if (left.startsWith("--")) { left = left.mid(2); unnamedArgument = false; } else if (left.startsWith('-') || (left.startsWith('/') && winmode)) { left = left.mid(1); unnamedArgument = false; } else if (n == 1 && left.startsWith("xmpp:")) { unnamedArgument = false; left = "uri"; right = str; } QByteArray name, value; if (unnamedArgument) { value = left; } else { name = left; value = right; if (aliases.contains(name)) { name = argdefs[aliases[name]].name; if (argdefs[name].needsValue && value.isNull() && n + 1 < argc) { value = QByteArray(argv[++n]); } } } if (map.contains(name)) { qDebug("CLI: Ignoring next value ('%s') for '%s' arg.", value.constData(), name.constData()); } else { map[name] = value; } if (terminalArgs.contains(name)) { break; } else { safe = n + 1; } } if (safeArgc) { *safeArgc = safe; } return map; }
void tst_QUdpSocket::loop_data() { QTest::addColumn<QByteArray>("peterMessage"); QTest::addColumn<QByteArray>("paulMessage"); QTest::addColumn<bool>("success"); QTest::newRow("\"Almond!\" | \"Joy!\"") << QByteArray("Almond!") << QByteArray("Joy!") << true; QTest::newRow("\"A\" | \"B\"") << QByteArray("A") << QByteArray("B") << true; QTest::newRow("\"AB\" | \"B\"") << QByteArray("AB") << QByteArray("B") << true; QTest::newRow("\"AB\" | \"BB\"") << QByteArray("AB") << QByteArray("BB") << true; QTest::newRow("\"A\\0B\" | \"B\\0B\"") << QByteArray::fromRawData("A\0B", 3) << QByteArray::fromRawData("B\0B", 3) << true; QTest::newRow("\"(nil)\" | \"(nil)\"") << QByteArray() << QByteArray() << true; QTest::newRow("Bigmessage") << QByteArray(600, '@') << QByteArray(600, '@') << true; }
// ### autotest failure for non-empty passPhrase and private key QByteArray QSslKey::toDer(const QByteArray &passPhrase) const { if (d->isNull) return QByteArray(); return d->derFromPem(toPem(passPhrase)); }
//Convenience constructor so you can say Item("foo") Item::Item(const char * const text) : generator(Text(QByteArray(text)).generator) {}
void wrapInFunction() { //! [0] QByteArray ba("Hello"); //! [0] //! [1] QByteArray ba; ba.resize(5); ba[0] = 0x3c; ba[1] = 0xb8; ba[2] = 0x64; ba[3] = 0x18; ba[4] = 0xca; //! [1] //! [2] for (int i = 0; i < ba.size(); ++i) { if (ba.at(i) >= 'a' && ba.at(i) <= 'f') cout << "Found character in range [a-f]" << endl; } //! [2] //! [3] QByteArray x("and"); x.prepend("rock "); // x == "rock and" x.append(" roll"); // x == "rock and roll" x.replace(5, 3, "&"); // x == "rock & roll" //! [3] //! [4] QByteArray ba("We must be <b>bold</b>, very <b>bold</b>"); int j = 0; while ((j = ba.indexOf("<b>", j)) != -1) { cout << "Found <b> tag at index position " << j << endl; ++j; } //! [4] //! [5] QByteArray().isNull(); // returns true QByteArray().isEmpty(); // returns true QByteArray("").isNull(); // returns false QByteArray("").isEmpty(); // returns true QByteArray("abc").isNull(); // returns false QByteArray("abc").isEmpty(); // returns false //! [5] //! [6] QByteArray ba("Hello"); int n = ba.size(); // n == 5 ba.data()[0]; // returns 'H' ba.data()[4]; // returns 'o' ba.data()[5]; // returns '\0' //! [6] //! [7] QByteArray().isEmpty(); // returns true QByteArray("").isEmpty(); // returns true QByteArray("abc").isEmpty(); // returns false //! [7] //! [8] QByteArray ba("Hello world"); char *data = ba.data(); while (*data) { cout << "[" << *data << "]" << endl; ++data; } //! [8] //! [9] QByteArray ba; for (int i = 0; i < 10; ++i) ba[i] = 'A' + i; // ba == "ABCDEFGHIJ" //! [9] //! [10] QByteArray ba("Stockholm"); ba.truncate(5); // ba == "Stock" //! [10] //! [11] QByteArray ba("STARTTLS\r\n"); ba.chop(2); // ba == "STARTTLS" //! [11] //! [12] QByteArray x("free"); QByteArray y("dom"); x += y; // x == "freedom" //! [12] //! [13] QByteArray().isNull(); // returns true QByteArray("").isNull(); // returns false QByteArray("abc").isNull(); // returns false //! [13] //! [14] QByteArray ba("Istambul"); ba.fill('o'); // ba == "oooooooo" ba.fill('X', 2); // ba == "XX" //! [14] //! [15] QByteArray x("ship"); QByteArray y("air"); x.prepend(y); // x == "airship" //! [15] //! [16] QByteArray x("free"); QByteArray y("dom"); x.append(y); // x == "freedom" //! [16] //! [17] QByteArray ba("Meal"); ba.insert(1, QByteArray("ontr")); // ba == "Montreal" //! [17] //! [18] QByteArray ba("Montreal"); ba.remove(1, 4); // ba == "Meal" //! [18] //! [19] QByteArray x("Say yes!"); QByteArray y("no"); x.replace(4, 3, y); // x == "Say no!" //! [19] //! [20] QByteArray ba("colour behaviour flavour neighbour"); ba.replace(QByteArray("ou"), QByteArray("o")); // ba == "color behavior flavor neighbor" //! [20] //! [21] QByteArray x("sticky question"); QByteArray y("sti"); x.indexOf(y); // returns 0 x.indexOf(y, 1); // returns 10 x.indexOf(y, 10); // returns 10 x.indexOf(y, 11); // returns -1 //! [21] //! [22] QByteArray ba("ABCBA"); ba.indexOf("B"); // returns 1 ba.indexOf("B", 1); // returns 1 ba.indexOf("B", 2); // returns 3 ba.indexOf("X"); // returns -1 //! [22] //! [23] QByteArray x("crazy azimuths"); QByteArray y("az"); x.lastIndexOf(y); // returns 6 x.lastIndexOf(y, 6); // returns 6 x.lastIndexOf(y, 5); // returns 2 x.lastIndexOf(y, 1); // returns -1 //! [23] //! [24] QByteArray ba("ABCBA"); ba.lastIndexOf("B"); // returns 3 ba.lastIndexOf("B", 3); // returns 3 ba.lastIndexOf("B", 2); // returns 1 ba.lastIndexOf("X"); // returns -1 //! [24] //! [25] QByteArray url("ftp://ftp.qt.nokia.com/"); if (url.startsWith("ftp:")) ... //! [25] //! [26] QByteArray url("http://qt.nokia.com/index.html"); if (url.endsWith(".html")) ... //! [26] //! [27] QByteArray x("Pineapple"); QByteArray y = x.left(4); // y == "Pine" //! [27] //! [28] QByteArray x("Pineapple"); QByteArray y = x.right(5); // y == "apple" //! [28] //! [29] QByteArray x("Five pineapples"); QByteArray y = x.mid(5, 4); // y == "pine" QByteArray z = x.mid(5); // z == "pineapples" //! [29] //! [30] QByteArray x("Qt by NOKIA"); QByteArray y = x.toLower(); // y == "qt by nokia" //! [30] //! [31] QByteArray x("Qt by NOKIA"); QByteArray y = x.toUpper(); // y == "QT BY NOKIA" //! [31] //! [32] QByteArray ba(" lots\t of\nwhitespace\r\n "); ba = ba.simplified(); // ba == "lots of whitespace"; //! [32] //! [33] QByteArray ba(" lots\t of\nwhitespace\r\n "); ba = ba.trimmed(); // ba == "lots\t of\nwhitespace"; //! [33] //! [34] QByteArray x("apple"); QByteArray y = x.leftJustified(8, '.'); // y == "apple..." //! [34] //! [35] QByteArray x("apple"); QByteArray y = x.rightJustified(8, '.'); // y == "...apple" //! [35] //! [36] QByteArray str("FF"); bool ok; int hex = str.toInt(&ok, 16); // hex == 255, ok == true int dec = str.toInt(&ok, 10); // dec == 0, ok == false //! [36] //! [37] QByteArray str("FF"); bool ok; long hex = str.toLong(&ok, 16); // hex == 255, ok == true long dec = str.toLong(&ok, 10); // dec == 0, ok == false //! [37] //! [38] QByteArray string("1234.56"); double a = string.toDouble(); // a == 1234.56 //! [38] //! [39] QByteArray text("Qt is great!"); text.toBase64(); // returns "UXQgaXMgZ3JlYXQh" //! [39] //! [40] QByteArray ba; int n = 63; ba.setNum(n); // ba == "63" ba.setNum(n, 16); // ba == "3f" //! [40] //! [41] int n = 63; QByteArray::number(n); // returns "63" QByteArray::number(n, 16); // returns "3f" QByteArray::number(n, 16).toUpper(); // returns "3F" //! [41] //! [42] QByteArray ba = QByteArray::number(12.3456, 'E', 3); // ba == 1.235E+01 //! [42] //! [43] static const char mydata[] = { 0x00, 0x00, 0x03, 0x84, 0x78, 0x9c, 0x3b, 0x76, 0xec, 0x18, 0xc3, 0x31, 0x0a, 0xf1, 0xcc, 0x99, ... 0x6d, 0x5b }; QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata)); QDataStream in(&data, QIODevice::ReadOnly); ... //! [43] //! [44] QByteArray text = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh"); text.data(); // returns "Qt is great!" //! [44] //! [45] QByteArray text = QByteArray::fromHex("517420697320677265617421"); text.data(); // returns "Qt is great!" //! [45] //! [46] QString tmp = "test"; QByteArray text = tmp.toLocal8Bit(); char *data = new char[text.size()] strcpy(data, text.data()); delete [] data; //! [46] //! [47] QString tmp = "test"; QByteArray text = tmp.toLocal8Bit(); char *data = new char[text.size() + 1] strcpy(data, text.data()); delete [] data; //! [47] //! [48] QByteArray ba1("ca\0r\0t"); ba1.size(); // Returns 2. ba1.constData(); // Returns "ca" with terminating \0. QByteArray ba2("ca\0r\0t", 3); ba2.size(); // Returns 3. ba2.constData(); // Returns "ca\0" with terminating \0. QByteArray ba3("ca\0r\0t", 4); ba3.size(); // Returns 4. ba2.constData(); // Returns "ca\0r" with terminating \0. const char cart[] = {'c', 'a', '\0', 'r', '\0', 't'}; QByteArray ba4(QByteArray::fromRawData(cart, 6)); ba4.size(); // Returns 6. ba4.constData(); // Returns "ca\0r\0t" without terminating \0. //! [48] }
int LoadCmd::writeToDB(const QString pkgname, QString &errMsg) { _selectMql = new MetaSQLQuery("SELECT cmd_id, -1, -1" " FROM <? literal(\"tablename\") ?> " " WHERE (cmd_name=<? value(\"name\") ?>);"); _updateMql = new MetaSQLQuery("UPDATE <? literal(\"tablename\") ?> " " SET cmd_module=<? value(\"module\") ?>, " " cmd_title=<? value(\"title\") ?>, " " cmd_privname=<? value(\"privname\") ?>, " " cmd_executable=<? value(\"executable\") ?>, " " cmd_descrip=<? value(\"notes\") ?> " " WHERE (cmd_id=<? value(\"id\") ?>) " "RETURNING cmd_id AS id;"); _insertMql = new MetaSQLQuery("INSERT INTO <? literal(\"tablename\") ?> (" " cmd_id, cmd_module," " cmd_title, cmd_descrip, " " cmd_privname," " cmd_executable, cmd_name" ") VALUES (" " DEFAULT, <? value(\"module\") ?>," " <? value(\"title\") ?>, <? value(\"notes\") ?>," " <? value(\"privname\") ?>," " <? value(\"executable\") ?>, <? value(\"name\") ?>)" " RETURNING cmd_id AS id;"); ParameterList params; params.append("tablename", "cmd"); params.append("module", _module); params.append("title", _title); params.append("privname", _privname); params.append("executable",_executable); int cmdid = Loadable::writeToDB(QByteArray(), pkgname, errMsg, params); if (cmdid < 0) return cmdid; // alter the name of the loadable's table if necessary QString prefix; if (_schema.isEmpty() && pkgname.isEmpty()) ; // leave it alone else if (_schema.isEmpty() && ! pkgname.isEmpty()) prefix = "pkg"; else if ("public" == _schema && pkgname.isEmpty()) ; // leave it alone else if ("public" == _schema && ! pkgname.isEmpty()) prefix = "public."; else if (! _schema.isEmpty() && pkgname.isEmpty()) prefix = _schema + ".pkg"; else if (! _schema.isEmpty() && ! pkgname.isEmpty()) prefix = _schema + ".pkg"; XSqlQuery delargs; delargs.prepare(QString("DELETE FROM %1cmdarg WHERE (cmdarg_cmd_id=:cmd_id);") .arg(prefix)); delargs.bindValue(":cmd_id", cmdid); if (! delargs.exec()) { QSqlError err = delargs.lastError(); errMsg = _sqlerrtxt.arg(_name).arg(err.driverText()).arg(err.databaseText()); return -8; } if (_args.size() > 0) { XSqlQuery insargs; insargs.prepare(QString("INSERT INTO %1cmdarg (cmdarg_cmd_id, cmdarg_order, " "cmdarg_arg) VALUES (:cmd_id, :order, :arg);") .arg(prefix)); for (int i = 0; i < _args.size(); i++) { insargs.bindValue(":cmd_id", cmdid); insargs.bindValue(":order", i); insargs.bindValue(":arg", _args.at(i)); if (! insargs.exec()) { QSqlError err = insargs.lastError(); errMsg = _sqlerrtxt.arg(_name).arg(err.driverText()).arg(err.databaseText()); return -9; } } } return cmdid; }
QStringList QGenericUnixTheme::themeNames() { QStringList result; if (QGuiApplication::desktopSettingsAware()) { if (QGuiApplicationPrivate::platformIntegration()->services()->desktopEnvironment() == QByteArray("KDE")) { #ifndef QT_NO_SETTINGS result.push_back(QLatin1String(QKdeTheme::name)); #endif } else if (QGuiApplicationPrivate::platformIntegration()->services()->desktopEnvironment() == QByteArray("GNOME")) { result.push_back(QLatin1String(QGnomeTheme::name)); } const QByteArray session = qgetenv("DESKTOP_SESSION"); if (!session.isEmpty() && session != "default") result.push_back(QString::fromLocal8Bit(session)); } // desktopSettingsAware if (result.isEmpty()) result.push_back(QLatin1String(QGenericUnixTheme::name)); return result; }
QByteArray Html5App::appViewerCppFileCode(QString *errorMessage) const { static const char* touchNavigavigationFiles[] = { "webtouchphysicsinterface.h", "webtouchphysics.h", "webtouchevent.h", "webtouchscroller.h", "webtouchnavigation.h", "webnavigation.h", "navigationcontroller.h", "webtouchphysicsinterface.cpp", "webtouchphysics.cpp", "webtouchevent.cpp", "webtouchscroller.cpp", "webtouchnavigation.cpp", "webnavigation.cpp", "navigationcontroller.cpp", }; static const QString touchNavigavigationDir = originsRoot() + appViewerOriginsSubDir + QLatin1String("touchnavigation/"); QByteArray touchNavigavigationCode; for (size_t i = 0; i < sizeof(touchNavigavigationFiles) / sizeof(touchNavigavigationFiles[0]); ++i) { QFile touchNavigavigationFile(touchNavigavigationDir + QLatin1String(touchNavigavigationFiles[i])); if (!touchNavigavigationFile.open(QIODevice::ReadOnly)) { if (errorMessage) *errorMessage = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp", "Could not open template file '%1'.").arg(touchNavigavigationFiles[i]); return QByteArray(); } QTextStream touchNavigavigationFileIn(&touchNavigavigationFile); QString line; while (!(line = touchNavigavigationFileIn.readLine()).isNull()) { if (line.startsWith(QLatin1String("#include")) || ((line.startsWith(QLatin1String("#ifndef")) || line.startsWith(QLatin1String("#define")) || line.startsWith(QLatin1String("#endif"))) && line.endsWith(QLatin1String("_H")))) continue; touchNavigavigationCode.append(line.toLatin1()); touchNavigavigationCode.append('\n'); } } QFile appViewerCppFile(path(AppViewerCppOrigin)); if (!appViewerCppFile.open(QIODevice::ReadOnly)) { if (errorMessage) *errorMessage = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp", "Could not open template file '%1'.").arg(path(AppViewerCppOrigin)); return QByteArray(); } QTextStream in(&appViewerCppFile); QByteArray appViewerCppCode; bool touchNavigavigationCodeInserted = false; QString line; while (!(line = in.readLine()).isNull()) { if (!touchNavigavigationCodeInserted && line == QLatin1String("#ifdef TOUCH_OPTIMIZED_NAVIGATION")) { appViewerCppCode.append(line.toLatin1()); appViewerCppCode.append('\n'); while (!(line = in.readLine()).isNull() && !line.contains(QLatin1String("#endif // TOUCH_OPTIMIZED_NAVIGATION"))) { if (!line.startsWith(QLatin1String("#include \""))) { appViewerCppCode.append(line.toLatin1()); appViewerCppCode.append('\n'); } } appViewerCppCode.append(touchNavigavigationCode); touchNavigavigationCodeInserted = true; } appViewerCppCode.append(line.toLatin1()); appViewerCppCode.append('\n'); } return appViewerCppCode; }
bool QmlProfilerFileReader::loadQzt(QIODevice *device) { QDataStream stream(device); stream.setVersion(QDataStream::Qt_5_5); QByteArray magic; stream >> magic; if (magic != QByteArray("QMLPROFILER")) { emit error(tr("Invalid magic: %1").arg(QLatin1String(magic))); return false; } qint32 dataStreamVersion; stream >> dataStreamVersion; if (dataStreamVersion > QDataStream::Qt_DefaultCompiledVersion) { emit error(tr("Unknown data stream version: %1").arg(dataStreamVersion)); return false; } stream.setVersion(dataStreamVersion); stream >> m_traceStart >> m_traceEnd; QBuffer buffer; QDataStream bufferStream(&buffer); bufferStream.setVersion(dataStreamVersion); QByteArray data; updateProgress(device); stream >> data; buffer.setData(qUncompress(data)); buffer.open(QIODevice::ReadOnly); bufferStream >> m_eventTypes; buffer.close(); emit typesLoaded(m_eventTypes); updateProgress(device); stream >> data; buffer.setData(qUncompress(data)); buffer.open(QIODevice::ReadOnly); bufferStream >> m_notes; buffer.close(); emit notesLoaded(m_notes); updateProgress(device); const int eventBufferLength = 1024; QVector<QmlEvent> eventBuffer(eventBufferLength); int eventBufferIndex = 0; while (!stream.atEnd()) { stream >> data; buffer.setData(qUncompress(data)); buffer.open(QIODevice::ReadOnly); while (!buffer.atEnd()) { if (isCanceled()) return false; QmlEvent &event = eventBuffer[eventBufferIndex]; bufferStream >> event; if (bufferStream.status() == QDataStream::Ok) { if (event.typeIndex() >= m_eventTypes.length()) { emit error(tr("Invalid type index %1").arg(event.typeIndex())); return false; } m_loadedFeatures |= (1ULL << m_eventTypes[event.typeIndex()].feature()); } else if (bufferStream.status() == QDataStream::ReadPastEnd) { break; // Apparently EOF is a character so we end up here after the last event. } else if (bufferStream.status() == QDataStream::ReadCorruptData) { emit error(tr("Corrupt data before position %1.").arg(device->pos())); return false; } else { Q_UNREACHABLE(); } if (++eventBufferIndex == eventBufferLength) { emit qmlEventsLoaded(eventBuffer); eventBufferIndex = 0; } } buffer.close(); updateProgress(device); } eventBuffer.resize(eventBufferIndex); emit qmlEventsLoaded(eventBuffer); emit success(); return true; }
#include <QCryptographicHash> #include <QDebug> #include <QFile> #include <QNetworkAccessManager> #include <QNetworkRequest> #include <QStringList> #include "qupyun.h" static const char SEPARATOR = '/'; static const QByteArray &MKDIR = QByteArray("folder"); static const char * const SDK_VERSION = "1.0"; QByteArray QUpYun::extraParamHeader(QUpYun::ExtraParam param) { switch (param) { case X_GMKERL_TYPE: return QByteArray("x-gmkerl-type"); case X_GMKERL_VALUE: return QByteArray("x-gmkerl-value"); case X_GMKERL_QUALITY: return QByteArray("x-gmkerl-quality"); case X_GMKERL_UNSHARP: return QByteArray("x-gmkerl-unsharp"); case X_GMKERL_THUMBNAIL: return QByteArray("x-gmkerl-thumbnail"); case X_GMKERL_ROTATE: return QByteArray("x-gmkerl-rotate"); case X_GMKERL_CROP: return QByteArray("x-gmkerl-crop"); case X_GMKERL_EXIF_SWITCH:
void TActionContext::execute() { T_TRACEFUNC(""); TAccessLog accessLog; THttpResponseHeader responseHeader; try { httpSocket = new THttpSocket; if (!httpSocket->setSocketDescriptor(socketDesc)) { emitError(httpSocket->error()); delete httpSocket; httpSocket = 0; return; } else { socketDesc = 0; } while (!httpSocket->canReadRequest()) { if (stopped) { tSystemDebug("Detected stop request"); break; } // Check idle timeout if (httpSocket->idleTime() >= 10) { tSystemWarn("Reading a socket timed out after 10 seconds. Descriptor:%d", (int)httpSocket->socketDescriptor()); break; } httpSocket->waitForReadyRead(100); } if (!httpSocket->canReadRequest()) { httpSocket->abort(); delete httpSocket; httpSocket = 0; return; } THttpRequest httpRequest = httpSocket->read(); const THttpRequestHeader &hdr = httpRequest.header(); // Access log QByteArray firstLine = hdr.method() + ' ' + hdr.path(); firstLine += QString(" HTTP/%1.%2").arg(hdr.majorVersion()).arg(hdr.minorVersion()).toLatin1(); accessLog.request = firstLine; accessLog.remoteHost = (Tf::app()->appSettings().value(LISTEN_PORT).toUInt() > 0) ? httpSocket->peerAddress().toString().toLatin1() : QByteArray("(unix)"); tSystemDebug("method : %s", hdr.method().data()); tSystemDebug("path : %s", hdr.path().data()); Tf::HttpMethod method = httpRequest.method(); QString path = THttpUtility::fromUrlEncoding(hdr.path().split('?').value(0)); // Routing info exists? TRouting rt = TUrlRoute::instance().findRouting(method, path); tSystemDebug("Routing: controller:%s action:%s", rt.controller.data(), rt.action.data()); if (rt.isEmpty()) { // Default URL routing rt.params = path.split('/'); if (path.startsWith(QLatin1Char('/')) && !rt.params.isEmpty()) { rt.params.removeFirst(); // unuse first item } if (path.endsWith(QLatin1Char('/')) && !rt.params.isEmpty()) { rt.params.removeLast(); // unuse last item } // Direct view render mode? if (Tf::app()->appSettings().value(DIRECT_VIEW_RENDER_MODE).toBool()) { // Direct view setting rt.controller = "directcontroller"; rt.action = "show"; } else { if (!rt.params.value(0).isEmpty()) { rt.controller = rt.params.takeFirst().toLower().toLatin1() + "controller"; if (rt.controller == "applicationcontroller") { rt.controller.clear(); // Can not call 'ApplicationController' } // Default action: index rt.action = rt.params.value(0, QLatin1String("index")).toLatin1(); if (!rt.params.isEmpty()) { rt.params.takeFirst(); } } tSystemDebug("Active Controller : %s", rt.controller.data()); } } // Call controller method TDispatcher<TActionController> ctlrDispatcher(rt.controller); currController = ctlrDispatcher.object(); if (currController) { currController->setActionName(rt.action); currController->setHttpRequest(httpRequest); // Session if (currController->sessionEnabled()) { TSession session; QByteArray sessionId = httpRequest.cookie(TSession::sessionName()); if (!sessionId.isEmpty()) { // Finds a session session = TSessionManager::instance().findSession(sessionId); } currController->setSession(session); // Exports flash-variant currController->exportAllFlashVariants(); } // Verify authenticity token if (Tf::app()->appSettings().value(ENABLE_CSRF_PROTECTION_MODULE, true).toBool() && currController->csrfProtectionEnabled() && !currController->exceptionActionsOfCsrfProtection().contains(rt.action)) { if (method == Tf::Post || method == Tf::Put || method == Tf::Delete) { if (!currController->verifyRequest(httpRequest)) { throw SecurityException("Invalid authenticity token", __FILE__, __LINE__); } } } if (currController->sessionEnabled()) { if (currController->session().id().isEmpty() || Tf::app()->appSettings().value(AUTO_ID_REGENERATION).toBool()) { TSessionManager::instance().remove(currController->session().sessionId); // Removes the old session // Re-generate session ID currController->session().sessionId = TSessionManager::instance().generateId(); tSystemDebug("Re-generate session ID: %s", currController->session().sessionId.data()); } // Sets CSRF protection informaion TActionController::setCsrfProtectionInto(currController->session()); } // Database Transaction transactions.setEnabled(currController->transactionEnabled()); // Do filters if (currController->preFilter()) { // Dispathes bool dispatched = ctlrDispatcher.invoke(rt.action, rt.params); if (dispatched) { autoRemoveFiles << currController->autoRemoveFiles; // Adds auto-remove files // Post fileter currController->postFilter(); if (currController->rollbackRequested()) { rollbackTransactions(); } else { // Commits a transaction to the database commitTransactions(); } // Session store if (currController->sessionEnabled()) { bool stored = TSessionManager::instance().store(currController->session()); if (stored) { QDateTime expire; if (TSessionManager::sessionLifeTime() > 0) { expire = QDateTime::currentDateTime().addSecs(TSessionManager::sessionLifeTime()); } // Sets the path in the session cookie QString cookiePath = Tf::app()->appSettings().value(SESSION_COOKIE_PATH).toString(); currController->addCookie(TSession::sessionName(), currController->session().id(), expire, cookiePath); } } } } // Sets the default status code of HTTP response accessLog.statusCode = (!currController->response.isBodyNull()) ? currController->statusCode() : Tf::InternalServerError; currController->response.header().setStatusLine(accessLog.statusCode, THttpUtility::getResponseReasonPhrase(accessLog.statusCode)); // Writes a response and access log accessLog.responseBytes = writeResponse(currController->response.header(), currController->response.bodyIODevice(), currController->response.bodyLength()); httpSocket->disconnectFromHost(); // Session GC TSessionManager::instance().collectGarbage(); } else { accessLog.statusCode = Tf::BadRequest; if (method == Tf::Get) { // GET Method path.remove(0, 1); QFile reqPath(Tf::app()->publicPath() + path); QFileInfo fi(reqPath); if (fi.isFile() && fi.isReadable()) { // Check "If-Modified-Since" header for caching bool sendfile = true; QByteArray ifModifiedSince = hdr.rawHeader("If-Modified-Since"); if (!ifModifiedSince.isEmpty()) { QDateTime dt = THttpUtility::fromHttpDateTimeString(ifModifiedSince); sendfile = (!dt.isValid() || dt != fi.lastModified()); } if (sendfile) { // Sends a request file responseHeader.setRawHeader("Last-Modified", THttpUtility::toHttpDateTimeString(fi.lastModified())); QByteArray type = Tf::app()->internetMediaType(fi.suffix()); accessLog.responseBytes = writeResponse(Tf::OK, responseHeader, type, &reqPath, reqPath.size()); } else { // Not send the data accessLog.responseBytes = writeResponse(Tf::NotModified, responseHeader); } } else { accessLog.responseBytes = writeResponse(Tf::NotFound, responseHeader); } accessLog.statusCode = responseHeader.statusCode(); } else if (method == Tf::Post) { // file upload? } else { // HEAD, DELETE, ... } } } catch (ClientErrorException &e) { tWarn("Caught ClientErrorException: status code:%d", e.statusCode()); accessLog.responseBytes = writeResponse(e.statusCode(), responseHeader); accessLog.statusCode = e.statusCode(); } catch (SqlException &e) { tError("Caught SqlException: %s [%s:%d]", qPrintable(e.message()), qPrintable(e.fileName()), e.lineNumber()); } catch (SecurityException &e) { tError("Caught SecurityException: %s [%s:%d]", qPrintable(e.message()), qPrintable(e.fileName()), e.lineNumber()); } catch (RuntimeException &e) { tError("Caught RuntimeException: %s [%s:%d]", qPrintable(e.message()), qPrintable(e.fileName()), e.lineNumber()); } catch (...) { tError("Caught Exception"); } accessLog.timestamp = QDateTime::currentDateTime(); writeAccessLog(accessLog); // Writes access log // Push to the pool TActionContext::releaseDatabases(); httpSocket->disconnectFromHost(); // Destorys the object in the thread which created it delete httpSocket; httpSocket = 0; }