static void
set_enabled (NMDevice *device, gboolean enabled)
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (device);
NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
gboolean old_available;
int ret;
const char *iface;
iface = nm_device_get_iface (NM_DEVICE (self));
nm_log_dbg (LOGD_WIMAX, "(%s): setting radio enabled %d -> %d",
iface, priv->enabled, enabled);
if (priv->enabled == enabled)
return;
old_available = nm_device_is_available (NM_DEVICE (device));
priv->enabled = enabled;
nm_log_dbg (LOGD_WIMAX, "(%s): radio now %s",
iface, priv->enabled ? "enabled" : "disabled");
/* Set the WiMAX device RF state to the current user-specified enabled state */
if (priv->sdk) {
ret = iwmx_sdk_rf_state_set (priv->sdk,
enabled ? WIMAX_API_RF_ON : WIMAX_API_RF_OFF);
if (ret < 0 && ret != -EINPROGRESS) {
nm_log_warn (LOGD_WIMAX, "(%s): failed to %s radio",
iface, priv->enabled ? "enable" : "disable");
}
}
update_availability (self, old_available);
}
static gboolean
sdk_action_defer_cb (gpointer user_data)
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (user_data);
gboolean old_available = nm_device_is_available (NM_DEVICE (self));
NM_DEVICE_WIMAX_GET_PRIVATE (self)->sdk_action_defer_id = 0;
update_availability (self, old_available);
return FALSE;
}
static void
wmx_state_change_cb (struct wmxsdk *wmxsdk,
WIMAX_API_DEVICE_STATUS new_status,
WIMAX_API_DEVICE_STATUS old_status,
WIMAX_API_STATUS_REASON reason,
WIMAX_API_CONNECTION_PROGRESS_INFO progress,
void *user_data)
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (user_data);
NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
NMDeviceState state;
const char *iface;
gboolean old_available = FALSE;
const char *nsp_name = NULL;
iface = nm_device_get_iface (NM_DEVICE (self));
nm_log_info (LOGD_WIMAX, "(%s): wimax state change %s -> %s (%s (%d))",
iface,
iwmx_sdk_dev_status_to_str (old_status),
iwmx_sdk_dev_status_to_str (new_status),
iwmx_sdk_con_progress_to_str (progress),
progress);
if (new_status == old_status)
return;
state = nm_device_get_state (NM_DEVICE (self));
old_available = nm_device_is_available (NM_DEVICE (self));
priv->status = new_status;
if (priv->current_nsp)
nsp_name = nm_wimax_nsp_get_name (priv->current_nsp);
switch (new_status) {
case WIMAX_API_DEVICE_STATUS_UnInitialized:
case WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW:
case WIMAX_API_DEVICE_STATUS_RF_OFF_HW:
case WIMAX_API_DEVICE_STATUS_RF_OFF_SW:
if (priv->wimaxd_enabled) {
priv->wimaxd_enabled = FALSE;
if (update_availability (self, old_available))
return;
}
break;
case WIMAX_API_DEVICE_STATUS_Connecting:
case WIMAX_API_DEVICE_STATUS_Data_Connected:
/* If for some reason we're initially connected, force a disconnect here */
if (state < NM_DEVICE_STATE_DISCONNECTED)
force_disconnect (self, wmxsdk);
/* Fall through */
case WIMAX_API_DEVICE_STATUS_Ready:
case WIMAX_API_DEVICE_STATUS_Scanning:
if (priv->wimaxd_enabled == FALSE) {
priv->wimaxd_enabled = TRUE;
if (update_availability (self, old_available))
return;
}
break;
default:
nm_log_warn (LOGD_WIMAX, "(%s): unhandled WiMAX device state %d",
iface, new_status);
break;
}
/* Handle activation success and failure */
if (nm_device_is_activating (NM_DEVICE (self))) {
if (new_status == WIMAX_API_DEVICE_STATUS_Data_Connected) {
/* Success */
clear_activation_timeout (self);
nm_log_info (LOGD_WIMAX, "(%s): connected to '%s'",
iface, nsp_name);
nm_device_activate_schedule_stage3_ip_config_start (NM_DEVICE (self));
return;
}
if (priv->connect_failed) {
/* Connection attempt failed */
nm_log_info (LOGD_WIMAX, "(%s): connection to '%s' failed: (%d) %s",
iface, nsp_name, reason, iwmx_sdk_reason_to_str (reason));
nm_device_state_changed (NM_DEVICE (self),
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
return;
}
/* If stage2 was postponed because the device was scanning or something,
* then check if we need to move to stage2 now that the device might be
* ready.
*/
if (state == NM_DEVICE_STATE_PREPARE && priv->prepare_done) {
if ( new_status == WIMAX_API_DEVICE_STATUS_Ready
|| new_status == WIMAX_API_DEVICE_STATUS_Connecting) {
nm_device_activate_schedule_stage2_device_config (NM_DEVICE (self));
return;
}
}
}
/* Handle disconnection */
if (state == NM_DEVICE_STATE_ACTIVATED) {
if ( old_status == WIMAX_API_DEVICE_STATUS_Data_Connected
&& new_status < WIMAX_API_DEVICE_STATUS_Connecting) {
nm_log_info (LOGD_WIMAX, "(%s): disconnected from '%s': (%d) %s",
iface, nsp_name, reason, iwmx_sdk_reason_to_str (reason));
nm_device_state_changed (NM_DEVICE (self),
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
}
}
}
/*
* Read and process poll commands
* Return: -1 for quit command
* 0 otherwise
*/
int process_args(int cmd_argc, char **cmd_argv, Poll **poll_list_ptr) {
// some commands need the poll_list head and others
// require the address of that head
Poll *poll_list = *poll_list_ptr;
if (cmd_argc <= 0) {
return 0;
} else if (strcmp(cmd_argv[0], "quit") == 0 && cmd_argc == 1) {
return -1;
} else if (strcmp(cmd_argv[0], "add_poll") == 0 && cmd_argc == 3) {
if (insert_new_poll(cmd_argv[1], strtol(cmd_argv[2], NULL, 10),
poll_list_ptr) == 1) {
error("Poll by this name already exists");
}
} else if (strcmp(cmd_argv[0], "list_polls") == 0 && cmd_argc == 1) {
print_polls(poll_list);
} else if (strcmp(cmd_argv[0], "configure_poll") == 0 && cmd_argc >= 3) {
int label_count = cmd_argc - 2;
int result = configure_poll(cmd_argv[1], &cmd_argv[2], label_count,
poll_list);
if (result == 1) {
error("Poll by this name does not exist");
} else if (result == 2) {
error("Wrong number of slot labels provided for this poll\n");
}
} else if (strcmp(cmd_argv[0], "add_participant") == 0 && cmd_argc == 4) {
int return_code = add_participant(cmd_argv[1], cmd_argv[2], poll_list,
cmd_argv[3]);
if (return_code == 1) {
error("Poll by this name does not exist");
} else if (return_code == 2) {
error("This Poll already has a participant by this name");
} else if (return_code == 3) {
error("Availability string is wrong size for this poll");
}
} else if (strcmp(cmd_argv[0], "add_comment") == 0 && cmd_argc >= 4) {
// first determine how long a string we need
int space_needed = 0;
int i;
for (i=3; i<cmd_argc; i++) {
space_needed += strlen(cmd_argv[i]) + 1;
}
// allocate the space
char *comment = malloc(space_needed);
if (comment == NULL) {
perror("malloc");
exit(1);
}
// copy in the bits to make a single string
strcpy(comment, cmd_argv[3]);
for (i=4; i<cmd_argc; i++) {
strcat(comment, " ");
strcat(comment, cmd_argv[i]);
}
int return_code = add_comment(cmd_argv[1], cmd_argv[2], comment,
poll_list);
// comment was only used as parameter so we are finished with it now
free(comment);
if (return_code == 1) {
error("There is no poll with this name");
} else if (return_code == 2) {
error("There is no participant by this name in this poll");
}
} else if (strcmp(cmd_argv[0], "update_availability") == 0 && cmd_argc == 4) {
int return_code = update_availability(cmd_argv[1], cmd_argv[2],
cmd_argv[3], poll_list);
if (return_code == 1) {
error("There is no poll with this name");
} else if (return_code == 2) {
error("There is no participant by this name in this poll");
} else if (return_code == 3) {
error("The length of the provided availability does not match"
"number of slots in this poll");
}
} else if (strcmp(cmd_argv[0], "delete_poll") == 0 && cmd_argc == 2) {
if (delete_poll(cmd_argv[1], poll_list_ptr) == 1) {
error("No poll by this name exists");
}
} else if (strcmp(cmd_argv[0], "print_poll_info") == 0 && cmd_argc == 2) {
if (print_poll_info(cmd_argv[1], poll_list) == 1) {
error("No poll by this name exists");
}
} else {
error("Incorrect syntax");
}
return 0;
}
