void server(int sock) { gnutls_session_t s = session(sock, 1); int err; time_t started = time(0); write(sock, &sock, 1); setup_killtimer(); do { await(sock); err = log(gnutls_handshake(s)); reset_killtimer(); } while (err != 0 && !gnutls_error_is_fatal(err)); log_error(err, started); for (;;) { char buffer[8192]; int len; do { await(sock); len = gnutls_record_recv(s, buffer, sizeof(buffer)); reset_killtimer(); } while (len < 0 && !gnutls_error_is_fatal(len)); log_error(len, started); gnutls_record_send(s, buffer, len); exit(0); } }
gboolean gsd_datetime_mechanism_set_date (GsdDatetimeMechanism *mechanism, guint day, guint month, guint year, DBusGMethodInvocation *context) { reset_killtimer (); g_debug ("SetDate(%d, %d, %d) called", day, month, year); return _set_date (mechanism, day, month, year, context); }
gboolean gsd_datetime_mechanism_get_timezone (GsdDatetimeMechanism *mechism, DBusGMethodInvocation *context) { gchar *timezone; reset_killtimer (); timezone = system_timezone_find (); dbus_g_method_return (context, timezone); return TRUE; }
gboolean gsd_datetime_mechanism_set_time (GsdDatetimeMechanism *mechanism, gint64 seconds_since_epoch, DBusGMethodInvocation *context) { struct timeval tv; reset_killtimer (); g_debug ("SetTime(%" G_GINT64_FORMAT ") called", seconds_since_epoch); tv.tv_sec = (time_t) seconds_since_epoch; tv.tv_usec = 0; return _set_time (mechanism, &tv, context); }
gboolean gnome_clock_applet_mechanism_set_time (GnomeClockAppletMechanism *mechanism, gint64 seconds_since_epoch, DBusGMethodInvocation *context) { struct timeval tv; reset_killtimer (); g_debug ("SetTime(%lld) called", seconds_since_epoch); tv.tv_sec = (time_t) seconds_since_epoch; tv.tv_usec = 0; return _set_time (mechanism, &tv, context); }
void client(int sock) { gnutls_session_t s = session(sock, 0); int err = 0; time_t started = time(0); setup_killtimer(); do { await(sock); err = log(gnutls_handshake(s)); reset_killtimer(); } while (err != 0 && !gnutls_error_is_fatal(err)); log_error(err, started); started = time(0); const char* line = "foobar!"; do { err = gnutls_record_send(s, line, strlen(line)); reset_killtimer(); } while (err < 0 && !gnutls_error_is_fatal(err)); log_error(err, started); char buffer[8192]; int len; do { await(sock); len = gnutls_record_recv(s, buffer, sizeof(buffer)); } while (len < 0 && !gnutls_error_is_fatal(len)); if (len > 0 && strcmp(line, buffer) == 0) { exit(0); } else { log(len); exit(1); } }
gboolean cpufreq_selector_service_can_set (CPUFreqSelectorService *service, DBusGMethodInvocation *context) { PolkitSubject *subject; PolkitAuthorizationResult *result; gchar *sender; gboolean ret; GError *error = NULL; reset_killtimer (); sender = dbus_g_method_get_sender (context); subject = polkit_system_bus_name_new (sender); g_free (sender); result = polkit_authority_check_authorization_sync (service->authority, subject, "org.consort.cpufreqselector", NULL, 0, NULL, &error); g_object_unref (subject); if (error) { dbus_g_method_return_error (context, error); g_error_free (error); return FALSE; } if (polkit_authorization_result_get_is_authorized (result)) { ret = TRUE; } else if (polkit_authorization_result_get_is_challenge (result)) { ret = TRUE; } else { ret = FALSE; } g_object_unref (result); dbus_g_method_return (context, ret); return TRUE; }
gboolean gsd_datetime_mechanism_set_timezone (GsdDatetimeMechanism *mechanism, const char *tz, DBusGMethodInvocation *context) { GError *error; reset_killtimer (); g_debug ("SetTimezone('%s') called", tz); if (!_check_polkit_for_action (mechanism, context)) return FALSE; error = NULL; if (!gsd_datetime_check_tz_name (tz, &error)) return FALSE; if (!system_timezone_set (tz, &error)) { GError *error2; int code; if (error->code == SYSTEM_TIMEZONE_ERROR_INVALID_TIMEZONE_FILE) code = GSD_DATETIME_MECHANISM_ERROR_INVALID_TIMEZONE_FILE; else code = GSD_DATETIME_MECHANISM_ERROR_GENERAL; error2 = g_error_new (GSD_DATETIME_MECHANISM_ERROR, code, "%s", error->message); g_error_free (error); dbus_g_method_return_error (context, error2); g_error_free (error2); return FALSE; } dbus_g_method_return (context); return TRUE; }
static gboolean register_mechanism (GsdDatetimeMechanism *mechanism) { GError *error = NULL; mechanism->priv->auth = polkit_authority_get_sync (NULL, &error); if (mechanism->priv->auth == NULL) { if (error != NULL) { g_critical ("error getting system bus: %s", error->message); g_error_free (error); } goto error; } mechanism->priv->system_bus_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (mechanism->priv->system_bus_connection == NULL) { if (error != NULL) { g_critical ("error getting system bus: %s", error->message); g_error_free (error); } goto error; } dbus_g_connection_register_g_object (mechanism->priv->system_bus_connection, "/", G_OBJECT (mechanism)); mechanism->priv->system_bus_proxy = dbus_g_proxy_new_for_name (mechanism->priv->system_bus_connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); reset_killtimer (); return TRUE; error: return FALSE; }
gboolean gnome_clock_applet_mechanism_set_timezone (GnomeClockAppletMechanism *mechanism, const char *zone_file, DBusGMethodInvocation *context) { GError *error; reset_killtimer (); g_debug ("SetTimezone('%s') called", zone_file); if (!_check_polkit_for_action (mechanism, context, "org.gnome.clockapplet.mechanism.settimezone")) return FALSE; error = NULL; if (!system_timezone_set_from_file (zone_file, &error)) { GError *error2; int code; if (error->code == SYSTEM_TIMEZONE_ERROR_INVALID_TIMEZONE_FILE) code = GNOME_CLOCK_APPLET_MECHANISM_ERROR_INVALID_TIMEZONE_FILE; else code = GNOME_CLOCK_APPLET_MECHANISM_ERROR_GENERAL; error2 = g_error_new (GNOME_CLOCK_APPLET_MECHANISM_ERROR, code, error->message); g_error_free (error); dbus_g_method_return_error (context, error2); g_error_free (error2); return FALSE; } dbus_g_method_return (context); return TRUE; }
gboolean gsd_datetime_mechanism_adjust_time (GsdDatetimeMechanism *mechanism, gint64 seconds_to_add, DBusGMethodInvocation *context) { struct timeval tv; reset_killtimer (); g_debug ("AdjustTime(%" G_GINT64_FORMAT " ) called", seconds_to_add); if (gettimeofday (&tv, NULL) != 0) { GError *error; error = g_error_new (GSD_DATETIME_MECHANISM_ERROR, GSD_DATETIME_MECHANISM_ERROR_GENERAL, "Error calling gettimeofday(): %s", strerror (errno)); dbus_g_method_return_error (context, error); g_error_free (error); return FALSE; } tv.tv_sec += (time_t) seconds_to_add; return _set_time (mechanism, &tv, context); }
gboolean gnome_clock_applet_mechanism_adjust_time (GnomeClockAppletMechanism *mechanism, gint64 seconds_to_add, DBusGMethodInvocation *context) { struct timeval tv; reset_killtimer (); g_debug ("AdjustTime(%lld) called", seconds_to_add); if (gettimeofday (&tv, NULL) != 0) { GError *error; error = g_error_new (GNOME_CLOCK_APPLET_MECHANISM_ERROR, GNOME_CLOCK_APPLET_MECHANISM_ERROR_GENERAL, "Error calling gettimeofday(): %s", strerror (errno)); dbus_g_method_return_error (context, error); g_error_free (error); return FALSE; } tv.tv_sec += (time_t) seconds_to_add; return _set_time (mechanism, &tv, context); }
static gboolean register_mechanism (GnomeClockAppletMechanism *mechanism) { GError *error = NULL; mechanism->priv->pol_ctx = polkit_context_new (); polkit_context_set_io_watch_functions (mechanism->priv->pol_ctx, pk_io_add_watch, pk_io_remove_watch); if (!polkit_context_init (mechanism->priv->pol_ctx, NULL)) { g_critical ("cannot initialize libpolkit"); goto error; } error = NULL; mechanism->priv->system_bus_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (mechanism->priv->system_bus_connection == NULL) { if (error != NULL) { g_critical ("error getting system bus: %s", error->message); g_error_free (error); } goto error; } dbus_g_connection_register_g_object (mechanism->priv->system_bus_connection, "/", G_OBJECT (mechanism)); mechanism->priv->system_bus_proxy = dbus_g_proxy_new_for_name (mechanism->priv->system_bus_connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); reset_killtimer (); return TRUE; error: return FALSE; }
gboolean cpufreq_selector_service_set_governor (CPUFreqSelectorService *service, guint cpu, const gchar *governor, DBusGMethodInvocation *context) { CPUFreqSelector *selector; GError *error = NULL; reset_killtimer (); if (!cpufreq_selector_service_check_policy (service, context, &error)) { dbus_g_method_return_error (context, error); g_error_free (error); return FALSE; } if (cpu > MAX_CPUS) { GError *err; err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Error setting governor on cpu %d: Invalid cpu", cpu); dbus_g_method_return_error (context, err); g_error_free (err); return FALSE; } selector = get_selector_for_cpu (service, cpu); if (!selector) { GError *err; err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Error setting governor on cpu %d: No cpufreq support", cpu); dbus_g_method_return_error (context, err); g_error_free (err); return FALSE; } cpufreq_selector_set_governor (selector, governor, &error); if (error) { GError *err; err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Error setting governor %s on cpu %d: %s", governor, cpu, error->message); dbus_g_method_return_error (context, err); g_error_free (err); g_error_free (error); return FALSE; } dbus_g_method_return (context); return TRUE; }
gboolean cpufreq_selector_service_register (CPUFreqSelectorService *service, GError **error) { DBusGConnection *connection; DBusGProxy *bus_proxy; gboolean res; guint result; GError *err = NULL; if (service->system_bus) { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_ALREADY_REGISTERED, "Service %s already registered", BUS_NAME); return FALSE; } connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err); if (!connection) { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Couldn't connect to system bus: %s", err->message); g_error_free (err); return FALSE; } bus_proxy = dbus_g_proxy_new_for_name (connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); if (!bus_proxy) { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Could not construct bus_proxy object"); return FALSE; } res = dbus_g_proxy_call (bus_proxy, "RequestName", &err, G_TYPE_STRING, BUS_NAME, G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID); g_object_unref (bus_proxy); if (!res) { if (err) { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Failed to acquire %s: %s", BUS_NAME, err->message); g_error_free (err); } else { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_DBUS, "Failed to acquire %s", BUS_NAME); } return FALSE; } if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) { g_set_error (error, CPUFREQ_SELECTOR_SERVICE_ERROR, SERVICE_ERROR_ALREADY_REGISTERED, "Service %s already registered", BUS_NAME); return FALSE; } service->authority = polkit_authority_get (); service->system_bus = connection; dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE, &dbus_glib_cpufreq_selector_service_object_info); dbus_g_connection_register_g_object (connection, "/org/gnome/cpufreq_selector/selector", G_OBJECT (service)); dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL, CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR); reset_killtimer (); return TRUE; }