umbctl \

CFLAGS+= -I${SRCTOP}/sys/dev/usb/net

PROG=	umbctl

MAN=	umbctl.8

BINDIR=	/sbin

.include <bsd.prog.mk>

.\"	$NetBSD$

.\"

.\" Copyright (c) 2018 by Pierre Pronchery <khorben@defora.org>

.\" All rights reserved.

.\"

.\" Redistribution and use in source and binary forms, with or without

.\" modification, are permitted provided that the following conditions

.\" are met:

.\" 1. Redistributions of source code must retain the above copyright

.\"    notice, this list of conditions and the following disclaimer.

.\" 2. Redistributions in binary form must reproduce the above copyright

.\"    notice, this list of conditions and the following disclaimer in the

.\"    documentation and/or other materials provided with the distribution.

.\"

.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS

.\" OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

.\" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

.\" DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,

.\" INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

.\" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

.\" SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

.\" STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

.\" IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

.\" POSSIBILITY OF SUCH DAMAGE.

.\"

.\" From: pppoectl.8,v 1.30 2016/09/12 05:35:20 sevan Exp $

.\"

.\" $Id$

.\"

.\" last edit-date: [Thu Aug 31 10:47:33 2000]

.\"

.Dd March 22, 2020

.Dt UMBCTL 8

.Os

.Sh NAME

.Nm umbctl

.Nd display or set parameters for a MBIM interface (4G/LTE)

.Sh SYNOPSIS

.Nm umbctl

.Op Fl v

.Ar ifname

.Op Ar parameter Op Ar value

.Ar ...

.Pp

.Nm umbctl

.Op Fl v

.Fl f Ar config-file

.Ar ifname

.Pp

.Nm umbctl

.Op Fl v

.Fl m Ar format

.Ar ifname

.Pp

.Sh DESCRIPTION

.Nm

supports the following options:

.Bl -tag -width XfXconfigXfileXXX -offset indent

.It Fl f Ar config-file

Parse

.Ar config-file

for

.Ar parameter Ns Op \&= Ns Ar value

pairs, one per line, as if they had been specified on the command line.

This allows the password or PIN codes to be not passed as command line

arguments.

Comments starting with # to the end of the current line are ignored.

.It Fl m Ar format

Displays the current settings in the

.Ar format

specified.

.It Fl v

Enables verbose mode.

.El

.Pp

The

.Xr umb 4

driver may require a number of additional arguments or optional

parameters besides the settings that can be adjusted with

.Xr ifconfig 8 .

These may be credentials or other tunable connectivity variables.

The

.Nm

utility can be used to display the current settings, or adjust these

parameters as required.

.Pp

For whatever intent

.Nm

is being called, at least the parameter

.Ar ifname

needs to be specified, naming the interface for which the settings

are to be performed or displayed.

Use

.Xr ifconfig 8

or

.Xr netstat 1

to see which interfaces are available.

.Pp

If no other parameter is given,

.Nm

will just list the current status for

.Ar ifname

and exit.

.Pp

If any additional parameter is supplied, superuser privileges are

required, and the command works in

.Ql set

mode.

This is normally done quietly, unless the option

.Fl v

is also enabled, which will cause a final printout of the status as

described above once all other actions have been taken.

.Pp

The parameters currently supported include:

.Bl -tag -width xxxxxxxxxxxxxxxxxxxxxxxxx -offset indent

.It Ar apn Ns \&= Ns Em access-point

Set the APN to

.Em access-point .

.It Ar username Ns \&= Ns Em username

Set the username to

.Em username .

.It Ar password Ns \&= Ns Em password

Set the password to

.Em password .

.It Ar pin Ns \&= Ns Em pin-code

Enter the PIN

.Em pin-code .

.It Ar puk Ns \&= Ns Em puk-code

Enter the PUK

.Em puk-code .

.It Ar roaming

Allow data connections when roaming.

.It Ar -roaming

Deny data connections when roaming.

.El

.Sh EXAMPLES

.Bd -literal

# umbctl umb0

umb0: state up, mode automatic, registration home network

	provider "BSD-Net", dataclass LTE, signal good

	phone number "+15554242", roaming "" (denied)

	APN "", TX 50000000, RX 100000000

	firmware "MBIM_FW_V1.0", hardware "MBIM_HW_V1.0"

.Ed

.Pp

Display the settings for umb0.

.Bd -literal

# umbctl umb0 apn operator.internet username mobile password mobile

.Ed

.Pp

Configure the connection parameters for umb0 from the command line.

.Bd -literal

# umbctl -f /dev/stdin umb0 << EOF

pin=1234

EOF

.Ed

.Pp

Configure the connection parameters for umb0 from a file.

.Sh SEE ALSO

.Xr netstat 1 ,

.Xr umb 4 ,

.Xr ifconfig 8 ,

.Xr ifwatchd 8

.Sh HISTORY

The

.Nm

utility first appeared in

.Nx 9.0 .

.Sh AUTHORS

The program was written by

.An Pierre Pronchery .

/* $FreeBSD$ */

/* $NetBSD$ */

/*

 * Original copyright (c) 2018 Pierre Pronchery <khorben@defora.org> (for the

 * NetBSD Project)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE DEVELOPERS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * Copyright (c) 2022 ADISTA SAS (FreeBSD updates)

 *

 * Updates for FreeBSD by Pierre Pronchery <pierre@defora.net>

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * - Redistributions of source code must retain the above copyright notice,

 *   this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright notice,

 *   this list of conditions and the following disclaimer in the documentation

 *   and/or other materials provided with the distribution.

 * - Neither the name of the copyright holder nor the names of its contributors

 *   may be used to endorse or promote products derived from this software

 *   without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/endian.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <sys/sockio.h>

#include <net/if.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <ctype.h>

#include <errno.h>

#include <inttypes.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include "mbim.h"

#include "if_umbreg.h"

/* constants */

static const struct umb_valdescr _umb_actstate[] =

	MBIM_ACTIVATION_STATE_DESCRIPTIONS;

static const struct umb_valdescr _umb_simstate[] =

	MBIM_SIMSTATE_DESCRIPTIONS;

static const struct umb_valdescr _umb_regstate[] =

	MBIM_REGSTATE_DESCRIPTIONS;

static const struct umb_valdescr _umb_pktstate[] =

	MBIM_PKTSRV_STATE_DESCRIPTIONS;

static const struct umb_valdescr _umb_dataclass[] =

	MBIM_DATACLASS_DESCRIPTIONS;

static const struct umb_valdescr _umb_state[] =

	UMB_INTERNAL_STATE_DESCRIPTIONS;

static const struct umb_valdescr _umb_pin_state[] =

{

	{ UMB_PIN_REQUIRED, "PIN required"},

	{ UMB_PIN_UNLOCKED, "PIN unlocked"},

	{ UMB_PUK_REQUIRED, "PUK required"},

	{ 0, NULL }

};

static const struct umb_valdescr _umb_regmode[] =

{

	{ MBIM_REGMODE_UNKNOWN, "unknown" },

	{ MBIM_REGMODE_AUTOMATIC, "automatic" },

	{ MBIM_REGMODE_MANUAL, "manual" },

	{ 0, NULL }

};

static const struct umb_valdescr _umb_ber[] =

{

	{ UMB_BER_EXCELLENT, "excellent" },

	{ UMB_BER_VERYGOOD, "very good" },

	{ UMB_BER_GOOD, "good" },

	{ UMB_BER_OK, "ok" },

	{ UMB_BER_MEDIUM, "medium" },

	{ UMB_BER_BAD, "bad" },

	{ UMB_BER_VERYBAD, "very bad" },

	{ UMB_BER_EXTREMELYBAD, "extremely bad" },

	{ 0, NULL }

};

/* prototypes */

static int _char_to_utf16(const char * in, uint16_t * out, size_t outlen);

static int _error(int ret, char const * format, ...);

static int _umbctl(char const * ifname, int verbose, int argc, char * argv[]);

static int _umbctl_file(char const * ifname, char const * filename,

		int verbose);

static int _umbctl_dump(char const * ifname, const char * format, int verbose);

static void _umbctl_dump_json(char const * ifname, struct umb_info * umbi);

static int _umbctl_gateway(char const * ifname);

static void _umbctl_info(char const * ifname, struct umb_info * umbi);

static int _umbctl_ioctl(char const * ifname, int fd, unsigned long request,

		struct ifreq * ifr);

static int _umbctl_set(char const * ifname, struct umb_parameter * umbp,

		int argc, char * argv[]);

static int _umbctl_socket(void);

static int _usage(void);

static void _print_utf16(uint16_t * in, int inlen);

static void _utf16_to_char(uint16_t * in, int inlen, char * out, size_t outlen);

/* functions */

/* char_to_utf16 */

/* this function is from OpenBSD's ifconfig(8) */

static int _char_to_utf16(const char * in, uint16_t * out, size_t outlen)

{

	int	n = 0;

	uint16_t c;

	for (;;) {

		c = *in++;

		if (c == '\0') {

			/*

			 * NUL termination is not required, but zero out the

			 * residual buffer

			 */

			memset(out, 0, outlen);

			return n;

		}

		if (outlen < sizeof(*out))

			return -1;

		*out++ = htole16(c);

		n += sizeof(*out);

		outlen -= sizeof(*out);

	}

}

/* error */

static int _error(int ret, char const * format, ...)

{

	va_list ap;

	fputs("umbctl: ", stderr);

	va_start(ap, format);

	vfprintf(stderr, format, ap);

	va_end(ap);

	fputs("\n", stderr);

	return ret;

}

/* umbctl */

static int _umbctl(char const * ifname, int verbose, int argc, char * argv[])

{

	int fd;

	struct ifreq ifr;

	struct umb_info umbi;

	struct umb_parameter umbp;

	if((fd = _umbctl_socket()) < 0)

		return 2;

	memset(&ifr, 0, sizeof(ifr));

	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

	if(argc != 0)

	{

		memset(&umbp, 0, sizeof(umbp));

		ifr.ifr_data = (caddr_t)&umbp;

		if(_umbctl_ioctl(ifname, fd, SIOCGUMBPARAM, &ifr) != 0

				|| _umbctl_set(ifname, &umbp, argc, argv) != 0

				|| _umbctl_ioctl(ifname, fd, SIOCSUMBPARAM,

					&ifr) != 0)

		{

			close(fd);

			return 2;

		}

	}

	if(argc == 0 || verbose > 0)

	{

		ifr.ifr_data = (caddr_t)&umbi;

		if(_umbctl_ioctl(ifname, fd, SIOCGUMBINFO, &ifr) != 0)

		{

			close(fd);

			return 3;

		}

		_umbctl_info(ifname, &umbi);

	}

	if(close(fd) != 0)

		return _error(2, "%s: %s", ifname, strerror(errno));

	return 0;

}

/* umbctl_file */

static int _file_parse(char const * ifname, struct umb_parameter * umbp,

		char const * filename);

static int _umbctl_file(char const * ifname, char const * filename, int verbose)

{

	int fd;

	struct ifreq ifr;

	struct umb_parameter umbp;

	struct umb_info umbi;

	if((fd = _umbctl_socket()) < 0)

		return 2;

	memset(&ifr, 0, sizeof(ifr));

	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

	ifr.ifr_data = (caddr_t)&umbp;

	memset(&umbp, 0, sizeof(umbp));

	if(_umbctl_ioctl(ifname, fd, SIOCGUMBPARAM, &ifr) != 0

			|| _file_parse(ifname, &umbp, filename) != 0

			|| _umbctl_ioctl(ifname, fd, SIOCSUMBPARAM, &ifr) != 0)

	{

		close(fd);

		return 2;

	}

	if(verbose > 0)

	{

		ifr.ifr_data = (caddr_t)&umbi;

		if(_umbctl_ioctl(ifname, fd, SIOCGUMBINFO, &ifr) != 0)

		{

			close(fd);

			return 3;

		}

		_umbctl_info(ifname, &umbi);

	}

	if(close(fd) != 0)

		return _error(2, "%s: %s", ifname, strerror(errno));

	return 0;

}

static int _file_parse(char const * ifname, struct umb_parameter * umbp,

		char const * filename)

{

	int ret = 0;

	FILE * fp;

	char buf[512];

	size_t len;

	int i;

	int eof;

	char * tokens[3] = { buf, NULL, NULL };

	char * p;

	if((fp = fopen(filename, "r")) == NULL)

		return _error(2, "%s: %s", filename, strerror(errno));

	while(fgets(buf, sizeof(buf), fp) != NULL)

	{

		if(buf[0] == '#')

			continue;

		buf[sizeof(buf) - 1] = '\0';

		if((len = strlen(buf)) > 0)

		{

			if(buf[len - 1] != '\n')

			{

				ret = _error(2, "%s: %s", filename,

						"Line too long");

				while((i = fgetc(fp)) != EOF && i != '\n');

				continue;

			}

			buf[len - 1] = '\0';

		}

		if((p = strchr(buf, '=')) != NULL)

		{

			tokens[1] = p + 1;

			*p = '\0';

		} else

			tokens[1] = NULL;

		ret |= _umbctl_set(ifname, umbp, (p != NULL) ? 2 : 1, tokens)

			? 2 : 0;

	}

	eof = feof(fp);

	if(fclose(fp) != 0 || !eof)

		return _error(2, "%s: %s", filename, strerror(errno));

	return ret;

}

/* umbctl_dump */

static int _umbctl_dump(char const * ifname, const char * format, int verbose)

{

	int fd;

	struct ifreq ifr;

	struct umb_info umbi;

	(void) verbose;

	if((fd = _umbctl_socket()) < 0)

		return 2;

	memset(&ifr, 0, sizeof(ifr));

	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

	ifr.ifr_data = (caddr_t)&umbi;

	if(_umbctl_ioctl(ifname, fd, SIOCGUMBINFO, &ifr) != 0)

	{

		close(fd);

		return 3;

	}

	if(close(fd) != 0)

		return _error(2, "%s: %s", ifname, strerror(errno));

	if(strncasecmp(format, "JSON", 4) == 0)

		_umbctl_dump_json(ifname, &umbi);

	else

		return _error(2, "%s: Unsupported format", format);

	return 0;

}

/* umbctl_dump_json */

static void _umbctl_dump_json(char const * ifname, struct umb_info * umbi)

{

#define JSON_START	printf("{")

#define JSON_END	printf("}\n")

#define JSON_SEP	printf(", ")

#define JSON_ARRAY_START	printf("[")

#define JSON_ARRAY_END	printf("]")

#define JSON_STRING(key, val)	printf("\"%s\": \"%s\"", key, val)

#define JSON_INT(key, val)	printf("\"%s\": %d", key, val)

#define JSON_ULONG(key, val)	printf("\"%s\": %lu", key, val)

#define JSON_BOOL(key, val)	printf("\"%s\": %s", key, (val)?"true":"false")

#define JSON_NULL(key)		printf("\"%s\": null", key)

#define JSON_KEY(key)		printf("\"%s\": ", key)

#define JSON_WSTRING(key, val, len)	(printf("\"%s\": \"", key),\

					 _print_utf16(val, len),printf("\""))

#define JSON_NULL_EMPTY(key, val)	(*val != '\0')?JSON_STRING(key, val):\

					JSON_NULL(key)

#define JSON_NULL_WEMPTY(key, val, len)	((char)htole16(*val) != '\0')?\

					JSON_WSTRING(key, val, len):\

					JSON_NULL(key)

	JSON_START;

	JSON_STRING("interface", ifname);

	JSON_SEP;

	JSON_NULL_EMPTY("state", umb_val2descr(_umb_state, umbi->state));

	JSON_SEP;

	JSON_NULL_EMPTY("pin-status", umb_val2descr(_umb_pin_state, umbi->pin_state));

	JSON_SEP;

	JSON_INT("pin-attempts-left", umbi->pin_attempts_left);

	JSON_SEP;

	JSON_NULL_EMPTY("activation", umb_val2descr(_umb_actstate, umbi->activation));

	JSON_SEP;

	JSON_NULL_EMPTY("sim-state", umb_val2descr(_umb_simstate, umbi->sim_state));

	JSON_SEP;

	JSON_NULL_EMPTY("sim-registration", umb_val2descr(_umb_regstate, umbi->regstate));

	JSON_SEP;

	JSON_NULL_EMPTY("sim-registration-mode", umb_val2descr(_umb_regmode, umbi->regmode));

	JSON_SEP;

	JSON_INT("network-errors", umbi->nwerror);

	JSON_SEP;

	JSON_NULL_EMPTY("packet-state", umb_val2descr(_umb_pktstate, umbi->packetstate));

	JSON_SEP;

	JSON_NULL_EMPTY("supported-dataclasses", umb_val2descr(_umb_dataclass, umbi->supportedclasses));

	JSON_SEP;

	JSON_NULL_EMPTY("preferred-dataclasses", umb_val2descr(_umb_dataclass, umbi->preferredclasses));

	JSON_SEP;

	JSON_NULL_EMPTY("offered-dataclasses", umb_val2descr(_umb_dataclass, umbi->highestclass));

	JSON_SEP;

	JSON_NULL_EMPTY("dataclass", umb_val2descr(_umb_dataclass, umbi->cellclass));

	JSON_SEP;

	JSON_NULL_WEMPTY("provider", umbi->provider, UMB_PROVIDERNAME_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("phone-number", umbi->pn, UMB_PHONENR_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("subscriber-id", umbi->sid, UMB_SUBSCRIBERID_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("iccid", umbi->iccid, UMB_ICCID_MAXLEN);

	JSON_SEP;

	JSON_BOOL("roaming-on", umbi->enable_roaming);

	JSON_SEP;

	JSON_NULL_WEMPTY("roaming-text", umbi->roamingtxt, UMB_ROAMINGTEXT_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("device-id", umbi->devid, UMB_DEVID_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("firmware", umbi->fwinfo, UMB_FWINFO_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("hardware", umbi->hwinfo, UMB_HWINFO_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("access-point-name", umbi->apn, UMB_APN_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("username", umbi->username, UMB_USERNAME_MAXLEN);

	JSON_SEP;

	JSON_NULL_WEMPTY("password", umbi->password, UMB_PASSWORD_MAXLEN);

	JSON_SEP;

	JSON_INT("rssi", umbi->rssi);

	JSON_SEP;

	JSON_INT("bit-error-rate", umbi->ber);

	JSON_SEP;

	JSON_BOOL("hw-radio-on", umbi->hw_radio_on);

	JSON_SEP;

	JSON_BOOL("sw-radio-on", umbi->sw_radio_on);

	JSON_SEP;

	JSON_ULONG("uplink-speed", umbi->uplink_speed);

	JSON_SEP;

	JSON_ULONG("downlink-speed", umbi->downlink_speed);

	JSON_SEP;

	JSON_KEY("ipv4-dns");

	JSON_ARRAY_START;

	/* TODO: Implement the DNS servers in the JSON object

	#define UMB_MAX_DNSSRV			2

		u_int32_t		ipv4dns[UMB_MAX_DNSSRV];

		XXX: The ipv4dns is either of maximum size or null terminated

		     (it's memset to 0)

	*/

	JSON_ARRAY_END;

	JSON_END;

}

/* umbctl_gateway */

static int _umbctl_gateway(char const * ifname)

{

	int fd;

	struct ifreq ifr;

	struct sockaddr_in * sin;

	if((fd = _umbctl_socket()) < 0)

		return 2;

	memset(&ifr, 0, sizeof(ifr));

	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

	if(_umbctl_ioctl(ifname, fd, SIOCGIFDSTADDR, &ifr) != 0)

	{

		close(fd);

		return 2;

	}

	sin = (struct sockaddr_in *)&ifr.ifr_dstaddr;

	printf("%s\n", inet_ntoa(sin->sin_addr));

	if(close(fd) != 0)

		return _error(2, "%s: %s", ifname, strerror(errno));

	return 0;

}

/* umbctl_info */

static void _umbctl_info(char const * ifname, struct umb_info * umbi)

{

	char provider[UMB_PROVIDERNAME_MAXLEN + 1];

	char pn[UMB_PHONENR_MAXLEN + 1];

	char roaming[UMB_ROAMINGTEXT_MAXLEN + 1];

	char apn[UMB_APN_MAXLEN + 1];

	char fwinfo[UMB_FWINFO_MAXLEN + 1];

	char hwinfo[UMB_HWINFO_MAXLEN + 1];

	_utf16_to_char(umbi->provider, UMB_PROVIDERNAME_MAXLEN,

			provider, sizeof(provider));

	_utf16_to_char(umbi->pn, UMB_PHONENR_MAXLEN, pn, sizeof(pn));

	_utf16_to_char(umbi->roamingtxt, UMB_ROAMINGTEXT_MAXLEN,

			roaming, sizeof(roaming));

	_utf16_to_char(umbi->apn, UMB_APN_MAXLEN, apn, sizeof(apn));

	_utf16_to_char(umbi->fwinfo, UMB_FWINFO_MAXLEN, fwinfo, sizeof(fwinfo));

	_utf16_to_char(umbi->hwinfo, UMB_HWINFO_MAXLEN, hwinfo, sizeof(hwinfo));

	printf("%s: state %s, mode %s, registration %s\n"

			"\tprovider \"%s\", dataclass %s, signal %s\n"

			"\tphone number \"%s\", roaming \"%s\" (%s)\n"

			"\tAPN \"%s\", TX %" PRIu64 ", RX %" PRIu64 "\n"

			"\tfirmware \"%s\", hardware \"%s\"\n",

			ifname, umb_val2descr(_umb_state, umbi->state),

			umb_val2descr(_umb_regmode, umbi->regmode),

			umb_val2descr(_umb_regstate, umbi->regstate), provider,

			umb_val2descr(_umb_dataclass, umbi->cellclass),

			umb_val2descr(_umb_ber, umbi->ber), pn, roaming,

			umbi->enable_roaming ? "allowed" : "denied",

			apn, umbi->uplink_speed, umbi->downlink_speed,

			fwinfo, hwinfo);

}

/* print_utf16 */

static void _print_utf16(uint16_t * in, int inlen)

{

	/* XXX Note to readers:

	 *

	 * The function was originally:

	 * do

	 * 	putc(isascii((char)htole16(*in)) ? (char)htole16(*in) : '?', stdout);

	 * while ((char)htole16(*(in++)) != '\0' && --inlen > 0);

	 *

	 * but in an effort to reuse the code, it is better to call

	 * _utf16_to_char instead.

	 */

	char buf[inlen + 1];

	_utf16_to_char(in, inlen, buf, inlen);

	buf[inlen] = '\0';

	printf("%s", buf);

}

/* umbctl_ioctl */

static int _umbctl_ioctl(char const * ifname, int fd, unsigned long request,

		struct ifreq * ifr)

{

	if(ioctl(fd, request, ifr) != 0)

		return _error(-1, "%s: %s", ifname, strerror(errno));

	return 0;

}

/* umbctl_set */

/* callbacks */

static int _set_apn(char const *, struct umb_parameter *, char const *);

static int _set_username(char const *, struct umb_parameter *, char const *);

static int _set_password(char const *, struct umb_parameter *, char const *);

static int _set_pin(char const *, struct umb_parameter *, char const *);

static int _set_puk(char const *, struct umb_parameter *, char const *);

static int _set_roaming_allow(char const *, struct umb_parameter *,

		char const *);

static int _set_roaming_deny(char const *, struct umb_parameter *,

		char const *);

static int _umbctl_set(char const * ifname, struct umb_parameter * umbp,

		int argc, char * argv[])

{

	struct

	{

		char const * name;

		int (*callback)(char const *,

				struct umb_parameter *, char const *);

		int parameter;

	} callbacks[] =

	{

		{ "apn", _set_apn, 1 },

		{ "username", _set_username, 1 },

		{ "password", _set_password, 1 },

		{ "pin", _set_pin, 1 },

		{ "puk", _set_puk, 1 },

		{ "roaming", _set_roaming_allow, 0 },

		{ "-roaming", _set_roaming_deny, 0 },

	};

	int i;

	size_t j;

	for(i = 0; i < argc; i++)

	{

		for(j = 0; j < sizeof(callbacks) / sizeof(*callbacks); j++)

			if(strcmp(argv[i], callbacks[j].name) == 0)

			{

				if(callbacks[j].parameter && i + 1 == argc)

					return _error(-1, "%s: Incomplete"

							" parameter", argv[i]);

				if(callbacks[j].callback(ifname, umbp,

							callbacks[j].parameter

							? argv[i + 1] : NULL))

					return -1;

				if(callbacks[j].parameter)

					i++;

				break;

			}

		if(j == sizeof(callbacks) / sizeof(*callbacks))

			return _error(-1, "%s: Unknown parameter", argv[i]);

	}

	return 0;

}

static int _set_apn(char const * ifname, struct umb_parameter * umbp,

		char const * apn)

{

	umbp->apnlen = _char_to_utf16(apn, umbp->apn, sizeof(umbp->apn));

	if(umbp->apnlen < 0 || (size_t)umbp->apnlen > sizeof(umbp->apn))

		return _error(-1, "%s: %s", ifname, "APN too long");

	return 0;

}

static int _set_username(char const * ifname, struct umb_parameter * umbp,

		char const * username)

{

	umbp->usernamelen = _char_to_utf16(username, umbp->username,

			sizeof(umbp->username));

	if(umbp->usernamelen < 0

			|| (size_t)umbp->usernamelen > sizeof(umbp->username))

		return _error(-1, "%s: %s", ifname, "Username too long");

	return 0;

}

static int _set_password(char const * ifname, struct umb_parameter * umbp,

		char const * password)

{

	umbp->passwordlen = _char_to_utf16(password, umbp->password,

			sizeof(umbp->password));

	if(umbp->passwordlen < 0

			|| (size_t)umbp->passwordlen > sizeof(umbp->password))

		return _error(-1, "%s: %s", ifname, "Password too long");

	return 0;

}

static int _set_pin(char const * ifname, struct umb_parameter * umbp,

		char const * pin)

{

	umbp->is_puk = 0;

	umbp->op = MBIM_PIN_OP_ENTER;

	umbp->pinlen = _char_to_utf16(pin, umbp->pin, sizeof(umbp->pin));

	if(umbp->pinlen < 0 || (size_t)umbp->pinlen

			> sizeof(umbp->pin))

		return _error(-1, "%s: %s", ifname, "PIN code too long");

	return 0;

}

static int _set_puk(char const * ifname, struct umb_parameter * umbp,

		char const * puk)

{

	umbp->is_puk = 1;

	umbp->op = MBIM_PIN_OP_ENTER;

	umbp->pinlen = _char_to_utf16(puk, umbp->pin, sizeof(umbp->pin));

	if(umbp->pinlen < 0 || (size_t)umbp->pinlen > sizeof(umbp->pin))

		return _error(-1, "%s: %s", ifname, "PUK code too long");

	return 0;

}

static int _set_roaming_allow(char const * ifname, struct umb_parameter * umbp,

		char const * unused)

{

	(void) ifname;

	(void) unused;

	umbp->roaming = 1;

	return 0;

}

static int _set_roaming_deny(char const * ifname, struct umb_parameter * umbp,

		char const * unused)

{

	(void) ifname;

	(void) unused;

	umbp->roaming = 0;

	return 0;

}

/* umbctl_socket */

static int _umbctl_socket(void)

{

	int fd;

	if((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)

		return _error(-1, "socket: %s", strerror(errno));

	return fd;

}

/* usage */

static int _usage(void)

{

	fputs("Usage: umbctl [-v] ifname [parameter [value]] [...]\n"

"       umbctl -f config-file ifname\n"

"       umbctl -g ifname\n"

"       umbctl -m format ifname [...]\n"

"\n"

"Note: -f and -m are mutually exclusive. The only supported format is JSON.\n",

			stderr);

	return 1;

}

/* utf16_to_char */

static void _utf16_to_char(uint16_t * in, int inlen, char * out, size_t outlen)

{

	uint16_t c;

	while (outlen > 0) {

		c = inlen > 0 ? htole16(*in) : 0;

		if (c == 0 || --outlen == 0) {

			/* always NUL terminate result */

			*out = '\0';

			break;

		}

		*out++ = isascii(c) ? (char)c : '?';

		in++;

		inlen--;

	}

}

/* main */

int main(int argc, char * argv[])

{

	int o;

	char const * filename = NULL;

	char const * format = NULL;

	int gateway = 0;

	int verbose = 0;

	while((o = getopt(argc, argv, "f:gm:v")) != -1)

		switch(o)

		{

			case 'f':

				filename = optarg;

				format = NULL;

				gateway = 0;

				break;

			case 'g':

				filename = NULL;

				format = NULL;

				gateway = 1;

				break;

			case 'm':

				filename = NULL;

				format = optarg;

				gateway = 0;

				break;

			case 'v':

				verbose++;

				break;

			default:

				return _usage();

		}

	if(optind == argc)

		return _usage();

	if(filename != NULL)

	{

		if(optind + 1 != argc)

			return _usage();

		return _umbctl_file(argv[optind], filename, verbose);

	}

	if(format != NULL)

	{

		if(optind + 1 != argc)

			return _usage();

		return _umbctl_dump(argv[optind], format, verbose);

	}

	if(gateway)

	{

		if(optind + 1 != argc)

			return _usage();

		return _umbctl_gateway(argv[optind]);

	}

	return _umbctl(argv[optind], verbose, argc - optind - 1,

			&argv[optind + 1]);

}

dev/usb/net/if_umb.c		optional umb

/*	$FreeBSD$ */

/*	$NetBSD$ */

/*	$OpenBSD: if_umb.c,v 1.18 2018/02/19 08:59:52 mpi Exp $ */

/*

 * Original copyright (c) 2016 genua mbH (OpenBSD version)

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 *

 * Copyright (c) 2022 ADISTA SAS (re-write for FreeBSD)

 *

 * Re-write for FreeBSD by Pierre Pronchery <pierre@defora.net>

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * - Redistributions of source code must retain the above copyright notice,

 *   this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright notice,

 *   this list of conditions and the following disclaimer in the documentation

 *   and/or other materials provided with the distribution.

 * - Neither the name of the copyright holder nor the names of its contributors

 *   may be used to endorse or promote products derived from this software

 *   without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * Mobile Broadband Interface Model specification:

 * http://www.usb.org/developers/docs/devclass_docs/MBIM10Errata1_073013.zip

 * Compliance testing guide

 * http://www.usb.org/developers/docs/devclass_docs/MBIM-Compliance-1.0.pdf

 */

#include <sys/param.h>

#include <sys/module.h>

#include <sys/endian.h>

#include <sys/kernel.h>

#include <sys/mbuf.h>

#include <sys/priv.h>

#include <sys/socket.h>

#include <sys/sockio.h>

#include <sys/systm.h>

#include <sys/syslog.h>

#include <sys/kernel.h>

#include <sys/queue.h>

#include <sys/conf.h>

#include <sys/bus.h>

#include <sys/mutex.h>

#include <sys/condvar.h>

#include <sys/taskqueue.h>

#include <machine/_inttypes.h>

#include <net/bpf.h>

#include <net/if.h>

#include <net/if_media.h>

#include <net/if_types.h>

#include <net/if_var.h>

#include <net/netisr.h>

#include <net/route.h>

#include <netinet/in.h>

#include <netinet/in_var.h>

#include <netinet/ip.h>

#include <dev/usb/usb.h>

#include <dev/usb/usb_cdc.h>

#include <dev/usb/usbdi.h>

#include <dev/usb/usb_device.h>

#include <dev/usb/usb_process.h>

#include <dev/usb/usbdi_util.h>

#include "usb_if.h"

#include "mbim.h"

#include "if_umbreg.h"

MALLOC_DECLARE(M_MBIM_CID_CONNECT);

MALLOC_DEFINE(M_MBIM_CID_CONNECT, "mbim_cid_connect",

		"Connection parameters for MBIM");

#ifdef UMB_DEBUG

#define DPRINTF(x...)							\

		do { if (umb_debug) log(LOG_DEBUG, x); } while (0)

#define DPRINTFN(n, x...)						\

		do { if (umb_debug >= (n)) log(LOG_DEBUG, x); } while (0)

#define DDUMPN(n, b, l)							\

		do {							\

			if (umb_debug >= (n))				\

				umb_dump((b), (l));			\

		} while (0)

int	 umb_debug = 1;

static char	*umb_uuid2str(uint8_t [MBIM_UUID_LEN]);

static void	 umb_dump(void *, int);

#else

#define DPRINTF(x...)		do { } while (0)

#define DPRINTFN(n, x...)	do { } while (0)

#define DDUMPN(n, b, l)		do { } while (0)

#endif

#define DEVNAM(sc)		device_get_nameunit((sc)->sc_dev)

/*

 * State change timeout

 */

#define UMB_STATE_CHANGE_TIMEOUT	30

/*

 * State change flags

 */

#define UMB_NS_DONT_DROP	0x0001	/* do not drop below current state */

#define UMB_NS_DONT_RAISE	0x0002	/* do not raise below current state */

/*

 * Diagnostic macros

 */

const struct umb_valdescr umb_regstates[] = MBIM_REGSTATE_DESCRIPTIONS;

const struct umb_valdescr umb_dataclasses[] = MBIM_DATACLASS_DESCRIPTIONS;

const struct umb_valdescr umb_simstate[] = MBIM_SIMSTATE_DESCRIPTIONS;

const struct umb_valdescr umb_messages[] = MBIM_MESSAGES_DESCRIPTIONS;

const struct umb_valdescr umb_status[] = MBIM_STATUS_DESCRIPTIONS;

const struct umb_valdescr umb_cids[] = MBIM_CID_DESCRIPTIONS;

const struct umb_valdescr umb_pktstate[] = MBIM_PKTSRV_STATE_DESCRIPTIONS;

const struct umb_valdescr umb_actstate[] = MBIM_ACTIVATION_STATE_DESCRIPTIONS;

const struct umb_valdescr umb_error[] = MBIM_ERROR_DESCRIPTIONS;

const struct umb_valdescr umb_pintype[] = MBIM_PINTYPE_DESCRIPTIONS;

const struct umb_valdescr umb_istate[] = UMB_INTERNAL_STATE_DESCRIPTIONS;

#define umb_regstate(c)		umb_val2descr(umb_regstates, (c))

#define umb_dataclass(c)	umb_val2descr(umb_dataclasses, (c))

#define umb_simstate(s)		umb_val2descr(umb_simstate, (s))

#define umb_request2str(m)	umb_val2descr(umb_messages, (m))

#define umb_status2str(s)	umb_val2descr(umb_status, (s))

#define umb_cid2str(c)		umb_val2descr(umb_cids, (c))

#define umb_packet_state(s)	umb_val2descr(umb_pktstate, (s))

#define umb_activation(s)	umb_val2descr(umb_actstate, (s))

#define umb_error2str(e)	umb_val2descr(umb_error, (e))

#define umb_pin_type(t)		umb_val2descr(umb_pintype, (t))

#define umb_istate(s)		umb_val2descr(umb_istate, (s))

static device_probe_t umb_probe;

static device_attach_t umb_attach;

static device_detach_t umb_detach;

static device_suspend_t umb_suspend;

static device_resume_t umb_resume;

static void	 umb_attach_task(struct usb_proc_msg *);

static usb_handle_request_t umb_handle_request;

static int	 umb_deactivate(device_t);

static void	 umb_ncm_setup(struct umb_softc *, struct usb_config *);

static void	 umb_close_bulkpipes(struct umb_softc *);

static int	 umb_ioctl(struct ifnet *, u_long, caddr_t);

static void	 umb_init(void *);

static void	 umb_input(struct ifnet *, struct mbuf *);

static int	 umb_output(struct ifnet *, struct mbuf *,

		    const struct sockaddr *, struct route *);

static void	 umb_start(struct ifnet *);

static void	 umb_start_task(struct usb_proc_msg *);

#if 0

static void	 umb_watchdog(struct ifnet *);

#endif

static void	 umb_statechg_timeout(void *);

static int	 umb_mediachange(struct ifnet *);

static void	 umb_mediastatus(struct ifnet *, struct ifmediareq *);

static void	 umb_add_task(struct umb_softc *sc, usb_proc_callback_t,

		    struct usb_proc_msg *, struct usb_proc_msg *, int);

static void	 umb_newstate(struct umb_softc *, enum umb_state, int);

static void	 umb_state_task(struct usb_proc_msg *);

static void	 umb_up(struct umb_softc *);

static void	 umb_down(struct umb_softc *, int);

static void	 umb_get_response_task(struct usb_proc_msg *);

static void	 umb_decode_response(struct umb_softc *, void *, int);

static void	 umb_handle_indicate_status_msg(struct umb_softc *, void *,

		    int);

static void	 umb_handle_opendone_msg(struct umb_softc *, void *, int);

static void	 umb_handle_closedone_msg(struct umb_softc *, void *, int);

static int	 umb_decode_register_state(struct umb_softc *, void *, int);

static int	 umb_decode_devices_caps(struct umb_softc *, void *, int);

static int	 umb_decode_subscriber_status(struct umb_softc *, void *, int);

static int	 umb_decode_radio_state(struct umb_softc *, void *, int);

static int	 umb_decode_pin(struct umb_softc *, void *, int);

static int	 umb_decode_packet_service(struct umb_softc *, void *, int);

static int	 umb_decode_signal_state(struct umb_softc *, void *, int);

static int	 umb_decode_connect_info(struct umb_softc *, void *, int);

static int	 umb_decode_ip_configuration(struct umb_softc *, void *, int);

static void	 umb_rx(struct umb_softc *);

static usb_callback_t umb_rxeof;

static void	 umb_rxflush(struct umb_softc *);

static int	 umb_encap(struct umb_softc *, struct mbuf *, struct usb_xfer *);

static usb_callback_t umb_txeof;

static void	 umb_txflush(struct umb_softc *);

static void	 umb_decap(struct umb_softc *, struct usb_xfer *, int);

static usb_error_t	 umb_send_encap_command(struct umb_softc *, void *, int);

static int	 umb_get_encap_response(struct umb_softc *, void *, int *);

static void	 umb_ctrl_msg(struct umb_softc *, uint32_t, void *, int);

static void	 umb_open(struct umb_softc *);

static void	 umb_close(struct umb_softc *);

static int	 umb_setpin(struct umb_softc *, int, int, void *, int, void *,

		    int);

static void	 umb_setdataclass(struct umb_softc *);

static void	 umb_radio(struct umb_softc *, int);

static void	 umb_allocate_cid(struct umb_softc *);

static void	 umb_send_fcc_auth(struct umb_softc *);

static void	 umb_packet_service(struct umb_softc *, int);

static void	 umb_connect(struct umb_softc *);

static void	 umb_disconnect(struct umb_softc *);

static void	 umb_send_connect(struct umb_softc *, int);

static void	 umb_qry_ipconfig(struct umb_softc *);

static void	 umb_cmd(struct umb_softc *, int, int, const void *, int);

static void	 umb_cmd1(struct umb_softc *, int, int, const void *, int, uint8_t *);

static void	 umb_command_done(struct umb_softc *, void *, int);

static void	 umb_decode_cid(struct umb_softc *, uint32_t, void *, int);

static void	 umb_decode_qmi(struct umb_softc *, uint8_t *, int);

static usb_callback_t umb_intr;

static char	*umb_ntop(struct sockaddr *);

static const int umb_xfer_tout = USB_DEFAULT_TIMEOUT;

static uint8_t	 umb_uuid_basic_connect[] = MBIM_UUID_BASIC_CONNECT;

static uint8_t	 umb_uuid_context_internet[] = MBIM_UUID_CONTEXT_INTERNET;

static uint8_t	 umb_uuid_qmi_mbim[] = MBIM_UUID_QMI_MBIM;

static uint32_t	 umb_session_id = 0;

static const struct usb_config umb_config[UMB_N_TRANSFER] = {

	[UMB_INTR_RX] = {

		.type = UE_INTERRUPT,

		.endpoint = UE_ADDR_ANY,

		.direction = UE_DIR_IN,

		.if_index = 1,

		.callback = umb_intr,

		.bufsize = sizeof (struct usb_cdc_notification),

		.flags = {.pipe_bof = 1,.short_xfer_ok = 1},

		.usb_mode = USB_MODE_HOST,

	},

	[UMB_BULK_RX] = {

		.type = UE_BULK,

		.endpoint = UE_ADDR_ANY,

		.direction = UE_DIR_IN,

		.if_index = 0,

		.callback = umb_rxeof,

		.bufsize = 8 * 1024,

		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.ext_buffer = 1},

		.usb_mode = USB_MODE_HOST,

	},

	[UMB_BULK_TX] = {

		.type = UE_BULK,

		.endpoint = UE_ADDR_ANY,

		.direction = UE_DIR_OUT,

		.if_index = 0,

		.callback = umb_txeof,

		.bufsize = 8 * 1024,

		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1},

		.timeout = umb_xfer_tout,

		.usb_mode = USB_MODE_HOST,

	},

};

static device_method_t umb_methods[] = {

	/* USB interface */

	DEVMETHOD(usb_handle_request, umb_handle_request),

	/* Device interface */

	DEVMETHOD(device_probe, umb_probe),

	DEVMETHOD(device_attach, umb_attach),

	DEVMETHOD(device_detach, umb_detach),

	DEVMETHOD(device_suspend, umb_suspend),

	DEVMETHOD(device_resume, umb_resume),

	DEVMETHOD_END

};

static driver_t umb_driver = {

	.name = "umb",

	.methods = umb_methods,

	.size = sizeof (struct umb_softc),

};

MALLOC_DEFINE(M_USB_UMB, "USB UMB", "USB MBIM driver");

const int umb_delay = 4000;

/*

 * These devices require an "FCC Authentication" command.

 */

#ifndef USB_VENDOR_SIERRA

# define USB_VENDOR_SIERRA	0x1199

#endif

#ifndef USB_PRODUCT_SIERRA_EM7455

# define USB_PRODUCT_SIERRA_EM7455	0x9079

#endif

const struct usb_device_id umb_fccauth_devs[] = {

	{

		.match_flag_vendor = 1,

		.match_flag_product = 1,

		.idVendor = USB_VENDOR_SIERRA,

		.idProduct = USB_PRODUCT_SIERRA_EM7455

	}

};

static const uint8_t umb_qmi_alloc_cid[] = {

	0x01,

	0x0f, 0x00,		/* len */

	0x00,			/* QMUX flags */

	0x00,			/* service "ctl" */

	0x00,			/* CID */

	0x00,			/* QMI flags */

	0x01,			/* transaction */

	0x22, 0x00,		/* msg "Allocate CID" */

	0x04, 0x00,		/* TLV len */

	0x01, 0x01, 0x00, 0x02	/* TLV */

};

static const uint8_t umb_qmi_fcc_auth[] = {

	0x01,

	0x0c, 0x00,		/* len */

	0x00,			/* QMUX flags */

	0x02,			/* service "dms" */

#define UMB_QMI_CID_OFFS	5

	0x00,			/* CID (filled in later) */

	0x00,			/* QMI flags */

	0x01, 0x00,		/* transaction */

	0x5f, 0x55,		/* msg "Send FCC Authentication" */

	0x00, 0x00		/* TLV len */

};

static int

umb_probe(device_t dev)

{

	struct usb_attach_arg *uaa = device_get_ivars(dev);

	usb_interface_descriptor_t *id;

	if (uaa->usb_mode != USB_MODE_HOST)

		return (ENXIO);

	if ((id = usbd_get_interface_descriptor(uaa->iface)) == NULL)

		return (ENXIO);

	/*

	 * If this function implements NCM, check if alternate setting

	 * 1 implements MBIM.

	 */

	if (id->bInterfaceClass == UICLASS_CDC &&

	    id->bInterfaceSubClass ==

	    UISUBCLASS_NETWORK_CONTROL_MODEL) {

		id = usbd_get_interface_descriptor(

				usbd_get_iface(uaa->device,

					uaa->info.bIfaceIndex + 1));

		if (id == NULL || id->bAlternateSetting != 1)

			return (ENXIO);

	}

#ifndef UISUBCLASS_MOBILE_BROADBAND_INTERFACE_MODEL

# define UISUBCLASS_MOBILE_BROADBAND_INTERFACE_MODEL 14

#endif

	if (id->bInterfaceClass == UICLASS_CDC &&

	    id->bInterfaceSubClass ==

	    UISUBCLASS_MOBILE_BROADBAND_INTERFACE_MODEL &&

	    id->bInterfaceProtocol == 0)

		return (BUS_PROBE_SPECIFIC);

	return (ENXIO);

}

static int

umb_attach(device_t dev)

{

	struct umb_softc *sc = device_get_softc(dev);

	struct usb_attach_arg *uaa = device_get_ivars(dev);

	struct usb_config config[UMB_N_TRANSFER];

	int	 v;

	const struct usb_cdc_union_descriptor *ud;

	const struct mbim_descriptor *md;

	int	 i;

	usb_interface_descriptor_t *id;

	struct usb_interface *iface;

	int	 data_ifaceno = -1;

	usb_error_t error;

	sc->sc_dev = dev;

	sc->sc_udev = uaa->device;

	memcpy(config, umb_config, sizeof (config));

	device_set_usb_desc(dev);

	sc->sc_ctrl_ifaceno = uaa->info.bIfaceNum;

	mtx_init(&sc->sc_mutex, device_get_nameunit(dev), NULL, MTX_DEF);

	/*

	 * Some MBIM hardware does not provide the mandatory CDC Union

	 * Descriptor, so we also look at matching Interface

	 * Association Descriptors to find out the MBIM Data Interface

	 * number.

	 */

	sc->sc_ver_maj = sc->sc_ver_min = -1;

	sc->sc_maxpktlen = MBIM_MAXSEGSZ_MINVAL;

	id = usbd_get_interface_descriptor(uaa->iface);

	ud = usbd_find_descriptor(sc->sc_udev, id, uaa->info.bIfaceIndex,

			UDESC_CS_INTERFACE, 0xff, UDESCSUB_CDC_UNION, 0xff);

	if (ud != NULL) {

		data_ifaceno = ud->bSlaveInterface[0];

	}

	md = usbd_find_descriptor(sc->sc_udev, id, uaa->info.bIfaceIndex,

			UDESC_CS_INTERFACE, 0xff, UDESCSUB_MBIM, 0xff);

	if (md != NULL) {

		v = UGETW(md->bcdMBIMVersion);

		sc->sc_ver_maj = MBIM_VER_MAJOR(v);

		sc->sc_ver_min = MBIM_VER_MINOR(v);

		sc->sc_ctrl_len = UGETW(md->wMaxControlMessage);

		/* Never trust a USB device! Could try to exploit us */

		if (sc->sc_ctrl_len < MBIM_CTRLMSG_MINLEN ||

				sc->sc_ctrl_len > MBIM_CTRLMSG_MAXLEN) {

			DPRINTF("control message len %d out of "

					"bounds [%d .. %d]\n",

					sc->sc_ctrl_len, MBIM_CTRLMSG_MINLEN,

					MBIM_CTRLMSG_MAXLEN);

			/* continue anyway */

		}

		sc->sc_maxpktlen = UGETW(md->wMaxSegmentSize);

		DPRINTFN(2, "ctrl_len=%d, maxpktlen=%d, cap=0x%x\n",

				sc->sc_ctrl_len, sc->sc_maxpktlen,

				md->bmNetworkCapabilities);

	}

	if (sc->sc_ver_maj < 0) {

		device_printf(dev, "error: missing MBIM descriptor\n");

		goto fail;

	}

	device_printf(dev, "version %d.%d\n", sc->sc_ver_maj,

	    sc->sc_ver_min);

	if (usbd_lookup_id_by_uaa(umb_fccauth_devs, sizeof (umb_fccauth_devs), uaa)) {

		sc->sc_flags |= UMBFLG_FCC_AUTH_REQUIRED;

		sc->sc_cid = -1;

	}

	for (i = 0; i < sc->sc_udev->ifaces_max; i++) {

		iface = usbd_get_iface(sc->sc_udev, i);

		id = usbd_get_interface_descriptor(iface);

		if (id == NULL)

			break;

		if (id->bInterfaceNumber == data_ifaceno) {

			sc->sc_data_iface = iface;

			sc->sc_ifaces_index[0] = i;

			sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex;

			break;

		}

	}

	if (sc->sc_data_iface == NULL) {

		device_printf(dev, "error: no data interface found\n");

		goto fail;

	}

	/*

	 * If this is a combined NCM/MBIM function, switch to

	 * alternate setting one to enable MBIM.

	 */

	id = usbd_get_interface_descriptor(uaa->iface);

	if (id != NULL && id->bInterfaceClass == UICLASS_CDC &&

	    id->bInterfaceSubClass == UISUBCLASS_NETWORK_CONTROL_MODEL) {

		device_printf(sc->sc_dev, "combined NCM/MBIM\n");

		error = usbd_req_set_alt_interface_no(sc->sc_udev,

				NULL, uaa->info.bIfaceIndex, 1);

		if (error != USB_ERR_NORMAL_COMPLETION) {

			device_printf(dev, "error: Could not switch to alternate setting for MBIM\n");

			goto fail;

		}

		sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex + 1;

	}

	if (usb_proc_create(&sc->sc_taskqueue, &sc->sc_mutex,

				device_get_nameunit(sc->sc_dev),

				USB_PRI_MED) != 0)

		goto fail;

	DPRINTFN(2, "ctrl-ifno#%d: data-ifno#%d\n", sc->sc_ctrl_ifaceno,

	    data_ifaceno);

	usb_callout_init_mtx(&sc->sc_statechg_timer, &sc->sc_mutex, 0);

	umb_ncm_setup(sc, config);

	DPRINTFN(2, "%s: rx/tx size %d/%d\n", DEVNAM(sc),

			sc->sc_rx_bufsz, sc->sc_tx_bufsz);

	sc->sc_rx_buf = malloc(sc->sc_rx_bufsz, M_DEVBUF, M_WAITOK);

	sc->sc_tx_buf = malloc(sc->sc_tx_bufsz, M_DEVBUF, M_WAITOK);

	for (i = 0; i != 32; i++) {

		error = usbd_set_alt_interface_index(sc->sc_udev,

				sc->sc_ifaces_index[0], i);

		if (error)

			break;

		error = usbd_transfer_setup(sc->sc_udev, sc->sc_ifaces_index,

				sc->sc_xfer, config, UMB_N_TRANSFER,

				sc, &sc->sc_mutex);

		if (error == USB_ERR_NORMAL_COMPLETION)

			break;

	}

	if (error || (i == 32)) {

		device_printf(sc->sc_dev, "error: failed to setup xfers\n");

		goto fail;

	}

	sc->sc_resp_buf = malloc(sc->sc_ctrl_len, M_DEVBUF, M_WAITOK);

	sc->sc_ctrl_msg = malloc(sc->sc_ctrl_len, M_DEVBUF, M_WAITOK);

	sc->sc_info.regstate = MBIM_REGSTATE_UNKNOWN;

	sc->sc_info.pin_attempts_left = UMB_VALUE_UNKNOWN;

	sc->sc_info.rssi = UMB_VALUE_UNKNOWN;

	sc->sc_info.ber = UMB_VALUE_UNKNOWN;

	/* defer attaching the interface */

	mtx_lock(&sc->sc_mutex);

	umb_add_task(sc, umb_attach_task,

			&sc->sc_proc_attach_task[0].hdr,

			&sc->sc_proc_attach_task[1].hdr, 0);

	mtx_unlock(&sc->sc_mutex);

	return (0);

fail:

	umb_detach(sc->sc_dev);

	return (ENXIO);

}

static void

umb_attach_task(struct usb_proc_msg *msg)

{

	struct umb_task *task = (struct umb_task *)msg;

	struct umb_softc *sc = task->sc;

	struct ifnet *ifp;

	mtx_unlock(&sc->sc_mutex);

	/* initialize the interface */

#ifndef IFT_MBIM

# define IFT_MBIM 0xfa

#endif

	sc->sc_if = ifp = if_alloc(IFT_MBIM);

	if (ifp == NULL) {

		device_printf(sc->sc_dev, "Could not allocate a network interface\n");

		goto fail;

	}

	if_initname(ifp, "umb", device_get_unit(sc->sc_dev));

	ifp->if_softc = sc;

	ifp->if_flags = IFF_SIMPLEX | IFF_MULTICAST | IFF_POINTOPOINT;

	ifp->if_ioctl = umb_ioctl;

	ifp->if_input = umb_input;

	ifp->if_output = umb_output;

	ifp->if_start = umb_start;

	ifp->if_init = umb_init;

#if 0

	ifp->if_watchdog = umb_watchdog;

#endif

	ifp->if_link_state = LINK_STATE_DOWN;

	ifmedia_init(&sc->sc_im, 0, umb_mediachange, umb_mediastatus);

	ifmedia_add(&sc->sc_im, IFM_NONE | IFM_AUTO, 0, NULL);

	ifp->if_addrlen = 0;

	ifp->if_hdrlen = sizeof (struct ncm_header16) +

	    sizeof (struct ncm_pointer16);

	/* XXX hard-coded atm */

	ifp->if_mtu = MIN(2048, sc->sc_maxpktlen);

	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);

	ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;

	IFQ_SET_READY(&ifp->if_snd);

	/* attach the interface */

	if_attach(ifp);

	bpfattach(ifp, DLT_RAW, 0);

	sc->sc_attached = 1;

	umb_init(sc);

fail:

	mtx_lock(&sc->sc_mutex);

}

static int

umb_detach(device_t dev)

{

	struct umb_softc *sc = device_get_softc(dev);

	struct ifnet *ifp = GET_IFP(sc);

	usb_proc_drain(&sc->sc_taskqueue);

	mtx_lock(&sc->sc_mutex);

	if (ifp != NULL && (ifp->if_drv_flags & IFF_DRV_RUNNING))

		umb_down(sc, 1);

	umb_close(sc);

	mtx_unlock(&sc->sc_mutex);

	usbd_transfer_unsetup(sc->sc_xfer, UMB_N_TRANSFER);

	free(sc->sc_tx_buf, M_DEVBUF);

	free(sc->sc_rx_buf, M_DEVBUF);

	usb_callout_drain(&sc->sc_statechg_timer);

	usb_proc_free(&sc->sc_taskqueue);

	mtx_destroy(&sc->sc_mutex);

	free(sc->sc_ctrl_msg, M_DEVBUF);

	free(sc->sc_resp_buf, M_DEVBUF);

	if (ifp != NULL && ifp->if_softc) {

		ifmedia_removeall(&sc->sc_im);

	}

	if (sc->sc_attached) {

		bpfdetach(ifp);

		if_detach(ifp);

		if_free(ifp);

		sc->sc_if = NULL;

	}

	return 0;

}

static void

umb_ncm_setup(struct umb_softc *sc, struct usb_config * config)

{

	usb_device_request_t req;

	struct ncm_ntb_parameters np;

	usb_error_t error;

	/* Query NTB tranfers sizes */

	req.bmRequestType = UT_READ_CLASS_INTERFACE;

	req.bRequest = NCM_GET_NTB_PARAMETERS;

	USETW(req.wValue, 0);

	USETW(req.wIndex, sc->sc_ctrl_ifaceno);

	USETW(req.wLength, sizeof (np));

	mtx_lock(&sc->sc_mutex);

	error = usbd_do_request(sc->sc_udev, &sc->sc_mutex, &req, &np);

	mtx_unlock(&sc->sc_mutex);

	if (error == USB_ERR_NORMAL_COMPLETION &&

	    UGETW(np.wLength) == sizeof (np)) {

		config[UMB_BULK_RX].bufsize = UGETDW(np.dwNtbInMaxSize);

		config[UMB_BULK_TX].bufsize = UGETDW(np.dwNtbOutMaxSize);

	}

	sc->sc_rx_bufsz = config[UMB_BULK_RX].bufsize;

	sc->sc_tx_bufsz = config[UMB_BULK_TX].bufsize;

}

static int

umb_handle_request(device_t dev,

    const void *preq, void **pptr, uint16_t *plen,

    uint16_t offset, uint8_t *pstate)

{

	/* FIXME really implement */

	return (ENXIO);

}

static int

umb_suspend(device_t dev)

{

	device_printf(dev, "Suspending\n");

	return (0);

}

static int

umb_resume(device_t dev)

{

	device_printf(dev, "Resuming\n");

	return (0);

}

static int

umb_deactivate(device_t dev)

{

	struct umb_softc *sc = device_get_softc(dev);

	struct ifnet *ifp = GET_IFP(sc);

	if (ifp != NULL) {

		if_dead(ifp);

	}

	sc->sc_dying = 1;

	return 0;

}

static void

umb_close_bulkpipes(struct umb_softc *sc)

{

	struct ifnet *ifp = GET_IFP(sc);

	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);

	umb_rxflush(sc);

	umb_txflush(sc);

	usbd_transfer_stop(sc->sc_xfer[UMB_BULK_RX]);

	usbd_transfer_stop(sc->sc_xfer[UMB_BULK_TX]);

}

static int

umb_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)

{

	struct umb_softc *sc = ifp->if_softc;

	struct in_ifaddr *ia = (struct in_ifaddr *)data;

	struct ifreq *ifr = (struct ifreq *)data;

	int error = 0;

	struct umb_parameter mp;

	if (sc->sc_dying)

		return EIO;

	switch (cmd) {

	case SIOCSIFADDR:

		switch (ia->ia_ifa.ifa_addr->sa_family) {

		case AF_INET:

			break;

#ifdef INET6

		case AF_INET6:

			break;

#endif /* INET6 */

		default:

			error = EAFNOSUPPORT;

			break;

		}

		break;

	case SIOCSIFFLAGS:

		mtx_lock(&sc->sc_mutex);

		umb_add_task(sc, umb_state_task,

				&sc->sc_proc_state_task[0].hdr,

				&sc->sc_proc_state_task[1].hdr, 1);

		mtx_unlock(&sc->sc_mutex);

		break;

	case SIOCGUMBINFO:

		error = copyout(&sc->sc_info, ifr->ifr_ifru.ifru_data,

		    sizeof (sc->sc_info));

		break;

	case SIOCSUMBPARAM:

		error = priv_check(curthread, PRIV_NET_SETIFPHYS);

		if (error)

			break;

		if ((error = copyin(ifr->ifr_ifru.ifru_data, &mp, sizeof (mp))) != 0)

			break;

		if ((error = umb_setpin(sc, mp.op, mp.is_puk, mp.pin, mp.pinlen,

		    mp.newpin, mp.newpinlen)) != 0)

			break;

		if (mp.apnlen < 0 || mp.apnlen > sizeof (sc->sc_info.apn)) {

			error = EINVAL;

			break;

		}

		sc->sc_roaming = mp.roaming ? 1 : 0;

		memset(sc->sc_info.apn, 0, sizeof (sc->sc_info.apn));

		memcpy(sc->sc_info.apn, mp.apn, mp.apnlen);

		sc->sc_info.apnlen = mp.apnlen;

		memset(sc->sc_info.username, 0, sizeof (sc->sc_info.username));

		memcpy(sc->sc_info.username, mp.username, mp.usernamelen);

		sc->sc_info.usernamelen = mp.usernamelen;

		memset(sc->sc_info.password, 0, sizeof (sc->sc_info.password));

		memcpy(sc->sc_info.password, mp.password, mp.passwordlen);

		sc->sc_info.passwordlen = mp.passwordlen;

		sc->sc_info.preferredclasses = mp.preferredclasses;

		umb_setdataclass(sc);

		break;

	case SIOCGUMBPARAM:

		memset(&mp, 0, sizeof (mp));

		memcpy(mp.apn, sc->sc_info.apn, sc->sc_info.apnlen);

		mp.apnlen = sc->sc_info.apnlen;

		mp.roaming = sc->sc_roaming;

		mp.preferredclasses = sc->sc_info.preferredclasses;

		error = copyout(&mp, ifr->ifr_ifru.ifru_data, sizeof (mp));

		break;

	case SIOCSIFMTU:

		/* Does this include the NCM headers and tail? */

		if (ifr->ifr_mtu > ifp->if_mtu) {

			error = EINVAL;

			break;

		}

		ifp->if_mtu = ifr->ifr_mtu;

		break;

	case SIOCAIFADDR:

	case SIOCSIFDSTADDR:

	case SIOCADDMULTI:

	case SIOCDELMULTI:

		break;

	case SIOCGIFMEDIA:

		error = ifmedia_ioctl(ifp, ifr, &sc->sc_im, cmd);

		break;

	default:

		error = EINVAL;

		break;

	}

	return (error);

}

static void

umb_init(void *arg)

{

	struct umb_softc *sc = arg;

	mtx_lock(&sc->sc_mutex);

	umb_add_task(sc, umb_start_task,

			&sc->sc_proc_start_task[0].hdr,

			&sc->sc_proc_start_task[1].hdr, 0);

	mtx_unlock(&sc->sc_mutex);

}

static void

umb_input(struct ifnet *ifp, struct mbuf *m)

{

	struct mbuf *mn;

	while (m) {

		mn = m->m_nextpkt;

		m->m_nextpkt = NULL;

		BPF_MTAP(ifp, m);

		netisr_dispatch(NETISR_IP, m);

		m = mn;

	}

}

static int

umb_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,

    struct route *rtp)

{

	int error;

	DPRINTFN(10, "%s: enter\n", __func__);

	switch (dst->sa_family) {

#ifdef INET6

	case AF_INET6:

		/* fall through */

#endif

	case AF_INET:

		break;

		/* silently drop dhclient packets */

	case AF_UNSPEC:

		m_freem(m);

		return (0);

		/* drop other packet types */

	default:

		m_freem(m);

		return (EAFNOSUPPORT);

	}

	/*

	 * Queue message on interface, and start output if interface

	 * not yet active.

	 */

	error = (ifp->if_transmit)(ifp, m);

	if (error) {

		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);

		return (ENOBUFS);

	}

	return (0);

}

static void

umb_start(struct ifnet *ifp)

{

	struct umb_softc *sc = ifp->if_softc;

	if (sc->sc_dying || !(ifp->if_drv_flags & IFF_DRV_RUNNING))

		return;

	mtx_lock(&sc->sc_mutex);

	usbd_transfer_start(sc->sc_xfer[UMB_BULK_TX]);

	mtx_unlock(&sc->sc_mutex);

}

static void

umb_start_task(struct usb_proc_msg *msg)

{

	struct umb_task *task = (struct umb_task *)msg;

	struct umb_softc *sc = task->sc;

	struct ifnet *ifp = GET_IFP(sc);

	DPRINTF("%s()\n", __func__);

	mtx_assert(&sc->sc_mutex, MA_OWNED);

	ifp->if_drv_flags |= IFF_DRV_RUNNING;

	/* start interrupt transfer */

	usbd_transfer_start(sc->sc_xfer[UMB_INTR_RX]);

	umb_open(sc);

}

#if 0

static void

umb_watchdog(struct ifnet *ifp)

{

	struct umb_softc *sc = ifp->if_softc;

	if (sc->sc_dying)

		return;

	if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);

	device_printf(sc->sc_dev, "watchdog timeout\n");

	usbd_transfer_drain(sc->sc_xfer[UMB_BULK_TX]);

	return;

}

#endif

static void

umb_statechg_timeout(void *arg)

{

	struct umb_softc *sc = arg;

	struct ifnet *ifp = GET_IFP(sc);

	mtx_assert(&sc->sc_mutex, MA_OWNED);

	if (sc->sc_info.regstate != MBIM_REGSTATE_ROAMING || sc->sc_roaming)

		if (ifp->if_flags & IFF_DEBUG)

			log(LOG_DEBUG, "%s: state change timeout\n",

					DEVNAM(sc));

	umb_add_task(sc, umb_state_task,

			&sc->sc_proc_state_task[0].hdr,

			&sc->sc_proc_state_task[1].hdr, 0);

}

static int

umb_mediachange(struct ifnet * ifp)

{

	return 0;

}

static void

umb_mediastatus(struct ifnet * ifp, struct ifmediareq * imr)

{

	switch (ifp->if_link_state) {

	case LINK_STATE_UP:

		imr->ifm_status = IFM_AVALID | IFM_ACTIVE;

		break;

	case LINK_STATE_DOWN:

		imr->ifm_status = IFM_AVALID;

		break;

	default: