3 * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 #define __STDC_FORMAT_MACROS
18 #include <sys/types.h>
29 #include <libubox/utils.h>
30 #include <libubox/uloop.h>
34 #include "data/mbim-service-basic-connect.h"
39 struct mbim_handler *current_handler;
40 static uint8_t uuid_context_type_internet[16] = { 0x7E, 0x5E, 0x2A, 0x7E, 0x4E, 0x6F, 0x72, 0x72, 0x73, 0x6B, 0x65, 0x6E, 0x7E, 0x5E, 0x2A, 0x7E };
45 mbim_device_caps_response(void *buffer, size_t len)
47 struct mbim_basic_connect_device_caps_r *caps = (struct mbim_basic_connect_device_caps_r *) buffer;
48 char *deviceid, *firmwareinfo, *hardwareinfo;
50 if (len < sizeof(struct mbim_basic_connect_device_caps_r)) {
51 fprintf(stderr, "message not long enough\n");
55 deviceid = mbim_get_string(&caps->deviceid, buffer);
56 firmwareinfo = mbim_get_string(&caps->firmwareinfo, buffer);
57 hardwareinfo = mbim_get_string(&caps->hardwareinfo, buffer);
59 printf(" devicetype: %04X - %s\n", le32toh(caps->devicetype),
60 mbim_enum_string(mbim_device_type_values, le32toh(caps->devicetype)));
61 printf(" cellularclass: %04X\n", le32toh(caps->cellularclass));
62 printf(" voiceclass: %04X - %s\n", le32toh(caps->voiceclass),
63 mbim_enum_string(mbim_voice_class_values, le32toh(caps->voiceclass)));
64 printf(" simclass: %04X\n", le32toh(caps->simclass));
65 printf(" dataclass: %04X\n", le32toh(caps->dataclass));
66 printf(" smscaps: %04X\n", le32toh(caps->smscaps));
67 printf(" controlcaps: %04X\n", le32toh(caps->controlcaps));
68 printf(" maxsessions: %04X\n", le32toh(caps->maxsessions));
69 printf(" deviceid: %s\n", deviceid);
70 printf(" firmwareinfo: %s\n", firmwareinfo);
71 printf(" hardwareinfo: %s\n", hardwareinfo);
77 mbim_pin_state_response(void *buffer, size_t len)
79 struct mbim_basic_connect_pin_r *pin = (struct mbim_basic_connect_pin_r *) buffer;
81 if (len < sizeof(struct mbim_basic_connect_pin_r)) {
82 fprintf(stderr, "message not long enough\n");
86 if (le32toh(pin->pinstate) != MBIM_PIN_STATE_UNLOCKED) {
87 fprintf(stderr, "required pin: %d - %s\n",
88 le32toh(pin->pintype), mbim_enum_string(mbim_pin_type_values, le32toh(pin->pintype)));
89 fprintf(stderr, "remaining attempts: %d\n", le32toh(pin->remainingattempts));
90 return le32toh(pin->pintype);
93 fprintf(stderr, "Pin Unlocked\n");
99 mbim_home_provider_response(void *buffer, size_t len)
101 struct mbim_basic_connect_home_provider_r *state = (struct mbim_basic_connect_home_provider_r *) buffer;
102 struct mbimprovider *provider;
103 char *provider_id, *provider_name;
105 if (len < sizeof(struct mbim_basic_connect_home_provider_r)) {
106 fprintf(stderr, "message not long enough\n");
110 provider = &state->provider;
111 provider_id = mbim_get_string(&provider->providerid, buffer);
112 provider_name = mbim_get_string(&provider->providername, buffer);
114 printf(" provider_id: %s\n", provider_id);
115 printf(" provider_name: %s\n", provider_name);
116 printf(" cellularclass: %04X - %s\n", le32toh(provider->cellularclass),
117 mbim_enum_string(mbim_cellular_class_values, le32toh(provider->cellularclass)));
118 printf(" rssi: %04X\n", le32toh(provider->rssi));
119 printf(" errorrate: %04X\n", le32toh(provider->errorrate));
125 mbim_registration_response(void *buffer, size_t len)
127 struct mbim_basic_connect_register_state_r *state = (struct mbim_basic_connect_register_state_r *) buffer;
128 char *provider_id, *provider_name, *roamingtext;
130 if (len < sizeof(struct mbim_basic_connect_register_state_r)) {
131 fprintf(stderr, "message not long enough\n");
135 provider_id = mbim_get_string(&state->providerid, buffer);
136 provider_name = mbim_get_string(&state->providername, buffer);
137 roamingtext = mbim_get_string(&state->roamingtext, buffer);
139 printf(" nwerror: %04X - %s\n", le32toh(state->nwerror),
140 mbim_enum_string(mbim_nw_error_values, le32toh(state->nwerror)));
141 printf(" registerstate: %04X - %s\n", le32toh(state->registerstate),
142 mbim_enum_string(mbim_register_state_values, le32toh(state->registerstate)));
143 printf(" registermode: %04X - %s\n", le32toh(state->registermode),
144 mbim_enum_string(mbim_register_mode_values, le32toh(state->registermode)));
145 printf(" availabledataclasses: %04X - %s\n", le32toh(state->availabledataclasses),
146 mbim_enum_string(mbim_data_class_values, le32toh(state->availabledataclasses)));
147 printf(" currentcellularclass: %04X - %s\n", le32toh(state->currentcellularclass),
148 mbim_enum_string(mbim_cellular_class_values, le32toh(state->currentcellularclass)));
149 printf(" provider_id: %s\n", provider_id);
150 printf(" provider_name: %s\n", provider_name);
151 printf(" roamingtext: %s\n", roamingtext);
153 if (le32toh(state->registerstate) == MBIM_REGISTER_STATE_HOME)
156 return le32toh(state->registerstate);
160 mbim_subscriber_response(void *buffer, size_t len)
162 struct mbim_basic_connect_subscriber_ready_status_r *state = (struct mbim_basic_connect_subscriber_ready_status_r *) buffer;
163 char *subscriberid, *simiccid;
166 if (len < sizeof(struct mbim_basic_connect_subscriber_ready_status_r)) {
167 fprintf(stderr, "message not long enough\n");
171 subscriberid = mbim_get_string(&state->subscriberid, buffer);
172 simiccid = mbim_get_string(&state->simiccid, buffer);
174 printf(" readystate: %04X - %s\n", le32toh(state->readystate),
175 mbim_enum_string(mbim_subscriber_ready_state_values, le32toh(state->readystate)));
176 printf(" simiccid: %s\n", simiccid);
177 printf(" subscriberid: %s\n", subscriberid);
178 if (le32toh(state->readyinfo) & MBIM_READY_INFO_FLAG_PROTECT_UNIQUE_ID)
179 printf(" dont display subscriberID: 1\n");
180 for (nr = 0; nr < le32toh(state->telephonenumberscount); nr++) {
181 struct mbim_string *str = (void *)&state->telephonenumbers + (nr * sizeof(struct mbim_string));
182 char *number = mbim_get_string(str, buffer);
183 printf(" number: %s\n", number);
186 if (MBIM_SUBSCRIBER_READY_STATE_INITIALIZED == le32toh(state->readystate))
189 return le32toh(state->readystate);
193 mbim_attach_response(void *buffer, size_t len)
195 struct mbim_basic_connect_packet_service_r *ps = (struct mbim_basic_connect_packet_service_r *) buffer;
197 if (len < sizeof(struct mbim_basic_connect_packet_service_r)) {
198 fprintf(stderr, "message not long enough\n");
202 printf(" nwerror: %04X - %s\n", le32toh(ps->nwerror),
203 mbim_enum_string(mbim_nw_error_values, le32toh(ps->nwerror)));
204 printf(" packetservicestate: %04X - %s\n", le32toh(ps->packetservicestate),
205 mbim_enum_string(mbim_packet_service_state_values, le32toh(ps->packetservicestate)));
206 printf(" uplinkspeed: %"PRIu64"\n", (uint64_t) le64toh(ps->uplinkspeed));
207 printf(" downlinkspeed: %"PRIu64"\n", (uint64_t) le64toh(ps->downlinkspeed));
209 if (MBIM_PACKET_SERVICE_STATE_ATTACHED == le32toh(ps->packetservicestate))
212 return le32toh(ps->packetservicestate);
216 mbim_connect_response(void *buffer, size_t len)
218 struct mbim_basic_connect_connect_r *c = (struct mbim_basic_connect_connect_r *) buffer;
220 if (len < sizeof(struct mbim_basic_connect_connect_r)) {
221 fprintf(stderr, "message not long enough\n");
225 printf(" sessionid: %d\n", le32toh(c->sessionid));
226 printf(" activationstate: %04X - %s\n", le32toh(c->activationstate),
227 mbim_enum_string(mbim_activation_state_values, le32toh(c->activationstate)));
228 printf(" voicecallstate: %04X - %s\n", le32toh(c->voicecallstate),
229 mbim_enum_string(mbim_voice_call_state_values, le32toh(c->voicecallstate)));
230 printf(" nwerror: %04X - %s\n", le32toh(c->nwerror),
231 mbim_enum_string(mbim_nw_error_values, le32toh(c->nwerror)));
232 printf(" iptype: %04X - %s\n", le32toh(c->iptype),
233 mbim_enum_string(mbim_context_ip_type_values, le32toh(c->iptype)));
235 if (MBIM_ACTIVATION_STATE_ACTIVATED == le32toh(c->activationstate))
238 return le32toh(c->activationstate);
242 mbim_config_response(void *buffer, size_t len)
244 struct mbim_basic_connect_ip_configuration_r *ip = (struct mbim_basic_connect_ip_configuration_r *) buffer;
249 if (len < sizeof(struct mbim_basic_connect_ip_configuration_r)) {
250 fprintf(stderr, "message not long enough\n");
254 if (le32toh(ip->ipv4configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_ADDRESS)
255 for (i = 0; i < le32toh(ip->ipv4addresscount); i++) {
256 offset = le32toh(ip->ipv4address) + (i * 4);
257 mbim_get_ipv4(buffer, out, 4 + offset);
258 printf(" ipv4address: %s/%d\n", out, mbim_get_int(buffer, offset));
260 if (le32toh(ip->ipv4configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_DNS) {
261 mbim_get_ipv4(buffer, out, le32toh(ip->ipv4gateway));
262 printf(" ipv4gateway: %s\n", out);
264 if (le32toh(ip->ipv4configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_MTU)
265 printf(" ipv4mtu: %d\n", le32toh(ip->ipv4mtu));
266 if (le32toh(ip->ipv4configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_DNS)
267 for (i = 0; i < le32toh(ip->ipv4dnsservercount); i++) {
268 mbim_get_ipv4(buffer, out, le32toh(ip->ipv4dnsserver) + (i * 4));
269 printf(" ipv4dnsserver: %s\n", out);
272 if (le32toh(ip->ipv6configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_ADDRESS)
273 for (i = 0; i < le32toh(ip->ipv6addresscount); i++) {
274 offset = le32toh(ip->ipv6address) + (i * 16);
275 mbim_get_ipv6(buffer, out, 4 + offset);
276 printf(" ipv6address: %s/%d\n", out, mbim_get_int(buffer, offset));
278 if (le32toh(ip->ipv6configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_DNS) {
279 mbim_get_ipv6(buffer, out, le32toh(ip->ipv6gateway));
280 printf(" ipv6gateway: %s\n", out);
282 if (le32toh(ip->ipv6configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_MTU)
283 printf(" ipv6mtu: %d\n", le32toh(ip->ipv6mtu));
284 if (le32toh(ip->ipv6configurationavailable) & MBIM_IP_CONFIGURATION_AVAILABLE_FLAG_DNS)
285 for (i = 0; i < le32toh(ip->ipv6dnsservercount); i++) {
286 mbim_get_ipv6(buffer, out, le32toh(ip->ipv6dnsserver) + (i * 16));
287 printf(" ipv6dnsserver: %s\n", out);
294 mbim_radio_response(void *buffer, size_t len)
296 struct mbim_basic_connect_radio_state_r *r = (struct mbim_basic_connect_radio_state_r *) buffer;
298 if (len < sizeof(struct mbim_basic_connect_radio_state_r)) {
299 fprintf(stderr, "message not long enough\n");
302 printf(" hwradiostate: %s\n", r->hwradiostate ? "on" : "off");
303 printf(" swradiostate: %s\n", r->swradiostate ? "on" : "off");
308 mbim_device_caps_request(void)
310 mbim_setup_command_msg(basic_connect, MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_DEVICE_CAPS, 0);
312 return mbim_send_command_msg();
316 mbim_pin_state_request(void)
318 mbim_setup_command_msg(basic_connect, MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_PIN, 0);
320 return mbim_send_command_msg();
324 mbim_home_provider_request(void)
326 mbim_setup_command_msg(basic_connect, MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CID_BASIC_CONNECT_HOME_PROVIDER, 0);
328 return mbim_send_command_msg();
332 mbim_registration_request(void)
335 struct mbim_basic_connect_register_state_s *rs =
336 (struct mbim_basic_connect_register_state_s *) mbim_setup_command_msg(basic_connect,
337 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_REGISTER_STATE,
338 sizeof(struct mbim_basic_connect_register_state_s));
340 rs->registeraction = htole32(MBIM_REGISTER_ACTION_AUTOMATIC);
342 mbim_setup_command_msg(basic_connect, MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_REGISTER_STATE, 0);
345 return mbim_send_command_msg();
349 mbim_subscriber_request(void)
351 mbim_setup_command_msg(basic_connect, MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_SUBSCRIBER_READY_STATUS, 0);
353 return mbim_send_command_msg();
357 _mbim_attach_request(int action)
359 struct mbim_basic_connect_packet_service_s *ps =
360 (struct mbim_basic_connect_packet_service_s *) mbim_setup_command_msg(basic_connect,
361 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_PACKET_SERVICE,
362 sizeof(struct mbim_basic_connect_packet_service_s));
364 ps->packetserviceaction = htole32(action);
366 return mbim_send_command_msg();
370 mbim_attach_request(void)
372 return _mbim_attach_request(MBIM_PACKET_SERVICE_ACTION_ATTACH);
376 mbim_detach_request(void)
378 return _mbim_attach_request(MBIM_PACKET_SERVICE_ACTION_DETACH);
382 mbim_connect_request(void)
385 struct mbim_basic_connect_connect_s *c =
386 (struct mbim_basic_connect_connect_s *) mbim_setup_command_msg(basic_connect,
387 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_CONNECT,
388 sizeof(struct mbim_basic_connect_connect_s));
390 c->activationcommand = htole32(MBIM_ACTIVATION_COMMAND_ACTIVATE);
391 c->iptype = htole32(MBIM_CONTEXT_IP_TYPE_DEFAULT);
392 memcpy(c->contexttype, uuid_context_type_internet, 16);
394 apn = index(*_argv, ':');
400 if (!strcmp(*_argv, "ipv4"))
401 c->iptype = htole32(MBIM_CONTEXT_IP_TYPE_IPV4);
402 else if (!strcmp(*_argv, "ipv6"))
403 c->iptype = htole32(MBIM_CONTEXT_IP_TYPE_IPV6);
404 else if (!strcmp(*_argv, "ipv4v6"))
405 c->iptype = htole32(MBIM_CONTEXT_IP_TYPE_IPV4V6);
407 mbim_encode_string(&c->accessstring, apn);
410 if (!strcmp(_argv[1], "pap"))
411 c->authprotocol = htole32(MBIM_AUTH_PROTOCOL_PAP);
412 else if (!strcmp(_argv[1], "chap"))
413 c->authprotocol = htole32(MBIM_AUTH_PROTOCOL_CHAP);
414 else if (!strcmp(_argv[1], "mschapv2"))
415 c->authprotocol = htole32(MBIM_AUTH_PROTOCOL_MSCHAPV2);
417 if (c->authprotocol) {
418 mbim_encode_string(&c->username, _argv[2]);
419 mbim_encode_string(&c->password, _argv[3]);
422 return mbim_send_command_msg();
426 mbim_disconnect_request(void)
428 struct mbim_basic_connect_connect_s *c =
429 (struct mbim_basic_connect_connect_s *) mbim_setup_command_msg(basic_connect,
430 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_CONNECT,
431 sizeof(struct mbim_basic_connect_connect_s));
433 c->activationcommand = htole32(MBIM_ACTIVATION_COMMAND_DEACTIVATE);
434 memcpy(c->contexttype, uuid_context_type_internet, 16);
438 return mbim_send_command_msg();
442 mbim_pin_sanitize(char *pin)
446 while (*pin && !isdigit(*pin))
451 while (*pin && isdigit(*pin))
460 mbim_pin_unlock_request(void)
462 struct mbim_basic_connect_pin_s *p =
463 (struct mbim_basic_connect_pin_s *) mbim_setup_command_msg(basic_connect,
464 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_PIN,
465 sizeof(struct mbim_basic_connect_pin_s));
466 char *pin = mbim_pin_sanitize(_argv[0]);
468 if (!pin || !strlen(pin)) {
469 fprintf(stderr, "failed to sanitize the pincode\n");
473 p->pintype = htole32(MBIM_PIN_TYPE_PIN1);
474 p->pinoperation = htole32(MBIM_PIN_OPERATION_ENTER);
475 mbim_encode_string(&p->pin, _argv[0]);
477 return mbim_send_command_msg();
481 mbim_config_request(void)
483 mbim_setup_command_msg(basic_connect,
484 MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_IP_CONFIGURATION,
485 sizeof(struct mbim_basic_connect_ip_configuration_q));
487 return mbim_send_command_msg();
491 mbim_radio_request(void)
494 struct mbim_basic_connect_radio_state_s *rs =
495 (struct mbim_basic_connect_radio_state_s *) mbim_setup_command_msg(basic_connect,
496 MBIM_MESSAGE_COMMAND_TYPE_SET, MBIM_CMD_BASIC_CONNECT_RADIO_STATE,
497 sizeof(struct mbim_basic_connect_radio_state_r));
499 if (!strcmp(_argv[0], "off"))
500 rs->radiostate = htole32(MBIM_RADIO_SWITCH_STATE_OFF);
502 rs->radiostate = htole32(MBIM_RADIO_SWITCH_STATE_ON);
504 mbim_setup_command_msg(basic_connect,
505 MBIM_MESSAGE_COMMAND_TYPE_QUERY, MBIM_CMD_BASIC_CONNECT_RADIO_STATE,
506 sizeof(struct mbim_basic_connect_radio_state_r));
508 return mbim_send_command_msg();
511 static struct mbim_handler handlers[] = {
512 { "caps", 0, mbim_device_caps_request, mbim_device_caps_response },
513 { "pinstate", 0, mbim_pin_state_request, mbim_pin_state_response },
514 { "unlock", 1, mbim_pin_unlock_request, mbim_pin_state_response },
515 { "home", 0, mbim_home_provider_request, mbim_home_provider_response },
516 { "registration", 0, mbim_registration_request, mbim_registration_response },
517 { "subscriber", 0, mbim_subscriber_request, mbim_subscriber_response },
518 { "attach", 0, mbim_attach_request, mbim_attach_response },
519 { "detach", 0, mbim_detach_request, mbim_attach_response },
520 { "connect", 0, mbim_connect_request, mbim_connect_response },
521 { "disconnect", 0, mbim_disconnect_request, mbim_connect_response },
522 { "config", 0, mbim_config_request, mbim_config_response },
523 { "radio", 0, mbim_radio_request, mbim_radio_response },
529 fprintf(stderr, "Usage: umbim <caps|pinstate|unlock|home|registration|subscriber|attach|detach|connect|disconnect|config|radio> [options]\n"
531 #ifdef LIBQMI_MBIM_PROXY
532 " -p use mbim-proxy\n"
534 " -d <device> the device (/dev/cdc-wdmX)\n"
535 " -t <transaction> the transaction id\n"
542 main(int argc, char **argv)
544 char *cmd, *device = NULL;
547 #ifdef LIBQMI_MBIM_PROXY
551 while ((ch = getopt(argc, argv, "pnvd:t:")) != -1) {
564 transaction_id = atoi(optarg);
566 #ifdef LIBQMI_MBIM_PROXY
576 if (!device || optind == argc)
582 _argc = argc - optind;
583 _argv = &argv[optind];
585 for (i = 0; i < ARRAY_SIZE(handlers); i++)
586 if (!strcmp(cmd, handlers[i].name))
587 current_handler = &handlers[i];
589 if (!current_handler || (optind + current_handler->argc > argc))
594 #ifdef LIBQMI_MBIM_PROXY
596 mbim_proxy_open(device);
601 mbim_send_open_msg();
602 else if (current_handler->request() < 0)