35#if defined SAILFISH_ACCESS_CONTROL && !defined SYSTEMD
36# error if SAILFISH_ACCESS_CONTROL is defined, SYSTEMD must be defined as well
53#define CONTROL_PENDING_USER_CHANGE_TIMEOUT (3000)
65const char *control_get_external_mode (
void);
66static void control_set_external_mode (
const char *mode);
67void control_clear_external_mode (
void);
68static void control_update_external_mode (
void);
69const char *control_get_target_mode (
void);
70static void control_set_target_mode (
const char *mode);
71void control_clear_target_mode (
void);
76void control_clear_internal_mode (
void);
77static void control_set_usb_mode (
const char *mode);
78void control_mode_switched (
const char *mode);
79static gboolean control_pending_user_change_cb (gpointer aptr);
80static bool control_have_pending_user_change (
void);
81static void control_begin_pending_user_change(
void);
82static void control_end_pending_user_change (
void);
88static bool control_get_enabled (
void);
90static bool control_get_in_rescue_mode (
void);
91static void control_set_in_rescue_mode (
bool in_rescue_mode);
92static void control_rethink_usb_mode (
void);
95void control_clear_cable_state (
void);
106static char *control_external_mode = NULL;
112static char *control_target_mode = NULL;
118static char *control_internal_mode = NULL;
122static char *control_selected_mode = NULL;
130static cable_state_t control_cable_state = CABLE_STATE_UNKNOWN;
134static uid_t control_user_for_mode = UID_UNKNOWN;
138static guint control_pending_user_change_id = 0;
142static bool control_in_rescue_mode =
false;
146static bool control_is_enabled =
false;
159 return control_user_for_mode;
169 LOG_REGISTER_CONTEXT;
171 if( control_user_for_mode != uid ) {
172 log_debug(
"control_user_for_mode: %d -> %d",
173 (
int)control_user_for_mode, (
int)uid);
174 control_user_for_mode = uid;
178const char *control_get_external_mode(
void)
180 LOG_REGISTER_CONTEXT;
185static void control_set_external_mode(
const char *mode)
187 LOG_REGISTER_CONTEXT;
189 gchar *previous = control_external_mode;
190 if( !g_strcmp0(previous, mode) )
193 log_debug(
"external_mode: %s -> %s",
196 control_external_mode = g_strdup(mode);
201 if( !strcmp(control_external_mode,
MODE_ASK) ) {
209 if( strcmp(control_external_mode,
MODE_BUSY) ) {
217 control_set_target_mode(control_external_mode);
224void control_clear_external_mode(
void)
226 LOG_REGISTER_CONTEXT;
228 g_free(control_external_mode),
229 control_external_mode = 0;
232static void control_update_external_mode(
void)
234 LOG_REGISTER_CONTEXT;
237 const char *external_mode = common_map_mode_to_external(internal_mode);
239 control_set_external_mode(external_mode);
242const char *control_get_target_mode(
void)
244 LOG_REGISTER_CONTEXT;
249static void control_set_target_mode(
const char *mode)
251 LOG_REGISTER_CONTEXT;
253 gchar *previous = control_target_mode;
254 if( !g_strcmp0(previous, mode) )
257 log_debug(
"target_mode: %s -> %s",
260 control_target_mode = g_strdup(mode);
275void control_clear_target_mode(
void)
277 LOG_REGISTER_CONTEXT;
279 g_free(control_target_mode),
280 control_target_mode = 0;
289 LOG_REGISTER_CONTEXT;
290 return control_selected_mode;
299 LOG_REGISTER_CONTEXT;
300 char *prev = control_selected_mode;
301 if( g_strcmp0(prev, mode) ) {
302 log_debug(
"requested: %s -> %s", prev, mode);
303 control_selected_mode = mode ? g_strdup(mode) : 0;
315 LOG_REGISTER_CONTEXT;
321 control_rethink_usb_mode();
334 LOG_REGISTER_CONTEXT;
336 return control_internal_mode;
339void control_clear_internal_mode(
void)
341 LOG_REGISTER_CONTEXT;
343 g_free(control_internal_mode),
344 control_internal_mode = 0;
351static void control_set_usb_mode(
const char *mode)
353 LOG_REGISTER_CONTEXT;
358 gchar *previous = control_internal_mode;
359 if( !g_strcmp0(previous, mode) )
362 log_debug(
"internal_mode: %s -> %s",
365 control_internal_mode = g_strdup(mode);
369 control_set_target_mode(control_internal_mode);
375 worker_request_hardware_mode(control_internal_mode);
385void control_mode_switched(
const char *mode)
387 LOG_REGISTER_CONTEXT;
391 if( g_strcmp0(control_internal_mode, mode) ) {
392 log_debug(
"internal_mode: %s -> %s",
393 control_internal_mode, mode);
394 g_free(control_internal_mode),
395 control_internal_mode = g_strdup(mode);
399 control_update_external_mode();
406static gboolean control_pending_user_change_cb(gpointer aptr)
410 if( control_pending_user_change_id ) {
411 log_debug(
"pending user change timeout");
412 control_pending_user_change_id = 0;
413 control_rethink_usb_mode();
416 return G_SOURCE_REMOVE;
421static bool control_have_pending_user_change(
void)
423 return control_pending_user_change_id != 0;
428static void control_begin_pending_user_change(
void)
430 if( !control_pending_user_change_id ) {
431 log_debug(
"pending user change started");
432 control_pending_user_change_id =
434 control_pending_user_change_cb, 0);
440static void control_end_pending_user_change(
void)
442 if( control_pending_user_change_id ) {
443 log_debug(
"pending user change stopped");
444 g_source_remove(control_pending_user_change_id),
445 control_pending_user_change_id = 0;
466 control_begin_pending_user_change();
468 control_end_pending_user_change();
474 control_rethink_usb_mode();
485 control_end_pending_user_change();
487 control_rethink_usb_mode();
494 log_debug(
"in_usermode = %d; in_shutdown = %d",
497 control_rethink_usb_mode();
504 log_debug(
"settings changed");
506 control_rethink_usb_mode();
515 control_rethink_usb_mode();
520static bool control_get_enabled(
void)
522 return control_is_enabled;
529 if( control_is_enabled != enable ) {
530 control_is_enabled = enable;
531 log_debug(
"control_enabled = %d", control_is_enabled);
533 control_rethink_usb_mode();
539static bool control_get_in_rescue_mode(
void)
541 return control_in_rescue_mode;
546static void control_set_in_rescue_mode(
bool in_rescue_mode)
548 if( control_in_rescue_mode != in_rescue_mode ) {
549 log_debug(
"in_rescue_mode: %d -> %d",
550 control_in_rescue_mode, in_rescue_mode);
551 control_in_rescue_mode = in_rescue_mode;
560static void control_rethink_usb_mode(
void)
562 LOG_REGISTER_CONTEXT;
567 const char *mode_to_use = 0;
568 char *mode_to_free = 0;
571 auto const char *use_mode(
const char *mode) {
572 if( g_strcmp0(mode_to_use, mode) ) {
573 log_debug(
"mode_to_use: %s -> %s",
574 mode_to_use ?:
"unset",
581 log_debug(
"re-evaluating usb mode ...");
584 auto const char *use_allocated_mode(
char *mode) {
585 g_free(mode_to_free), mode_to_free = mode;
586 return use_mode(mode_to_free);
593 if( !control_get_enabled() ) {
594 log_debug(
"starting up; mode changes blocked");
603 if( cable_state != CABLE_STATE_PC_CONNECTED ) {
606 control_set_in_rescue_mode(
false);
608 if( cable_state == CABLE_STATE_CHARGER_CONNECTED ) {
627 if( usbmoded_get_rescue_mode() || control_get_in_rescue_mode() ) {
633 use_mode(MODE_DEVELOPER);
634 control_set_in_rescue_mode(
true);
638 control_set_in_rescue_mode(
false);
642 if( usbmoded_get_diag_mode() ) {
647 log_err(
"Diagnostic mode is not configured!");
651 log_debug(
"Entering diagnostic mode!");
667 log_debug(
"in bootup; dynamic modes blocked");
686 log_debug(
"in shutdown, retaining '%s' mode", current_mode);
700 log_debug(
"mode '%s' is not valid", mode_to_use);
703 else if( !usbmoded_is_mode_permitted(mode_to_use, current_user) ) {
706 log_debug(
"mode '%s' is not permitted", mode_to_use);
718 uid_t uid = (current_user == UID_UNKNOWN) ? 0 : current_user;
719 use_allocated_mode(config_get_mode_setting(uid));
726 if( !g_strcmp0(mode_to_use,
MODE_ASK) ) {
727 if( current_user == UID_UNKNOWN ) {
730 log_debug(
"mode '%s' is not applicable", mode_to_use);
735 if( *available && !strchr(available,
',') ) {
736 use_allocated_mode(available), available = 0;
755 else if( !usbmoded_is_mode_permitted(mode_to_use, current_user) ) {
756 log_debug(
"mode '%s' is not permitted", mode_to_use);
772 if( !g_strcmp0(current_mode, mode_to_use) ) {
777 log_debug(
"mode '%s' must be terminated", mode_to_use);
790 if( !g_strcmp0(mode_to_use,
MODE_ASK) ) {
793 log_debug(
"mode '%s' is not applicable", mode_to_use);
796 else if( g_strcmp0(current_mode, mode_to_use) ) {
801 log_debug(
"mode '%s' is not applicable", mode_to_use);
813 log_debug(
"selected mode = %s", mode_to_use);
814 control_set_usb_mode(mode_to_use);
821 g_free(mode_to_free);
830 LOG_REGISTER_CONTEXT;
832 cable_state_t prev = control_cable_state;
833 control_cable_state = cable_state;
835 if( control_cable_state == prev )
838 log_debug(
"control_cable_state: %s -> %s",
839 cable_state_repr(prev),
840 cable_state_repr(control_cable_state));
842 control_rethink_usb_mode();
854 LOG_REGISTER_CONTEXT;
856 return control_cable_state;
859void control_clear_cable_state(
void)
861 LOG_REGISTER_CONTEXT;
863 control_cable_state = CABLE_STATE_UNKNOWN;
872 LOG_REGISTER_CONTEXT;
874 bool connected =
false;
876 case CABLE_STATE_CHARGER_CONNECTED:
877 case CABLE_STATE_PC_CONNECTED:
int common_valid_mode(const char *mode)
gchar * common_get_mode_list(mode_list_type_t type, uid_t uid)
bool common_modename_is_static(const char *modename)
void control_settings_changed(void)
void control_set_cable_state(cable_state_t cable_state)
const char * control_get_usb_mode(void)
void control_device_state_changed(void)
void control_user_changed(void)
#define CONTROL_PENDING_USER_CHANGE_TIMEOUT
uid_t control_get_user_for_mode(void)
bool control_select_mode(const char *mode)
void control_init_done_changed(void)
void control_device_lock_changed(void)
void control_set_enabled(bool enable)
void control_set_selected_mode(const char *mode)
bool control_get_connection_state(void)
cable_state_t control_get_cable_state(void)
void control_set_user_for_mode(uid_t uid)
const char * control_get_selected_mode(void)
void umdbus_send_current_state_signal(const char *state_ind)
void umdbus_send_target_state_signal(const char *state_ind)
void umdbus_send_event_signal(const char *state_ind)
#define MODE_CHARGING_FALLBACK
void usbmoded_refresh_modedata(const char *modename)
bool usbmoded_in_usermode(void)
GList * usbmoded_get_modelist(void)
bool usbmoded_init_done_p(void)
bool usbmoded_in_shutdown(void)
bool usbmoded_can_export(void)
uid_t usbmoded_get_current_user(void)