X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgdbusaddress.c;h=8c1d31c76876e3d64c8f7b22f9bf191f76c763f4;hb=b8c13a01b6bd5601eb3519dd3b20daed4bbc2e72;hp=c4895913bb1558241cc01462868d9b4be0926ae2;hpb=be247379f003bbb619a71f351e53fba14eec7a15;p=platform%2Fupstream%2Fglib.git diff --git a/gio/gdbusaddress.c b/gio/gdbusaddress.c index c489591..8c1d31c 100644 --- a/gio/gdbusaddress.c +++ b/gio/gdbusaddress.c @@ -24,7 +24,8 @@ #include #include -#include +#include +#include #include "gioerror.h" #include "gdbusutils.h" @@ -36,14 +37,22 @@ #include "giostream.h" #include "gasyncresult.h" #include "gsimpleasyncresult.h" +#include "glib-private.h" #include "gdbusprivate.h" +#include "giomodule-priv.h" +#include "gdbusdaemon.h" #ifdef G_OS_UNIX #include #endif +#ifdef G_OS_WIN32 +#include +#include +#include +#endif + #include "glibintl.h" -#include "gioalias.h" /** * SECTION:gdbusaddress @@ -149,19 +158,16 @@ is_valid_unix (const gchar *address_entry, { if (tmpdir != NULL || abstract != NULL) goto meaningless; - /* TODO: validate path */ } else if (tmpdir != NULL) { if (path != NULL || abstract != NULL) goto meaningless; - /* TODO: validate tmpdir */ } else if (abstract != NULL) { if (path != NULL || tmpdir != NULL) goto meaningless; - /* TODO: validate abstract */ } else { @@ -260,6 +266,13 @@ is_valid_nonce_tcp (const gchar *address_entry, goto out; } + if (host != NULL) + { + /* TODO: validate host */ + } + + nonce_file = nonce_file; /* To avoid -Wunused-but-set-variable */ + ret= TRUE; out: @@ -334,6 +347,11 @@ is_valid_tcp (const gchar *address_entry, goto out; } + if (host != NULL) + { + /* TODO: validate host */ + } + ret= TRUE; out: @@ -433,7 +451,7 @@ _g_dbus_address_parse_entry (const gchar *address_entry, g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, - _("Address element `%s', does not contain a colon (:)"), + _("Address element `%s' does not contain a colon (:)"), address_entry); goto out; } @@ -454,16 +472,28 @@ _g_dbus_address_parse_entry (const gchar *address_entry, g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, - _("Key/Value pair %d, `%s', in address element `%s', does not contain an equal sign"), + _("Key/Value pair %d, `%s', in address element `%s' does not contain an equal sign"), n, kv_pair, address_entry); goto out; } - /* TODO: actually validate that no illegal characters are present before and after then '=' sign */ key = g_uri_unescape_segment (kv_pair, s, NULL); value = g_uri_unescape_segment (s + 1, kv_pair + strlen (kv_pair), NULL); + if (key == NULL || value == NULL) + { + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_INVALID_ARGUMENT, + _("Error unescaping key or value in Key/Value pair %d, `%s', in address element `%s'"), + n, + kv_pair, + address_entry); + g_free (key); + g_free (value); + goto out; + } g_hash_table_insert (key_value_pairs, key, value); } @@ -558,7 +588,7 @@ g_dbus_address_connect (const gchar *address_entry, { const gchar *s; const gchar *host; - guint port; + glong port; gchar *endp; gboolean is_nonce; @@ -604,7 +634,7 @@ g_dbus_address_connect (const gchar *address_entry, } } - /* TODO: deal with family */ + /* TODO: deal with family key/value-pair */ connectable = g_network_address_new (host, port); } else if (g_strcmp0 (address_entry, "autolaunch:") == 0) @@ -652,49 +682,67 @@ g_dbus_address_connect (const gchar *address_entry, if (nonce_file != NULL) { - gchar *nonce_contents; - gsize nonce_length; + gchar nonce_contents[16 + 1]; + size_t num_bytes_read; + FILE *f; - /* TODO: too dangerous to read the entire file? (think denial-of-service etc.) */ - if (!g_file_get_contents (nonce_file, - &nonce_contents, - &nonce_length, - error)) + /* be careful to read only 16 bytes - we also check that the file is only 16 bytes long */ + f = fopen (nonce_file, "rb"); + if (f == NULL) { - g_prefix_error (error, _("Error reading nonce file `%s':"), nonce_file); + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_INVALID_ARGUMENT, + _("Error opening nonce file `%s': %s"), + nonce_file, + g_strerror (errno)); g_object_unref (ret); ret = NULL; goto out; } - - if (nonce_length != 16) + num_bytes_read = fread (nonce_contents, + sizeof (gchar), + 16 + 1, + f); + if (num_bytes_read != 16) { - g_set_error (error, - G_IO_ERROR, - G_IO_ERROR_INVALID_ARGUMENT, - _("The nonce-file `%s' was %" G_GSIZE_FORMAT " bytes. Expected 16 bytes."), - nonce_file, - nonce_length); - g_free (nonce_contents); + if (num_bytes_read == 0) + { + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_INVALID_ARGUMENT, + _("Error reading from nonce file `%s': %s"), + nonce_file, + g_strerror (errno)); + } + else + { + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_INVALID_ARGUMENT, + _("Error reading from nonce file `%s', expected 16 bytes, got %d"), + nonce_file, + (gint) num_bytes_read); + } g_object_unref (ret); ret = NULL; + fclose (f); goto out; } + fclose (f); if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret), nonce_contents, - nonce_length, + 16, NULL, cancellable, error)) { - g_prefix_error (error, _("Error write contents of nonce file `%s' to stream:"), nonce_file); + g_prefix_error (error, _("Error writing contents of nonce file `%s' to stream:"), nonce_file); g_object_unref (ret); ret = NULL; - g_free (nonce_contents); goto out; } - g_free (nonce_contents); } } @@ -732,7 +780,6 @@ g_dbus_address_try_connect_one (const gchar *address_entry, if (ret == NULL) goto out; - /* TODO: validate that guid is of correct format */ guid = g_hash_table_lookup (key_value_pairs, "guid"); if (guid != NULL && out_guid != NULL) *out_guid = g_strdup (guid); @@ -779,16 +826,13 @@ get_stream_thread_func (GSimpleAsyncResult *res, cancellable, &error); if (data->stream == NULL) - { - g_simple_async_result_set_from_error (res, error); - g_error_free (error); - } + g_simple_async_result_take_error (res, error); } /** * g_dbus_address_get_stream: * @address: A valid D-Bus address. - * @cancellable: A #GCancellable or %NULL. + * @cancellable: (allow-none): A #GCancellable or %NULL. * @callback: A #GAsyncReadyCallback to call when the request is satisfied. * @user_data: Data to pass to @callback. * @@ -820,6 +864,7 @@ g_dbus_address_get_stream (const gchar *address, callback, user_data, g_dbus_address_get_stream); + g_simple_async_result_set_check_cancellable (res, cancellable); data = g_new0 (GetStreamData, 1); data->address = g_strdup (address); g_simple_async_result_set_op_res_gpointer (res, @@ -840,7 +885,7 @@ g_dbus_address_get_stream (const gchar *address, * * Finishes an operation started with g_dbus_address_get_stream(). * - * Returns: A #GIOStream or %NULL if @error is set. + * Returns: (transfer full): A #GIOStream or %NULL if @error is set. * * Since: 2.26 */ @@ -876,7 +921,7 @@ g_dbus_address_get_stream_finish (GAsyncResult *res, * g_dbus_address_get_stream_sync: * @address: A valid D-Bus address. * @out_guid: %NULL or return location to store the GUID extracted from @address, if any. - * @cancellable: A #GCancellable or %NULL. + * @cancellable: (allow-none): A #GCancellable or %NULL. * @error: Return location for error or %NULL. * * Synchronously connects to an endpoint specified by @address and @@ -886,7 +931,7 @@ g_dbus_address_get_stream_finish (GAsyncResult *res, * This is a synchronous failable function. See * g_dbus_address_get_stream() for the asynchronous version. * - * Returns: A #GIOStream or %NULL if @error is set. + * Returns: (transfer full): A #GIOStream or %NULL if @error is set. * * Since: 2.26 */ @@ -908,7 +953,7 @@ g_dbus_address_get_stream_sync (const gchar *address, last_error = NULL; addr_array = g_strsplit (address, ";", 0); - if (addr_array[0] == NULL) + if (addr_array != NULL && addr_array[0] == NULL) { last_error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, @@ -978,6 +1023,14 @@ get_session_address_dbus_launch (GError **error) restore_dbus_verbose = FALSE; old_dbus_verbose = NULL; + /* Don't run binaries as root if we're setuid. */ + if (GLIB_PRIVATE_CALL (g_check_setuid) ()) + { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, + _("Cannot spawn a message bus when setuid")); + goto out; + } + machine_id = _g_dbus_get_machine_id (error); if (machine_id == NULL) { @@ -1018,36 +1071,12 @@ get_session_address_dbus_launch (GError **error) &exit_status, error)) { - g_prefix_error (error, _("Error spawning command line `%s': "), command_line); goto out; } - if (!WIFEXITED (exit_status)) + if (!g_spawn_check_exit_status (exit_status, error)) { - gchar *escaped_stderr; - escaped_stderr = g_strescape (launch_stderr, ""); - g_set_error (error, - G_IO_ERROR, - G_IO_ERROR_FAILED, - _("Abnormal program termination spawning command line `%s': %s"), - command_line, - escaped_stderr); - g_free (escaped_stderr); - goto out; - } - - if (WEXITSTATUS (exit_status) != 0) - { - gchar *escaped_stderr; - escaped_stderr = g_strescape (launch_stderr, ""); - g_set_error (error, - G_IO_ERROR, - G_IO_ERROR_FAILED, - _("Command line `%s' exited with non-zero exit status %d: %s"), - command_line, - WEXITSTATUS (exit_status), - escaped_stderr); - g_free (escaped_stderr); + g_prefix_error (error, _("Error spawning command line `%s': "), command_line); goto out; } @@ -1101,17 +1130,311 @@ get_session_address_dbus_launch (GError **error) } #endif +#ifdef G_OS_WIN32 + +#define DBUS_DAEMON_ADDRESS_INFO "DBusDaemonAddressInfo" +#define DBUS_DAEMON_MUTEX "DBusDaemonMutex" +#define UNIQUE_DBUS_INIT_MUTEX "UniqueDBusInitMutex" +#define DBUS_AUTOLAUNCH_MUTEX "DBusAutolaunchMutex" + +static void +release_mutex (HANDLE mutex) +{ + ReleaseMutex (mutex); + CloseHandle (mutex); +} + +static HANDLE +acquire_mutex (const char *mutexname) +{ + HANDLE mutex; + DWORD res; + + mutex = CreateMutexA (NULL, FALSE, mutexname); + if (!mutex) + return 0; + + res = WaitForSingleObject (mutex, INFINITE); + switch (res) + { + case WAIT_ABANDONED: + release_mutex (mutex); + return 0; + case WAIT_FAILED: + case WAIT_TIMEOUT: + return 0; + } + + return mutex; +} + +static gboolean +is_mutex_owned (const char *mutexname) +{ + HANDLE mutex; + gboolean res = FALSE; + + mutex = CreateMutexA (NULL, FALSE, mutexname); + if (WaitForSingleObject (mutex, 10) == WAIT_TIMEOUT) + res = TRUE; + else + ReleaseMutex (mutex); + CloseHandle (mutex); + + return res; +} + +static char * +read_shm (const char *shm_name) +{ + HANDLE shared_mem; + char *shared_data; + char *res; + int i; + + res = NULL; + + for (i = 0; i < 20; i++) + { + shared_mem = OpenFileMappingA (FILE_MAP_READ, FALSE, shm_name); + if (shared_mem != 0) + break; + Sleep (100); + } + + if (shared_mem != 0) + { + shared_data = MapViewOfFile (shared_mem, FILE_MAP_READ, 0, 0, 0); + if (shared_data != NULL) + { + res = g_strdup (shared_data); + UnmapViewOfFile (shared_data); + } + CloseHandle (shared_mem); + } + + return res; +} + +static HANDLE +set_shm (const char *shm_name, const char *value) +{ + HANDLE shared_mem; + char *shared_data; + + shared_mem = CreateFileMappingA (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, + 0, strlen (value) + 1, shm_name); + if (shared_mem == 0) + return 0; + + shared_data = MapViewOfFile (shared_mem, FILE_MAP_WRITE, 0, 0, 0 ); + if (shared_data == NULL) + return 0; + + strcpy (shared_data, value); + + UnmapViewOfFile (shared_data); + + return shared_mem; +} + +/* These keep state between publish_session_bus and unpublish_session_bus */ +static HANDLE published_daemon_mutex; +static HANDLE published_shared_mem; + +static gboolean +publish_session_bus (const char *address) +{ + HANDLE init_mutex; + + init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX); + + published_daemon_mutex = CreateMutexA (NULL, FALSE, DBUS_DAEMON_MUTEX); + if (WaitForSingleObject (published_daemon_mutex, 10 ) != WAIT_OBJECT_0) + { + release_mutex (init_mutex); + CloseHandle (published_daemon_mutex); + published_daemon_mutex = NULL; + return FALSE; + } + + published_shared_mem = set_shm (DBUS_DAEMON_ADDRESS_INFO, address); + if (!published_shared_mem) + { + release_mutex (init_mutex); + CloseHandle (published_daemon_mutex); + published_daemon_mutex = NULL; + return FALSE; + } + + release_mutex (init_mutex); + return TRUE; +} + +static void +unpublish_session_bus (void) +{ + HANDLE init_mutex; + + init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX); + + CloseHandle (published_shared_mem); + published_shared_mem = NULL; + + release_mutex (published_daemon_mutex); + published_daemon_mutex = NULL; + + release_mutex (init_mutex); +} + +static void +wait_console_window (void) +{ + FILE *console = fopen ("CONOUT$", "w"); + + SetConsoleTitleW (L"gdbus-daemon output. Type any character to close this window."); + fprintf (console, _("(Type any character to close this window)\n")); + fflush (console); + _getch (); +} + +static void +open_console_window (void) +{ + if (((HANDLE) _get_osfhandle (fileno (stdout)) == INVALID_HANDLE_VALUE || + (HANDLE) _get_osfhandle (fileno (stderr)) == INVALID_HANDLE_VALUE) && AllocConsole ()) + { + if ((HANDLE) _get_osfhandle (fileno (stdout)) == INVALID_HANDLE_VALUE) + freopen ("CONOUT$", "w", stdout); + + if ((HANDLE) _get_osfhandle (fileno (stderr)) == INVALID_HANDLE_VALUE) + freopen ("CONOUT$", "w", stderr); + + SetConsoleTitleW (L"gdbus-daemon debug output."); + + atexit (wait_console_window); + } +} +static void +idle_timeout_cb (GDBusDaemon *daemon, gpointer user_data) +{ + GMainLoop *loop = user_data; + g_main_loop_quit (loop); +} + +__declspec(dllexport) void CALLBACK g_win32_run_session_bus (HWND hwnd, HINSTANCE hinst, char *cmdline, int nCmdShow); + +__declspec(dllexport) void CALLBACK +g_win32_run_session_bus (HWND hwnd, HINSTANCE hinst, char *cmdline, int nCmdShow) +{ + GDBusDaemon *daemon; + GMainLoop *loop; + const char *address; + GError *error = NULL; + + if (g_getenv ("GDBUS_DAEMON_DEBUG") != NULL) + open_console_window (); + + loop = g_main_loop_new (NULL, FALSE); + + address = "nonce-tcp:"; + daemon = _g_dbus_daemon_new (address, NULL, &error); + if (daemon == NULL) + { + g_printerr ("Can't init bus: %s\n", error->message); + return; + } + + g_signal_connect (daemon, "idle-timeout", G_CALLBACK (idle_timeout_cb), loop); + + if ( publish_session_bus (_g_dbus_daemon_get_address (daemon))) + { + g_main_loop_run (loop); + + unpublish_session_bus (); + } + + g_main_loop_unref (loop); + g_object_unref (daemon); +} + +static gchar * +get_session_address_dbus_launch (GError **error) +{ + HANDLE autolaunch_mutex, init_mutex; + char *address = NULL; + wchar_t gio_path[MAX_PATH+1+200]; + + autolaunch_mutex = acquire_mutex (DBUS_AUTOLAUNCH_MUTEX); + + init_mutex = acquire_mutex (UNIQUE_DBUS_INIT_MUTEX); + + if (is_mutex_owned (DBUS_DAEMON_MUTEX)) + address = read_shm (DBUS_DAEMON_ADDRESS_INFO); + + release_mutex (init_mutex); + + if (address == NULL) + { + gio_path[MAX_PATH] = 0; + if (GetModuleFileNameW (_g_io_win32_get_module (), gio_path, MAX_PATH)) + { + PROCESS_INFORMATION pi = { 0 }; + STARTUPINFOW si = { 0 }; + BOOL res; + wchar_t gio_path_short[MAX_PATH]; + wchar_t rundll_path[MAX_PATH*2]; + wchar_t args[MAX_PATH*4]; + + GetShortPathNameW (gio_path, gio_path_short, MAX_PATH); + + GetWindowsDirectoryW (rundll_path, MAX_PATH); + wcscat (rundll_path, L"\\rundll32.exe"); + if (GetFileAttributesW (rundll_path) == INVALID_FILE_ATTRIBUTES) + { + GetSystemDirectoryW (rundll_path, MAX_PATH); + wcscat (rundll_path, L"\\rundll32.exe"); + } + + wcscpy (args, L"\""); + wcscat (args, rundll_path); + wcscat (args, L"\" "); + wcscat (args, gio_path_short); + wcscat (args, L",g_win32_run_session_bus@16"); + + res = CreateProcessW (rundll_path, args, + 0, 0, FALSE, + NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW | DETACHED_PROCESS, + 0, NULL /* TODO: Should be root */, + &si, &pi); + if (res) + address = read_shm (DBUS_DAEMON_ADDRESS_INFO); + } + } + + release_mutex (autolaunch_mutex); + + if (address == NULL) + g_set_error (error, + G_IO_ERROR, + G_IO_ERROR_FAILED, + _("Session dbus not running, and autolaunch failed")); + + return address; +} +#endif + /* ---------------------------------------------------------------------------------------------------- */ -/* TODO: implement for UNIX, Win32 and OS X */ static gchar * get_session_address_platform_specific (GError **error) { gchar *ret; -#ifdef G_OS_UNIX +#if defined (G_OS_UNIX) || defined(G_OS_WIN32) /* need to handle OS X in a different way since `dbus-launch --autolaunch' probably won't work there */ ret = get_session_address_dbus_launch (error); #else + /* TODO: implement for OS X */ ret = NULL; g_set_error (error, G_IO_ERROR, @@ -1126,7 +1449,7 @@ get_session_address_platform_specific (GError **error) /** * g_dbus_address_get_for_bus_sync: * @bus_type: A #GBusType. - * @cancellable: A #GCancellable or %NULL. + * @cancellable: (allow-none): A #GCancellable or %NULL. * @error: Return location for error or %NULL. * * Synchronously looks up the D-Bus address for the well-known message @@ -1253,7 +1576,7 @@ g_dbus_address_get_for_bus_sync (GBusType bus_type, { g_print ("GDBus-debug:Address: Cannot look-up address bus type `%s': %s\n", _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type), - local_error->message); + local_error ? local_error->message : ""); } _g_dbus_debug_print_unlock (); } @@ -1263,6 +1586,3 @@ g_dbus_address_get_for_bus_sync (GBusType bus_type, return ret; } - -#define __G_DBUS_ADDRESS_C__ -#include "gioaliasdef.c"