diff options
Diffstat (limited to 'netwerk/protocol/gio/nsGIOProtocolHandler.cpp')
| -rw-r--r-- | netwerk/protocol/gio/nsGIOProtocolHandler.cpp | 1027 |
1 files changed, 1027 insertions, 0 deletions
diff --git a/netwerk/protocol/gio/nsGIOProtocolHandler.cpp b/netwerk/protocol/gio/nsGIOProtocolHandler.cpp new file mode 100644 index 0000000000..469d7982d4 --- /dev/null +++ b/netwerk/protocol/gio/nsGIOProtocolHandler.cpp @@ -0,0 +1,1027 @@ +/* vim:set ts=2 sw=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * This code is based on original Mozilla gnome-vfs extension. It implements + * input stream provided by GVFS/GIO. + */ +#include "nsGIOProtocolHandler.h" +#include "GIOChannelChild.h" +#include "mozilla/Components.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/Logging.h" +#include "mozilla/net/NeckoChild.h" +#include "mozilla/NullPrincipal.h" +#include "nsIPrefBranch.h" +#include "nsIPrefService.h" +#include "nsIObserver.h" +#include "nsCRT.h" +#include "nsThreadUtils.h" +#include "nsProxyRelease.h" +#include "nsIStringBundle.h" +#include "nsMimeTypes.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsServiceManagerUtils.h" +#include "nsIURI.h" +#include "nsIAuthPrompt.h" +#include "nsIChannel.h" +#include "nsIInputStream.h" +#include "nsIProtocolHandler.h" +#include "mozilla/Monitor.h" +#include "prtime.h" +#include <gio/gio.h> +#include <algorithm> + +using namespace mozilla; + +#define MOZ_GIO_SCHEME "moz-gio" +#define MOZ_GIO_SUPPORTED_PROTOCOLS "network.gio.supported-protocols" + +//----------------------------------------------------------------------------- + +// NSPR_LOG_MODULES=gio:5 +LazyLogModule gGIOLog("gio"); +#undef LOG +#define LOG(args) MOZ_LOG(gGIOLog, mozilla::LogLevel::Debug, args) + +//----------------------------------------------------------------------------- +static nsresult MapGIOResult(gint code) { + switch (code) { + case G_IO_ERROR_NOT_FOUND: + return NS_ERROR_FILE_NOT_FOUND; // shows error + case G_IO_ERROR_INVALID_ARGUMENT: + return NS_ERROR_INVALID_ARG; + case G_IO_ERROR_NOT_SUPPORTED: + return NS_ERROR_NOT_AVAILABLE; + case G_IO_ERROR_NO_SPACE: + return NS_ERROR_FILE_NO_DEVICE_SPACE; + case G_IO_ERROR_READ_ONLY: + return NS_ERROR_FILE_READ_ONLY; + case G_IO_ERROR_PERMISSION_DENIED: + return NS_ERROR_FILE_ACCESS_DENIED; // wrong password/login + case G_IO_ERROR_CLOSED: + return NS_BASE_STREAM_CLOSED; // was EOF + case G_IO_ERROR_NOT_DIRECTORY: + return NS_ERROR_FILE_NOT_DIRECTORY; + case G_IO_ERROR_PENDING: + return NS_ERROR_IN_PROGRESS; + case G_IO_ERROR_EXISTS: + return NS_ERROR_FILE_ALREADY_EXISTS; + case G_IO_ERROR_IS_DIRECTORY: + return NS_ERROR_FILE_IS_DIRECTORY; + case G_IO_ERROR_NOT_MOUNTED: + return NS_ERROR_NOT_CONNECTED; // shows error + case G_IO_ERROR_HOST_NOT_FOUND: + return NS_ERROR_UNKNOWN_HOST; // shows error + case G_IO_ERROR_CANCELLED: + return NS_ERROR_ABORT; + case G_IO_ERROR_NOT_EMPTY: + return NS_ERROR_FILE_DIR_NOT_EMPTY; + case G_IO_ERROR_FILENAME_TOO_LONG: + return NS_ERROR_FILE_NAME_TOO_LONG; + case G_IO_ERROR_INVALID_FILENAME: + return NS_ERROR_FILE_INVALID_PATH; + case G_IO_ERROR_TIMED_OUT: + return NS_ERROR_NET_TIMEOUT; // shows error + case G_IO_ERROR_WOULD_BLOCK: + return NS_BASE_STREAM_WOULD_BLOCK; + case G_IO_ERROR_FAILED_HANDLED: + return NS_ERROR_ABORT; // Cancel on login dialog + + /* unhandled: + G_IO_ERROR_NOT_REGULAR_FILE, + G_IO_ERROR_NOT_SYMBOLIC_LINK, + G_IO_ERROR_NOT_MOUNTABLE_FILE, + G_IO_ERROR_TOO_MANY_LINKS, + G_IO_ERROR_ALREADY_MOUNTED, + G_IO_ERROR_CANT_CREATE_BACKUP, + G_IO_ERROR_WRONG_ETAG, + G_IO_ERROR_WOULD_RECURSE, + G_IO_ERROR_BUSY, + G_IO_ERROR_WOULD_MERGE, + G_IO_ERROR_TOO_MANY_OPEN_FILES + */ + // Make GCC happy + default: + return NS_ERROR_FAILURE; + } +} + +static nsresult MapGIOResult(GError* result) { + if (!result) { + return NS_OK; + } + return MapGIOResult(result->code); +} + +/** Return values for mount operation. + * These enums are used as mount operation return values. + */ +enum class MountOperationResult { + MOUNT_OPERATION_IN_PROGRESS, /** \enum operation in progress */ + MOUNT_OPERATION_SUCCESS, /** \enum operation successful */ + MOUNT_OPERATION_FAILED /** \enum operation not successful */ +}; + +//----------------------------------------------------------------------------- +/** + * Sort function compares according to file type (directory/file) + * and alphabethical order + * @param a pointer to GFileInfo object to compare + * @param b pointer to GFileInfo object to compare + * @return -1 when first object should be before the second, 0 when equal, + * +1 when second object should be before the first + */ +static gint FileInfoComparator(gconstpointer a, gconstpointer b) { + GFileInfo* ia = (GFileInfo*)a; + GFileInfo* ib = (GFileInfo*)b; + if (g_file_info_get_file_type(ia) == G_FILE_TYPE_DIRECTORY && + g_file_info_get_file_type(ib) != G_FILE_TYPE_DIRECTORY) { + return -1; + } + if (g_file_info_get_file_type(ib) == G_FILE_TYPE_DIRECTORY && + g_file_info_get_file_type(ia) != G_FILE_TYPE_DIRECTORY) { + return 1; + } + + return nsCRT::strcasecmp(g_file_info_get_name(ia), g_file_info_get_name(ib)); +} + +/* Declaration of mount callback functions */ +static void mount_enclosing_volume_finished(GObject* source_object, + GAsyncResult* res, + gpointer user_data); +static void mount_operation_ask_password( + GMountOperation* mount_op, const char* message, const char* default_user, + const char* default_domain, GAskPasswordFlags flags, gpointer user_data); +//----------------------------------------------------------------------------- +class nsGIOInputStream final : public nsIInputStream { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + + explicit nsGIOInputStream(const nsCString& uriSpec) : mSpec(uriSpec) {} + + void SetChannel(nsIChannel* channel) { + // We need to hold an owning reference to our channel. This is done + // so we can access the channel's notification callbacks to acquire + // a reference to a nsIAuthPrompt if we need to handle an interactive + // mount operation. + // + // However, the channel can only be accessed on the main thread, so + // we have to be very careful with ownership. Moreover, it doesn't + // support threadsafe addref/release, so proxying is the answer. + // + // Also, it's important to note that this likely creates a reference + // cycle since the channel likely owns this stream. This reference + // cycle is broken in our Close method. + + mChannel = do_AddRef(channel).take(); + } + void SetMountResult(MountOperationResult result, gint error_code); + + private: + ~nsGIOInputStream() { Close(); } + nsresult DoOpen(); + nsresult DoRead(char* aBuf, uint32_t aCount, uint32_t* aCountRead); + nsresult SetContentTypeOfChannel(const char* contentType); + nsresult MountVolume(); + nsresult DoOpenDirectory(); + nsresult DoOpenFile(GFileInfo* info); + nsCString mSpec; + nsIChannel* mChannel{nullptr}; // manually refcounted + GFile* mHandle{nullptr}; + GFileInputStream* mStream{nullptr}; + uint64_t mBytesRemaining{UINT64_MAX}; + nsresult mStatus{NS_OK}; + GList* mDirList{nullptr}; + GList* mDirListPtr{nullptr}; + nsCString mDirBuf; + uint32_t mDirBufCursor{0}; + bool mDirOpen{false}; + MountOperationResult mMountRes = + MountOperationResult::MOUNT_OPERATION_SUCCESS; + mozilla::Monitor mMonitorMountInProgress MOZ_UNANNOTATED{ + "GIOInputStream::MountFinished"}; + gint mMountErrorCode{}; +}; + +/** + * Set result of mount operation and notify monitor waiting for results. + * This method is called in main thread as long as it is used only + * in mount_enclosing_volume_finished function. + * @param result Result of mount operation + */ +void nsGIOInputStream::SetMountResult(MountOperationResult result, + gint error_code) { + mozilla::MonitorAutoLock mon(mMonitorMountInProgress); + mMountRes = result; + mMountErrorCode = error_code; + mon.Notify(); +} + +/** + * Start mount operation and wait in loop until it is finished. This method is + * called from thread which is trying to read from location. + */ +nsresult nsGIOInputStream::MountVolume() { + GMountOperation* mount_op = g_mount_operation_new(); + g_signal_connect(mount_op, "ask-password", + G_CALLBACK(mount_operation_ask_password), mChannel); + mMountRes = MountOperationResult::MOUNT_OPERATION_IN_PROGRESS; + /* g_file_mount_enclosing_volume uses a dbus request to mount the volume. + Callback mount_enclosing_volume_finished is called in main thread + (not this thread on which this method is called). */ + g_file_mount_enclosing_volume(mHandle, G_MOUNT_MOUNT_NONE, mount_op, nullptr, + mount_enclosing_volume_finished, this); + mozilla::MonitorAutoLock mon(mMonitorMountInProgress); + /* Waiting for finish of mount operation thread */ + while (mMountRes == MountOperationResult::MOUNT_OPERATION_IN_PROGRESS) { + mon.Wait(); + } + + g_object_unref(mount_op); + + if (mMountRes == MountOperationResult::MOUNT_OPERATION_FAILED) { + return MapGIOResult(mMountErrorCode); + } + return NS_OK; +} + +/** + * Create list of infos about objects in opened directory + * Return: NS_OK when list obtained, otherwise error code according + * to failed operation. + */ +nsresult nsGIOInputStream::DoOpenDirectory() { + GError* error = nullptr; + + GFileEnumerator* f_enum = g_file_enumerate_children( + mHandle, "standard::*,time::*", G_FILE_QUERY_INFO_NONE, nullptr, &error); + if (!f_enum) { + nsresult rv = MapGIOResult(error); + g_warning("Cannot read from directory: %s", error->message); + g_error_free(error); + return rv; + } + // fill list of file infos + GFileInfo* info = g_file_enumerator_next_file(f_enum, nullptr, &error); + while (info) { + mDirList = g_list_append(mDirList, info); + info = g_file_enumerator_next_file(f_enum, nullptr, &error); + } + g_object_unref(f_enum); + if (error) { + g_warning("Error reading directory content: %s", error->message); + nsresult rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + mDirOpen = true; + + // Sort list of file infos by using FileInfoComparator function + mDirList = g_list_sort(mDirList, FileInfoComparator); + mDirListPtr = mDirList; + + // Write column names + mDirBuf.AppendLiteral( + "200: filename content-length last-modified file-type\n"); + + SetContentTypeOfChannel(APPLICATION_HTTP_INDEX_FORMAT); + return NS_OK; +} + +/** + * Create file stream and set mime type for channel + * @param info file info used to determine mime type + * @return NS_OK when file stream created successfuly, error code otherwise + */ +nsresult nsGIOInputStream::DoOpenFile(GFileInfo* info) { + GError* error = nullptr; + + mStream = g_file_read(mHandle, nullptr, &error); + if (!mStream) { + nsresult rv = MapGIOResult(error); + g_warning("Cannot read from file: %s", error->message); + g_error_free(error); + return rv; + } + + const char* content_type = g_file_info_get_content_type(info); + if (content_type) { + char* mime_type = g_content_type_get_mime_type(content_type); + if (mime_type) { + if (strcmp(mime_type, APPLICATION_OCTET_STREAM) != 0) { + SetContentTypeOfChannel(mime_type); + } + g_free(mime_type); + } + } else { + g_warning("Missing content type."); + } + + mBytesRemaining = g_file_info_get_size(info); + // Update the content length attribute on the channel. We do this + // synchronously without proxying. This hack is not as bad as it looks! + mChannel->SetContentLength(mBytesRemaining); + + return NS_OK; +} + +/** + * Start file open operation, mount volume when needed and according to file + * type create file output stream or read directory content. + * @return NS_OK when file or directory opened successfully, error code + * otherwise + */ +nsresult nsGIOInputStream::DoOpen() { + nsresult rv; + GError* error = nullptr; + + NS_ASSERTION(mHandle == nullptr, "already open"); + + mHandle = g_file_new_for_uri(mSpec.get()); + + GFileInfo* info = g_file_query_info(mHandle, "standard::*", + G_FILE_QUERY_INFO_NONE, nullptr, &error); + + if (error) { + if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_MOUNTED) { + // location is not yet mounted, try to mount + g_error_free(error); + if (NS_IsMainThread()) { + return NS_ERROR_NOT_CONNECTED; + } + error = nullptr; + rv = MountVolume(); + if (rv != NS_OK) { + return rv; + } + // get info again + info = g_file_query_info(mHandle, "standard::*", G_FILE_QUERY_INFO_NONE, + nullptr, &error); + // second try to get file info from remote files after media mount + if (!info) { + g_warning("Unable to get file info: %s", error->message); + rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + } else { + g_warning("Unable to get file info: %s", error->message); + rv = MapGIOResult(error); + g_error_free(error); + return rv; + } + } + // Get file type to handle directories and file differently + GFileType f_type = g_file_info_get_file_type(info); + if (f_type == G_FILE_TYPE_DIRECTORY) { + // directory + rv = DoOpenDirectory(); + } else if (f_type != G_FILE_TYPE_UNKNOWN) { + // file + rv = DoOpenFile(info); + } else { + g_warning("Unable to get file type."); + rv = NS_ERROR_FILE_NOT_FOUND; + } + if (info) { + g_object_unref(info); + } + return rv; +} + +/** + * 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; + } + 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; +} + +/** + * This class is used to implement SetContentTypeOfChannel. + */ +class nsGIOSetContentTypeEvent : public mozilla::Runnable { + public: + nsGIOSetContentTypeEvent(nsIChannel* channel, const char* contentType) + : mozilla::Runnable("nsGIOSetContentTypeEvent"), + mChannel(channel), + mContentType(contentType) { + // stash channel reference in mChannel. no AddRef here! see note + // in SetContentTypeOfchannel. + } + + NS_IMETHOD Run() override { + mChannel->SetContentType(mContentType); + return NS_OK; + } + + private: + nsIChannel* mChannel; + nsCString mContentType; +}; + +nsresult nsGIOInputStream::SetContentTypeOfChannel(const char* contentType) { + // We need to proxy this call over to the main thread. We post an + // asynchronous event in this case so that we don't delay reading data, and + // we know that this is safe to do since the channel's reference will be + // released asynchronously as well. We trust the ordering of the main + // thread's event queue to protect us against memory corruption. + + nsresult rv; + nsCOMPtr<nsIRunnable> ev = + new nsGIOSetContentTypeEvent(mChannel, contentType); + if (!ev) { + rv = NS_ERROR_OUT_OF_MEMORY; + } else { + rv = NS_DispatchToMainThread(ev); + } + return rv; +} + +NS_IMPL_ISUPPORTS(nsGIOInputStream, nsIInputStream) + +/** + * Free all used memory and close stream. + */ +NS_IMETHODIMP +nsGIOInputStream::Close() { + if (mStream) { + g_object_unref(mStream); + mStream = nullptr; + } + + if (mHandle) { + g_object_unref(mHandle); + mHandle = nullptr; + } + + if (mDirList) { + // Destroy the list of GIOFileInfo objects... + g_list_foreach(mDirList, (GFunc)g_object_unref, nullptr); + g_list_free(mDirList); + mDirList = nullptr; + mDirListPtr = nullptr; + } + + if (mChannel) { + NS_ReleaseOnMainThread("nsGIOInputStream::mChannel", dont_AddRef(mChannel)); + + mChannel = nullptr; + } + + mSpec.Truncate(); // free memory + + // Prevent future reads from re-opening the handle. + if (NS_SUCCEEDED(mStatus)) { + mStatus = NS_BASE_STREAM_CLOSED; + } + + return NS_OK; +} + +/** + * Return number of remaining bytes available on input + * @param aResult remaining bytes + */ +NS_IMETHODIMP +nsGIOInputStream::Available(uint64_t* aResult) { + if (NS_FAILED(mStatus)) { + return mStatus; + } + + *aResult = mBytesRemaining; + + return NS_OK; +} + +/** + * Return the status of the input stream + */ +NS_IMETHODIMP +nsGIOInputStream::StreamStatus() { return mStatus; } + +/** + * Trying to read from stream. When location is not available it tries to mount + * it. + * @param aBuf buffer to put read data + * @param aCount length of aBuf + * @param aCountRead number of bytes actually read + */ +NS_IMETHODIMP +nsGIOInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aCountRead) { + *aCountRead = 0; + // Check if file is already opened, otherwise open it + if (!mStream && !mDirOpen && mStatus == NS_OK) { + mStatus = DoOpen(); + if (NS_FAILED(mStatus)) { + return mStatus; + } + } + + mStatus = DoRead(aBuf, aCount, aCountRead); + // Check if all data has been read + if (mStatus == NS_BASE_STREAM_CLOSED) { + return NS_OK; + } + + // Check whenever any error appears while reading + return mStatus; +} + +NS_IMETHODIMP +nsGIOInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* aResult) { + // There is no way to implement this using GnomeVFS, but fortunately + // that doesn't matter. Because we are a blocking input stream, Necko + // isn't going to call our ReadSegments method. + MOZ_ASSERT_UNREACHABLE("nsGIOInputStream::ReadSegments"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsGIOInputStream::IsNonBlocking(bool* aResult) { + *aResult = false; + return NS_OK; +} + +//----------------------------------------------------------------------------- + +/** + * Called when finishing mount operation. Result of operation is set in + * nsGIOInputStream. This function is called in main thread as an async request + * typically from dbus. + * @param source_object GFile object which requested the mount + * @param res result object + * @param user_data pointer to nsGIOInputStream + */ +static void mount_enclosing_volume_finished(GObject* source_object, + GAsyncResult* res, + gpointer user_data) { + GError* error = nullptr; + + nsGIOInputStream* istream = static_cast<nsGIOInputStream*>(user_data); + + g_file_mount_enclosing_volume_finish(G_FILE(source_object), res, &error); + + if (error) { + g_warning("Mount failed: %s %d", error->message, error->code); + istream->SetMountResult(MountOperationResult::MOUNT_OPERATION_FAILED, + error->code); + g_error_free(error); + } else { + istream->SetMountResult(MountOperationResult::MOUNT_OPERATION_SUCCESS, 0); + } +} + +/** + * This function is called when username or password are requested from user. + * This function is called in main thread as async request from dbus. + * @param mount_op mount operation + * @param message message to show to user + * @param default_user preffered user + * @param default_domain domain name + * @param flags what type of information is required + * @param user_data nsIChannel + */ +static void mount_operation_ask_password( + GMountOperation* mount_op, const char* message, const char* default_user, + const char* default_domain, GAskPasswordFlags flags, gpointer user_data) { + nsIChannel* channel = (nsIChannel*)user_data; + if (!channel) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // We can't handle request for domain + if (flags & G_ASK_PASSWORD_NEED_DOMAIN) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + + nsCOMPtr<nsIAuthPrompt> prompt; + NS_QueryNotificationCallbacks(channel, prompt); + + // If no auth prompt, then give up. We could failover to using the + // WindowWatcher service, but that might defeat a consumer's purposeful + // attempt to disable authentication (for whatever reason). + if (!prompt) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Parse out the host and port... + nsCOMPtr<nsIURI> uri; + channel->GetURI(getter_AddRefs(uri)); + if (!uri) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + + nsAutoCString scheme, hostPort; + uri->GetScheme(scheme); + uri->GetHostPort(hostPort); + + // It doesn't make sense for either of these strings to be empty. What kind + // of funky URI is this? + if (scheme.IsEmpty() || hostPort.IsEmpty()) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Construct the single signon key. Altering the value of this key will + // cause people's remembered passwords to be forgotten. Think carefully + // before changing the way this key is constructed. + nsAutoString key, realm; + + NS_ConvertUTF8toUTF16 dispHost(scheme); + dispHost.AppendLiteral("://"); + dispHost.Append(NS_ConvertUTF8toUTF16(hostPort)); + + key = dispHost; + if (*default_domain != '\0') { + // We assume the realm string is ASCII. That might be a bogus assumption, + // but we have no idea what encoding GnomeVFS is using, so for now we'll + // limit ourselves to ISO-Latin-1. XXX What is a better solution? + realm.Append('"'); + realm.Append(NS_ConvertASCIItoUTF16(default_domain)); + realm.Append('"'); + key.Append(' '); + key.Append(realm); + } + // Construct the message string... + // + // We use Necko's string bundle here. This code really should be encapsulated + // behind some Necko API, after all this code is based closely on the code in + // nsHttpChannel.cpp. + nsCOMPtr<nsIStringBundleService> bundleSvc = + do_GetService(NS_STRINGBUNDLE_CONTRACTID); + if (!bundleSvc) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + nsCOMPtr<nsIStringBundle> bundle; + bundleSvc->CreateBundle("chrome://global/locale/commonDialogs.properties", + getter_AddRefs(bundle)); + if (!bundle) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + nsAutoString nsmessage; + + if (flags & G_ASK_PASSWORD_NEED_PASSWORD) { + if (flags & G_ASK_PASSWORD_NEED_USERNAME) { + if (!realm.IsEmpty()) { + AutoTArray<nsString, 2> strings = {realm, dispHost}; + bundle->FormatStringFromName("EnterLoginForRealm3", strings, nsmessage); + } else { + AutoTArray<nsString, 1> strings = {dispHost}; + bundle->FormatStringFromName("EnterUserPasswordFor2", strings, + nsmessage); + } + } else { + NS_ConvertUTF8toUTF16 userName(default_user); + AutoTArray<nsString, 2> strings = {userName, dispHost}; + bundle->FormatStringFromName("EnterPasswordFor", strings, nsmessage); + } + } else { + g_warning("Unknown mount operation request (flags: %x)", flags); + } + + if (nsmessage.IsEmpty()) { + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + return; + } + // Prompt the user... + nsresult rv; + bool retval = false; + char16_t *user = nullptr, *pass = nullptr; + if (default_user) { + // user will be freed by PromptUsernameAndPassword + user = ToNewUnicode(NS_ConvertUTF8toUTF16(default_user)); + } + if (flags & G_ASK_PASSWORD_NEED_USERNAME) { + rv = prompt->PromptUsernameAndPassword( + nullptr, nsmessage.get(), key.get(), + nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY, &user, &pass, &retval); + } else { + rv = prompt->PromptPassword(nullptr, nsmessage.get(), key.get(), + nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY, &pass, + &retval); + } + if (NS_FAILED(rv) || !retval) { // was || user == '\0' || pass == '\0' + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_ABORTED); + free(user); + free(pass); + return; + } + /* GIO should accept UTF8 */ + g_mount_operation_set_username(mount_op, NS_ConvertUTF16toUTF8(user).get()); + g_mount_operation_set_password(mount_op, NS_ConvertUTF16toUTF8(pass).get()); + free(user); + free(pass); + g_mount_operation_reply(mount_op, G_MOUNT_OPERATION_HANDLED); +} + +//----------------------------------------------------------------------------- + +mozilla::StaticRefPtr<nsGIOProtocolHandler> nsGIOProtocolHandler::sSingleton; + +already_AddRefed<nsGIOProtocolHandler> nsGIOProtocolHandler::GetSingleton() { + if (!sSingleton) { + sSingleton = new nsGIOProtocolHandler(); + sSingleton->Init(); + ClearOnShutdown(&sSingleton); + } + return do_AddRef(sSingleton); +} + +NS_IMPL_ISUPPORTS(nsGIOProtocolHandler, nsIProtocolHandler, nsIObserver) + +nsresult nsGIOProtocolHandler::Init() { + if (net::IsNeckoChild()) { + net::NeckoChild::InitNeckoChild(); + } + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (prefs) { + InitSupportedProtocolsPref(prefs); + prefs->AddObserver(MOZ_GIO_SUPPORTED_PROTOCOLS, this, false); + } + + return NS_OK; +} + +void nsGIOProtocolHandler::InitSupportedProtocolsPref(nsIPrefBranch* prefs) { + nsCOMPtr<nsIIOService> ioService = components::IO::Service(); + if (NS_WARN_IF(!ioService)) { + LOG(("gio: ioservice not available\n")); + return; + } + + // 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 sftp protocol so + // far. + nsAutoCString prefValue; + nsresult rv = prefs->GetCharPref(MOZ_GIO_SUPPORTED_PROTOCOLS, prefValue); + if (NS_SUCCEEDED(rv)) { + prefValue.StripWhitespace(); + ToLowerCase(prefValue); + } else { + prefValue.AssignLiteral("" // use none by default + ); + } + LOG(("gio: supported protocols \"%s\"\n", prefValue.get())); + + // Unregister any previously registered dynamic protocols. + for (const nsCString& scheme : mSupportedProtocols) { + LOG(("gio: unregistering handler for \"%s\"", scheme.get())); + ioService->UnregisterProtocolHandler(scheme); + } + mSupportedProtocols.Clear(); + + // Register each protocol from the pref branch to reference + // nsGIOProtocolHandler. + for (const nsDependentCSubstring& protocol : prefValue.Split(',')) { + if (NS_WARN_IF(!StringEndsWith(protocol, ":"_ns))) { + continue; // each protocol must end with a `:` character to be recognized + } + + nsCString scheme(Substring(protocol, 0, protocol.Length() - 1)); + if (NS_SUCCEEDED(ioService->RegisterProtocolHandler( + scheme, this, + nsIProtocolHandler::URI_STD | + nsIProtocolHandler::URI_DANGEROUS_TO_LOAD, + /* aDefaultPort */ -1))) { + LOG(("gio: successfully registered handler for \"%s\"", scheme.get())); + mSupportedProtocols.AppendElement(scheme); + } else { + LOG(("gio: failed to register handler for \"%s\"", scheme.get())); + } + } +} + +bool nsGIOProtocolHandler::IsSupportedProtocol(const nsCString& aScheme) { + for (const auto& protocol : mSupportedProtocols) { + if (aScheme.EqualsIgnoreCase(protocol)) { + return true; + } + } + return false; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::GetScheme(nsACString& aScheme) { + aScheme.AssignLiteral(MOZ_GIO_SCHEME); + return NS_OK; +} + +static bool IsValidGIOScheme(const nsACString& aScheme) { + // Verify that GIO supports this URI scheme. + GVfs* gvfs = g_vfs_get_default(); + + if (!gvfs) { + g_warning("Cannot get GVfs object."); + return false; + } + + const gchar* const* uri_schemes = g_vfs_get_supported_uri_schemes(gvfs); + + while (*uri_schemes != nullptr) { + // While flatSpec ends with ':' the uri_scheme does not. Therefore do not + // compare last character. + if (aScheme.Equals(*uri_schemes)) { + return true; + } + uri_schemes++; + } + + return false; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::NewChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo, + nsIChannel** aResult) { + NS_ENSURE_ARG_POINTER(aURI); + nsresult rv; + + nsAutoCString spec; + rv = aURI->GetSpec(spec); + if (NS_FAILED(rv)) { + return rv; + } + + nsAutoCString scheme; + rv = aURI->GetScheme(scheme); + if (NS_FAILED(rv)) { + return rv; + } + + if (!IsSupportedProtocol(scheme)) { + return NS_ERROR_UNKNOWN_PROTOCOL; + } + + // g_vfs_get_supported_uri_schemes() returns a very limited list in the + // child due to the sandbox, so we only check if its valid for the parent. + if (XRE_IsParentProcess() && !IsValidGIOScheme(scheme)) { + return NS_ERROR_UNKNOWN_PROTOCOL; + } + + RefPtr<nsBaseChannel> channel; + if (net::IsNeckoChild()) { + channel = new mozilla::net::GIOChannelChild(aURI); + // set the loadInfo on the new channel + channel->SetLoadInfo(aLoadInfo); + + rv = channel->SetContentType(nsLiteralCString(UNKNOWN_CONTENT_TYPE)); + NS_ENSURE_SUCCESS(rv, rv); + + channel.forget(aResult); + return NS_OK; + } + + RefPtr<nsGIOInputStream> stream = new nsGIOInputStream(spec); + if (!stream) { + return NS_ERROR_OUT_OF_MEMORY; + } + + RefPtr<nsGIOInputStream> tmpStream = stream; + rv = NS_NewInputStreamChannelInternal(aResult, aURI, tmpStream.forget(), + nsLiteralCString(UNKNOWN_CONTENT_TYPE), + ""_ns, // aContentCharset + aLoadInfo); + if (NS_SUCCEEDED(rv)) { + stream->SetChannel(*aResult); + } + + return rv; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::AllowPort(int32_t aPort, const char* aScheme, + bool* aResult) { + // Don't override anything. + *aResult = false; + return NS_OK; +} + +NS_IMETHODIMP +nsGIOProtocolHandler::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) == 0) { + nsCOMPtr<nsIPrefBranch> prefs = do_QueryInterface(aSubject); + InitSupportedProtocolsPref(prefs); + } + return NS_OK; +} |