9c3ac2fb60
This property contains the DBus path of a Bearer object of type MM_BEARER_TYPE_DEFAULT_ATTACH, which is automatically exposed by the modem when registered in the LTE network. Unlike standard bearer objects created by the user, this bearer won't allow any connection/disconnection request, as its status is bound to the LTE registration exclusively. The bearer settings exposed by the object include the APN details that have been used during the initial packet network attach, which may be defined by modem settings (e.g. if previously configured in the firmware which APN to use for the given SIM card operator) or by the network itself (e.g. if none configured, or if a network override is required as when roaming). The bearer object will be created as soon as the LTE attach status details are known, and only while the modem is enabled. The implementation allows modems to update the LTE attach status details during runtime, so the bearer object with the settings may be recreated during runtime as well.
1104 lines
55 KiB
C
1104 lines
55 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* mmcli -- Control modem status & access information from the command line
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Copyright (C) 2018 Aleksander Morgado <aleksander@aleksander.es>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <libmm-glib.h>
|
|
#include "mm-common-helpers.h"
|
|
#include "mmcli-output.h"
|
|
|
|
/******************************************************************************/
|
|
/* List of sections (grouped fields) displayed in the human-friendly output */
|
|
|
|
typedef struct {
|
|
const gchar *name;
|
|
} SectionInfo;
|
|
|
|
static SectionInfo section_infos[] = {
|
|
[MMC_S_MODEM_GENERAL] = { "General" },
|
|
[MMC_S_MODEM_HARDWARE] = { "Hardware" },
|
|
[MMC_S_MODEM_SYSTEM] = { "System" },
|
|
[MMC_S_MODEM_NUMBERS] = { "Numbers" },
|
|
[MMC_S_MODEM_STATUS] = { "Status" },
|
|
[MMC_S_MODEM_MODES] = { "Modes" },
|
|
[MMC_S_MODEM_BANDS] = { "Bands" },
|
|
[MMC_S_MODEM_IP] = { "IP" },
|
|
[MMC_S_MODEM_3GPP] = { "3GPP" },
|
|
[MMC_S_MODEM_3GPP_EPS] = { "3GPP EPS" },
|
|
[MMC_S_MODEM_3GPP_SCAN] = { "3GPP scan" },
|
|
[MMC_S_MODEM_3GPP_USSD] = { "3GPP USSD" },
|
|
[MMC_S_MODEM_CDMA] = { "CDMA" },
|
|
[MMC_S_MODEM_SIM] = { "SIM" },
|
|
[MMC_S_MODEM_BEARER] = { "Bearer" },
|
|
[MMC_S_MODEM_TIME] = { "Time" },
|
|
[MMC_S_MODEM_TIMEZONE] = { "Timezone" },
|
|
[MMC_S_MODEM_MESSAGING] = { "Messaging" },
|
|
[MMC_S_MODEM_SIGNAL] = { "Signal" },
|
|
[MMC_S_MODEM_SIGNAL_CDMA1X] = { "CDMA1x" },
|
|
[MMC_S_MODEM_SIGNAL_EVDO] = { "EV-DO" },
|
|
[MMC_S_MODEM_SIGNAL_GSM] = { "GSM" },
|
|
[MMC_S_MODEM_SIGNAL_UMTS] = { "UMTS" },
|
|
[MMC_S_MODEM_SIGNAL_LTE] = { "LTE" },
|
|
[MMC_S_MODEM_OMA] = { "OMA" },
|
|
[MMC_S_MODEM_OMA_CURRENT] = { "Current session" },
|
|
[MMC_S_MODEM_OMA_PENDING] = { "Pending sessions" },
|
|
[MMC_S_MODEM_LOCATION] = { "Location" },
|
|
[MMC_S_MODEM_LOCATION_3GPP] = { "3GPP" },
|
|
[MMC_S_MODEM_LOCATION_GPS] = { "GPS" },
|
|
[MMC_S_MODEM_LOCATION_CDMABS] = { "CDMA BS" },
|
|
[MMC_S_MODEM_FIRMWARE] = { "Firmware" },
|
|
[MMC_S_BEARER_GENERAL] = { "General" },
|
|
[MMC_S_BEARER_STATUS] = { "Status" },
|
|
[MMC_S_BEARER_PROPERTIES] = { "Properties" },
|
|
[MMC_S_BEARER_IPV4_CONFIG] = { "IPv4 configuration" },
|
|
[MMC_S_BEARER_IPV6_CONFIG] = { "IPv6 configuration" },
|
|
[MMC_S_BEARER_STATS] = { "Statistics" },
|
|
[MMC_S_CALL_GENERAL] = { "General" },
|
|
[MMC_S_CALL_PROPERTIES] = { "Properties" },
|
|
[MMC_S_CALL_AUDIO_FORMAT] = { "Audio format" },
|
|
[MMC_S_SMS_GENERAL] = { "General" },
|
|
[MMC_S_SMS_CONTENT] = { "Content" },
|
|
[MMC_S_SMS_PROPERTIES] = { "Properties" },
|
|
[MMC_S_SIM_GENERAL] = { "General" },
|
|
[MMC_S_SIM_PROPERTIES] = { "Properties" },
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/* List of fields */
|
|
|
|
typedef struct {
|
|
const gchar *key;
|
|
const gchar *name;
|
|
MmcS section;
|
|
} FieldInfo;
|
|
|
|
static FieldInfo field_infos[] = {
|
|
[MMC_F_GENERAL_DBUS_PATH] = { "modem.dbus-path", "dbus path", MMC_S_MODEM_GENERAL, },
|
|
[MMC_F_GENERAL_DEVICE_ID] = { "modem.generic.device-identifier", "device id", MMC_S_MODEM_GENERAL, },
|
|
[MMC_F_HARDWARE_MANUFACTURER] = { "modem.generic.manufacturer", "manufacturer", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_MODEL] = { "modem.generic.model", "model", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_REVISION] = { "modem.generic.revision", "revision", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_HW_REVISION] = { "modem.generic.hardware-revision", "h/w revision", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_SUPPORTED_CAPABILITIES] = { "modem.generic.supported-capabilities", "supported", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_CURRENT_CAPABILITIES] = { "modem.generic.current-capabilities", "current", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_HARDWARE_EQUIPMENT_ID] = { "modem.generic.equipment-identifier", "equipment id", MMC_S_MODEM_HARDWARE, },
|
|
[MMC_F_SYSTEM_DEVICE] = { "modem.generic.device", "device", MMC_S_MODEM_SYSTEM, },
|
|
[MMC_F_SYSTEM_DRIVERS] = { "modem.generic.drivers", "drivers", MMC_S_MODEM_SYSTEM, },
|
|
[MMC_F_SYSTEM_PLUGIN] = { "modem.generic.plugin", "plugin", MMC_S_MODEM_SYSTEM, },
|
|
[MMC_F_SYSTEM_PRIMARY_PORT] = { "modem.generic.primary-port", "primary port", MMC_S_MODEM_SYSTEM, },
|
|
[MMC_F_SYSTEM_PORTS] = { "modem.generic.ports", "ports", MMC_S_MODEM_SYSTEM, },
|
|
[MMC_F_NUMBERS_OWN] = { "modem.generic.own-numbers", "own", MMC_S_MODEM_NUMBERS, },
|
|
[MMC_F_STATUS_LOCK] = { "modem.generic.unlock-required", "lock", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_UNLOCK_RETRIES] = { "modem.generic.unlock-retries", "unlock retries", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_STATE] = { "modem.generic.state", "state", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_FAILED_REASON] = { "modem.generic.state-failed-reason", "failed reason", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_POWER_STATE] = { "modem.generic.power-state", "power state", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_ACCESS_TECH] = { "modem.generic.access-technologies", "access tech", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_SIGNAL_QUALITY_VALUE] = { "modem.generic.signal-quality.value", "signal quality", MMC_S_MODEM_STATUS, },
|
|
[MMC_F_STATUS_SIGNAL_QUALITY_RECENT] = { "modem.generic.signal-quality.recent", NULL, MMC_S_UNKNOWN, },
|
|
[MMC_F_MODES_SUPPORTED] = { "modem.generic.supported-modes", "supported", MMC_S_MODEM_MODES, },
|
|
[MMC_F_MODES_CURRENT] = { "modem.generic.current-modes", "current", MMC_S_MODEM_MODES, },
|
|
[MMC_F_BANDS_SUPPORTED] = { "modem.generic.supported-bands", "supported", MMC_S_MODEM_BANDS, },
|
|
[MMC_F_BANDS_CURRENT] = { "modem.generic.current-bands", "current", MMC_S_MODEM_BANDS, },
|
|
[MMC_F_IP_SUPPORTED] = { "modem.generic.supported-ip-families", "supported", MMC_S_MODEM_IP, },
|
|
[MMC_F_3GPP_IMEI] = { "modem.3gpp.imei", "imei", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_ENABLED_LOCKS] = { "modem.3gpp.enabled-locks", "enabled locks", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_OPERATOR_ID] = { "modem.3gpp.operator-code", "operator id", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_OPERATOR_NAME] = { "modem.3gpp.operator-name", "operator name", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_REGISTRATION] = { "modem.3gpp.registration-state", "registration", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_PCO] = { "modem.3gpp.pco", "pco", MMC_S_MODEM_3GPP, },
|
|
[MMC_F_3GPP_EPS_UE_MODE] = { "modem.3gpp.eps.ue-mode-operation", "ue mode of operation", MMC_S_MODEM_3GPP_EPS, },
|
|
[MMC_F_3GPP_EPS_INITIAL_BEARER_PATH] = { "modem.3gpp.eps.initial-bearer.dbus-path", "initial bearer dbus path", MMC_S_MODEM_3GPP_EPS, },
|
|
[MMC_F_3GPP_SCAN_NETWORKS] = { "modem.3gpp.scan-networks", "networks", MMC_S_MODEM_3GPP_SCAN, },
|
|
[MMC_F_3GPP_USSD_STATUS] = { "modem.3gpp.ussd.status", "status", MMC_S_MODEM_3GPP_USSD, },
|
|
[MMC_F_3GPP_USSD_NETWORK_REQUEST] = { "modem.3gpp.ussd.network-request", "network request", MMC_S_MODEM_3GPP_USSD, },
|
|
[MMC_F_3GPP_USSD_NETWORK_NOTIFICATION] = { "modem.3gpp.ussd.network-notification", "network notification", MMC_S_MODEM_3GPP_USSD, },
|
|
[MMC_F_CDMA_MEID] = { "modem.cdma.meid", "meid", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_ESN] = { "modem.cdma.esn", "esn", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_SID] = { "modem.cdma.sid", "sid", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_NID] = { "modem.cdma.nid", "nid", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_REGISTRATION_CDMA1X] = { "modem.cdma.cdma1x-registration-state", "registration cdma1x", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_REGISTRATION_EVDO] = { "modem.cdma.evdo-registration-state", "registration evdo", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_CDMA_ACTIVATION] = { "modem.cdma.activation-state", "activation", MMC_S_MODEM_CDMA, },
|
|
[MMC_F_SIM_PATH] = { "modem.generic.sim", "dbus path", MMC_S_MODEM_SIM, },
|
|
[MMC_F_BEARER_PATHS] = { "modem.generic.bearers", "dbus path", MMC_S_MODEM_BEARER, },
|
|
[MMC_F_TIME_CURRENT] = { "modem.time.current", "current", MMC_S_MODEM_TIME, },
|
|
[MMC_F_TIMEZONE_CURRENT] = { "modem.timezone.current", "current", MMC_S_MODEM_TIMEZONE, },
|
|
[MMC_F_TIMEZONE_DST_OFFSET] = { "modem.time.dst-offset", "dst offset", MMC_S_MODEM_TIMEZONE, },
|
|
[MMC_F_TIMEZONE_LEAP_SECONDS] = { "modem.time.leap-seconds", "leap seconds", MMC_S_MODEM_TIMEZONE, },
|
|
[MMC_F_MESSAGING_SUPPORTED_STORAGES] = { "modem.messaging.supported-storages", "supported storages", MMC_S_MODEM_MESSAGING, },
|
|
[MMC_F_MESSAGING_DEFAULT_STORAGES] = { "modem.messaging.default-storages", "default storages", MMC_S_MODEM_MESSAGING, },
|
|
[MMC_F_SIGNAL_REFRESH_RATE] = { "modem.signal.refresh.rate", "refresh rate", MMC_S_MODEM_SIGNAL, },
|
|
[MMC_F_SIGNAL_CDMA1X_RSSI] = { "modem.signal.cdma1x.rssi", "rssi", MMC_S_MODEM_SIGNAL_CDMA1X, },
|
|
[MMC_F_SIGNAL_CDMA1X_ECIO] = { "modem.signal.cdma1x.ecio", "ecio", MMC_S_MODEM_SIGNAL_CDMA1X, },
|
|
[MMC_F_SIGNAL_EVDO_RSSI] = { "modem.signal.evdo.rssi", "rssi", MMC_S_MODEM_SIGNAL_EVDO, },
|
|
[MMC_F_SIGNAL_EVDO_ECIO] = { "modem.signal.evdo.ecio", "ecio", MMC_S_MODEM_SIGNAL_EVDO, },
|
|
[MMC_F_SIGNAL_EVDO_SINR] = { "modem.signal.evdo.sinr", "sinr", MMC_S_MODEM_SIGNAL_EVDO, },
|
|
[MMC_F_SIGNAL_EVDO_IO] = { "modem.signal.evdo.io", "io", MMC_S_MODEM_SIGNAL_EVDO, },
|
|
[MMC_F_SIGNAL_GSM_RSSI] = { "modem.signal.gsm.rssi", "rssi", MMC_S_MODEM_SIGNAL_GSM, },
|
|
[MMC_F_SIGNAL_UMTS_RSSI] = { "modem.signal.umts.rssi", "rssi", MMC_S_MODEM_SIGNAL_UMTS, },
|
|
[MMC_F_SIGNAL_UMTS_RSCP] = { "modem.signal.umts.rscp", "rscp", MMC_S_MODEM_SIGNAL_UMTS, },
|
|
[MMC_F_SIGNAL_UMTS_ECIO] = { "modem.signal.umts.ecio", "ecio", MMC_S_MODEM_SIGNAL_UMTS, },
|
|
[MMC_F_SIGNAL_LTE_RSSI] = { "modem.signal.lte.rssi", "rssi", MMC_S_MODEM_SIGNAL_LTE, },
|
|
[MMC_F_SIGNAL_LTE_RSRQ] = { "modem.signal.lte.rsrq", "rsrq", MMC_S_MODEM_SIGNAL_LTE, },
|
|
[MMC_F_SIGNAL_LTE_RSRP] = { "modem.signal.lte.rsrp", "rsrp", MMC_S_MODEM_SIGNAL_LTE, },
|
|
[MMC_F_SIGNAL_LTE_SNR] = { "modem.signal.lte.snr", "s/n", MMC_S_MODEM_SIGNAL_LTE, },
|
|
[MMC_F_OMA_FEATURES] = { "modem.oma.features", "features", MMC_S_MODEM_OMA, },
|
|
[MMC_F_OMA_CURRENT_TYPE] = { "modem.oma.current.type", "type", MMC_S_MODEM_OMA_CURRENT, },
|
|
[MMC_F_OMA_CURRENT_STATE] = { "modem.oma.current.state", "state", MMC_S_MODEM_OMA_CURRENT, },
|
|
[MMC_F_OMA_PENDING_SESSIONS] = { "modem.oma.pending-sessions", "sessions", MMC_S_MODEM_OMA_PENDING, },
|
|
[MMC_F_LOCATION_CAPABILITIES] = { "modem.location.capabilities", "capabilities", MMC_S_MODEM_LOCATION, },
|
|
[MMC_F_LOCATION_ENABLED] = { "modem.location.enabled", "enabled", MMC_S_MODEM_LOCATION, },
|
|
[MMC_F_LOCATION_SIGNALS] = { "modem.location.signals", "signals", MMC_S_MODEM_LOCATION, },
|
|
[MMC_F_LOCATION_GPS_REFRESH_RATE] = { "modem.location.gps.refresh-rate", "refresh rate", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_SUPL_SERVER] = { "modem.location.gps.supl-server", "a-gps supl server", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_ASSISTANCE] = { "modem.location.gps.assistance", "supported assistance", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_ASSISTANCE_SERVERS] = { "modem.location.gps.assistance-servers", "assistance servers", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_3GPP_MCC] = { "modem.location.3gpp.mcc", "operator code", MMC_S_MODEM_LOCATION_3GPP, },
|
|
[MMC_F_LOCATION_3GPP_MNC] = { "modem.location.3gpp.mnc", "operator name", MMC_S_MODEM_LOCATION_3GPP, },
|
|
[MMC_F_LOCATION_3GPP_LAC] = { "modem.location.3gpp.lac", "location area code", MMC_S_MODEM_LOCATION_3GPP, },
|
|
[MMC_F_LOCATION_3GPP_TAC] = { "modem.location.3gpp.tac", "tracking area code", MMC_S_MODEM_LOCATION_3GPP, },
|
|
[MMC_F_LOCATION_3GPP_CID] = { "modem.location.3gpp.cid", "cell id", MMC_S_MODEM_LOCATION_3GPP, },
|
|
[MMC_F_LOCATION_GPS_NMEA] = { "modem.location.gps.nmea", "nmea", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_UTC] = { "modem.location.gps.utc", "utc", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_LONG] = { "modem.location.gps.longitude", "longitude", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_LAT] = { "modem.location.gps.latitude", "latitude", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_GPS_ALT] = { "modem.location.gps.altitude", "altitude", MMC_S_MODEM_LOCATION_GPS, },
|
|
[MMC_F_LOCATION_CDMABS_LONG] = { "modem.location.cdma-bs.longitude", "longitude", MMC_S_MODEM_LOCATION_CDMABS, },
|
|
[MMC_F_LOCATION_CDMABS_LAT] = { "modem.location.cdma-bs.latitude", "latitude", MMC_S_MODEM_LOCATION_CDMABS, },
|
|
[MMC_F_FIRMWARE_LIST] = { "modem.firmware-list", "list", MMC_S_MODEM_FIRMWARE, },
|
|
[MMC_F_BEARER_GENERAL_DBUS_PATH] = { "bearer.dbus-path", "dbus path", MMC_S_BEARER_GENERAL, },
|
|
[MMC_F_BEARER_GENERAL_TYPE] = { "bearer.type", "type", MMC_S_BEARER_GENERAL, },
|
|
[MMC_F_BEARER_STATUS_CONNECTED] = { "bearer.status.connected", "connected", MMC_S_BEARER_STATUS, },
|
|
[MMC_F_BEARER_STATUS_SUSPENDED] = { "bearer.status.suspended", "suspended", MMC_S_BEARER_STATUS, },
|
|
[MMC_F_BEARER_STATUS_INTERFACE] = { "bearer.status.interface", "interface", MMC_S_BEARER_STATUS, },
|
|
[MMC_F_BEARER_STATUS_IP_TIMEOUT] = { "bearer.status.ip-timeout", "ip timeout", MMC_S_BEARER_STATUS, },
|
|
[MMC_F_BEARER_PROPERTIES_APN] = { "bearer.properties.apn", "apn", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_ROAMING] = { "bearer.properties.roaming", "roaming", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_IP_TYPE] = { "bearer.properties.ip-type", "ip type", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_USER] = { "bearer.properties.user", "user", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_PASSWORD] = { "bearer.properties.password", "password", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_NUMBER] = { "bearer.properties.number", "number", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_PROPERTIES_RM_PROTOCOL] = { "bearer.properties.rm-protocol", "rm protocol", MMC_S_BEARER_PROPERTIES, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_METHOD] = { "bearer.ipv4-config.method", "method", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_ADDRESS] = { "bearer.ipv4-config.address", "address", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_PREFIX] = { "bearer.ipv4-config.prefix", "prefix", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_GATEWAY] = { "bearer.ipv4-config.gateway", "gateway", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_DNS] = { "bearer.ipv4-config.dns", "dns", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV4_CONFIG_MTU] = { "bearer.ipv4-config.mtu", "mtu", MMC_S_BEARER_IPV4_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_METHOD] = { "bearer.ipv6-config.method", "method", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_ADDRESS] = { "bearer.ipv6-config.address", "address", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_PREFIX] = { "bearer.ipv6-config.prefix", "prefix", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_GATEWAY] = { "bearer.ipv6-config.gateway", "gateway", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_DNS] = { "bearer.ipv6-config.dns", "dns", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_IPV6_CONFIG_MTU] = { "bearer.ipv6-config.mtu", "mtu", MMC_S_BEARER_IPV6_CONFIG, },
|
|
[MMC_F_BEARER_STATS_DURATION] = { "bearer.stats.duration", "duration", MMC_S_BEARER_STATS, },
|
|
[MMC_F_BEARER_STATS_BYTES_RX] = { "bearer.stats.bytes-rx", "bytes rx", MMC_S_BEARER_STATS, },
|
|
[MMC_F_BEARER_STATS_BYTES_TX] = { "bearer.stats.bytes-tx", "bytes tx", MMC_S_BEARER_STATS, },
|
|
[MMC_F_CALL_GENERAL_DBUS_PATH] = { "call.dbus-path", "dbus path", MMC_S_CALL_GENERAL, },
|
|
[MMC_F_CALL_PROPERTIES_NUMBER] = { "call.properties.number", "number", MMC_S_CALL_PROPERTIES, },
|
|
[MMC_F_CALL_PROPERTIES_DIRECTION] = { "call.properties.direction", "direction", MMC_S_CALL_PROPERTIES, },
|
|
[MMC_F_CALL_PROPERTIES_STATE] = { "call.properties.state", "state", MMC_S_CALL_PROPERTIES, },
|
|
[MMC_F_CALL_PROPERTIES_STATE_REASON] = { "call.properties.state-reason", "state reason", MMC_S_CALL_PROPERTIES, },
|
|
[MMC_F_CALL_PROPERTIES_AUDIO_PORT] = { "call.properties.audio-port", "audio port", MMC_S_CALL_PROPERTIES, },
|
|
[MMC_F_CALL_AUDIO_FORMAT_ENCODING] = { "call.audio-format.encoding", "encoding", MMC_S_CALL_AUDIO_FORMAT, },
|
|
[MMC_F_CALL_AUDIO_FORMAT_RESOLUTION] = { "call.audio-format.resolution", "resolution", MMC_S_CALL_AUDIO_FORMAT, },
|
|
[MMC_F_CALL_AUDIO_FORMAT_RATE] = { "call.audio-format.rate", "rate", MMC_S_CALL_AUDIO_FORMAT, },
|
|
[MMC_F_SMS_GENERAL_DBUS_PATH] = { "sms.dbus-path", "dbus path", MMC_S_SMS_GENERAL, },
|
|
[MMC_F_SMS_CONTENT_NUMBER] = { "sms.content.number", "number", MMC_S_SMS_CONTENT, },
|
|
[MMC_F_SMS_CONTENT_TEXT] = { "sms.content.text", "text", MMC_S_SMS_CONTENT, },
|
|
[MMC_F_SMS_CONTENT_DATA] = { "sms.content.data", "data", MMC_S_SMS_CONTENT, },
|
|
[MMC_F_SMS_PROPERTIES_PDU_TYPE] = { "sms.properties.pdu-type", "pdu type", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_STATE] = { "sms.properties.state", "state", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_VALIDITY] = { "sms.properties.validity", "validity", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_STORAGE] = { "sms.properties.storage", "storage", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_SMSC] = { "sms.properties.smsc", "smsc", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_CLASS] = { "sms.properties.class", "class", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_TELESERVICE_ID] = { "sms.properties.teleservice-id", "teleservice id", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_SERVICE_CATEGORY] = { "sms.properties.service-category", "service category", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_DELIVERY_REPORT] = { "sms.properties.delivery-report", "delivery report", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_MSG_REFERENCE] = { "sms.properties.message-reference", "message reference", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_TIMESTAMP] = { "sms.properties.timestamp", "timestamp", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_DELIVERY_STATE] = { "sms.properties.delivery-state", "delivery state", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SMS_PROPERTIES_DISCH_TIMESTAMP] = { "sms.properties.discharge-timestamp", "discharge timestamp", MMC_S_SMS_PROPERTIES, },
|
|
[MMC_F_SIM_GENERAL_DBUS_PATH] = { "sim.dbus-path", "dbus path", MMC_S_SIM_GENERAL, },
|
|
[MMC_F_SIM_PROPERTIES_IMSI] = { "sim.properties.imsi", "imsi", MMC_S_SIM_PROPERTIES, },
|
|
[MMC_F_SIM_PROPERTIES_ICCID] = { "sim.properties.iccid", "iccid", MMC_S_SIM_PROPERTIES, },
|
|
[MMC_F_SIM_PROPERTIES_OPERATOR_ID] = { "sim.properties.operator-code", "operator id", MMC_S_SIM_PROPERTIES, },
|
|
[MMC_F_SIM_PROPERTIES_OPERATOR_NAME] = { "sim.properties.operator-name", "operator name", MMC_S_SIM_PROPERTIES, },
|
|
[MMC_F_MODEM_LIST_DBUS_PATH] = { "modem-list", "modems", MMC_S_UNKNOWN, },
|
|
[MMC_F_SMS_LIST_DBUS_PATH] = { "modem.messaging.sms", "sms messages", MMC_S_UNKNOWN, },
|
|
[MMC_F_CALL_LIST_DBUS_PATH] = { "modem.voice.call", "calls", MMC_S_UNKNOWN, },
|
|
};
|
|
|
|
/******************************************************************************/
|
|
/* Output type selection */
|
|
|
|
static MmcOutputType selected_type = MMC_OUTPUT_TYPE_NONE;
|
|
|
|
void
|
|
mmcli_output_set (MmcOutputType type)
|
|
{
|
|
selected_type = type;
|
|
}
|
|
|
|
MmcOutputType
|
|
mmcli_output_get (void)
|
|
{
|
|
return selected_type;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Generic output management */
|
|
|
|
typedef enum {
|
|
VALUE_TYPE_SINGLE,
|
|
VALUE_TYPE_MULTIPLE,
|
|
VALUE_TYPE_LISTITEM,
|
|
} ValueType;
|
|
|
|
typedef struct {
|
|
MmcF field;
|
|
ValueType type;
|
|
} OutputItem;
|
|
|
|
typedef struct {
|
|
OutputItem base;
|
|
gchar *value;
|
|
} OutputItemSingle;
|
|
|
|
typedef struct {
|
|
OutputItem base;
|
|
gchar **values;
|
|
gboolean multiline;
|
|
} OutputItemMultiple;
|
|
|
|
typedef struct {
|
|
OutputItem base;
|
|
gchar *prefix;
|
|
gchar *value;
|
|
gchar *extra;
|
|
} OutputItemListitem;
|
|
|
|
static GList *output_items;
|
|
|
|
static void
|
|
output_item_free (OutputItem *item)
|
|
{
|
|
switch (item->type) {
|
|
case VALUE_TYPE_SINGLE:
|
|
g_free (((OutputItemSingle *)item)->value);
|
|
g_slice_free (OutputItemSingle, (OutputItemSingle *)item);
|
|
break;
|
|
case VALUE_TYPE_MULTIPLE:
|
|
g_strfreev (((OutputItemMultiple *)item)->values);
|
|
g_slice_free (OutputItemMultiple, (OutputItemMultiple *)item);
|
|
break;
|
|
case VALUE_TYPE_LISTITEM:
|
|
g_free (((OutputItemListitem *)item)->prefix);
|
|
g_free (((OutputItemListitem *)item)->value);
|
|
g_free (((OutputItemListitem *)item)->extra);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
filter_out_value (const gchar *value)
|
|
{
|
|
return (!g_strcmp0 (value, "unknown") || !g_strcmp0 (value, "none"));
|
|
}
|
|
|
|
static void
|
|
output_item_new_take_single (MmcF field,
|
|
gchar *value)
|
|
{
|
|
OutputItemSingle *item;
|
|
|
|
item = g_slice_new0 (OutputItemSingle);
|
|
item->base.field = field;
|
|
item->base.type = VALUE_TYPE_SINGLE;
|
|
|
|
if (filter_out_value (value))
|
|
g_free (value);
|
|
else
|
|
item->value = value;
|
|
|
|
output_items = g_list_prepend (output_items, item);
|
|
}
|
|
|
|
static void
|
|
output_item_new_take_multiple (MmcF field,
|
|
gchar **values,
|
|
gboolean multiline)
|
|
{
|
|
OutputItemMultiple *item;
|
|
|
|
item = g_slice_new0 (OutputItemMultiple);
|
|
item->base.field = field;
|
|
item->base.type = VALUE_TYPE_MULTIPLE;
|
|
item->multiline = multiline;
|
|
|
|
if (values && (g_strv_length (values) == 1) && filter_out_value (values[0]))
|
|
g_strfreev (values);
|
|
else
|
|
item->values = values;
|
|
|
|
output_items = g_list_prepend (output_items, item);
|
|
}
|
|
|
|
static void
|
|
output_item_new_take_listitem (MmcF field,
|
|
gchar *prefix,
|
|
gchar *value,
|
|
gchar *extra)
|
|
{
|
|
OutputItemListitem *item;
|
|
|
|
item = g_slice_new0 (OutputItemListitem);
|
|
item->base.field = field;
|
|
item->base.type = VALUE_TYPE_LISTITEM;
|
|
item->prefix = prefix;
|
|
item->value = value;
|
|
item->extra = extra;
|
|
|
|
output_items = g_list_prepend (output_items, item);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_list (MmcF field,
|
|
const gchar *str)
|
|
{
|
|
gchar **split;
|
|
|
|
split = str ? g_strsplit (str, ",", -1) : NULL;
|
|
if (split) {
|
|
guint i;
|
|
for (i = 0; split[i]; i++)
|
|
g_strstrip (split[i]);
|
|
}
|
|
|
|
output_item_new_take_multiple (field, split, FALSE);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_list_take (MmcF field,
|
|
gchar *str)
|
|
{
|
|
mmcli_output_string_list (field, str);
|
|
g_free (str);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_multiline (MmcF field,
|
|
const gchar *str)
|
|
{
|
|
gchar **split;
|
|
|
|
split = str ? g_strsplit (str, "\n", -1) : NULL;
|
|
if (split) {
|
|
guint i;
|
|
for (i = 0; split[i]; i++)
|
|
g_strstrip (split[i]);
|
|
}
|
|
|
|
output_item_new_take_multiple (field, split, TRUE);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_multiline_take (MmcF field,
|
|
gchar *str)
|
|
{
|
|
mmcli_output_string_multiline (field, str);
|
|
g_free (str);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_array (MmcF field,
|
|
const gchar **strv,
|
|
gboolean multiline)
|
|
{
|
|
output_item_new_take_multiple (field, g_strdupv ((gchar **)strv), multiline);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_array_take (MmcF field,
|
|
gchar **strv,
|
|
gboolean multiline)
|
|
{
|
|
output_item_new_take_multiple (field, strv, multiline);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string (MmcF field,
|
|
const gchar *str)
|
|
{
|
|
output_item_new_take_single (field, g_strdup (str));
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_take (MmcF field,
|
|
gchar *str)
|
|
{
|
|
output_item_new_take_single (field, str);
|
|
}
|
|
|
|
void
|
|
mmcli_output_string_take_typed (MmcF field,
|
|
gchar *value,
|
|
const gchar *type)
|
|
{
|
|
if (value && selected_type == MMC_OUTPUT_TYPE_HUMAN) {
|
|
gchar *aux;
|
|
|
|
aux = g_strdup_printf ("%s %s", value, type);
|
|
g_free (value);
|
|
output_item_new_take_single (field, aux);
|
|
return;
|
|
}
|
|
|
|
output_item_new_take_single (field, value);
|
|
}
|
|
|
|
void
|
|
mmcli_output_listitem (MmcF field,
|
|
const gchar *prefix,
|
|
const gchar *value,
|
|
const gchar *extra)
|
|
{
|
|
output_item_new_take_listitem (field, g_strdup (prefix), g_strdup (value), g_strdup (extra));
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* (Custom) Signal quality output */
|
|
|
|
void
|
|
mmcli_output_signal_quality (guint value,
|
|
gboolean recent)
|
|
{
|
|
/* Merge value and recent flag in a single item in human output */
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN) {
|
|
output_item_new_take_single (MMC_F_STATUS_SIGNAL_QUALITY_VALUE,
|
|
g_strdup_printf ("%u%% (%s)", value, recent ? "recent" : "cached"));
|
|
return;
|
|
}
|
|
|
|
output_item_new_take_single (MMC_F_STATUS_SIGNAL_QUALITY_VALUE,
|
|
g_strdup_printf ("%u", value));
|
|
output_item_new_take_single (MMC_F_STATUS_SIGNAL_QUALITY_RECENT,
|
|
g_strdup_printf ("%s", recent ? "yes" : "no"));
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* (Custom) State output */
|
|
|
|
void
|
|
mmcli_output_state (MMModemState state,
|
|
MMModemStateFailedReason reason)
|
|
{
|
|
#define KNRM "\x1B[0m"
|
|
#define KRED "\x1B[31m"
|
|
#define KGRN "\x1B[32m"
|
|
#define KYEL "\x1B[33m"
|
|
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN) {
|
|
if (state == MM_MODEM_STATE_FAILED)
|
|
output_item_new_take_single (MMC_F_STATUS_STATE, g_strdup_printf (KRED "%s" KNRM, mm_modem_state_get_string (state)));
|
|
else if (state == MM_MODEM_STATE_CONNECTED)
|
|
output_item_new_take_single (MMC_F_STATUS_STATE, g_strdup_printf (KGRN "%s" KNRM, mm_modem_state_get_string (state)));
|
|
else if (state == MM_MODEM_STATE_CONNECTING)
|
|
output_item_new_take_single (MMC_F_STATUS_STATE, g_strdup_printf (KYEL "%s" KNRM, mm_modem_state_get_string (state)));
|
|
else
|
|
output_item_new_take_single (MMC_F_STATUS_STATE, g_strdup (mm_modem_state_get_string (state))) ;
|
|
|
|
if (state == MM_MODEM_STATE_FAILED)
|
|
output_item_new_take_single (MMC_F_STATUS_FAILED_REASON,
|
|
g_strdup_printf (KRED "%s" KNRM, mm_modem_state_failed_reason_get_string (reason)));
|
|
return;
|
|
}
|
|
|
|
output_item_new_take_single (MMC_F_STATUS_STATE, g_strdup (mm_modem_state_get_string (state)));
|
|
output_item_new_take_single (MMC_F_STATUS_FAILED_REASON,
|
|
(state == MM_MODEM_STATE_FAILED) ?
|
|
g_strdup (mm_modem_state_failed_reason_get_string (reason)) :
|
|
NULL);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* (Custom) Network scan output */
|
|
|
|
static gchar *
|
|
build_network_info (MMModem3gppNetwork *network)
|
|
{
|
|
const gchar *operator_code;
|
|
const gchar *operator_name;
|
|
gchar *access_technologies;
|
|
const gchar *availability;
|
|
gchar *out;
|
|
|
|
operator_code = mm_modem_3gpp_network_get_operator_code (network);
|
|
operator_name = mm_modem_3gpp_network_get_operator_long (network);
|
|
if (!operator_name)
|
|
operator_name = mm_modem_3gpp_network_get_operator_short (network);
|
|
access_technologies = mm_modem_access_technology_build_string_from_mask (mm_modem_3gpp_network_get_access_technology (network));
|
|
availability = mm_modem_3gpp_network_availability_get_string (mm_modem_3gpp_network_get_availability (network));
|
|
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN)
|
|
out = g_strdup_printf ("%s - %s (%s, %s)",
|
|
operator_code ? operator_code : "code n/a",
|
|
operator_name ? operator_name : "name n/a",
|
|
access_technologies,
|
|
availability);
|
|
else
|
|
out = g_strdup_printf ("operator-code: %s, operator-name: %s, access-technologies: %s, availability: %s",
|
|
operator_code ? operator_code : "--",
|
|
operator_name ? operator_name : "--",
|
|
access_technologies,
|
|
availability);
|
|
g_free (access_technologies);
|
|
|
|
return out;
|
|
}
|
|
|
|
void
|
|
mmcli_output_scan_networks (GList *network_list)
|
|
{
|
|
gchar **networks = NULL;
|
|
|
|
if (network_list) {
|
|
GPtrArray *aux;
|
|
GList *l;
|
|
|
|
aux = g_ptr_array_new ();
|
|
for (l = network_list; l; l = g_list_next (l))
|
|
g_ptr_array_add (aux, build_network_info ((MMModem3gppNetwork *)(l->data)));
|
|
g_ptr_array_add (aux, NULL);
|
|
networks = (gchar **) g_ptr_array_free (aux, FALSE);
|
|
}
|
|
|
|
/* When printing human result, we want to show some result even if no networks
|
|
* are found, so we force a explicit string result. */
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN && !networks)
|
|
output_item_new_take_single (MMC_F_3GPP_SCAN_NETWORKS, g_strdup ("n/a"));
|
|
else
|
|
output_item_new_take_multiple (MMC_F_3GPP_SCAN_NETWORKS, networks, TRUE);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* (Custom) Firmware list output */
|
|
|
|
static void
|
|
build_firmware_info_human (GPtrArray *array,
|
|
MMFirmwareProperties *props,
|
|
gboolean selected)
|
|
{
|
|
g_ptr_array_add (array, g_strdup (mm_firmware_properties_get_unique_id (props)));
|
|
g_ptr_array_add (array, g_strdup_printf ("\tcurrent: %s", selected ? "yes" : "no"));
|
|
|
|
if (mm_firmware_properties_get_image_type (props) == MM_FIRMWARE_IMAGE_TYPE_GOBI) {
|
|
const gchar *aux;
|
|
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_version (props)) != NULL)
|
|
g_ptr_array_add (array, g_strdup_printf ("\tgobi pri version: %s", aux));
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_info (props)) != NULL)
|
|
g_ptr_array_add (array, g_strdup_printf ("\tgobi pri info: %s", aux));
|
|
if ((aux = mm_firmware_properties_get_gobi_boot_version (props)) != NULL)
|
|
g_ptr_array_add (array, g_strdup_printf ("\tgobi boot version: %s", aux));
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_unique_id (props)) != NULL)
|
|
g_ptr_array_add (array, g_strdup_printf ("\tgobi pri unique id: %s", aux));
|
|
if ((aux = mm_firmware_properties_get_gobi_modem_unique_id (props)) != NULL)
|
|
g_ptr_array_add (array, g_strdup_printf ("\tgobi modem unique id: %s", aux));
|
|
}
|
|
}
|
|
|
|
static void
|
|
build_firmware_info_keyvalue (GPtrArray *array,
|
|
MMFirmwareProperties *props,
|
|
gboolean selected)
|
|
{
|
|
GString *str;
|
|
|
|
str = g_string_new ("");
|
|
g_string_append_printf (str, "unique-id: %s", mm_firmware_properties_get_unique_id (props));
|
|
g_string_append_printf (str, ", current: %s", selected ? "yes" : "no");
|
|
|
|
if (mm_firmware_properties_get_image_type (props) == MM_FIRMWARE_IMAGE_TYPE_GOBI) {
|
|
const gchar *aux;
|
|
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_version (props)) != NULL)
|
|
g_string_append_printf (str, ", gobi-pri-version: %s", aux);
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_info (props)) != NULL)
|
|
g_string_append_printf (str, ", gobi-pri-info: %s", aux);
|
|
if ((aux = mm_firmware_properties_get_gobi_boot_version (props)) != NULL)
|
|
g_string_append_printf (str, ", gobi-boot-version: %s", aux);
|
|
if ((aux = mm_firmware_properties_get_gobi_pri_unique_id (props)) != NULL)
|
|
g_string_append_printf (str, ", gobi-pri-unique id: %s", aux);
|
|
if ((aux = mm_firmware_properties_get_gobi_modem_unique_id (props)) != NULL)
|
|
g_string_append_printf (str, ", gobi-modem-unique id: %s", aux);
|
|
}
|
|
|
|
g_ptr_array_add (array, g_string_free (str, FALSE));
|
|
}
|
|
|
|
void
|
|
mmcli_output_firmware_list (GList *firmware_list,
|
|
MMFirmwareProperties *selected)
|
|
{
|
|
gchar **firmwares = NULL;
|
|
|
|
if (firmware_list) {
|
|
GPtrArray *aux;
|
|
GList *l;
|
|
|
|
aux = g_ptr_array_new ();
|
|
for (l = firmware_list; l; l = g_list_next (l)) {
|
|
MMFirmwareProperties *props = (MMFirmwareProperties *)(l->data);
|
|
gboolean current_selected;
|
|
|
|
current_selected = (selected &&
|
|
g_str_equal (mm_firmware_properties_get_unique_id (props),
|
|
mm_firmware_properties_get_unique_id (selected)));
|
|
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN)
|
|
build_firmware_info_human (aux, props, current_selected);
|
|
else
|
|
build_firmware_info_keyvalue (aux, props, current_selected);
|
|
}
|
|
g_ptr_array_add (aux, NULL);
|
|
firmwares = (gchar **) g_ptr_array_free (aux, FALSE);
|
|
}
|
|
|
|
/* When printing human result, we want to show some result even if no firmwares
|
|
* are found, so we force a explicit string result. */
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN && !firmwares)
|
|
output_item_new_take_single (MMC_F_FIRMWARE_LIST, g_strdup ("n/a"));
|
|
else
|
|
output_item_new_take_multiple (MMC_F_FIRMWARE_LIST, firmwares, TRUE);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* (Custom) PCO list output */
|
|
|
|
void
|
|
mmcli_output_pco_list (GList *pco_list)
|
|
{
|
|
GPtrArray *aux;
|
|
GList *l;
|
|
|
|
if (!pco_list) {
|
|
output_item_new_take_single (MMC_F_3GPP_PCO, NULL);
|
|
return;
|
|
}
|
|
|
|
aux = g_ptr_array_new ();
|
|
for (l = pco_list; l; l = g_list_next (l)) {
|
|
MMPco *pco;
|
|
gchar *pco_data_hex;
|
|
const guint8 *pco_data;
|
|
gsize pco_data_size;
|
|
|
|
pco = MM_PCO (l->data);
|
|
pco_data = mm_pco_get_data (pco, &pco_data_size);
|
|
pco_data_hex = (pco_data ? mm_utils_bin2hexstr (pco_data, pco_data_size) : NULL);
|
|
|
|
if (selected_type == MMC_OUTPUT_TYPE_HUMAN)
|
|
g_ptr_array_add (aux, g_strdup_printf ("%u: (%s) '%s'\n",
|
|
mm_pco_get_session_id (pco),
|
|
mm_pco_is_complete (pco) ? "complete" : "partial",
|
|
pco_data_hex ? pco_data_hex : ""));
|
|
else
|
|
g_ptr_array_add (aux, g_strdup_printf ("session-id: %u, complete: %s, data: %s\n",
|
|
mm_pco_get_session_id (pco),
|
|
mm_pco_is_complete (pco) ? "yes" : "no",
|
|
pco_data_hex ? pco_data_hex : ""));
|
|
g_free (pco_data_hex);
|
|
}
|
|
g_ptr_array_add (aux, NULL);
|
|
|
|
output_item_new_take_multiple (MMC_F_3GPP_PCO, (gchar **) g_ptr_array_free (aux, FALSE), TRUE);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Human-friendly output */
|
|
|
|
#define HUMAN_MAX_VALUE_LENGTH 60
|
|
|
|
static gint
|
|
list_sort_human (const OutputItem *item_a,
|
|
const OutputItem *item_b)
|
|
{
|
|
if (field_infos[item_a->field].section < field_infos[item_b->field].section)
|
|
return -1;
|
|
if (field_infos[item_a->field].section > field_infos[item_b->field].section)
|
|
return 1;
|
|
return item_a->field - item_b->field;
|
|
}
|
|
|
|
static void
|
|
dump_output_human (void)
|
|
{
|
|
GList *l;
|
|
MmcS current_section = MMC_S_UNKNOWN;
|
|
guint longest_section_name = 0;
|
|
guint longest_field_name = 0;
|
|
|
|
output_items = g_list_sort (output_items, (GCompareFunc) list_sort_human);
|
|
|
|
/* First pass to process */
|
|
for (l = output_items; l; l = g_list_next (l)) {
|
|
OutputItem *item_l;
|
|
guint aux;
|
|
gboolean ignore = FALSE;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
|
|
/* Post-process values */
|
|
if (item_l->type == VALUE_TYPE_SINGLE) {
|
|
OutputItemSingle *single = (OutputItemSingle *)item_l;
|
|
|
|
if (!single->value)
|
|
ignore = TRUE;
|
|
} else if (item_l->type == VALUE_TYPE_MULTIPLE) {
|
|
OutputItemMultiple *multiple = (OutputItemMultiple *)item_l;
|
|
|
|
if (!multiple->values)
|
|
ignore = TRUE;
|
|
}
|
|
|
|
/* Compute max lengths */
|
|
if (!ignore) {
|
|
aux = strlen (section_infos[field_infos[item_l->field].section].name);
|
|
if (aux > longest_section_name)
|
|
longest_section_name = aux;
|
|
aux = strlen (field_infos[item_l->field].name);
|
|
if (aux > longest_field_name)
|
|
longest_field_name = aux;
|
|
}
|
|
}
|
|
|
|
/* Second pass to print */
|
|
for (l = output_items; l; l = g_list_next (l)) {
|
|
OutputItem *item_l;
|
|
OutputItemSingle *single = NULL;
|
|
OutputItemMultiple *multiple = NULL;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
if (item_l->type == VALUE_TYPE_SINGLE)
|
|
single = (OutputItemSingle *)item_l;
|
|
else if (item_l->type == VALUE_TYPE_MULTIPLE)
|
|
multiple = (OutputItemMultiple *)item_l;
|
|
else
|
|
g_assert_not_reached ();
|
|
|
|
/* Ignore items without a value set */
|
|
if ((single && (!single->value || !single->value[0])) ||
|
|
(multiple && !multiple->values))
|
|
continue;
|
|
|
|
/* Section change? */
|
|
if (field_infos[item_l->field].section != current_section) {
|
|
current_section = field_infos[item_l->field].section;
|
|
g_print (" %.*s\n",
|
|
longest_section_name + longest_field_name + 4,
|
|
"------------------------------------------------------------");
|
|
g_print (" %-*.*s | ",
|
|
longest_section_name,
|
|
longest_section_name,
|
|
section_infos[field_infos[item_l->field].section].name);
|
|
} else
|
|
g_print (" %*.*s | ",
|
|
longest_section_name,
|
|
longest_section_name,
|
|
"");
|
|
|
|
g_print ("%*.*s: ",
|
|
longest_field_name, longest_field_name, field_infos[item_l->field].name);
|
|
|
|
if (single) {
|
|
gchar **split_lines;
|
|
guint i;
|
|
|
|
split_lines = g_strsplit (single->value, "\n", -1);
|
|
for (i = 0; split_lines[i]; i++) {
|
|
if (i != 0) {
|
|
g_print (" %*.*s | %*.*s ",
|
|
longest_section_name, longest_section_name, "",
|
|
longest_field_name, longest_field_name, "");
|
|
}
|
|
g_print ("%s\n", split_lines[i]);
|
|
}
|
|
g_strfreev (split_lines);
|
|
} else if (multiple) {
|
|
guint line_length = 0;
|
|
guint n, i;
|
|
|
|
n = multiple->values ? g_strv_length (multiple->values) : 0;
|
|
for (i = 0; i < n; i++) {
|
|
const gchar *value;
|
|
guint value_length;
|
|
|
|
value = multiple->values[i];
|
|
value_length = strlen (value) + ((i < (n - 1)) ? 2 : 0);
|
|
if ((multiple->multiline && i != 0) || ((line_length + value_length) > HUMAN_MAX_VALUE_LENGTH)) {
|
|
line_length = 0;
|
|
g_print ("\n"
|
|
" %*.*s | %*.*s ",
|
|
longest_section_name, longest_section_name, "",
|
|
longest_field_name, longest_field_name, "");
|
|
} else
|
|
line_length += value_length;
|
|
g_print ("%s%s", value, (!multiple->multiline && i < (n - 1)) ? ", " : "");
|
|
}
|
|
g_print ("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_output_list_human (MmcF field)
|
|
{
|
|
GList *l;
|
|
guint n;
|
|
|
|
g_assert (field != MMC_F_UNKNOWN);
|
|
|
|
/* First pass to process */
|
|
for (n = 0, l = output_items; l; l = g_list_next (l), n++) {
|
|
OutputItem *item_l;
|
|
OutputItemListitem *listitem;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
g_assert (item_l->type == VALUE_TYPE_LISTITEM);
|
|
listitem = (OutputItemListitem *)item_l;
|
|
g_assert (listitem->value);
|
|
|
|
/* All items must be of same type */
|
|
g_assert_cmpint (item_l->field, ==, field);
|
|
}
|
|
|
|
/* Second pass to print */
|
|
if (n == 0) {
|
|
g_print ("No %s were found\n", field_infos[field].name);
|
|
return;
|
|
}
|
|
for (l = output_items; l; l = g_list_next (l)) {
|
|
OutputItemListitem *listitem;
|
|
|
|
listitem = (OutputItemListitem *)(l->data);
|
|
g_print ("%s%s %s\n", listitem->prefix, listitem->value, listitem->extra);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Key-value output */
|
|
|
|
#define KEY_ARRAY_LENGTH_SUFFIX ".length"
|
|
#define KEY_ARRAY_VALUE_SUFFIX ".value"
|
|
|
|
static gint
|
|
list_sort_keyvalue (const OutputItem *item_a,
|
|
const OutputItem *item_b)
|
|
{
|
|
return item_a->field - item_b->field;
|
|
}
|
|
|
|
static void
|
|
dump_output_keyvalue (void)
|
|
{
|
|
GList *l;
|
|
guint longest_field_key = 0;
|
|
|
|
output_items = g_list_sort (output_items, (GCompareFunc) list_sort_keyvalue);
|
|
|
|
/* First pass to process */
|
|
for (l = output_items; l; l = g_list_next (l)) {
|
|
OutputItem *item_l;
|
|
OutputItemMultiple *multiple = NULL;
|
|
guint key_length;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
if (item_l->type == VALUE_TYPE_MULTIPLE)
|
|
multiple = (OutputItemMultiple *)item_l;
|
|
|
|
key_length = strlen (field_infos[item_l->field].key);
|
|
|
|
/* when printing array contents, each item is given with an index,
|
|
* e.g.: something.value[1]
|
|
* The max length of the field will need to consider the array length
|
|
* in order to accommodate the length of the index.
|
|
*/
|
|
if (multiple) {
|
|
guint n;
|
|
|
|
n = multiple->values ? g_strv_length (multiple->values) : 0;
|
|
if (n > 0) {
|
|
key_length += ((strlen (KEY_ARRAY_VALUE_SUFFIX)) + 3);
|
|
if (n > 10)
|
|
key_length++;
|
|
}
|
|
}
|
|
|
|
if (key_length > longest_field_key)
|
|
longest_field_key = key_length;
|
|
}
|
|
|
|
/* Second pass to print */
|
|
for (l = output_items; l; l = g_list_next (l)) {
|
|
OutputItem *item_l;
|
|
OutputItemSingle *single = NULL;
|
|
OutputItemMultiple *multiple = NULL;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
if (item_l->type == VALUE_TYPE_SINGLE)
|
|
single = (OutputItemSingle *)item_l;
|
|
else if (item_l->type == VALUE_TYPE_MULTIPLE)
|
|
multiple = (OutputItemMultiple *)item_l;
|
|
else
|
|
g_assert_not_reached ();
|
|
|
|
if (single) {
|
|
gchar *escaped = NULL;
|
|
|
|
if (single->value)
|
|
escaped = g_strescape (single->value, NULL);
|
|
g_print ("%-*.*s : %s\n",
|
|
longest_field_key, longest_field_key, field_infos[item_l->field].key,
|
|
escaped ? escaped : "--");
|
|
g_free (escaped);
|
|
} else if (multiple) {
|
|
guint n;
|
|
|
|
n = multiple->values ? g_strv_length (multiple->values) : 0;
|
|
if (n > 0) {
|
|
guint i;
|
|
gchar *new_key;
|
|
|
|
new_key = g_strdup_printf ("%s" KEY_ARRAY_LENGTH_SUFFIX, field_infos[item_l->field].key);
|
|
g_print ("%-*.*s : %u\n", longest_field_key, longest_field_key, new_key, n);
|
|
g_free (new_key);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
gchar *escaped = NULL;
|
|
|
|
/* Printed indices start at 1 */
|
|
new_key = g_strdup_printf ("%s" KEY_ARRAY_VALUE_SUFFIX "[%u]", field_infos[item_l->field].key, i + 1);
|
|
escaped = g_strescape (multiple->values[i], NULL);
|
|
g_print ("%-*.*s : %s\n", longest_field_key, longest_field_key, new_key, escaped);
|
|
g_free (escaped);
|
|
g_free (new_key);
|
|
}
|
|
} else
|
|
g_print ("%-*.*s : --\n",
|
|
longest_field_key, longest_field_key, field_infos[item_l->field].key);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_output_list_keyvalue (MmcF field)
|
|
{
|
|
GList *l;
|
|
guint key_length;
|
|
guint n;
|
|
gchar *new_key;
|
|
|
|
g_assert (field != MMC_F_UNKNOWN);
|
|
key_length = strlen (field_infos[field].key);
|
|
|
|
/* First pass to process */
|
|
for (n = 0, l = output_items; l; l = g_list_next (l), n++) {
|
|
OutputItem *item_l;
|
|
OutputItemListitem *listitem;
|
|
|
|
item_l = (OutputItem *)(l->data);
|
|
g_assert (item_l->type == VALUE_TYPE_LISTITEM);
|
|
listitem = (OutputItemListitem *)item_l;
|
|
g_assert (listitem->value);
|
|
|
|
/* All items must be of same type */
|
|
g_assert_cmpint (item_l->field, ==, field);
|
|
}
|
|
|
|
if (n > 0) {
|
|
key_length += ((strlen (KEY_ARRAY_VALUE_SUFFIX)) + 3);
|
|
if (n > 10)
|
|
key_length++;
|
|
}
|
|
|
|
new_key = g_strdup_printf ("%s" KEY_ARRAY_LENGTH_SUFFIX, field_infos[field].key);
|
|
g_print ("%-*.*s : %u\n", key_length, key_length, new_key, n);
|
|
g_free (new_key);
|
|
|
|
/* Second pass to print */
|
|
for (n = 0, l = output_items; l; l = g_list_next (l), n++) {
|
|
OutputItemListitem *listitem;
|
|
|
|
listitem = (OutputItemListitem *)(l->data);
|
|
new_key = g_strdup_printf ("%s" KEY_ARRAY_VALUE_SUFFIX "[%u]", field_infos[field].key, n + 1);
|
|
g_print ("%-*.*s : %s\n",
|
|
key_length, key_length, new_key,
|
|
listitem->value);
|
|
g_free (new_key);
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* Dump output */
|
|
|
|
void
|
|
mmcli_output_dump (void)
|
|
{
|
|
switch (selected_type) {
|
|
case MMC_OUTPUT_TYPE_NONE:
|
|
break;
|
|
case MMC_OUTPUT_TYPE_HUMAN:
|
|
dump_output_human ();
|
|
break;
|
|
case MMC_OUTPUT_TYPE_KEYVALUE:
|
|
dump_output_keyvalue ();
|
|
break;
|
|
}
|
|
|
|
g_list_free_full (output_items, (GDestroyNotify) output_item_free);
|
|
output_items = NULL;
|
|
|
|
fflush (stdout);
|
|
}
|
|
|
|
void
|
|
mmcli_output_list_dump (MmcF field)
|
|
{
|
|
switch (selected_type) {
|
|
case MMC_OUTPUT_TYPE_NONE:
|
|
break;
|
|
case MMC_OUTPUT_TYPE_HUMAN:
|
|
dump_output_list_human (field);
|
|
break;
|
|
case MMC_OUTPUT_TYPE_KEYVALUE:
|
|
dump_output_list_keyvalue (field);
|
|
break;
|
|
}
|
|
|
|
g_list_free_full (output_items, (GDestroyNotify) output_item_free);
|
|
output_items = NULL;
|
|
|
|
fflush (stdout);
|
|
}
|