QByteArray K3BookmarkDrag::encodedData( const char* mime ) const { QByteArray a; Q3CString mimetype( mime ); if ( mimetype == "text/uri-list" ) return Q3UriDrag::encodedData( mime ); else if ( mimetype == "application/x-xbel" ) { a = m_doc.toByteArray(); //kDebug(7043) << "K3BookmarkDrag::encodedData " << m_doc.toCString(); } else if ( mimetype == "text/plain" ) { KUrl::List m_lstDragURLs; if ( K3URLDrag::decode( this, m_lstDragURLs ) ) { QStringList uris; KUrl::List::ConstIterator uit = m_lstDragURLs.constBegin(); KUrl::List::ConstIterator uEnd = m_lstDragURLs.constEnd(); for ( ; uit != uEnd ; ++uit ) uris.append( (*uit).prettyUrl() ); Q3CString s = uris.join( "\n" ).toLocal8Bit(); a.resize( s.length() + 1 ); // trailing zero memcpy( a.data(), s.data(), s.length() + 1 ); } } return a; }
QVariant SuovaFileInfo::information(const QString &key) const { QString shortKey = withoutContext(key); // nie:title --> title if( shortKey == "fileLastAccessed") return accessed(); else if( shortKey == "fileLastModified") return modified(); else if( shortKey == "fileName") return fileName(); else if( shortKey == "fileSize") return bytes(); else if( shortKey == "contentCreated") return created(); else if( shortKey == "isStoredAs") return urn(); else if( shortKey == "mimeType") return mimetype(); else if( shortKey == "title") return title(); else if( shortKey == "url") return url(); return QVariant(); }
void MimeTypeList::Build() { ASSERT(fLock.IsLocked()); BMessage message; BMimeType::GetInstalledTypes(&message); int32 count; uint32 type; message.GetInfo("types", &type, &count); for (int32 index = 0; index < count; index++) { const char* str; if (message.FindString("types", index, &str) != B_OK) continue; BMimeType mimetype(str); if (mimetype.InitCheck() != B_OK) continue; ShortMimeInfo* mimeInfo = new ShortMimeInfo(mimetype); fMimeList.AddItem(mimeInfo); if (mimeInfo->IsCommonMimeType()) fCommonMimeList.AddItem(mimeInfo); } fCommonMimeList.SortItems(&ShortMimeInfo::CompareShortDescription); fLock.Unlock(); }
int cdmifs_write( const char *path, const char *data, size_t size, off_t offset, struct fuse_file_info *fi ) { json_t *handle = long2pointer( fi->fh ); int ret; const char *mime = NULL; cdmi_request_t request; if( data == NULL ) data = ""; mime = json_string_value( json_object_get(handle, "mimetype") ); if( offset == 0 ) mime = mimetype( data, size, mime ); memset( &request, 0, sizeof( cdmi_request_t ) ); request.type = PUT; request.cdmi = 0; request.rawdata = data; request.length = size; request.offset = offset; request.flags = CDMI_DATAOBJECT; ret = cdmi_put( &request, path ); cdmi_free( &request ); if( ret < 1 ) return errno == 0 ? -EIO : -errno; return size; }
OMX_ERRORTYPE COmxILAudioFileSourceAPB0Port::SetFormatInPortDefinition(const OMX_PARAM_PORTDEFINITIONTYPE& aPortDefinition, TBool& /*aUpdateProcessingFunction*/) { OMX_ERRORTYPE omxErr = OMX_ErrorNone; if (aPortDefinition.format.audio.eEncoding == OMX_AUDIO_CodingUnused) { OMX_STRING ptempMIMEType = GetParamPortDefinition().format.audio.cMIMEType; GetParamPortDefinition().format.audio = aPortDefinition.format.audio; GetParamPortDefinition().format.audio.cMIMEType = ptempMIMEType; if(aPortDefinition.format.audio.cMIMEType) { TInt len= strlen (aPortDefinition.format.audio.cMIMEType); if(len > 0) { TPtrC8 mimetype(reinterpret_cast<const TUint8 *>(aPortDefinition.format.audio.cMIMEType), len +1 ); HBufC8 *pHBuf = mimetype.Alloc(); if(pHBuf != NULL ) { iMimeType.Close(); iMimeType.Assign(pHBuf ); TUint8* pTempBuff = const_cast<TUint8*>(iMimeType.PtrZ() ); GetParamPortDefinition().format.audio.cMIMEType = reinterpret_cast<OMX_STRING>(pTempBuff ); } } } } else { omxErr = OMX_ErrorUnsupportedSetting; } return omxErr; }
QList<QVariant> SuovaFileInfo::allInformation() const { QList<QVariant> information; information << accessed() << modified() << fileName() << bytes() << created() << urn() << mimetype() << title() << url(); return information; }
KFileMetaInfo KFileItem::metaInfo(bool autoget, int what) const { if ((isRegularFile() || isDir()) && autoget && !d->m_metaInfo.isValid()) { bool isLocalUrl; KUrl url(mostLocalUrl(isLocalUrl)); d->m_metaInfo = KFileMetaInfo(url.toLocalFile(), mimetype(), (KFileMetaInfo::What)what); } return d->m_metaInfo; }
wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType) { InitIfNeeded(); wxFileType * fileType = NULL; // mime types are not case-sensitive wxString mimetype(mimeType); mimetype.MakeLower(); // first look for an exact match int index = m_aTypes.Index(mimetype); if ( index != wxNOT_FOUND ) { fileType = new wxFileType; fileType->m_impl->Init(this, index); } // then try to find "text/*" as match for "text/plain" (for example) // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return // the whole string - ok. index = wxNOT_FOUND; wxString strCategory = mimetype.BeforeFirst(wxT('/')); size_t nCount = m_aTypes.GetCount(); #if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */ # pragma ivdep # pragma swp # pragma unroll # pragma prefetch # if 0 # pragma simd noassert # endif #endif /* VDM auto patch */ for ( size_t n = 0; n < nCount; n++ ) { if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) && m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) { index = n; break; } } if ( index != wxNOT_FOUND ) { // don't throw away fileType that was already found if (!fileType) fileType = new wxFileType; fileType->m_impl->Init(this, index); } return fileType; }
/** * If the load fails, you can get the (translateable) error message using \a error(). * @return true on success */ bool Reader::load(const QString &filename) { QFile orafile(filename); if(!orafile.open(QIODevice::ReadOnly)) { _error = orafile.errorString(); return false; } ZipReader zip(&orafile); if(!zip.isReadable()) { _error = QApplication::tr("ORA file is unreadable!"); return false; } // Make sure this is an OpenRaster file { QByteArray mimetype(zip.fileData("mimetype")); qDebug() << "read mimetype:" << mimetype; if(mimetype != "image/openraster") { _error = QApplication::tr("File is not an OpenRaster file"); return false; } } // Read the stack QDomDocument doc; if(doc.setContent(zip.fileData("stack.xml"), true, &_error) == false) return false; const QDomElement stackroot = doc.documentElement().firstChildElement("stack"); // Get the size of the image // These attributes are required by ORA standard. QSize imagesize( doc.documentElement().attribute("w").toInt(), doc.documentElement().attribute("h").toInt() ); if(imagesize.isEmpty()) { _error = QApplication::tr("Image has zero size!"); return false; } // Initialize the layer stack now that we know the size _commands.append(MessagePtr(new protocol::CanvasResize(imagesize.width(), imagesize.height()))); _layerid = 0; _annotationid = 0; // Load the layer images if(loadLayers(zip, stackroot, QPoint()) == false) return false; return true; }
KIso::KIso(const QString& filename, const QString & _mimetype) : KArchive(0L) { KISOFUNC; KISODEBUG("Starting KIso: " << filename << " - type: " << _mimetype); m_startsec = -1; m_filename = filename; d = new KIsoPrivate; QString mimetype(_mimetype); bool forced = true; if (mimetype.isEmpty()) { QMimeDatabase db; QMimeType mt = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent); if (mt.isValid()) mimetype = mt.name(); //qDebug() << "KIso::KIso mimetype=" << mimetype << endl; // Don't move to prepareDevice - the other constructor theoretically allows ANY filter if (mimetype == "application/x-tgz" || mimetype == "application/x-targz" || // the latter is deprecated but might still be around mimetype == "application/x-webarchive") // that's a gzipped tar file, so ask for gzip filter mimetype = "application/x-gzip"; else if (mimetype == "application/x-tbz") // that's a bzipped2 tar file, so ask for bz2 filter mimetype = "application/x-bzip2"; else { // Something else. Check if it's not really gzip though (e.g. for KOffice docs) QFile file(filename); if (file.open(QIODevice::ReadOnly)) { char firstByte; char secondByte; char thirdByte; file.getChar(&firstByte); file.getChar(&secondByte); file.getChar(&thirdByte); if (firstByte == 0037 && secondByte == (char)0213) mimetype = "application/x-gzip"; else if (firstByte == 'B' && secondByte == 'Z' && thirdByte == 'h') mimetype = "application/x-bzip2"; else if (firstByte == 'P' && secondByte == 'K' && thirdByte == 3) { char fourthByte; file.getChar(&fourthByte); if (fourthByte == 4) mimetype = "application/x-zip"; } } } forced = false; } prepareDevice(filename, mimetype, forced); }
const char* FileInfo::mimeclass() { mimetype(); if ( _mimetype == "wav" ) _mimeclass = "audio"; if ( _mimetype == "mp3" ) _mimeclass = "audio"; if ( _mimetype == "trs" ) _mimeclass = "transcript"; if ( _mimetype == "tag" ) _mimeclass = "transcript"; return _mimeclass.c_str(); }
const KFileMetaInfo & KFileItem::metaInfo(bool autoget, int) const { bool isLocalURL; KURL url = mostLocalURL(isLocalURL); if ( autoget && !m_metaInfo.isValid() && KGlobalSettings::showFilePreview(url) ) { m_metaInfo = KFileMetaInfo( url, mimetype() ); } return m_metaInfo; }
void HttpGetThread::run() { int pos; std::string querystring = ""; if((pos = (int) mRequest.uri.find_last_of('?')) != std::string::npos) { querystring = mRequest.uri.substr(pos+1); } else pos = (int) mRequest.uri.length(); std::string uri = mRequest.uri.substr(0,pos); if(Script::is_uri_a_script(uri)) { Script * script = Script::buildScript(uri,querystring); mResponse.body = script->execute(); } else { std::ifstream file(mRequest.uri.c_str()); std::string data; char c; while(file.good()) { c = file.get(); if(file.good()) data.push_back(c); } mResponse.body = data; } std::stringstream ss(std::stringstream::in | std::stringstream::out); int length = (int) mResponse.body.length(); ss << length; mResponse.add_header("Content-Length",ss.str()); MIME mimetype(mRequest.uri); mResponse.add_header("Content-Type", mimetype.type()); mResponse.code = Response::OK; }
bool KFileItem::acceptsDrops() const { // A directory ? if ( S_ISDIR( mode() ) ) { return isWritable(); } // But only local .desktop files and executables if ( !d->m_bIsLocalUrl ) return false; if ( mimetype() == "application/x-desktop") return true; // Executable, shell script ... ? if ( QFileInfo(d->m_url.toLocalFile()).isExecutable() ) return true; return false; }
bool KFileItem::acceptsDrops() { // A directory ? if ( S_ISDIR( mode() ) ) { return isWritable(); } // But only local .desktop files and executables if ( !m_bIsLocalURL ) return false; if ( mimetype() == "application/x-desktop") return true; // Executable, shell script ... ? if ( ::access( QFile::encodeName(m_url.path()), X_OK ) == 0 ) return true; return false; }
QMimeSource* Q3MimeSourceFactory::dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions) const { QMimeSource* r = 0; QStringList attempted_names(abs_name); QFileInfo fi(abs_name); if (fi.isReadable()) { // get the right mimetype QString e = fi.extension(false); QByteArray mimetype("application/octet-stream"); if (extensions.contains(e)) mimetype = extensions[e].latin1(); if (!QImageReader::imageFormat(abs_name).isEmpty()) mimetype = "application/x-qt-image"; QFile f(abs_name); if (f.open(QIODevice::ReadOnly) && f.size()) { QByteArray ba; ba.resize(f.size()); f.readBlock(ba.data(), ba.size()); Q3StoredDrag* sr = new Q3StoredDrag(mimetype); sr->setEncodedData(ba); delete d->last; d->last = r = sr; } } // we didn't find the mime-source, so ask the default factory for // the mime-source (this one will iterate over all installed ones) // // this looks dangerous, as this dataInternal() function will be // called again when the default factory loops over all installed // factories (including this), but the static bool looping in // data() avoids endless recursions if (!r && this != defaultFactory()) r = (QMimeSource*)defaultFactory()->data(abs_name); return r; }
bool CPyMFC_CustomProtocol::doCallback(LPCWSTR url) { PyMFCEnterPython e; { if (!mapfunc | !*mapfunc) { return false; } PyDTObject f(*mapfunc, true); f.incRef(); PyDTUnicode s(url); try { PyDTObject ret = f.call("O", s.get()); if (!ret.isTrue()) { return false; } m_dwPos = 0; PyDTDict d(ret); PyDTUnicode mimetype(d.getItem("mimetype")); m_mimetype = mimetype.asUnicode(); PyDTString src(d.getItem("src")); m_src.SetCount(src.size()); memcpy(m_src.GetData(), src.asString(), src.size()); } catch (PyDTException &exc) { exc.setError(); PyErr_Print(); return false; } } return true; }
// grab the content type header String HTTPHeader::getContentType() { if (pcontenttype != NULL) { String mimetype(pcontenttype->after(" ")); if (mimetype.length() < 1) return "-"; unsigned char c; size_t j = 0; while (j < mimetype.length()) { c = mimetype[j]; if (c == ' ' || c == ';' || c < 32) { // remove the mimetype = mimetype.subString(0, j); // extra info not needed j = 0; } ++j; } mimetype.toLower(); return mimetype; } return "-"; }
String FrameLoaderClientAndroid::generatedMIMETypeForURLScheme(const String& URLScheme) const { // FIXME, copy from Apple's port String mimetype("x-apple-web-kit/"); mimetype.append(URLScheme.lower()); return mimetype; }
// test whether or not a request should be scanned based on sent & received headers int CSPlugin::scanTest(HTTPHeader * requestheader, HTTPHeader * docheader, const char *user, int filtergroup, const char *ip) { char *i; //exceptionvirusmimetypelist String mimetype(docheader->getContentType()); #ifdef DGDEBUG std::cout<<"mimetype: "<<mimetype<<std::endl; #endif i = exceptionvirusmimetypelist.findInList(mimetype.toCharArray()); if (i != NULL) { return DGCS_NOSCAN; // match } String disposition(docheader->disposition()); #ifdef DGDEBUG std::cout<<"disposition: "<<disposition<<std::endl; #endif String url(requestheader->url()); String urld(requestheader->decode(url)); urld.removeWhiteSpace(); urld.toLower(); urld.removePTP(); String domain, tempurl, foundurl, path, extension; unsigned int fl; if (urld.contains("/")) { domain = urld.before("/"); path = "/" + urld.after("/"); path.hexDecode(); path.realPath(); } else { domain = urld; } // don't scan our web server if (((o.fg[filtergroup]->reporting_level == 1) || (o.fg[filtergroup]->reporting_level == 2)) && domain.startsWith(o.fg[filtergroup]->access_denied_domain)) { return DGCS_NOSCAN; } //exceptionvirusextensionlist if (disposition.length() > 2) { extension = disposition; while (extension.contains(".")) { extension = extension.after("."); } extension = "." + extension; } else { if (!path.contains("?")) { extension = path; } else if (mimetype.contains("application/")) { extension = path; if (extension.contains("?")) { extension = extension.before("?"); } } } #ifdef DGDEBUG std::cout<<"extension: "<<extension<<std::endl; #endif if (extension.contains(".")) { i = exceptionvirusextensionlist.findEndsWith(extension.toCharArray()); if (i != NULL) { return DGCS_NOSCAN; // match } } // exceptionvirussitelist tempurl = domain; #ifdef DGDEBUG std::cout<<"domain: "<<domain<<std::endl; #endif while (tempurl.contains(".")) { i = exceptionvirussitelist.findInList(tempurl.toCharArray()); if (i != NULL) { return DGCS_NOSCAN; // exact match } tempurl = tempurl.after("."); // check for being in higher level domains } if (tempurl.length() > 1) { // allows matching of .tld tempurl = "." + tempurl; i = exceptionvirussitelist.findInList(tempurl.toCharArray()); if (i != NULL) { return DGCS_NOSCAN; // exact match } } // exceptionvirusurllist tempurl = domain + path; if (tempurl.endsWith("/")) { tempurl.chop(); // chop off trailing / if any } while (tempurl.before("/").contains(".")) { i = exceptionvirusurllist.findStartsWith(tempurl.toCharArray()); if (i != NULL) { foundurl = i; fl = foundurl.length(); if (tempurl.length() > fl) { unsigned char c = tempurl[fl]; if (c == '/' || c == '?' || c == '&' || c == '=') { return DGCS_NOSCAN; // matches /blah/ or /blah/foo but not /blahfoo } } else { return DGCS_NOSCAN; // exact match } } tempurl = tempurl.after("."); // check for being in higher level domains } #ifdef DGDEBUG std::cout << "URL " << url << " is going to need AV scanning." << std::endl; #endif return DGCS_NEEDSCAN; }
// default method for deciding whether we will handle a request bool DMPlugin::willHandle(HTTPHeader *requestheader, HTTPHeader *docheader) { // match user agent first (quick) if (!(alwaysmatchua || ua_match.match(requestheader->userAgent().toCharArray()))) return false; // then check standard lists (mimetypes & extensions) // mimetypes String mimetype(""); bool matchedmime = false; if (mimelistenabled) { mimetype = docheader->getContentType(); #ifdef DGDEBUG std::cout<<"mimetype: "<<mimetype<<std::endl; #endif if (mimetypelist.findInList(mimetype.toCharArray()) == NULL) { if (!extensionlistenabled) return false; } else matchedmime = true; } if (extensionlistenabled && !matchedmime) { // determine the extension String path(requestheader->decode(requestheader->url())); path.removeWhiteSpace(); path.toLower(); path.removePTP(); path = path.after("/"); path.hexDecode(); path.realPath(); String disposition(docheader->disposition()); String extension; if (disposition.length() > 2) { extension = disposition; while (extension.contains(".")) { extension = extension.after("."); } extension = "." + extension; } else { if (!path.contains("?")) { extension = path; } else { if (mimetype.length() == 0) mimetype = docheader->getContentType(); if (mimetype.contains("application/")) { extension = path; if (extension.contains("?")) { extension = extension.before("?"); } } } } #ifdef DGDEBUG std::cout<<"extension: "<<extension<<std::endl; #endif // check the extension list if (!extension.contains(".") || (extensionlist.findEndsWith(extension.toCharArray()) == NULL)) return matchedmime; } return true; }
void nuiMimeMultiPart::Dump(nglOStream* pStream) { nglString varname(_T("MyParam")); nglString value(_T("MyValue")); nglString fileref(_T("MyFile")); nglString filename(_T("prout.txt")); // nglString filename(_T("")); nglString mimetype("plain/text"); const uint8* data = (const uint8*)"YATTA!"; uint32 datalen = strlen((const char*)data); ////////////////////////////////////// nglString str; // prepare start and end boundaries: nglString start; start.CFormat(_T("--%s"), mBoundary.GetChars()); nglString end; end.Add(_T("\n")); end.Add(start); end.Add(_T("--\n")); start.Add(_T("\n")); { std::map<nglString, nglString>::const_iterator it = mVariables.begin(); std::map<nglString, nglString>::const_iterator end = mVariables.end(); while (it != end) { pStream->WriteText(start); str.CFormat(_T("Content-Disposition: form-data; name=\"%s\"\n\n"), it->first.GetChars()); pStream->WriteText(str); pStream->WriteText(it->second); pStream->WriteText(_T("\n")); ++it; } } { for (uint32 i = 0; i < mpFiles.size(); i++) { pStream->WriteText(start); str.CFormat(_T("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"\n"), mpFiles[i]->mVarName.GetChars(), mpFiles[i]->mFileName.GetChars()); pStream->WriteText(str); str.CFormat(_T("Content-Transfer-Encoding: %s\n"), mpFiles[i]->mContentTransfertEncoding.GetChars()); pStream->WriteText(str); str.CFormat(_T("Content-Type: %s\n\n"), mpFiles[i]->mType.GetChars()); pStream->WriteText(str); pStream->WriteUInt8(&mpFiles[i]->mContents[0], mpFiles[i]->mContents.size()); } } if (mVariables.empty() && mpFiles.empty()) pStream->WriteText(start); pStream->WriteText(end); //mem.WriteUInt8((const uint8*)"\0", 1); // Add final 0 for printf //nglString enc(mem.GetBufferData(), mem.GetSize()); //NGL_OUT(_T("Mime encoded:\n%s\n"), enc.GetChars()); }