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;
}
