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 static enum qmi_cmd_result
 140 cmd_dms_change_pin_prepare(struct qmi_msg *msg, char *arg)
 141 {
 142         if (!dms_req_data.pin || !dms_req_data.new_pin) {
 143                 uqmi_add_error("Missing argument");
 144                 return QMI_CMD_EXIT;
 145         }
 146
 147         struct qmi_dms_uim_change_pin_request dms_change_pin_req = {
 148                 QMI_INIT_SEQUENCE(info,
 149                         .pin_id = dms_req_data.pin_id
 150                 ),
 151                 QMI_INIT_PTR(info.old_pin, dms_req_data.pin),
 152                 QMI_INIT_PTR(info.new_pin, dms_req_data.new_pin)
 153         };
 154
 155         qmi_set_dms_uim_change_pin_request(msg, &dms_change_pin_req);
 156         return QMI_CMD_REQUEST;
 157 }
 158
 159 #define cmd_dms_change_pin1_cb no_cb
 160 static enum qmi_cmd_result
 161 cmd_dms_change_pin1_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 162 {
 163         dms_req_data.pin_id = QMI_DMS_UIM_PIN_ID_PIN;
 164         return cmd_dms_change_pin_prepare(msg, arg);
 165 }
 166
 167 #define cmd_dms_change_pin2_cb no_cb
 168 static enum qmi_cmd_result
 169 cmd_dms_change_pin2_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 170 {
 171         dms_req_data.pin_id = QMI_DMS_UIM_PIN_ID_PIN2;
 172         return cmd_dms_change_pin_prepare(msg, arg);
 173 }
 174
 175 #define cmd_dms_set_new_pin_cb no_cb
 176 static enum qmi_cmd_result
 177 cmd_dms_set_new_pin_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 178 {
 179         dms_req_data.new_pin = arg;
 180         return QMI_CMD_DONE;
 181 }
 182
 183 #define cmd_dms_set_puk_cb no_cb
 184 static enum qmi_cmd_result
 185 cmd_dms_set_puk_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 186 {
 187         dms_req_data.puk = arg;
 188         return QMI_CMD_DONE;
 189 }
 190
 191 #define cmd_dms_unblock_pin1_cb no_cb
 192 static enum qmi_cmd_result
 193 cmd_dms_unblock_pin1_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 194 {
 195         if (!dms_req_data.puk || !dms_req_data.new_pin) {
 196                 uqmi_add_error("Missing argument");
 197                 return QMI_CMD_EXIT;
 198         }
 199
 200         struct qmi_dms_uim_unblock_pin_request dms_unlock_pin_req = {
 201                 QMI_INIT_SEQUENCE(info,
 202                                 .pin_id = QMI_DMS_UIM_PIN_ID_PIN
 203                         ),
 204                 QMI_INIT_PTR(info.puk, dms_req_data.puk),
 205                 QMI_INIT_PTR(info.new_pin, dms_req_data.new_pin)
 206                 };
 207
 208         qmi_set_dms_uim_unblock_pin_request(msg, &dms_unlock_pin_req);
 209         return QMI_CMD_REQUEST;
 210 }
 211
 212 #define cmd_dms_unblock_pin2_cb no_cb
 213 static enum qmi_cmd_result
 214 cmd_dms_unblock_pin2_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 215 {
 216         if (!dms_req_data.puk || !dms_req_data.new_pin) {
 217                 uqmi_add_error("Missing argument");
 218                 return QMI_CMD_EXIT;
 219         }
 220
 221         struct qmi_dms_uim_unblock_pin_request dms_unlock_pin_req = {
 222                 QMI_INIT_SEQUENCE(info,
 223                         .pin_id = QMI_DMS_UIM_PIN_ID_PIN2
 224                 ),
 225                 QMI_INIT_PTR(info.puk, dms_req_data.puk),
 226                 QMI_INIT_PTR(info.new_pin, dms_req_data.new_pin)
 227         };
 228
 229         qmi_set_dms_uim_unblock_pin_request(msg, &dms_unlock_pin_req);
 230         return QMI_CMD_REQUEST;
 231 }
 232
 233 static void cmd_dms_get_iccid_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 234 {
 235         struct qmi_dms_uim_get_iccid_response res;
 236
 237         qmi_parse_dms_uim_get_iccid_response(msg, &res);
 238         if (res.data.iccid)
 239                 blobmsg_add_string(&status, NULL, res.data.iccid);
 240 }
 241
 242 static enum qmi_cmd_result
 243 cmd_dms_get_iccid_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 244 {
 245         qmi_set_dms_uim_get_iccid_request(msg);
 246         return QMI_CMD_REQUEST;
 247 }
 248
 249 static void cmd_dms_get_imsi_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 250 {
 251         struct qmi_dms_uim_get_imsi_response res;
 252
 253         qmi_parse_dms_uim_get_imsi_response(msg, &res);
 254         if (res.data.imsi)
 255                 blobmsg_add_string(&status, NULL, res.data.imsi);
 256 }
 257
 258 static enum qmi_cmd_result
 259 cmd_dms_get_imsi_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 260 {
 261         qmi_set_dms_uim_get_imsi_request(msg);
 262         return QMI_CMD_REQUEST;
 263 }
 264
 265 static void cmd_dms_get_msisdn_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 266 {
 267         struct qmi_dms_get_msisdn_response res;
 268
 269         qmi_parse_dms_get_msisdn_response(msg, &res);
 270         if (res.data.msisdn)
 271                 blobmsg_add_string(&status, NULL, res.data.msisdn);
 272 }
 273
 274 static enum qmi_cmd_result
 275 cmd_dms_get_msisdn_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 276 {
 277         qmi_set_dms_get_msisdn_request(msg);
 278         return QMI_CMD_REQUEST;
 279 }
 280
 281 #define cmd_dms_reset_cb no_cb
 282 static enum qmi_cmd_result
 283 cmd_dms_reset_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 284 {
 285         qmi_set_dms_reset_request(msg);
 286         return QMI_CMD_REQUEST;
 287 }
 288
 289 #define cmd_dms_set_operating_mode_cb no_cb
 290 static enum qmi_cmd_result
 291 cmd_dms_set_operating_mode_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 292 {
 293         static const char *modes[] = {
 294                 [QMI_DMS_OPERATING_MODE_ONLINE] = "online",
 295                 [QMI_DMS_OPERATING_MODE_LOW_POWER] = "low_power",
 296                 [QMI_DMS_OPERATING_MODE_FACTORY_TEST] = "factory_test",
 297                 [QMI_DMS_OPERATING_MODE_OFFLINE] = "offline",
 298                 [QMI_DMS_OPERATING_MODE_RESET] = "reset",
 299                 [QMI_DMS_OPERATING_MODE_SHUTTING_DOWN] = "shutting_down",
 300                 [QMI_DMS_OPERATING_MODE_PERSISTENT_LOW_POWER] = "persistent_low_power",
 301                 [QMI_DMS_OPERATING_MODE_MODE_ONLY_LOW_POWER] = "mode_only_low_power",
 302         };
 303         static struct qmi_dms_set_operating_mode_request sreq = {
 304                 QMI_INIT(mode, QMI_DMS_OPERATING_MODE_ONLINE),
 305         };
 306         int i;
 307
 308         for (i = 0; i < ARRAY_SIZE(modes); i++) {
 309                 if (!modes[i])
 310                         continue;
 311
 312                 if (strcmp(arg, modes[i]) != 0)
 313                         continue;
 314
 315                 sreq.data.mode = i;
 316                 qmi_set_dms_set_operating_mode_request(msg, &sreq);
 317                 return QMI_CMD_REQUEST;
 318         }
 319
 320         return uqmi_add_error("Invalid argument");
 321 }