Home | History | Annotate | Line # | Download | only in umbctl
umbctl.c revision 1.1 
      1 /* $NetBSD: umbctl.c,v 1.1 2018/07/31 16:44:29 khorben Exp $ */
      2 /*
      3  * Copyright (c) 2018 Pierre Pronchery <khorben (at) defora.org>
      4  *
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR
     17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     19  * IN NO EVENT SHALL THE DEVELOPERS BE LIABLE FOR ANY DIRECT, INDIRECT,
     20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 
     29 
     30 #include <sys/endian.h>
     31 #include <sys/ioctl.h>
     32 #include <sys/socket.h>
     33 
     34 #include <net/if.h>
     35 
     36 #include <ctype.h>
     37 #include <errno.h>
     38 #include <stdarg.h>
     39 #include <stdio.h>
     40 #include <string.h>
     41 #include <unistd.h>
     42 
     43 #include <dev/usb/mbim.h>
     44 #include <dev/usb/if_umbreg.h>
     45 
     46 
     47 /* constants */
     48 static const struct umb_valdescr _umb_regstate[] =
     49 	MBIM_REGSTATE_DESCRIPTIONS;
     50 
     51 static const struct umb_valdescr _umb_dataclass[] =
     52 	MBIM_DATACLASS_DESCRIPTIONS;
     53 
     54 static const struct umb_valdescr _umb_state[] =
     55 	UMB_INTERNAL_STATE_DESCRIPTIONS;
     56 
     57 static const struct umb_valdescr _umb_regmode[] =
     58 {
     59 	{ MBIM_REGMODE_UNKNOWN, "unknown" },
     60 	{ MBIM_REGMODE_AUTOMATIC, "automatic" },
     61 	{ MBIM_REGMODE_MANUAL, "manual" },
     62 	{ 0, NULL }
     63 };
     64 
     65 static const struct umb_valdescr _umb_ber[] =
     66 {
     67 	{ UMB_BER_EXCELLENT, "excellent" },
     68 	{ UMB_BER_VERYGOOD, "very good" },
     69 	{ UMB_BER_GOOD, "good" },
     70 	{ UMB_BER_OK, "ok" },
     71 	{ UMB_BER_MEDIUM, "medium" },
     72 	{ UMB_BER_BAD, "bad" },
     73 	{ UMB_BER_VERYBAD, "very bad" },
     74 	{ UMB_BER_EXTREMELYBAD, "extremely bad" },
     75 	{ 0, NULL }
     76 };
     77 
     78 
     79 /* prototypes */
     80 static int _char_to_utf16(const char * in, uint16_t * out, size_t outlen);
     81 static int _error(int ret, char const * format, ...);
     82 static int _umbctl(char const * ifname, int verbose, int argc, char * argv[]);
     83 static int _umbctl_file(char const * ifname, char const * filename, int verbose,
     84 		int argc, char * argv[]);
     85 static void _umbctl_info(char const * ifname, struct umb_info * umbi);
     86 static int _umbctl_ioctl(char const * ifname, int fd, unsigned long request,
     87 		struct ifreq * ifr);
     88 static int _umbctl_set(char const * ifname, struct umb_parameter * umbp,
     89 		int argc, char * argv[]);
     90 static int _umbctl_socket(void);
     91 static int _usage(void);
     92 static void _utf16_to_char(uint16_t *in, int inlen, char *out, size_t outlen);
     93 
     94 
     95 /* functions */
     96 /* char_to_utf16 */
     97 /* this function is from OpenBSD's ifconfig(8) */
     98 static int _char_to_utf16(const char * in, uint16_t * out, size_t outlen)
     99 {
    100 	int	n = 0;
    101 	uint16_t c;
    102 
    103 	for (;;) {
    104 		c = *in++;
    105 
    106 		if (c == '\0') {
    107 			/*
    108 			 * NUL termination is not required, but zero out the
    109 			 * residual buffer
    110 			 */
    111 			memset(out, 0, outlen);
    112 			return n;
    113 		}
    114 		if (outlen < sizeof(*out))
    115 			return -1;
    116 
    117 		*out++ = htole16(c);
    118 		n += sizeof(*out);
    119 		outlen -= sizeof(*out);
    120 	}
    121 }
    122 
    123 
    124 /* error */
    125 static int _error(int ret, char const * format, ...)
    126 {
    127 	va_list ap;
    128 
    129 	fputs("umbctl: ", stderr);
    130 	va_start(ap, format);
    131 	vfprintf(stderr, format, ap);
    132 	va_end(ap);
    133 	fputs("\n", stderr);
    134 	return ret;
    135 }
    136 
    137 
    138 /* umbctl */
    139 static int _umbctl(char const * ifname, int verbose, int argc, char * argv[])
    140 {
    141 	int fd;
    142 	struct ifreq ifr;
    143 	struct umb_info umbi;
    144 	struct umb_parameter umbp;
    145 
    146 	if((fd = _umbctl_socket()) < 0)
    147 		return 2;
    148 	memset(&ifr, 0, sizeof(ifr));
    149 	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
    150 	if(argc != 0)
    151 	{
    152 		memset(&umbp, 0, sizeof(umbp));
    153 		ifr.ifr_data = &umbp;
    154 		if(_umbctl_ioctl(ifname, fd, SIOCGUMBPARAM, &ifr) != 0
    155 				|| _umbctl_set(ifname, &umbp, argc, argv) != 0
    156 				|| _umbctl_ioctl(ifname, fd, SIOCSUMBPARAM,
    157 					&ifr) != 0)
    158 		{
    159 			close(fd);
    160 			return 2;
    161 		}
    162 	}
    163 	if(argc == 0 || verbose > 0)
    164 	{
    165 		ifr.ifr_data = &umbi;
    166 		if(_umbctl_ioctl(ifname, fd, SIOCGUMBINFO, &ifr) != 0)
    167 		{
    168 			close(fd);
    169 			return 3;
    170 		}
    171 		_umbctl_info(ifname, &umbi);
    172 	}
    173 	if(close(fd) != 0)
    174 		return _error(2, "%s: %s", ifname, strerror(errno));
    175 	return 0;
    176 }
    177 
    178 
    179 /* umbctl_file */
    180 static int _umbctl_file(char const * ifname, char const * filename, int verbose,
    181 		int argc, char * argv[])
    182 {
    183 	int fd;
    184 	struct ifreq ifr;
    185 	struct umb_info umbi;
    186 	struct umb_parameter umbp;
    187 	FILE * fp;
    188 	char buf[512];
    189 	int eof;
    190 	char * tokens[3] = { buf, NULL, NULL };
    191 	char * p;
    192 
    193 	if((fp = fopen(filename, "r")) == NULL)
    194 		return _error(2, "%s: %s", filename, strerror(errno));
    195 	memset(&umbp, 0, sizeof(umbp));
    196 	while(fgets(buf, sizeof(buf), fp) != NULL)
    197 	{
    198 		if(buf[0] == '#')
    199 			continue;
    200 		buf[sizeof(buf) - 1] = '\0';
    201 		if((p = strstr(buf, "=")) != NULL)
    202 		{
    203 			tokens[1] = p + 1;
    204 			*p = '\0';
    205 		} else
    206 			tokens[1] = NULL;
    207 		if(_umbctl_set(ifname, &umbp, (p != NULL) ? 2 : 1, tokens) != 0)
    208 			break;
    209 	}
    210 	eof = feof(fp);
    211 	if(fclose(fp) != 0 || !eof)
    212 		return _error(2, "%s: %s", filename, strerror(errno));
    213 	if((fd = _umbctl_socket()) < 0)
    214 		return 2;
    215 	memset(&ifr, 0, sizeof(ifr));
    216 	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
    217 	ifr.ifr_data = &umbp;
    218 	if(_umbctl_ioctl(ifname, fd, SIOCGUMBPARAM, &ifr) != 0
    219 			|| _umbctl_set(ifname, &umbp, argc, argv) != 0
    220 			|| _umbctl_ioctl(ifname, fd, SIOCSUMBPARAM, &ifr) != 0)
    221 	{
    222 		close(fd);
    223 		return 2;
    224 	}
    225 	if(verbose > 0)
    226 	{
    227 		ifr.ifr_data = &umbi;
    228 		if(_umbctl_ioctl(ifname, fd, SIOCGUMBINFO, &ifr) != 0)
    229 		{
    230 			close(fd);
    231 			return 3;
    232 		}
    233 		_umbctl_info(ifname, &umbi);
    234 	}
    235 	if(close(fd) != 0)
    236 		return _error(2, "%s: %s", ifname, strerror(errno));
    237 	return 0;
    238 }
    239 
    240 
    241 /* umbctl_info */
    242 static void _umbctl_info(char const * ifname, struct umb_info * umbi)
    243 {
    244 	char provider[UMB_PROVIDERNAME_MAXLEN + 1];
    245 	char pn[UMB_PHONENR_MAXLEN + 1];
    246 	char roaming[UMB_ROAMINGTEXT_MAXLEN + 1];
    247 	char apn[UMB_APN_MAXLEN + 1];
    248 	char fwinfo[UMB_FWINFO_MAXLEN + 1];
    249 	char hwinfo[UMB_HWINFO_MAXLEN + 1];
    250 
    251 	_utf16_to_char(umbi->provider, UMB_PROVIDERNAME_MAXLEN,
    252 			provider, sizeof(provider));
    253 	_utf16_to_char(umbi->pn, UMB_PHONENR_MAXLEN, pn, sizeof(pn));
    254 	_utf16_to_char(umbi->roamingtxt, UMB_ROAMINGTEXT_MAXLEN,
    255 			roaming, sizeof(roaming));
    256 	_utf16_to_char(umbi->apn, UMB_APN_MAXLEN, apn, sizeof(apn));
    257 	_utf16_to_char(umbi->fwinfo, UMB_FWINFO_MAXLEN, fwinfo, sizeof(fwinfo));
    258 	_utf16_to_char(umbi->hwinfo, UMB_HWINFO_MAXLEN, hwinfo, sizeof(hwinfo));
    259 	printf("%s: state %s, mode %s, registration %s\n"
    260 			"\tprovider \"%s\", dataclass %s, signal %s\n"
    261 			"\tphone number \"%s\", roaming \"%s\" (%s)\n"
    262 			"\tAPN \"%s\", TX %" PRIu64 ", RX %" PRIu64 "\n"
    263 			"\tfirmware \"%s\", hardware \"%s\"\n",
    264 			ifname, umb_val2descr(_umb_state, umbi->state),
    265 			umb_val2descr(_umb_regmode, umbi->regmode),
    266 			umb_val2descr(_umb_regstate, umbi->regstate), provider,
    267 			umb_val2descr(_umb_dataclass, umbi->cellclass),
    268 			umb_val2descr(_umb_ber, umbi->ber), pn, roaming,
    269 			umbi->enable_roaming ? "allowed" : "denied",
    270 			apn, umbi->uplink_speed, umbi->downlink_speed,
    271 			fwinfo, hwinfo);
    272 }
    273 
    274 
    275 /* umbctl_ioctl */
    276 static int _umbctl_ioctl(char const * ifname, int fd, unsigned long request,
    277 		struct ifreq * ifr)
    278 {
    279 	if(ioctl(fd, request, ifr) != 0)
    280 		return _error(-1, "%s: %s", ifname, strerror(errno));
    281 	return 0;
    282 }
    283 
    284 
    285 /* umbctl_set */
    286 /* callbacks */
    287 static int _set_apn(char const *, struct umb_parameter *, char const *);
    288 static int _set_username(char const *, struct umb_parameter *, char const *);
    289 static int _set_password(char const *, struct umb_parameter *, char const *);
    290 static int _set_pin(char const *, struct umb_parameter *, char const *);
    291 static int _set_puk(char const *, struct umb_parameter *, char const *);
    292 static int _set_roaming_allow(char const *, struct umb_parameter *,
    293 		char const *);
    294 static int _set_roaming_deny(char const *, struct umb_parameter *,
    295 		char const *);
    296 
    297 static int _umbctl_set(char const * ifname, struct umb_parameter * umbp,
    298 		int argc, char * argv[])
    299 {
    300 	struct
    301 	{
    302 		char const * name;
    303 		int (*callback)(char const *,
    304 				struct umb_parameter *, char const *);
    305 		int parameter;
    306 	} callbacks[] =
    307 	{
    308 		{ "apn", _set_apn, 1 },
    309 		{ "username", _set_username, 1 },
    310 		{ "password", _set_password, 1 },
    311 		{ "pin", _set_pin, 1 },
    312 		{ "puk", _set_puk, 1 },
    313 		{ "roaming", _set_roaming_allow, 0 },
    314 		{ "-roaming", _set_roaming_deny, 0 },
    315 	};
    316 	int i;
    317 	size_t j;
    318 
    319 	for(i = 0; i < argc; i++)
    320 	{
    321 		for(j = 0; j < sizeof(callbacks) / sizeof(*callbacks); j++)
    322 			if(strcmp(argv[i], callbacks[j].name) == 0)
    323 			{
    324 				if(callbacks[j].parameter && i + 1 == argc)
    325 					return _error(-1, "%s: Incomplete"
    326 							" parameter", argv[i]);
    327 				if(callbacks[j].callback(ifname, umbp,
    328 							callbacks[j].parameter
    329 							? argv[i + 1] : NULL))
    330 					return -1;
    331 				if(callbacks[j].parameter)
    332 					i++;
    333 				break;
    334 			}
    335 		if(j == sizeof(callbacks) / sizeof(*callbacks))
    336 			return _error(-1, "%s: Unknown parameter", argv[i]);
    337 	}
    338 	return 0;
    339 }
    340 
    341 static int _set_apn(char const * ifname, struct umb_parameter * umbp,
    342 		char const * apn)
    343 {
    344 	umbp->apnlen = _char_to_utf16(apn, umbp->apn, sizeof(umbp->apn));
    345 	if(umbp->apnlen < 0 || (size_t)umbp->apnlen > sizeof(umbp->apn))
    346 		return _error(-1, "%s: %s", ifname, "APN too long");
    347 	return 0;
    348 }
    349 
    350 static int _set_username(char const * ifname, struct umb_parameter * umbp,
    351 		char const * username)
    352 {
    353 	umbp->usernamelen = _char_to_utf16(username, umbp->username,
    354 			sizeof(umbp->username));
    355 	if(umbp->usernamelen < 0
    356 			|| (size_t)umbp->usernamelen > sizeof(umbp->username))
    357 		return _error(-1, "%s: %s", ifname, "Username too long");
    358 	return 0;
    359 }
    360 
    361 static int _set_password(char const * ifname, struct umb_parameter * umbp,
    362 		char const * password)
    363 {
    364 	umbp->passwordlen = _char_to_utf16(password, umbp->password,
    365 			sizeof(umbp->password));
    366 	if(umbp->passwordlen < 0
    367 			|| (size_t)umbp->passwordlen > sizeof(umbp->password))
    368 		return _error(-1, "%s: %s", ifname, "Password too long");
    369 	return 0;
    370 }
    371 
    372 static int _set_pin(char const * ifname, struct umb_parameter * umbp,
    373 		char const * pin)
    374 {
    375 	umbp->is_puk = 0;
    376 	umbp->op = MBIM_PIN_OP_ENTER;
    377 	umbp->pinlen = _char_to_utf16(pin, umbp->pin, sizeof(umbp->pin));
    378 	if(umbp->pinlen < 0 || (size_t)umbp->pinlen
    379 			> sizeof(umbp->pin))
    380 		return _error(-1, "%s: %s", ifname, "PIN code too long");
    381 	return 0;
    382 }
    383 
    384 static int _set_puk(char const * ifname, struct umb_parameter * umbp,
    385 		char const * puk)
    386 {
    387 	umbp->is_puk = 1;
    388 	umbp->op = MBIM_PIN_OP_ENTER;
    389 	umbp->pinlen = _char_to_utf16(puk, umbp->pin, sizeof(umbp->pin));
    390 	if(umbp->pinlen < 0 || (size_t)umbp->pinlen > sizeof(umbp->pin))
    391 		return _error(-1, "%s: %s", ifname, "PUK code too long");
    392 	return 0;
    393 }
    394 
    395 static int _set_roaming_allow(char const * ifname, struct umb_parameter * umbp,
    396 		char const * unused)
    397 {
    398 	(void) ifname;
    399 	(void) unused;
    400 
    401 	umbp->roaming = 1;
    402 	return 0;
    403 }
    404 
    405 static int _set_roaming_deny(char const * ifname, struct umb_parameter * umbp,
    406 		char const * unused)
    407 {
    408 	(void) ifname;
    409 	(void) unused;
    410 
    411 	umbp->roaming = 0;
    412 	return 0;
    413 }
    414 
    415 
    416 /* umbctl_socket */
    417 static int _umbctl_socket(void)
    418 {
    419 	int fd;
    420 
    421 	if((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    422 		return _error(-1, "socket: %s", strerror(errno));
    423 	return fd;
    424 }
    425 
    426 
    427 /* usage */
    428 static int _usage(void)
    429 {
    430 	fputs("Usage: umbctl [-v] ifname [parameter[=value]] [...]\n"
    431 "       umbctl -f config-file ifname [...]\n",
    432 			stderr);
    433 	return 1;
    434 }
    435 
    436 
    437 /* utf16_to_char */
    438 static void _utf16_to_char(uint16_t *in, int inlen, char *out, size_t outlen)
    439 {
    440 	uint16_t c;
    441 
    442 	while (outlen > 0) {
    443 		c = inlen > 0 ? htole16(*in) : 0;
    444 		if (c == 0 || --outlen == 0) {
    445 			/* always NUL terminate result */
    446 			*out = '\0';
    447 			break;
    448 		}
    449 		*out++ = isascii(c) ? (char)c : '?';
    450 		in++;
    451 		inlen--;
    452 	}
    453 }
    454 
    455 
    456 /* main */
    457 int main(int argc, char * argv[])
    458 {
    459 	int o;
    460 	char const * filename = NULL;
    461 	int verbose = 0;
    462 
    463 	while((o = getopt(argc, argv, "f:v")) != -1)
    464 		switch(o)
    465 		{
    466 			case 'f':
    467 				filename = optarg;
    468 				break;
    469 			case 'v':
    470 				verbose++;
    471 				break;
    472 			default:
    473 				return _usage();
    474 		}
    475 	if(optind == argc)
    476 		return _usage();
    477 	if(filename != NULL)
    478 		return _umbctl_file(argv[optind], filename, verbose,
    479 				argc - optind - 1, &argv[optind + 1]);
    480 	return _umbctl(argv[optind], verbose, argc - optind - 1,
    481 			&argv[optind + 1]);
    482 }
    483