// static nsresult IndexedDatabaseManager::GetASCIIOriginFromWindow(nsPIDOMWindow* aWindow, nsCString& aASCIIOrigin) { NS_ASSERTION(NS_IsMainThread(), "We're about to touch a window off the main thread!"); if (!aWindow) { aASCIIOrigin.AssignLiteral("chrome"); NS_ASSERTION(nsContentUtils::IsCallerChrome(), "Null window but not chrome!"); return NS_OK; } nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(aWindow); NS_ENSURE_TRUE(sop, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal(); NS_ENSURE_TRUE(principal, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); if (nsContentUtils::IsSystemPrincipal(principal)) { aASCIIOrigin.AssignLiteral("chrome"); } else { nsresult rv = nsContentUtils::GetASCIIOrigin(principal, aASCIIOrigin); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); if (aASCIIOrigin.EqualsLiteral("null")) { NS_WARNING("IndexedDB databases not allowed for this principal!"); return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; } } return NS_OK; }
nsresult ICameraControl::GetCameraName(uint32_t aDeviceNum, nsCString& aDeviceName) { int32_t count = android::Camera::getNumberOfCameras(); int32_t deviceNum = static_cast<int32_t>(aDeviceNum); DOM_CAMERA_LOGI("GetCameraName : getNumberOfCameras() returned %d\n", count); if (deviceNum < 0 || deviceNum > count) { DOM_CAMERA_LOGE("GetCameraName : invalid device number (%u)\n", aDeviceNum); return NS_ERROR_INVALID_ARG; } android::CameraInfo info; int rv = android::Camera::getCameraInfo(deviceNum, &info); if (rv != 0) { DOM_CAMERA_LOGE("GetCameraName : get_camera_info(%d) failed: %d\n", deviceNum, rv); return NS_ERROR_NOT_AVAILABLE; } switch (info.facing) { case CAMERA_FACING_BACK: aDeviceName.AssignLiteral("back"); break; case CAMERA_FACING_FRONT: aDeviceName.AssignLiteral("front"); break; default: aDeviceName.AssignLiteral("extra-camera-"); aDeviceName.AppendInt(deviceNum); break; } return NS_OK; }
void CreateFileTask::GetPermissionAccessType(nsCString& aAccess) const { if (mReplace) { aAccess.AssignLiteral("write"); return; } aAccess.AssignLiteral("create"); }
void VRSystemManagerOpenVR::GetControllerDeviceId(::vr::ETrackedDeviceClass aDeviceType, ::vr::TrackedDeviceIndex_t aDeviceIndex, nsCString& aId) { switch (aDeviceType) { case ::vr::TrackedDeviceClass_Controller: { ::vr::ETrackedPropertyError err; uint32_t requiredBufferLen; bool isFound = false; char charBuf[128]; requiredBufferLen = mVRSystem->GetStringTrackedDeviceProperty(aDeviceIndex, ::vr::Prop_RenderModelName_String, charBuf, 128, &err); if (requiredBufferLen > 128) { MOZ_CRASH("Larger than the buffer size."); } MOZ_ASSERT(requiredBufferLen && err == ::vr::TrackedProp_Success); nsCString deviceId(charBuf); if (deviceId.Find("knuckles") != kNotFound) { aId.AssignLiteral("OpenVR Knuckles"); isFound = true; } requiredBufferLen = mVRSystem->GetStringTrackedDeviceProperty(aDeviceIndex, ::vr::Prop_SerialNumber_String, charBuf, 128, &err); if (requiredBufferLen > 128) { MOZ_CRASH("Larger than the buffer size."); } MOZ_ASSERT(requiredBufferLen && err == ::vr::TrackedProp_Success); deviceId.Assign(charBuf); if (deviceId.Find("MRSOURCE") != kNotFound) { aId.AssignLiteral("Spatial Controller (Spatial Interaction Source) "); mIsWindowsMR = true; isFound = true; } if (!isFound) { aId.AssignLiteral("OpenVR Gamepad"); } break; } case ::vr::TrackedDeviceClass_GenericTracker: { aId.AssignLiteral("OpenVR Tracker"); break; } default: MOZ_ASSERT(false); break; } }
nsresult nsFileChannel::MakeFileInputStream(nsIFile *file, nsCOMPtr<nsIInputStream> &stream, nsCString &contentType) { // we accept that this might result in a disk hit to stat the file bool isDir; nsresult rv = file->IsDirectory(&isDir); if (NS_FAILED(rv)) { // canonicalize error message if (rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) rv = NS_ERROR_FILE_NOT_FOUND; return rv; } if (isDir) { rv = nsDirectoryIndexStream::Create(file, getter_AddRefs(stream)); if (NS_SUCCEEDED(rv) && !HasContentTypeHint()) contentType.AssignLiteral(APPLICATION_HTTP_INDEX_FORMAT); } else { rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file); if (NS_SUCCEEDED(rv) && !HasContentTypeHint()) { // Use file extension to infer content type nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1", &rv); if (NS_SUCCEEDED(rv)) { mime->GetTypeFromFile(file, contentType); } } } return rv; }
static void PgpMimeGetNeedsAddonString(nsCString &aResult) { aResult.AssignLiteral("???"); nsCOMPtr<nsIStringBundleService> stringBundleService = mozilla::services::GetStringBundleService(); nsCOMPtr<nsIStringBundle> stringBundle; nsresult rv = stringBundleService->CreateBundle(PGPMIME_PROPERTIES_URL, getter_AddRefs(stringBundle)); if (NS_FAILED(rv)) return; nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); if (NS_FAILED(rv)) return; nsCString url; if (NS_FAILED(prefs->GetCharPref("mail.pgpmime.addon_url", getter_Copies(url)))) return; NS_ConvertUTF8toUTF16 url16(url); const char16_t *formatStrings[] = { url16.get() }; nsString result; rv = stringBundle->FormatStringFromName(MOZ_UTF16(PGPMIME_STR_NOT_SUPPORTED_ID), formatStrings, 1, getter_Copies(result)); if (NS_FAILED(rv)) return; aResult = NS_ConvertUTF16toUTF8(result); }
int msg_server_send_mail(nsIMsgIncomingServer * pIncomingServer, const nsCString & mimeContent, nsCString & err_msg) { nsresult rv = NS_OK; ews_session * session = NULL; nsCOMPtr<IMailEwsMsgIncomingServer> ewsServer(do_QueryInterface(pIncomingServer, &rv)); NS_ENSURE_SUCCESS(rv, EWS_FAIL); nsCOMPtr<IMailEwsService> ewsService; rv = ewsServer->GetService(getter_AddRefs(ewsService)); NS_ENSURE_SUCCESS(rv, EWS_FAIL); nsresult rv1 = ewsService->GetNewSession(&session); int ret = EWS_FAIL; if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv1) && session) { ret = do_send_mail(session, mimeContent.get(), mimeContent.Length(), getter_Copies(err_msg)); } else { err_msg.AssignLiteral(""); ret = (session ? EWS_FAIL : 401); } if (session) ewsService->ReleaseSession(session); return ret; }
NS_IMETHODIMP GnomeKeyring::Init() #endif { nsresult ret; nsCOMPtr<nsIServiceManager> servMan; nsCOMPtr<nsIPrefService> prefService; nsCOMPtr<nsIPrefBranch> pref; #ifdef PR_LOGGING gGnomeKeyringLog = PR_NewLogModule("GnomeKeyringLog"); #endif keyringName.AssignLiteral(kDefaultKeyring); ret = NS_GetServiceManager(getter_AddRefs(servMan)); if (ret != NS_OK) { return ret; } ret = servMan->GetServiceByContractID("@mozilla.org/preferences-service;1", NS_GET_IID(nsIPrefService), getter_AddRefs(prefService)); if (ret != NS_OK) { return ret; } ret = prefService->ReadUserPrefs(nullptr); if (ret != NS_OK) { return ret; } ret = prefService->GetBranch(kPrefsBranch, getter_AddRefs(pref)); if (ret != NS_OK) { return ret; } PRInt32 prefType; ret = pref->GetPrefType(kPrefsKeyring, &prefType); if (ret != NS_OK) { return ret; } if (prefType == 32) { char* tempKeyringName; pref->GetCharPref(kPrefsKeyring, &tempKeyringName); keyringName = tempKeyringName; if ( keyringName.IsVoid() || keyringName.IsEmpty() ) keyringName.AssignLiteral(kDefaultKeyring); } /* Create the password keyring, it doesn't hurt if it already exists */ GnomeKeyringResult result = gnome_keyring_create_sync(keyringName.get(), NULL); if ((result != GNOME_KEYRING_RESULT_OK) && (result != GNOME_KEYRING_RESULT_KEYRING_ALREADY_EXISTS)) { NS_ERROR("Can't open or create password keyring!"); return NS_ERROR_FAILURE; } return ret; }
/* * get "charset" information from clipboard data * return value can be: * 1. "UTF-16": mozilla or "text/html" with "charset=utf-16" * 2. "UNKNOWN": mozilla can't detect what encode it use * 3. other: "text/html" with other charset than utf-16 */ void GetHTMLCharset(guchar * data, int32_t dataLength, nsCString& str) { // if detect "FFFE" or "FEFF", assume UTF-16 PRUnichar* beginChar = (PRUnichar*)data; if ((beginChar[0] == 0xFFFE) || (beginChar[0] == 0xFEFF)) { str.AssignLiteral("UTF-16"); return; } // no "FFFE" and "FEFF", assume ASCII first to find "charset" info const nsDependentCString htmlStr((const char *)data, dataLength); nsACString::const_iterator start, end; htmlStr.BeginReading(start); htmlStr.EndReading(end); nsACString::const_iterator valueStart(start), valueEnd(start); if (CaseInsensitiveFindInReadable( NS_LITERAL_CSTRING("CONTENT=\"text/html;"), start, end)) { start = end; htmlStr.EndReading(end); if (CaseInsensitiveFindInReadable( NS_LITERAL_CSTRING("charset="), start, end)) { valueStart = end; start = end; htmlStr.EndReading(end); if (FindCharInReadable('"', start, end)) valueEnd = start; } } // find "charset" in HTML if (valueStart != valueEnd) { str = Substring(valueStart, valueEnd); ToUpperCase(str); #ifdef DEBUG_CLIPBOARD printf("Charset of HTML = %s\n", charsetUpperStr.get()); #endif return; } str.AssignLiteral("UNKNOWN"); }
void nsIsIndexFrame::GetSubmitCharset(nsCString& oCharset) { oCharset.AssignLiteral("UTF-8"); // default to utf-8 // XXX // We may want to get it from the HTML 4 Accept-Charset attribute first // see 17.3 The FORM element in HTML 4 for details // Get the charset from document nsIDocument* doc = mContent->GetDocument(); if (doc) { oCharset = doc->GetDocumentCharacterSet(); } }
nsresult GetExchangeTZId(calITimezone * tz, nsCString & tzId) { nsCOMPtr<calITimezoneService> tzService(do_GetService(CAL_TIMEZONESERVICE_CONTRACTID)); tzId.AssignLiteral(""); for (size_t i = 0; i < TIMEZONES_COUNT; i+=2) { nsCOMPtr<calITimezone> timezone; nsCString exId; exId.AssignLiteral(TIMEZONES[i + 1]); tzService->GetTimezone(exId, getter_AddRefs(timezone)); if (tz == timezone) { tzId.AssignLiteral(TIMEZONES[i + 1]); break; } } return NS_OK; }
// set up the internal streams void nsMIMEInputStream::InitStreams() { NS_ASSERTION(!mStartedReading, "Don't call initStreams twice without rewinding"); mStartedReading = true; // We'll use the content-length stream to add the final \r\n if (mAddContentLength) { uint64_t cl = 0; if (mData) { mData->Available(&cl); } mContentLength.AssignLiteral("Content-Length: "); mContentLength.AppendInt(cl); mContentLength.AppendLiteral("\r\n\r\n"); } else { mContentLength.AssignLiteral("\r\n"); } mCLStream->ShareData(mContentLength.get(), -1); mHeaderStream->ShareData(mHeaders.get(), -1); }
// maxSize may be -1 if unknown static void MakeRangeSpec(PRInt64 size, PRInt64 maxSize, PRInt32 chunkSize, PRBool fetchRemaining, nsCString &rangeSpec) { rangeSpec.AssignLiteral("bytes="); rangeSpec.AppendInt(size); rangeSpec.Append('-'); if (fetchRemaining) return; PRInt64 end = size + chunkSize; if (maxSize != -1 && end > maxSize) end = maxSize; end -= 1; rangeSpec.AppendInt(end); }
// maxSize may be -1 if unknown static void MakeRangeSpec(const PRInt64 &size, const PRInt64 &maxSize, PRInt32 chunkSize, PRBool fetchRemaining, nsCString &rangeSpec) { rangeSpec.AssignLiteral("bytes="); rangeSpec.AppendInt(PRInt64(size)); rangeSpec.Append('-'); if (fetchRemaining) return; PRInt64 end = size + PRInt64(chunkSize); if (maxSize != PRInt64(-1) && end > maxSize) end = maxSize; end -= 1; rangeSpec.AppendInt(PRInt64(end)); }
// maxSize may be -1 if unknown static void MakeRangeSpec(const int64_t &size, const int64_t &maxSize, int32_t chunkSize, bool fetchRemaining, nsCString &rangeSpec) { rangeSpec.AssignLiteral("bytes="); rangeSpec.AppendInt(int64_t(size)); rangeSpec.Append('-'); if (fetchRemaining) return; int64_t end = size + int64_t(chunkSize); if (maxSize != int64_t(-1) && end > maxSize) end = maxSize; end -= 1; rangeSpec.AppendInt(int64_t(end)); }
void nsGIOProtocolHandler::InitSupportedProtocolsPref(nsIPrefBranch *prefs) { // Get user preferences to determine which protocol is supported. // Gvfs/GIO has a set of supported protocols like obex, network, archive, // computer, dav, cdda, gphoto2, trash, etc. Some of these seems to be // irrelevant to process by browser. By default accept only smb and sftp // protocols so far. nsresult rv = prefs->GetCharPref(MOZ_GIO_SUPPORTED_PROTOCOLS, getter_Copies(mSupportedProtocols)); if (NS_SUCCEEDED(rv)) { mSupportedProtocols.StripWhitespace(); ToLowerCase(mSupportedProtocols); } else mSupportedProtocols.AssignLiteral("smb:,sftp:"); // use defaults LOG(("gio: supported protocols \"%s\"\n", mSupportedProtocols.get())); }
nsresult nsFileChannel::MakeFileInputStream(nsIFile *file, nsCOMPtr<nsIInputStream> &stream, nsCString &contentType, bool async) { // we accept that this might result in a disk hit to stat the file bool isDir; nsresult rv = file->IsDirectory(&isDir); if (NS_FAILED(rv)) { // canonicalize error message if (rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) rv = NS_ERROR_FILE_NOT_FOUND; if (async && (NS_ERROR_FILE_NOT_FOUND == rv)) { // We don't return "Not Found" errors here. Since we could not find // the file, it's not a directory anyway. isDir = false; } else { return rv; } } if (isDir) { rv = nsDirectoryIndexStream::Create(file, getter_AddRefs(stream)); if (NS_SUCCEEDED(rv) && !HasContentTypeHint()) contentType.AssignLiteral(APPLICATION_HTTP_INDEX_FORMAT); } else { rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file, -1, -1, async? nsIFileInputStream::DEFER_OPEN : 0); if (NS_SUCCEEDED(rv) && !HasContentTypeHint()) { // Use file extension to infer content type nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1", &rv); if (NS_SUCCEEDED(rv)) { mime->GetTypeFromFile(file, contentType); } } } return rv; }
static void UpdateMimeContentToEwsFormat(nsCString & mimeContent, bool & has_uid, nsCString & uid) { nsresult rv = NS_OK; nsCOMPtr<calIICSService> icsService = do_GetService(CAL_ICSSERVICE_CONTRACTID, &rv); NS_FAILED_WARN(rv); if (!icsService) return; nsCOMPtr<calIIcalComponent> component; rv = icsService->ParseICS(mimeContent, nullptr, getter_AddRefs(component)); NS_FAILED_WARN(rv); if (!component) return; //check METHOD nsCString method; rv = component->GetMethod(method); NS_FAILED_WARN(rv); if (NS_FAILED(rv) || method.IsEmpty()) { component->SetMethod(NS_LITERAL_CSTRING("PUBLISH")); } //Check UID nsCOMPtr<calIIcalComponent> todo; rv = component->GetFirstSubcomponent(NS_LITERAL_CSTRING("VTODO"), getter_AddRefs(todo)); NS_FAILED_WARN(rv); if (todo) { rv = todo->GetUid(uid); NS_FAILED_WARN(rv); if (NS_FAILED(rv) || uid.IsEmpty()) { has_uid = false; rv = GenerateUid(uid); NS_FAILED_WARN(rv); if (NS_SUCCEEDED(rv) && !uid.IsEmpty()) { todo->SetUid(uid); } } else { has_uid = true; } } else { has_uid = false; uid.AssignLiteral(""); } mailews_logger << "origianl ics:" << mimeContent.get() << std::endl; component->SerializeToICS(mimeContent); mailews_logger << "updated ics:" << mimeContent.get() << std::endl; }
void RemoveTask::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral("write"); }
/** * Read content of file or create file list from directory * @param aBuf read destination buffer * @param aCount length of destination buffer * @param aCountRead number of read characters * @return NS_OK when read successfully, NS_BASE_STREAM_CLOSED when end of file, * error code otherwise */ nsresult nsGIOInputStream::DoRead(char *aBuf, uint32_t aCount, uint32_t *aCountRead) { nsresult rv = NS_ERROR_NOT_AVAILABLE; if (mStream) { // file read GError *error = nullptr; uint32_t bytes_read = g_input_stream_read(G_INPUT_STREAM(mStream), aBuf, aCount, nullptr, &error); if (error) { rv = MapGIOResult(error); *aCountRead = 0; g_warning("Cannot read from file: %s", error->message); g_error_free(error); return rv; } *aCountRead = bytes_read; mBytesRemaining -= *aCountRead; return NS_OK; } else if (mDirOpen) { // directory read while (aCount && rv != NS_BASE_STREAM_CLOSED) { // Copy data out of our buffer uint32_t bufLen = mDirBuf.Length() - mDirBufCursor; if (bufLen) { uint32_t n = std::min(bufLen, aCount); memcpy(aBuf, mDirBuf.get() + mDirBufCursor, n); *aCountRead += n; aBuf += n; aCount -= n; mDirBufCursor += n; } if (!mDirListPtr) // Are we at the end of the directory list? { rv = NS_BASE_STREAM_CLOSED; } else if (aCount) // Do we need more data? { GFileInfo *info = (GFileInfo *) mDirListPtr->data; // Prune '.' and '..' from directory listing. const char * fname = g_file_info_get_name(info); if (fname && fname[0] == '.' && (fname[1] == '\0' || (fname[1] == '.' && fname[2] == '\0'))) { mDirListPtr = mDirListPtr->next; continue; } mDirBuf.AssignLiteral("201: "); // The "filename" field nsCString escName; nsCOMPtr<nsINetUtil> nu = do_GetService(NS_NETUTIL_CONTRACTID); if (nu && fname) { nu->EscapeString(nsDependentCString(fname), nsINetUtil::ESCAPE_URL_PATH, escName); mDirBuf.Append(escName); mDirBuf.Append(' '); } // The "content-length" field // XXX truncates size from 64-bit to 32-bit mDirBuf.AppendInt(int32_t(g_file_info_get_size(info))); mDirBuf.Append(' '); // The "last-modified" field // // NSPR promises: PRTime is compatible with time_t // we just need to convert from seconds to microseconds GTimeVal gtime; g_file_info_get_modification_time(info, >ime); PRExplodedTime tm; PRTime pt = ((PRTime) gtime.tv_sec) * 1000000; PR_ExplodeTime(pt, PR_GMTParameters, &tm); { char buf[64]; PR_FormatTimeUSEnglish(buf, sizeof(buf), "%a,%%20%d%%20%b%%20%Y%%20%H:%M:%S%%20GMT ", &tm); mDirBuf.Append(buf); } // The "file-type" field switch (g_file_info_get_file_type(info)) { case G_FILE_TYPE_REGULAR: mDirBuf.AppendLiteral("FILE "); break; case G_FILE_TYPE_DIRECTORY: mDirBuf.AppendLiteral("DIRECTORY "); break; case G_FILE_TYPE_SYMBOLIC_LINK: mDirBuf.AppendLiteral("SYMBOLIC-LINK "); break; default: break; } mDirBuf.Append('\n'); mDirBufCursor = 0; mDirListPtr = mDirListPtr->next; } } } return rv; }
void GetFilesTaskChild::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral("read"); }
nsHtml5Parser::GetCommand(nsCString& aCommand) { aCommand.AssignLiteral("view"); }
void GetFileOrDirectoryTaskParent::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral(DIRECTORY_READ_PERMISSION); }
void GetDirectoryListingTaskChild::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral(DIRECTORY_READ_PERMISSION); }
void CreateDirectoryTaskChild::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral(DIRECTORY_CREATE_PERMISSION); }
void CreateDirectoryTaskParent::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral(CREATE_DIRECTORY_TASK_PERMISSION); }
nsresult nsDataHandler::ParseURI(nsCString& spec, nsCString& contentType, nsCString& contentCharset, bool& isBase64, nsCString& dataBuffer, nsCString& hashRef) { isBase64 = false; // move past "data:" char *buffer = (char *) PL_strcasestr(spec.BeginWriting(), "data:"); if (!buffer) { // malformed uri return NS_ERROR_MALFORMED_URI; } buffer += 5; // First, find the start of the data char *comma = strchr(buffer, ','); if (!comma) return NS_ERROR_MALFORMED_URI; *comma = '\0'; // determine if the data is base64 encoded. char *base64 = PL_strcasestr(buffer, ";base64"); if (base64) { isBase64 = true; *base64 = '\0'; } if (comma == buffer) { // nothing but data contentType.AssignLiteral("text/plain"); contentCharset.AssignLiteral("US-ASCII"); } else { // everything else is content type char *semiColon = (char *) strchr(buffer, ';'); if (semiColon) *semiColon = '\0'; if (semiColon == buffer || base64 == buffer) { // there is no content type, but there are other parameters contentType.AssignLiteral("text/plain"); } else { contentType = buffer; ToLowerCase(contentType); } if (semiColon) { char *charset = PL_strcasestr(semiColon + 1, "charset="); if (charset) contentCharset = charset + sizeof("charset=") - 1; *semiColon = ';'; } } *comma = ','; if (isBase64) *base64 = ';'; contentType.StripWhitespace(); contentCharset.StripWhitespace(); // Split encoded data from terminal "#ref" (if present) char *data = comma + 1; char *hash = strchr(data, '#'); if (!hash) { dataBuffer.Assign(data); hashRef.Truncate(); } else { dataBuffer.Assign(data, hash - data); hashRef.Assign(hash); } return NS_OK; }
nsresult nsDataHandler::ParseURI(nsCString& spec, nsCString& contentType, nsCString* contentCharset, bool& isBase64, nsCString* dataBuffer) { isBase64 = false; // move past "data:" const char* roBuffer = (const char*) PL_strcasestr(spec.get(), "data:"); if (!roBuffer) { // malformed uri return NS_ERROR_MALFORMED_URI; } roBuffer += sizeof("data:") - 1; // First, find the start of the data const char* roComma = strchr(roBuffer, ','); const char* roHash = strchr(roBuffer, '#'); if (!roComma || (roHash && roHash < roComma)) { return NS_ERROR_MALFORMED_URI; } if (roComma == roBuffer) { // nothing but data contentType.AssignLiteral("text/plain"); if (contentCharset) { contentCharset->AssignLiteral("US-ASCII"); } } else { // Make a copy of the non-data part so we can null out parts of it as // we go. This copy will be a small number of chars, in contrast to the // data which may be large. char* buffer = PL_strndup(roBuffer, roComma - roBuffer); // determine if the data is base64 encoded. char* base64 = PL_strcasestr(buffer, BASE64_EXTENSION); if (base64) { char *beyond = base64 + sizeof(BASE64_EXTENSION) - 1; // Per the RFC 2397 grammar, "base64" MUST be at the end of the // non-data part. // // But we also allow it in between parameters so a subsequent ";" // is ok as well (this deals with *broken* data URIs, see bug // 781693 for an example). Anything after "base64" in the non-data // part will be discarded in this case, however. if (*beyond == '\0' || *beyond == ';') { isBase64 = true; *base64 = '\0'; } } // everything else is content type char *semiColon = (char *) strchr(buffer, ';'); if (semiColon) *semiColon = '\0'; if (semiColon == buffer || base64 == buffer) { // there is no content type, but there are other parameters contentType.AssignLiteral("text/plain"); } else { contentType.Assign(buffer); ToLowerCase(contentType); contentType.StripWhitespace(); } if (semiColon && contentCharset) { char *charset = PL_strcasestr(semiColon + 1, "charset="); if (charset) { contentCharset->Assign(charset + sizeof("charset=") - 1); contentCharset->StripWhitespace(); } } free(buffer); } if (dataBuffer) { // Split encoded data from terminal "#ref" (if present) const char* roData = roComma + 1; bool ok = !roHash ? dataBuffer->Assign(roData, mozilla::fallible) : dataBuffer->Assign(roData, roHash - roData, mozilla::fallible); if (!ok) { return NS_ERROR_OUT_OF_MEMORY; } } return NS_OK; }
void GetDirectoryListingTask::GetPermissionAccessType(nsCString& aAccess) const { aAccess.AssignLiteral("read"); }
nsresult nsDataHandler::ParseURI(nsCString& spec, nsCString& contentType, nsCString& contentCharset, bool& isBase64, nsCString& dataBuffer, nsCString& hashRef) { isBase64 = false; // move past "data:" char *buffer = (char *) PL_strcasestr(spec.BeginWriting(), "data:"); if (!buffer) { // malformed uri return NS_ERROR_MALFORMED_URI; } buffer += 5; // First, find the start of the data char *comma = strchr(buffer, ','); char *hash = strchr(buffer, '#'); if (!comma || (hash && hash < comma)) return NS_ERROR_MALFORMED_URI; *comma = '\0'; // determine if the data is base64 encoded. char *base64 = PL_strcasestr(buffer, BASE64_EXTENSION); if (base64) { char *beyond = base64 + strlen(BASE64_EXTENSION); // per the RFC 2397 grammar, "base64" MUST be followed by a comma // previously substituted by '\0', but we also allow it in between // parameters so a subsequent ";" is ok as well (this deals with // *broken* data URIs, see bug 781693 for an example) if (*beyond == '\0' || *beyond == ';') { isBase64 = true; *base64 = '\0'; } } if (comma == buffer) { // nothing but data contentType.AssignLiteral("text/plain"); contentCharset.AssignLiteral("US-ASCII"); } else { // everything else is content type char *semiColon = (char *) strchr(buffer, ';'); if (semiColon) *semiColon = '\0'; if (semiColon == buffer || base64 == buffer) { // there is no content type, but there are other parameters contentType.AssignLiteral("text/plain"); } else { contentType = buffer; ToLowerCase(contentType); } if (semiColon) { char *charset = PL_strcasestr(semiColon + 1, "charset="); if (charset) contentCharset = charset + sizeof("charset=") - 1; *semiColon = ';'; } } *comma = ','; if (isBase64) *base64 = ';'; contentType.StripWhitespace(); contentCharset.StripWhitespace(); // Split encoded data from terminal "#ref" (if present) char *data = comma + 1; if (!hash) { dataBuffer.Assign(data); hashRef.Truncate(); } else { dataBuffer.Assign(data, hash - data); hashRef.Assign(hash); } return NS_OK; }