Home | History | Annotate | Line # | Download | only in ifconfig
media.c revision 1.6 
      1 #include <sys/cdefs.h>
      2 #ifndef lint
      3 __RCSID("$NetBSD: media.c,v 1.6 2011/08/29 14:35:00 joerg Exp $");
      4 #endif /* not lint */
      5 
      6 #include <assert.h>
      7 #include <err.h>
      8 #include <errno.h>
      9 #include <stdio.h>
     10 #include <stdlib.h>
     11 #include <string.h>
     12 #include <util.h>
     13 
     14 #include <sys/ioctl.h>
     15 
     16 #include <net/if.h>
     17 #include <net/if_dl.h>
     18 #include <net/if_media.h>
     19 
     20 #include <prop/proplib.h>
     21 
     22 #include "env.h"
     23 #include "extern.h"
     24 #include "media.h"
     25 #include "parse.h"
     26 #include "util.h"
     27 #include "prog_ops.h"
     28 
     29 static void init_current_media(prop_dictionary_t, prop_dictionary_t);
     30 static void media_constructor(void) __attribute__((constructor));
     31 static int setmedia(prop_dictionary_t, prop_dictionary_t);
     32 static int setmediainst(prop_dictionary_t, prop_dictionary_t);
     33 static int setmediamode(prop_dictionary_t, prop_dictionary_t);
     34 static int setmediaopt(prop_dictionary_t, prop_dictionary_t);
     35 static int unsetmediaopt(prop_dictionary_t, prop_dictionary_t);
     36 
     37 /*
     38  * Media stuff.  Whenever a media command is first performed, the
     39  * currently select media is grabbed for this interface.  If `media'
     40  * is given, the current media word is modifed.  `mediaopt' commands
     41  * only modify the set and clear words.  They then operate on the
     42  * current media word later.
     43  */
     44 static int	media_current;
     45 static int	mediaopt_set;
     46 static int	mediaopt_clear;
     47 
     48 static struct usage_func usage;
     49 
     50 static const int ifm_status_valid_list[] = IFM_STATUS_VALID_LIST;
     51 
     52 static const struct ifmedia_status_description ifm_status_descriptions[] =
     53     IFM_STATUS_DESCRIPTIONS;
     54 
     55 static struct pstr mediamode = PSTR_INITIALIZER1(&mediamode, "mediamode",
     56     setmediamode, "mediamode", false, &command_root.pb_parser);
     57 
     58 static struct pinteger mediainst = PINTEGER_INITIALIZER1(&mediainst,
     59     "mediainst", 0, IFM_INST_MAX, 10, setmediainst, "mediainst",
     60     &command_root.pb_parser);
     61 
     62 static struct pstr unmediaopt = PSTR_INITIALIZER1(&unmediaopt, "-mediaopt",
     63     unsetmediaopt, "unmediaopt", false, &command_root.pb_parser);
     64 
     65 static struct pstr mediaopt = PSTR_INITIALIZER1(&mediaopt, "mediaopt",
     66     setmediaopt, "mediaopt", false, &command_root.pb_parser);
     67 
     68 static struct pstr media = PSTR_INITIALIZER1(&media, "media", setmedia, "media",
     69     false, &command_root.pb_parser);
     70 
     71 static const struct kwinst mediakw[] = {
     72 	  {.k_word = "instance", .k_key = "anymedia", .k_type = KW_T_BOOL,
     73 	   .k_bool = true, .k_act = "media", .k_deact = "mediainst",
     74 	   .k_nextparser = &mediainst.pi_parser}
     75 	, {.k_word = "inst", .k_key = "anymedia", .k_type = KW_T_BOOL,
     76 	   .k_bool = true, .k_act = "media", .k_deact = "mediainst",
     77 	   .k_nextparser = &mediainst.pi_parser}
     78 	, {.k_word = "media", .k_key = "anymedia", .k_type = KW_T_BOOL,
     79 	   .k_bool = true, .k_deact = "media", .k_altdeact = "anymedia",
     80 	   .k_nextparser = &media.ps_parser}
     81 	, {.k_word = "mediaopt", .k_key = "anymedia", .k_type = KW_T_BOOL,
     82 	   .k_bool = true, .k_deact = "mediaopt", .k_altdeact = "instance",
     83 	   .k_nextparser = &mediaopt.ps_parser}
     84 	, {.k_word = "-mediaopt", .k_key = "anymedia", .k_type = KW_T_BOOL,
     85 	   .k_bool = true, .k_deact = "unmediaopt", .k_altdeact = "media",
     86 	   .k_nextparser = &unmediaopt.ps_parser}
     87 	, {.k_word = "mode", .k_key = "anymedia", .k_type = KW_T_BOOL,
     88 	   .k_bool = true, .k_deact = "mode",
     89 	   .k_nextparser = &mediamode.ps_parser}
     90 };
     91 
     92 struct pkw kwmedia = PKW_INITIALIZER(&kwmedia, "media keywords", NULL, NULL,
     93     mediakw, __arraycount(mediakw), NULL);
     94 
     95 __dead static void
     96 media_error(int type, const char *val, const char *opt)
     97 {
     98 	errx(EXIT_FAILURE, "unknown %s media %s: %s",
     99 		get_media_type_string(type), opt, val);
    100 }
    101 
    102 void
    103 init_current_media(prop_dictionary_t env, prop_dictionary_t oenv)
    104 {
    105 	const char *ifname;
    106 	struct ifmediareq ifmr;
    107 
    108 	if ((ifname = getifname(env)) == NULL)
    109 		err(EXIT_FAILURE, "getifname");
    110 
    111 	/*
    112 	 * If we have not yet done so, grab the currently-selected
    113 	 * media.
    114 	 */
    115 
    116 	if (prop_dictionary_get(env, "initmedia") == NULL) {
    117 		memset(&ifmr, 0, sizeof(ifmr));
    118 
    119 		if (direct_ioctl(env, SIOCGIFMEDIA, &ifmr) == -1) {
    120 			/*
    121 			 * If we get E2BIG, the kernel is telling us
    122 			 * that there are more, so we can ignore it.
    123 			 */
    124 			if (errno != E2BIG)
    125 				err(EXIT_FAILURE, "SIOCGIFMEDIA");
    126 		}
    127 
    128 		if (!prop_dictionary_set_bool(oenv, "initmedia", true)) {
    129 			err(EXIT_FAILURE, "%s: prop_dictionary_set_bool",
    130 			    __func__);
    131 		}
    132 		media_current = ifmr.ifm_current;
    133 	}
    134 
    135 	/* Sanity. */
    136 	if (IFM_TYPE(media_current) == 0)
    137 		errx(EXIT_FAILURE, "%s: no link type?", ifname);
    138 }
    139 
    140 void
    141 process_media_commands(prop_dictionary_t env)
    142 {
    143 	struct ifreq ifr;
    144 
    145 	if (prop_dictionary_get(env, "media") == NULL &&
    146 	    prop_dictionary_get(env, "mediaopt") == NULL &&
    147 	    prop_dictionary_get(env, "unmediaopt") == NULL &&
    148 	    prop_dictionary_get(env, "mediamode") == NULL) {
    149 		/* Nothing to do. */
    150 		return;
    151 	}
    152 
    153 	/*
    154 	 * Media already set up, and commands sanity-checked.  Set/clear
    155 	 * any options, and we're ready to go.
    156 	 */
    157 	media_current |= mediaopt_set;
    158 	media_current &= ~mediaopt_clear;
    159 
    160 	memset(&ifr, 0, sizeof(ifr));
    161 	ifr.ifr_media = media_current;
    162 
    163 	if (direct_ioctl(env, SIOCSIFMEDIA, &ifr) == -1)
    164 		err(EXIT_FAILURE, "SIOCSIFMEDIA");
    165 }
    166 
    167 static int
    168 setmedia(prop_dictionary_t env, prop_dictionary_t oenv)
    169 {
    170 	int type, subtype, inst;
    171 	prop_data_t data;
    172 	char *val;
    173 
    174 	init_current_media(env, oenv);
    175 
    176 	data = (prop_data_t)prop_dictionary_get(env, "media");
    177 	assert(data != NULL);
    178 
    179 	/* Only one media command may be given. */
    180 	/* Must not come after mode commands */
    181 	/* Must not come after mediaopt commands */
    182 
    183 	/*
    184 	 * No need to check if `instance' has been issued; setmediainst()
    185 	 * craps out if `media' has not been specified.
    186 	 */
    187 
    188 	type = IFM_TYPE(media_current);
    189 	inst = IFM_INST(media_current);
    190 
    191 	val = strndup(prop_data_data_nocopy(data), prop_data_size(data));
    192 	if (val == NULL)
    193 		return -1;
    194 
    195 	/* Look up the subtype. */
    196 	subtype = get_media_subtype(type, val);
    197 	if (subtype == -1)
    198 		media_error(type, val, "subtype");
    199 
    200 	/* Build the new current media word. */
    201 	media_current = IFM_MAKEWORD(type, subtype, 0, inst);
    202 
    203 	/* Media will be set after other processing is complete. */
    204 	return 0;
    205 }
    206 
    207 static int
    208 setmediaopt(prop_dictionary_t env, prop_dictionary_t oenv)
    209 {
    210 	char *invalid;
    211 	prop_data_t data;
    212 	char *val;
    213 
    214 	init_current_media(env, oenv);
    215 
    216 	data = (prop_data_t)prop_dictionary_get(env, "mediaopt");
    217 	assert(data != NULL);
    218 
    219 	/* Can only issue `mediaopt' once. */
    220 	/* Can't issue `mediaopt' if `instance' has already been issued. */
    221 
    222 	val = strndup(prop_data_data_nocopy(data), prop_data_size(data));
    223 	if (val == NULL)
    224 		return -1;
    225 
    226 	mediaopt_set = get_media_options(media_current, val, &invalid);
    227 	free(val);
    228 	if (mediaopt_set == -1)
    229 		media_error(media_current, invalid, "option");
    230 
    231 	/* Media will be set after other processing is complete. */
    232 	return 0;
    233 }
    234 
    235 static int
    236 unsetmediaopt(prop_dictionary_t env, prop_dictionary_t oenv)
    237 {
    238 	char *invalid, *val;
    239 	prop_data_t data;
    240 
    241 	init_current_media(env, oenv);
    242 
    243 	data = (prop_data_t)prop_dictionary_get(env, "unmediaopt");
    244 	if (data == NULL) {
    245 		errno = ENOENT;
    246 		return -1;
    247 	}
    248 
    249 	val = strndup(prop_data_data_nocopy(data), prop_data_size(data));
    250 	if (val == NULL)
    251 		return -1;
    252 
    253 	/*
    254 	 * No need to check for A_MEDIAINST, since the test for A_MEDIA
    255 	 * implicitly checks for A_MEDIAINST.
    256 	 */
    257 
    258 	mediaopt_clear = get_media_options(media_current, val, &invalid);
    259 	free(val);
    260 	if (mediaopt_clear == -1)
    261 		media_error(media_current, invalid, "option");
    262 
    263 	/* Media will be set after other processing is complete. */
    264 	return 0;
    265 }
    266 
    267 static int
    268 setmediainst(prop_dictionary_t env, prop_dictionary_t oenv)
    269 {
    270 	int type, subtype, options;
    271 	int64_t inst;
    272 	bool rc;
    273 
    274 	init_current_media(env, oenv);
    275 
    276 	rc = prop_dictionary_get_int64(env, "mediainst", &inst);
    277 	assert(rc);
    278 
    279 	/* Can only issue `instance' once. */
    280 	/* Must have already specified `media' */
    281 
    282 	type = IFM_TYPE(media_current);
    283 	subtype = IFM_SUBTYPE(media_current);
    284 	options = IFM_OPTIONS(media_current);
    285 
    286 	media_current = IFM_MAKEWORD(type, subtype, options, inst);
    287 
    288 	/* Media will be set after other processing is complete. */
    289 	return 0;
    290 }
    291 
    292 static int
    293 setmediamode(prop_dictionary_t env, prop_dictionary_t oenv)
    294 {
    295 	int type, subtype, options, inst, mode;
    296 	prop_data_t data;
    297 	char *val;
    298 
    299 	init_current_media(env, oenv);
    300 
    301 	data = (prop_data_t)prop_dictionary_get(env, "mediamode");
    302 	assert(data != NULL);
    303 
    304 	type = IFM_TYPE(media_current);
    305 	subtype = IFM_SUBTYPE(media_current);
    306 	options = IFM_OPTIONS(media_current);
    307 	inst = IFM_INST(media_current);
    308 
    309 	val = strndup(prop_data_data_nocopy(data), prop_data_size(data));
    310 	if (val == NULL)
    311 		return -1;
    312 
    313 	mode = get_media_mode(type, val);
    314 	if (mode == -1)
    315 		media_error(type, val, "mode");
    316 
    317 	free(val);
    318 
    319 	media_current = IFM_MAKEWORD(type, subtype, options, inst) | mode;
    320 
    321 	/* Media will be set after other processing is complete. */
    322 	return 0;
    323 }
    324 
    325 void
    326 print_media_word(int ifmw, const char *opt_sep)
    327 {
    328 	const char *str;
    329 
    330 	printf("%s", get_media_subtype_string(ifmw));
    331 
    332 	/* Find mode. */
    333 	if (IFM_MODE(ifmw) != 0) {
    334 		str = get_media_mode_string(ifmw);
    335 		if (str != NULL)
    336 			printf(" mode %s", str);
    337 	}
    338 
    339 	/* Find options. */
    340 	for (; (str = get_media_option_string(&ifmw)) != NULL; opt_sep = ",")
    341 		printf("%s%s", opt_sep, str);
    342 
    343 	if (IFM_INST(ifmw) != 0)
    344 		printf(" instance %d", IFM_INST(ifmw));
    345 }
    346 
    347 void
    348 media_status(prop_dictionary_t env, prop_dictionary_t oenv)
    349 {
    350 	struct ifmediareq ifmr;
    351 	int af, i, s;
    352 	int *media_list;
    353 	const char *ifname;
    354 
    355 	if ((ifname = getifname(env)) == NULL)
    356 		err(EXIT_FAILURE, "getifname");
    357 	if ((af = getaf(env)) == -1)
    358 		af = AF_UNSPEC;
    359 
    360 	/* get out early if the family is unsupported by the kernel */
    361 	if ((s = getsock(af)) == -1)
    362 		err(EXIT_FAILURE, "%s: getsock", __func__);
    363 
    364 	memset(&ifmr, 0, sizeof(ifmr));
    365 	estrlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
    366 
    367 	if (prog_ioctl(s, SIOCGIFMEDIA, &ifmr) == -1) {
    368 		/*
    369 		 * Interface doesn't support SIOC{G,S}IFMEDIA.
    370 		 */
    371 		return;
    372 	}
    373 
    374 	if (ifmr.ifm_count == 0) {
    375 		warnx("%s: no media types?", ifname);
    376 		return;
    377 	}
    378 
    379 	media_list = (int *)malloc(ifmr.ifm_count * sizeof(int));
    380 	if (media_list == NULL)
    381 		err(EXIT_FAILURE, "malloc");
    382 	ifmr.ifm_ulist = media_list;
    383 
    384 	if (prog_ioctl(s, SIOCGIFMEDIA, &ifmr) == -1)
    385 		err(EXIT_FAILURE, "SIOCGIFMEDIA");
    386 
    387 	printf("\tmedia: %s ", get_media_type_string(ifmr.ifm_current));
    388 	print_media_word(ifmr.ifm_current, " ");
    389 	if (ifmr.ifm_active != ifmr.ifm_current) {
    390 		printf(" (");
    391 		print_media_word(ifmr.ifm_active, " ");
    392 		printf(")");
    393 	}
    394 	printf("\n");
    395 
    396 	if (ifmr.ifm_status & IFM_STATUS_VALID) {
    397 		const struct ifmedia_status_description *ifms;
    398 		int bitno, found = 0;
    399 
    400 		printf("\tstatus: ");
    401 		for (bitno = 0; ifm_status_valid_list[bitno] != 0; bitno++) {
    402 			for (ifms = ifm_status_descriptions;
    403 			     ifms->ifms_valid != 0; ifms++) {
    404 				if (ifms->ifms_type !=
    405 				      IFM_TYPE(ifmr.ifm_current) ||
    406 				    ifms->ifms_valid !=
    407 				      ifm_status_valid_list[bitno])
    408 					continue;
    409 				printf("%s%s", found ? ", " : "",
    410 				    IFM_STATUS_DESC(ifms, ifmr.ifm_status));
    411 				found = 1;
    412 
    413 				/*
    414 				 * For each valid indicator bit, there's
    415 				 * only one entry for each media type, so
    416 				 * terminate the inner loop now.
    417 				 */
    418 				break;
    419 			}
    420 		}
    421 
    422 		if (found == 0)
    423 			printf("unknown");
    424 		printf("\n");
    425 	}
    426 
    427 	if (get_flag('m')) {
    428 		int type, printed_type;
    429 
    430 		for (type = IFM_NMIN; type <= IFM_NMAX; type += IFM_NMIN) {
    431 			for (i = 0, printed_type = 0; i < ifmr.ifm_count; i++) {
    432 				if (IFM_TYPE(media_list[i]) != type)
    433 					continue;
    434 				if (printed_type == 0) {
    435 					printf("\tsupported %s media:\n",
    436 					    get_media_type_string(type));
    437 					printed_type = 1;
    438 				}
    439 				printf("\t\tmedia ");
    440 				print_media_word(media_list[i], " mediaopt ");
    441 				printf("\n");
    442 			}
    443 		}
    444 	}
    445 
    446 	free(media_list);
    447 }
    448 
    449 static void
    450 media_usage(prop_dictionary_t env)
    451 {
    452 	fprintf(stderr,
    453 	    "\t[ media type ] [ mediaopt opts ] [ -mediaopt opts ] "
    454 	    "[ instance minst ]\n");
    455 }
    456 
    457 static void
    458 media_constructor(void)
    459 {
    460 	if (register_flag('m') != 0)
    461 		err(EXIT_FAILURE, __func__);
    462 	usage_func_init(&usage, media_usage);
    463 	register_usage(&usage);
    464 }
    465