colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

api: new carrier lock support

Browse Source 
Adding support for carrier lock for MBIM modems using google simlock
mechanism.
This commit is contained in:
Ujjwal Pande
2023-05-25 21:42:01 +00:00
committed by Aleksander Morgado
parent 97c32d6e51
commit e3a1206c57
9 changed files with 404 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
cli/mmcli-modem-3gpp.c
View File

@@ -54,6 +54,7 @@ static gchar *set_initial_eps_bearer_settings_str;
static gchar *disable_facility_lock_str;
static gchar *set_packet_service_state_str;
static gchar *set_nr5g_registration_settings_str;
static gchar *set_carrier_lock_str;
static GOptionEntry entries[] = {
{ "3gpp-scan", 0, 0, G_OPTION_ARG_NONE, &scan_flag,
@@ -88,6 +89,10 @@ static GOptionEntry entries[] = {
"Set 5GNR registration settings",
"[\"key=value,...\"]"
},
{ "3gpp-set-carrier-lock", 0, 0, G_OPTION_ARG_STRING, &set_carrier_lock_str,
"Carrier Lock",
"[(Data)]"
},
{ NULL }
};
@@ -122,7 +127,8 @@ mmcli_modem_3gpp_options_enabled (void)
!!set_initial_eps_bearer_settings_str +
!!disable_facility_lock_str +
!!set_packet_service_state_str +
!!set_nr5g_registration_settings_str);
!!set_nr5g_registration_settings_str +
!!set_carrier_lock_str);
if (n_actions > 1) {
g_printerr ("error: too many 3GPP actions requested\n");
@@ -420,6 +426,32 @@ set_nr5g_registration_settings_ready (MMModem3gpp *modem_3gpp,
mmcli_async_operation_done ();
}
static void
set_carrier_lock_process_reply (gboolean result,
const GError *error)
{
if (!result) {
g_printerr ("error: couldn't send carrier lock information: '%s'\n",
error ? error->message : "unknown error");
exit (EXIT_FAILURE);
}
g_print ("successfully sent carrier lock information to modem\n");
}
static void
set_carrier_lock_ready (MMModem3gpp *modem_3gpp,
GAsyncResult *result)
{
gboolean operation_result;
g_autoptr(GError) error = NULL;
operation_result = mm_modem_3gpp_set_carrier_lock_finish (modem_3gpp, result, &error);
set_carrier_lock_process_reply (operation_result, error);
mmcli_async_operation_done ();
}
static void
get_modem_ready (GObject *source,
GAsyncResult *result)
@@ -455,6 +487,28 @@ get_modem_ready (GObject *source,
return;
}
/* Request to set carrier Lock */
if (set_carrier_lock_str) {
gsize data_size = 0;
g_autofree guint8 *data = NULL;
GError *error = NULL;
data = mm_utils_hexstr2bin (set_carrier_lock_str, -1, &data_size, &error);
if (!data) {
g_printerr ("Failed to read data from the input: %s\n", error->message);
exit (EXIT_FAILURE);
return;
}
mm_modem_3gpp_set_carrier_lock (ctx->modem_3gpp,
data,
(guint32)data_size,
ctx->cancellable,
(GAsyncReadyCallback)set_carrier_lock_ready,
NULL);
return;
}
ensure_modem_enabled ();
/* Request to scan networks? */
@@ -617,6 +671,28 @@ mmcli_modem_3gpp_run_synchronous (GDBusConnection *connection)
return;
}
/* Request to set carrier Lock */
if (set_carrier_lock_str) {
gsize data_size = 0;
g_autofree guint8 *data = NULL;
gboolean result;
data = mm_utils_hexstr2bin (set_carrier_lock_str, -1, &data_size, &error);
if (!data) {
g_printerr ("Failed to read data from the input: %s\n", error->message);
exit (EXIT_FAILURE);
return;
}
result = mm_modem_3gpp_set_carrier_lock_sync (ctx->modem_3gpp,
data,
(guint32)data_size,
NULL,
&error);
set_carrier_lock_process_reply (result, error);
return;
}
ensure_modem_enabled ();
/* Request to register the modem? */

4
data/org.freedesktop.ModemManager1.conf.polkit
View File

@@ -128,6 +128,10 @@
send_interface="org.freedesktop.ModemManager1.Modem.Modem3gpp"
send_member="DisableFacilityLock"/>
<allow send_destination="org.freedesktop.ModemManager1"
send_interface="org.freedesktop.ModemManager1.Modem.Modem3gpp"
send_member="SetCarrierLock"/>
<!-- org.freedesktop.ModemManager1.Modem.ModemCdma.xml -->
<!-- Protected by the Device.Control policy rule -->

6
docs/reference/libmm-glib/libmm-glib-sections.txt
View File

@@ -576,6 +576,9 @@ mm_modem_3gpp_set_packet_service_state_sync
mm_modem_3gpp_set_nr5g_registration_settings
mm_modem_3gpp_set_nr5g_registration_settings_finish
mm_modem_3gpp_set_nr5g_registration_settings_sync
mm_modem_3gpp_set_carrier_lock
mm_modem_3gpp_set_carrier_lock_finish
mm_modem_3gpp_set_carrier_lock_sync
<SUBSECTION Standard>
MMModem3gppClass
MMModem3gppPrivate
@@ -2417,6 +2420,9 @@ mm_gdbus_modem3gpp_call_register_sync
mm_gdbus_modem3gpp_call_scan
mm_gdbus_modem3gpp_call_scan_finish
mm_gdbus_modem3gpp_call_scan_sync
mm_gdbus_modem3gpp_call_set_carrier_lock
mm_gdbus_modem3gpp_call_set_carrier_lock_finish
mm_gdbus_modem3gpp_call_set_carrier_lock_sync
mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation
mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish
mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync

14
introspection/org.freedesktop.ModemManager1.Modem.Modem3gpp.xml
View File

@@ -229,6 +229,20 @@
<arg name="properties" type="(us)" direction="in" />
</method>
<!--
SetCarrierLock:
@data: The list of carrier network information to be sent to be configured.
Command to send the list of carrier network information to the modem.
Since: 1.22
-->
<method name="SetCarrierLock">
<arg name="data" type="ay" direction="in">
<annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
</arg>
</method>
<!--
SetPacketServiceState:
@state: a <link linkend="MMModem3gppPacketServiceState">MMModem3gppPacketServiceState</link>.

95
libmm-glib/mm-modem-3gpp.c
View File

@@ -1510,6 +1510,101 @@ mm_modem_3gpp_set_nr5g_registration_settings_sync (MMModem3gpp *
/*****************************************************************************/
/**
* mm_modem_3gpp_set_carrier_lock_finish:
* @self: A #MMModem3gpp.
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
* @error: Return location for error or %NULL.
*
* Finishes an operation started with mm_modem_3gpp_set_carrier_lock().
*
* Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
* Since: 1.22
*/
gboolean
mm_modem_3gpp_set_carrier_lock_finish (MMModem3gpp *self,
GAsyncResult *res,
GError **error)
{
g_return_val_if_fail (MM_IS_MODEM_3GPP (self), FALSE);
return mm_gdbus_modem3gpp_call_set_carrier_lock_finish (MM_GDBUS_MODEM3GPP (self), res, error);
}
/**
* mm_modem_3gpp_set_carrier_lock:
* @self: A #MMModem3gpp.
* @data: (array length=data_size): Carrier lock information.
* @data_size: size of @data.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or
* %NULL.
* @user_data: User data to pass to @callback.
*
* Asynchronously sends the carrier lock information to the modem.
*
* When the operation is finished, @callback will be invoked in the
* <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
* of the thread you are calling this method from. You can then call
* mm_modem_location_inject_assistance_data_finish() to get the result of the
* operation.
*
* See mm_modem_3gpp_set_carrier_lock_sync() for the synchronous,
* blocking version of this method.
*
* Since: 1.22
*/
void
mm_modem_3gpp_set_carrier_lock (MMModem3gpp *self,
const guint8 *data,
gsize data_size,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (MM_IS_MODEM_3GPP (self));
mm_gdbus_modem3gpp_call_set_carrier_lock (MM_GDBUS_MODEM3GPP (self),
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, data, data_size, sizeof (guint8)),
cancellable,
callback,
user_data);
}
/**
* mm_modem_3gpp_set_carrier_lock_sync:
* @self: A #MMModem3gpp.
* @data: (array length=data_size): Carrier lock information.
* @data_size: size of @data.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously sends the carrier lock information to the modem..
*
* The calling thread is blocked until a reply is received. See
* mm_modem_3gpp_set_carrier_lock() for the asynchronous version of this method.
*
* Returns: %TRUE if the carrier network info is successfully send, %FALSE if @error is set.
*
* Since: 1.22
*/
gboolean
mm_modem_3gpp_set_carrier_lock_sync (MMModem3gpp *self,
const guint8 *data,
gsize data_size,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail (MM_IS_MODEM_3GPP (self), FALSE);
return mm_gdbus_modem3gpp_call_set_carrier_lock_sync (MM_GDBUS_MODEM3GPP (self),
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, data, data_size, sizeof (guint8)),
cancellable,
error);
}
/*****************************************************************************/
static void
mm_modem_3gpp_init (MMModem3gpp *self)
{

15
libmm-glib/mm-modem-3gpp.h
View File

@@ -219,6 +219,21 @@ gboolean mm_modem_3gpp_set_nr5g_registration_settings_sync (MMModem3gpp
GCancellable *cancellable,
GError **error);
gboolean mm_modem_3gpp_set_carrier_lock_finish (MMModem3gpp *self,
GAsyncResult *res,
GError **error);
void mm_modem_3gpp_set_carrier_lock (MMModem3gpp *self,
const guint8 *data,
gsize data_size,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean mm_modem_3gpp_set_carrier_lock_sync (MMModem3gpp *self,
const guint8 *data,
gsize data_size,
GCancellable *cancellable,
GError **error);
G_END_DECLS
#endif /* _MM_MODEM_3GPP_H_ */

87
src/mm-broadband-modem-mbim.c
View File

@@ -145,6 +145,7 @@ struct _MMBroadbandModemMbimPrivate {
gboolean is_intel_reset_supported;
gboolean is_slot_info_status_supported;
gboolean is_ms_sar_supported;
gboolean is_google_carrier_lock_supported;
/* Process unsolicited notifications */
guint notification_id;
@@ -3386,6 +3387,16 @@ query_device_services_ready (MbimDevice *device,
continue;
}
if (service == MBIM_SERVICE_GOOGLE) {
for (j = 0; j < device_services[i]->cids_count; j++) {
if (device_services[i]->cids[j] == MBIM_CID_GOOGLE_CARRIER_LOCK) {
mm_obj_dbg (self, "Google carrier lock is supported");
self->priv->is_google_carrier_lock_supported = TRUE;
}
}
continue;
}
/* no optional features to check in remaining services */
}
mbim_device_service_element_array_free (device_services);
@@ -5121,6 +5132,14 @@ basic_connect_notification_subscriber_ready_status (MMBroadbandModemMbim *self,
active_sim_event = TRUE;
}
if ((self->priv->enabled_cache.last_ready_state != MBIM_SUBSCRIBER_READY_STATE_DEVICE_LOCKED &&
ready_state == MBIM_SUBSCRIBER_READY_STATE_DEVICE_LOCKED) ||
(self->priv->enabled_cache.last_ready_state == MBIM_SUBSCRIBER_READY_STATE_DEVICE_LOCKED &&
ready_state != MBIM_SUBSCRIBER_READY_STATE_DEVICE_LOCKED)) {
mm_obj_dbg (self, "Lock state change detected");
active_sim_event = TRUE;
}
self->priv->enabled_cache.last_ready_state = ready_state;
if (active_sim_event) {
@@ -9618,6 +9637,71 @@ set_packet_service_state (MMIfaceModem3gpp *self,
task);
}
/*****************************************************************************/
/* Set carrier lock */
static gboolean
modem_set_carrier_lock_finish (MMIfaceModem3gpp *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
set_carrier_lock_ready (MbimDevice *device,
GAsyncResult *res,
GTask *task)
{
g_autoptr(MbimMessage) response = NULL;
GError *error = NULL;
response = mbim_device_command_finish (device, res, &error);
if (response &&
mbim_message_response_get_result (response, MBIM_MESSAGE_TYPE_COMMAND_DONE, &error)) {
g_task_return_boolean (task, TRUE);
} else if (g_error_matches (error, MBIM_STATUS_ERROR, MBIM_STATUS_ERROR_OPERATION_NOT_ALLOWED)) {
g_clear_error (&error);
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "operation not allowed");
} else
g_task_return_error (task, error);
g_object_unref (task);
}
static void
modem_set_carrier_lock (MMIfaceModem3gpp *_self,
const guint8 *data,
gsize data_size,
GAsyncReadyCallback callback,
gpointer user_data)
{
MMBroadbandModemMbim *self = MM_BROADBAND_MODEM_MBIM (_self);
MbimDevice *device;
g_autoptr(MbimMessage) message = NULL;
GTask *task;
if (!peek_device (self, &device, callback, user_data))
return;
task = g_task_new (self, NULL, callback, user_data);
if (!self->priv->is_google_carrier_lock_supported) {
g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Google carrier lock is not supported");
g_object_unref (task);
return;
}
mm_obj_dbg (self, "Sending carrier lock request...");
message = mbim_message_google_carrier_lock_set_new (data_size, data, NULL);
mbim_device_command (device,
message,
10,
NULL,
(GAsyncReadyCallback)set_carrier_lock_ready,
task);
}
/*****************************************************************************/
@@ -9853,6 +9937,9 @@ iface_modem_3gpp_init (MMIfaceModem3gpp *iface)
iface->disable_facility_lock_finish = modem_3gpp_disable_facility_lock_finish;
iface->set_packet_service_state = set_packet_service_state;
iface->set_packet_service_state_finish = set_packet_service_state_finish;
/* carrier lock */
iface->set_carrier_lock = modem_set_carrier_lock;
iface->set_carrier_lock_finish = modem_set_carrier_lock_finish;
}
static void

96
src/mm-iface-modem-3gpp.c
View File

@@ -3360,6 +3360,98 @@ load_imei_ready (MMIfaceModem3gpp *self,
interface_initialization_step (task);
}
/*****************************************************************************/
typedef struct {
MmGdbusModem3gpp *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModem3gpp *self;
GVariant *data;
} HandleSetCarrierLockContext;
static void
handle_set_carrier_lock_context_free (HandleSetCarrierLockContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_variant_unref (ctx->data);
g_free (ctx);
}
static void
handle_set_carrier_lock_ready (MMIfaceModem3gpp *self,
GAsyncResult *res,
HandleSetCarrierLockContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_3GPP_GET_INTERFACE (self)->set_carrier_lock_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem3gpp_complete_set_carrier_lock (ctx->skeleton, ctx->invocation);
handle_set_carrier_lock_context_free (ctx);
}
static void
handle_set_carrier_lock_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleSetCarrierLockContext *ctx)
{
GError *error = NULL;
const guint8 *data;
gsize data_size;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_set_carrier_lock_context_free (ctx);
return;
}
/* If carrier lock is not implemented, report an error */
if (!MM_IFACE_MODEM_3GPP_GET_INTERFACE (self)->set_carrier_lock ||
!MM_IFACE_MODEM_3GPP_GET_INTERFACE (self)->set_carrier_lock_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot send set carrier lock request to modem: "
"operation not supported");
handle_set_carrier_lock_context_free (ctx);
return;
}
data = (const guint8 *) g_variant_get_fixed_array (ctx->data, &data_size, sizeof (guint8));
MM_IFACE_MODEM_3GPP_GET_INTERFACE (self)->set_carrier_lock (ctx->self,
data,
data_size,
(GAsyncReadyCallback)handle_set_carrier_lock_ready,
ctx);
}
static gboolean
handle_set_carrier_lock (MmGdbusModem3gpp *skeleton,
GDBusMethodInvocation *invocation,
GVariant *data,
MMIfaceModem3gpp *self)
{
HandleSetCarrierLockContext *ctx;
ctx = g_new0 (HandleSetCarrierLockContext, 1);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->data = g_variant_ref (data);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_set_carrier_lock_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
static void
interface_initialization_step (GTask *task)
{
@@ -3498,6 +3590,10 @@ interface_initialization_step (GTask *task)
"handle-disable-facility-lock",
G_CALLBACK (handle_disable_facility_lock),
self);
g_signal_connect (ctx->skeleton,
"handle-set-carrier-lock",
G_CALLBACK (handle_set_carrier_lock),
self);
/* Finally, export the new interface */
mm_gdbus_object_skeleton_set_modem3gpp (MM_GDBUS_OBJECT_SKELETON (self),

10
src/mm-iface-modem-3gpp.h
View File

@@ -273,6 +273,16 @@ struct _MMIfaceModem3gpp {
gboolean (* set_nr5g_registration_settings_finish) (MMIfaceModem3gpp *self,
GAsyncResult *res,
GError **error);
/* Set carrier lock */
void (* set_carrier_lock) (MMIfaceModem3gpp *self,
const guint8 *data,
gsize data_size,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean (*set_carrier_lock_finish) (MMIfaceModem3gpp *self,
GAsyncResult *res,
GError **error);
};
GType mm_iface_modem_3gpp_get_type (void);