commands-dms.c

   1 #include "qmi-message.h"
   2
   3 static struct {
   4         QmiDmsUimPinId pin_id;
   5         char* pin;
   6         char* new_pin;
   7         char* puk;
   8 } dms_req_data;
   9
  10 static const char *get_pin_status(int status)
  11 {
  12         static const char *pin_status[] = {
  13                 [QMI_DMS_UIM_PIN_STATUS_NOT_INITIALIZED] = "not_initialized",
  14                 [QMI_DMS_UIM_PIN_STATUS_ENABLED_NOT_VERIFIED] = "not_verified",
  15                 [QMI_DMS_UIM_PIN_STATUS_ENABLED_VERIFIED] = "verified",
  16                 [QMI_DMS_UIM_PIN_STATUS_DISABLED] = "disabled",
  17                 [QMI_DMS_UIM_PIN_STATUS_BLOCKED] = "blocked",
  18                 [QMI_DMS_UIM_PIN_STATUS_PERMANENTLY_BLOCKED] = "permanently_blocked",
  19                 [QMI_DMS_UIM_PIN_STATUS_UNBLOCKED] = "unblocked",
  20                 [QMI_DMS_UIM_PIN_STATUS_CHANGED] = "changed",
  21         };
  22         const char *res = "Unknown";
  23
  24         if (status < ARRAY_SIZE(pin_status) && pin_status[status])
  25                 res = pin_status[status];
  26
  27         return res;
  28 }
  29
  30 static void cmd_dms_get_pin_status_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
  31 {
  32         struct qmi_dms_uim_get_pin_status_response res;
  33         void *c;
  34
  35         qmi_parse_dms_uim_get_pin_status_response(msg, &res);
  36         c = blobmsg_open_table(&status, NULL);
  37         if (res.set.pin1_status) {
  38                 blobmsg_add_string(&status, "pin1_status", get_pin_status(res.data.pin1_status.current_status));
  39                 blobmsg_add_u32(&status, "pin1_verify_tries", (int32_t) res.data.pin1_status.verify_retries_left);
  40                 blobmsg_add_u32(&status, "pin1_unblock_tries", (int32_t) res.data.pin1_status.unblock_retries_left);
  41         }
  42         if (res.set.pin2_status) {
  43                 blobmsg_add_string(&status, "pin2_status", get_pin_status(res.data.pin2_status.current_status));
  44                 blobmsg_add_u32(&status, "pin2_verify_tries", (int32_t) res.data.pin2_status.verify_retries_left);
  45                 blobmsg_add_u32(&status, "pin2_unblock_tries", (int32_t) res.data.pin2_status.unblock_retries_left);
  46         }
  47         blobmsg_close_table(&status, c);
  48 }
  49
  50 static enum qmi_cmd_result
  51 cmd_dms_get_pin_status_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  52 {
  53         qmi_set_dms_uim_get_pin_status_request(msg);
  54         return QMI_CMD_REQUEST;
  55 }
  56
  57 #define cmd_dms_verify_pin1_cb no_cb
  58 static enum qmi_cmd_result
  59 cmd_dms_verify_pin1_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  60 {
  61         struct qmi_dms_uim_verify_pin_request data = {
  62                 QMI_INIT_SEQUENCE(info,
  63                         .pin_id = QMI_DMS_UIM_PIN_ID_PIN,
  64                         .pin = arg
  65                 )
  66         };
  67         qmi_set_dms_uim_verify_pin_request(msg, &data);
  68         return QMI_CMD_REQUEST;
  69 }
  70
  71 #define cmd_dms_verify_pin2_cb no_cb
  72 static enum qmi_cmd_result
  73 cmd_dms_verify_pin2_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  74 {
  75         struct qmi_dms_uim_verify_pin_request data = {
  76                 QMI_INIT_SEQUENCE(info,
  77                         .pin_id = QMI_DMS_UIM_PIN_ID_PIN2,
  78                         .pin = arg
  79                 )
  80         };
  81         qmi_set_dms_uim_verify_pin_request(msg, &data);
  82         return QMI_CMD_REQUEST;
  83 }
  84
  85 #define cmd_dms_set_pin_cb no_cb
  86 static enum qmi_cmd_result
  87 cmd_dms_set_pin_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  88 {
  89         dms_req_data.pin = arg;
  90         return QMI_CMD_DONE;
  91 }
  92
  93 static enum qmi_cmd_result
  94 cmd_dms_set_pin_protection_prepare(struct qmi_msg *msg, char *arg)
  95 {
  96         if (!dms_req_data.pin) {
  97                 uqmi_add_error("Missing argument");
  98                 return QMI_CMD_EXIT;
  99         }
 100
 101         int is_enabled;
 102         if (strcasecmp(arg, "disabled") == 0)
 103                 is_enabled = false;
 104         else if (strcasecmp(arg, "enabled") == 0)
 105                 is_enabled = true;
 106         else {
 107                 uqmi_add_error("Invalid value (valid: disabled, enabled)");
 108                 return QMI_CMD_EXIT;
 109         }
 110
 111         struct qmi_dms_uim_set_pin_protection_request dms_pin_protection_req = {
 112                 QMI_INIT_SEQUENCE(info,
 113                         .pin_id = dms_req_data.pin_id
 114                 ),
 115                 QMI_INIT_PTR(info.pin, dms_req_data.pin),
 116                 QMI_INIT_PTR(info.protection_enabled, is_enabled)
 117         };
 118
 119         qmi_set_dms_uim_set_pin_protection_request(msg, &dms_pin_protection_req);
 120         return QMI_CMD_REQUEST;
 121 }
 122
 123 #define cmd_dms_set_pin1_protection_cb no_cb
 124 static enum qmi_cmd_result
 125 cmd_dms_set_pin1_protection_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 126 {
 127         dms_req_data.pin_id = QMI_DMS_UIM_PIN_ID_PIN;
 128         return cmd_dms_set_pin_protection_prepare(msg, arg);
 129 }
 130
 131 #define cmd_dms_set_pin2_protection_cb no_cb
 132 static enum qmi_cmd_result
 133 cmd_dms_set_pin2_protection_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 134 {
 135         dms_req_data.pin_id = QMI_DMS_UIM_PIN_ID_PIN2;
 136         return cmd_dms_set_pin_protection_prepare(msg, arg);
 137 }
 138
 139 #define cmd_dms_set_new_pin_cb no_cb
 140 static enum qmi_cmd_result
 141 cmd_dms_set_new_pin_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 142 {
 143         dms_req_data.new_pin = arg;
 144         return QMI_CMD_DONE;
 145 }
 146
 147 #define cmd_dms_set_puk_cb no_cb
 148 static enum qmi_cmd_result
 149 cmd_dms_set_puk_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 150 {
 151         dms_req_data.puk = arg;
 152         return QMI_CMD_DONE;
 153 }
 154
 155 #define cmd_dms_unblock_pin1_cb no_cb
 156 static enum qmi_cmd_result
 157 cmd_dms_unblock_pin1_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 158 {
 159         if (!dms_req_data.puk || !dms_req_data.new_pin) {
 160                 uqmi_add_error("Missing argument");
 161                 return QMI_CMD_EXIT;
 162         }
 163
 164         struct qmi_dms_uim_unblock_pin_request dms_unlock_pin_req = {
 165                 QMI_INIT_SEQUENCE(info,
 166                                 .pin_id = QMI_DMS_UIM_PIN_ID_PIN
 167                         ),
 168                 QMI_INIT_PTR(info.puk, dms_req_data.puk),
 169                 QMI_INIT_PTR(info.new_pin, dms_req_data.new_pin)
 170                 };
 171
 172         qmi_set_dms_uim_unblock_pin_request(msg, &dms_unlock_pin_req);
 173         return QMI_CMD_REQUEST;
 174 }
 175
 176 #define cmd_dms_unblock_pin2_cb no_cb
 177 static enum qmi_cmd_result
 178 cmd_dms_unblock_pin2_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 179 {
 180         if (!dms_req_data.puk || !dms_req_data.new_pin) {
 181                 uqmi_add_error("Missing argument");
 182                 return QMI_CMD_EXIT;
 183         }
 184
 185         struct qmi_dms_uim_unblock_pin_request dms_unlock_pin_req = {
 186                 QMI_INIT_SEQUENCE(info,
 187                         .pin_id = QMI_DMS_UIM_PIN_ID_PIN2
 188                 ),
 189                 QMI_INIT_PTR(info.puk, dms_req_data.puk),
 190                 QMI_INIT_PTR(info.new_pin, dms_req_data.new_pin)
 191         };
 192
 193         qmi_set_dms_uim_unblock_pin_request(msg, &dms_unlock_pin_req);
 194         return QMI_CMD_REQUEST;
 195 }
 196
 197 static void cmd_dms_get_iccid_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 198 {
 199         struct qmi_dms_uim_get_iccid_response res;
 200
 201         qmi_parse_dms_uim_get_iccid_response(msg, &res);
 202         if (res.data.iccid)
 203                 blobmsg_add_string(&status, NULL, res.data.iccid);
 204 }
 205
 206 static enum qmi_cmd_result
 207 cmd_dms_get_iccid_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 208 {
 209         qmi_set_dms_uim_get_iccid_request(msg);
 210         return QMI_CMD_REQUEST;
 211 }
 212
 213 static void cmd_dms_get_imsi_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 214 {
 215         struct qmi_dms_uim_get_imsi_response res;
 216
 217         qmi_parse_dms_uim_get_imsi_response(msg, &res);
 218         if (res.data.imsi)
 219                 blobmsg_add_string(&status, NULL, res.data.imsi);
 220 }
 221
 222 static enum qmi_cmd_result
 223 cmd_dms_get_imsi_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 224 {
 225         qmi_set_dms_uim_get_imsi_request(msg);
 226         return QMI_CMD_REQUEST;
 227 }
 228
 229 static void cmd_dms_get_msisdn_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 230 {
 231         struct qmi_dms_get_msisdn_response res;
 232
 233         qmi_parse_dms_get_msisdn_response(msg, &res);
 234         if (res.data.msisdn)
 235                 blobmsg_add_string(&status, NULL, res.data.msisdn);
 236 }
 237
 238 static enum qmi_cmd_result
 239 cmd_dms_get_msisdn_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 240 {
 241         qmi_set_dms_get_msisdn_request(msg);
 242         return QMI_CMD_REQUEST;
 243 }
 244
 245 #define cmd_dms_reset_cb no_cb
 246 static enum qmi_cmd_result
 247 cmd_dms_reset_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 248 {
 249         qmi_set_dms_reset_request(msg);
 250         return QMI_CMD_REQUEST;
 251 }
 252
 253 #define cmd_dms_set_operating_mode_cb no_cb
 254 static enum qmi_cmd_result
 255 cmd_dms_set_operating_mode_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 256 {
 257         static const char *modes[] = {
 258                 [QMI_DMS_OPERATING_MODE_ONLINE] = "online",
 259                 [QMI_DMS_OPERATING_MODE_LOW_POWER] = "low_power",
 260                 [QMI_DMS_OPERATING_MODE_FACTORY_TEST] = "factory_test",
 261                 [QMI_DMS_OPERATING_MODE_OFFLINE] = "offline",
 262                 [QMI_DMS_OPERATING_MODE_RESET] = "reset",
 263                 [QMI_DMS_OPERATING_MODE_SHUTTING_DOWN] = "shutting_down",
 264                 [QMI_DMS_OPERATING_MODE_PERSISTENT_LOW_POWER] = "persistent_low_power",
 265                 [QMI_DMS_OPERATING_MODE_MODE_ONLY_LOW_POWER] = "mode_only_low_power",
 266         };
 267         static struct qmi_dms_set_operating_mode_request sreq = {
 268                 QMI_INIT(mode, QMI_DMS_OPERATING_MODE_ONLINE),
 269         };
 270         int i;
 271
 272         for (i = 0; i < ARRAY_SIZE(modes); i++) {
 273                 if (!modes[i])
 274                         continue;
 275
 276                 if (strcmp(arg, modes[i]) != 0)
 277                         continue;
 278
 279                 sreq.data.mode = i;
 280                 qmi_set_dms_set_operating_mode_request(msg, &sreq);
 281                 return QMI_CMD_REQUEST;
 282         }
 283
 284         return uqmi_add_error("Invalid argument");
 285 }