自学教程：C++ IFM_TYPE函数代码示例

static voidsetmedia(const char *val, int d, int s, const struct afswtch *afp){	struct ifmediareq *ifmr;	int subtype;	ifmr = ifmedia_getstate(s);	/*	 * We are primarily concerned with the top-level type.	 * However, "current" may be only IFM_NONE, so we just look	 * for the top-level type in the first "supported type"	 * entry.	 *	 * (I'm assuming that all supported media types for a given	 * interface will be the same top-level type..)	 */	subtype = get_media_subtype(IFM_TYPE(ifmr->ifm_ulist[0]), val);	strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));	ifr.ifr_media = (ifmr->ifm_current & ~(IFM_NMASK|IFM_TMASK)) |	    IFM_TYPE(ifmr->ifm_ulist[0]) | subtype;	if ((ifr.ifr_media & IFM_TMASK) == 0) {		ifr.ifr_media &= ~(IFM_GMASK | IFM_OMASK);	}	ifmr->ifm_current = ifr.ifr_media;	callback_register(setifmediacallback, (void *)ifmr);}

/* * Set media options. */intqe_ifmedia_upd(struct ifnet *ifp){	struct qe_softc *sc = ifp->if_softc;	struct ifmedia *ifm = &sc->sc_ifmedia;	bus_space_tag_t t = sc->sc_bustag;	bus_space_handle_t mr = sc->sc_mr;	int newmedia = ifm->ifm_media;	uint8_t plscc, phycc;#if defined(SUN4U) || defined(__GNUC__)	(void)&t;#endif	if (IFM_TYPE(newmedia) != IFM_ETHER)		return (EINVAL);	plscc = bus_space_read_1(t, mr, QE_MRI_PLSCC) & ~QE_MR_PLSCC_PORTMASK;	phycc = bus_space_read_1(t, mr, QE_MRI_PHYCC) & ~QE_MR_PHYCC_ASEL;	if (IFM_SUBTYPE(newmedia) == IFM_AUTO)		phycc |= QE_MR_PHYCC_ASEL;	else if (IFM_SUBTYPE(newmedia) == IFM_10_T)		plscc |= QE_MR_PLSCC_TP;	else if (IFM_SUBTYPE(newmedia) == IFM_10_5)		plscc |= QE_MR_PLSCC_AUI;	bus_space_write_1(t, mr, QE_MRI_PLSCC, plscc);	bus_space_write_1(t, mr, QE_MRI_PHYCC, phycc);	return (0);}

intinit_current_media(int s, char *ifname){	int media_current;	struct ifmediareq ifmr;	(void) memset(&ifmr, 0, sizeof(ifmr));	(void) strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));	if (ioctl(s, SIOCGIFMEDIA, (caddr_t) & ifmr) < 0) {		/*		 * If we get E2BIG, the kernel is telling us		 * that there are more, so we can ignore it.		 */		if (errno != E2BIG)			return(-1);	}	media_current = ifmr.ifm_current;	/* Sanity. */	if (IFM_TYPE(media_current) == 0) {		printf("%% init_current_media: %s: no link type?/n", ifname);		return(-1);	}	return(media_current);}

intrtems_ifmedia2str (int media, char *buf, int bufsz){  const char *mdesc;  const char *dupdesc = 0;  /* only ethernet supported, so far */  if (IFM_ETHER != IFM_TYPE (media))    return -1;  if (!(mdesc = find_desc (IFM_SUBTYPE (media), shared_media_strings)))    mdesc = find_desc (IFM_SUBTYPE (media), ethern_media_strings);  if (!mdesc)    return -1;  if (IFM_NONE != IFM_SUBTYPE (media))    dupdesc = IFM_FDX & media ? " full-duplex" : " half-duplex";  return WHATPRINT (buf, bufsz,                    "Ethernet [phy instance: %" PRId32 "]: (link %s, autoneg %s) -- media: %s%s",                    (int32_t) IFM_INST (media),                    IFM_LINK_OK & media ? "ok" : "down",                    IFM_ANEG_DIS & media ? "off" : "on",                    mdesc, dupdesc ? dupdesc : "");}

static inttr_pcmcia_mediachange(struct tr_softc *sc){	int setspeed = 0;	if (IFM_TYPE(sc->sc_media.ifm_media) != IFM_TOKEN)		return EINVAL;	switch (IFM_SUBTYPE(sc->sc_media.ifm_media)) {	case IFM_TOK_STP16:	case IFM_TOK_UTP16:		if ((sc->sc_init_status & RSP_16) == 0)			setspeed = 1;		break;	case IFM_TOK_STP4:	case IFM_TOK_UTP4:		if ((sc->sc_init_status & RSP_16) != 0)			setspeed = 1;		break;	}	if (setspeed != 0) {		tr_stop(sc);		if (sc->sc_enabled)			tr_pcmcia_disable(sc);		sc->sc_init_status ^= RSP_16;		/* XXX 100 Mbit/s */		if (sc->sc_enabled)			tr_pcmcia_enable(sc);	}	/*	 * XXX Handle Early Token Release !!!!	 */	return 0;}

static bools_wireless_nic (const char* name){    int sock = 0;    bool result = FALSE;    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)        return FALSE;#if defined (SIOCGIFMEDIA)    struct ifmediareq ifmr;    memset (&ifmr, 0, sizeof (struct ifmediareq));    strncpy(ifmr.ifm_name, name, sizeof (ifmr.ifm_name));    int res = ioctl (sock, SIOCGIFMEDIA, (caddr_t) &ifmr);    if (res != -1)        result = (IFM_TYPE (ifmr.ifm_current) == IFM_IEEE80211);#elif defined (SIOCGIWNAME)    struct iwreq wrq;    memset (&wrq, 0, sizeof (struct iwreq));    strncpy (wrq.ifr_name, name, sizeof (wrq.ifr_name));    int res = ioctl (sock, SIOCGIWNAME, (caddr_t) &wrq);    if (res != -1)        result = TRUE;#endif    close (sock);    return result;}

static voidset_port_media(struct cfg *cfg, char *argv[]){	etherswitch_port_t p;	int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];	int subtype;		bzero(&p, sizeof(p));	p.es_port = cfg->unit;	p.es_ifmr.ifm_ulist = ifm_ulist;	p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;	if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)		err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");	subtype = get_media_subtype(IFM_TYPE(ifm_ulist[0]), argv[1]);	p.es_ifr.ifr_media = (p.es_ifmr.ifm_current & IFM_IMASK) |	        IFM_TYPE(ifm_ulist[0]) | subtype;	if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)		err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");}

static struct ifmedia_description *get_toptype_desc(int ifmw){	struct ifmedia_description *desc;	for (desc = ifm_type_descriptions; desc->ifmt_string != NULL; desc++)		if (IFM_TYPE(ifmw) == desc->ifmt_word)			break;	return desc;}

bool NetworkInterface::isWireless(){   struct ifmediareq ifm;   memset(&ifm, 0, sizeof(struct ifmediareq));   strncpy(ifm.ifm_name, name.toLocal8Bit(), IFNAMSIZ);   int s = socket(AF_INET, SOCK_DGRAM, 0);   ioctl(s, SIOCGIFMEDIA, &ifm);   return IFM_TYPE(ifm.ifm_active) == IFM_IEEE80211;}

const char     *get_media_type_string(uint64_t mword){	const struct ifmedia_description *desc;	for (desc = ifm_type_descriptions; desc->ifmt_string != NULL;	     desc++) {		if (IFM_TYPE(mword) == desc->ifmt_word)			return (desc->ifmt_string);	}	return ("<unknown type>");}

/********************************************************************* * *  Media Ioctl callback * *  This routine is called when the user changes speed/duplex using *  media/mediopt option with ifconfig. * **********************************************************************/intixl_if_media_change(if_ctx_t ctx){	struct ifmedia *ifm = iflib_get_media(ctx);	INIT_DEBUGOUT("ixl_media_change: begin");	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)		return (EINVAL);	if_printf(iflib_get_ifp(ctx), "Media change is currently not supported./n");	return (ENODEV);}

intintmediaopt(char *ifname, int ifs, int argc, char **argv){	int set, media_current, mediaopt;	if (NO_ARG(argv[0])) {		set = 0;		argc--;		argv++;	} else		set = 1;	argv++;	argc--;	if ((set && (argc != 1)) || (!set && (argc > 1))) {		printf("%% mediaopt <option>/n");		printf("%% no mediaopt [option]/n");		return(0);	}        media_current = init_current_media(ifs, ifname);	if (media_current == -1) {		if (errno == EINVAL)			printf("%% This device does not support "			    "media commands./n");		else			printf("%% Failed to initialize media: %s/n",			    strerror(errno));		return(0);	}	if (argc == 1)		mediaopt = get_media_options(IFM_TYPE(media_current), argv[0]);	else		mediaopt = IFM_OPTIONS(media_current);	if (mediaopt == -1)		return(0);	if (set)		media_current |= mediaopt;	else		media_current &= ~mediaopt;	process_media_commands(ifs, ifname, media_current);	return(0);}

static intsln_media_upd(struct ifnet *ifp){	struct sln_softc *sc = ifp->if_softc;	struct ifmedia *ifm = &sc->ifmedia;	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)		return EINVAL;	if (ifp->if_flags & IFF_UP)		sln_init(sc);	return 0;}

voidmedia_supported(int s, char *ifname, char *hdr_delim, char *body_delim){	u_int64_t *media_list;	int i, type, printed_type;	struct ifmediareq ifmr;	memset(&ifmr, 0, sizeof(ifmr));	strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));	if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {		if (errno != ENOTTY)			printf("%% media_supported: 1/SIOCGIFMEDIA: %s/n",			    strerror(errno));		return;	}	media_list = calloc(ifmr.ifm_count, sizeof(*media_list));	if (media_list == NULL) {		printf("%% media_status: calloc: %s/n", strerror(errno));		return;	}	ifmr.ifm_ulist = media_list;	if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {		printf("%% media_supported: 2/SIOCGIFMEDIA: %s/n", 		    strerror(errno));		return;	}	for (type = IFM_NMIN; type <= IFM_NMAX; type += IFM_NMIN) {		for (i = 0, printed_type = 0; i < ifmr.ifm_count; i++) {			if (IFM_TYPE(media_list[i]) == type) {				if (printed_type == 0) {				    printf("%sSupported media types on %s:/n",				        hdr_delim, ifname);				    printed_type = 1;				}				printf("%s", body_delim);				print_media_word(media_list[i], 0, 1);				printf("/n");			}		}	}	free(media_list);	return;}

static voidsetmediamode(const char *val, int d, int s, const struct afswtch *afp){	struct ifmediareq *ifmr;	int mode;	ifmr = ifmedia_getstate(s);	mode = get_media_mode(IFM_TYPE(ifmr->ifm_ulist[0]), val);	strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));	ifr.ifr_media = (ifmr->ifm_current & ~IFM_MMASK) | mode;	ifmr->ifm_current = ifr.ifr_media;	callback_register(setifmediacallback, (void *)ifmr);}

static BooleanisVPNInterfaceWifi (struct service *serv){	u_int32_t  media;	char      *interface_buf = getVPNInterfaceBuf(serv);	if (interface_buf && interface_buf[0]) {		media = get_if_media(interface_buf);	} else {		media = 0;	}	if (IFM_TYPE(media) == IFM_IEEE80211) {		return true;	}	return false;}

int connection_active(char *if_name, int if_type) {        /*        *  Returns 1 if the network status on the interface is active.        *  if_type: 0 for ethernet, 1 for ieee80211         */        struct ifmediareq ifmr;        const struct ifmedia_status_description *ifms;        static const int ifm_status_valid_list[] = IFM_STATUS_VALID_LIST;        static const struct ifmedia_status_description ifm_status_descriptions[] = IFM_STATUS_DESCRIPTIONS;        int 		bit = 0, 	s = -1, res;        s = open_socket(AF_INET);        if (s < 0) {            printf("error opening socket: %s/n", strerror(errno));        }        memset(&ifmr, 0, sizeof(ifmr));        strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));        res = ioctl(s, SIOCGIFMEDIA, (caddr_t) & ifmr);        close(s);        if (res) {            printf("res: %d (%s)/n", res, strerror(errno));            return 0;        }        if (if_type) {            /* ieee80211 check */            if (IFM_ACTIVE) {                printf("connection_active: ieee80211 network is active/n");                return 1;            }            printf("connection_active: ieee80211 failed check/n");            return 0;        } else {            /* ethernet check */            for (ifms = ifm_status_descriptions; ifms->ifms_valid != 0; ifms++) {                if (ifms->ifms_type == IFM_TYPE(ifmr.ifm_current))                    if (strcmp(IFM_STATUS_DESC(ifms, ifmr.ifm_status), "active") == 0) {                        printf("connection_active: ethernet network is active/n");                        return 1;                    } else {                        printf("connection_active: ethernet failed check/n");                        return 0;                    }            }        }}

/* * FreeBSD allows for Virtual Access Points * We need to check if the interface is a Virtual Interface Master * and if so, don't use it. * This check is made by virtue of being a IEEE80211 device but * returning the SSID gives an error. */intif_vimaster(const char *ifname){	struct ifmediareq ifmr;	memset(&ifmr, 0, sizeof(ifmr));	strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));	if (ioctl(socket_afnet, SIOCGIFMEDIA, &ifmr) == -1)		return -1;	if (ifmr.ifm_status & IFM_AVALID &&	    IFM_TYPE(ifmr.ifm_active) == IFM_IEEE80211)	{		if (getifssid(ifname, NULL) == -1)			return 1;	}	return 0;}

static intle_pci_mediachange(struct lance_softc *sc){	struct ifmedia *ifm = &sc->sc_media;	uint16_t reg;	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)		return (EINVAL);	if (IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1)		le_pci_wrbcr(sc, LE_BCR49,		    (le_pci_rdbcr(sc, LE_BCR49) & ~LE_B49_PHYSEL) | 0x1);	else if (IFM_SUBTYPE(ifm->ifm_media) == IFM_AUTO)		le_pci_wrbcr(sc, LE_BCR2,		    le_pci_rdbcr(sc, LE_BCR2) | LE_B2_ASEL);	else {		le_pci_wrbcr(sc, LE_BCR2,		    le_pci_rdbcr(sc, LE_BCR2) & ~LE_B2_ASEL);		reg = le_pci_rdcsr(sc, LE_CSR15);		reg &= ~LE_C15_PORTSEL(LE_PORTSEL_MASK);		if (IFM_SUBTYPE(ifm->ifm_media) == IFM_10_T)			reg |= LE_C15_PORTSEL(LE_PORTSEL_10T);		else			reg |= LE_C15_PORTSEL(LE_PORTSEL_AUI);		le_pci_wrcsr(sc, LE_CSR15, reg);	}	reg = le_pci_rdbcr(sc, LE_BCR9);	if (IFM_OPTIONS(ifm->ifm_media) & IFM_FDX) {		reg |= LE_B9_FDEN;		/*		 * Allow FDX on AUI only if explicitly chosen,		 * not in autoselect mode.		 */		if (IFM_SUBTYPE(ifm->ifm_media) == IFM_10_5)			reg |= LE_B9_AUIFD;		else			reg &= ~LE_B9_AUIFD;	} else		reg &= ~LE_B9_FDEN;	le_pci_wrbcr(sc, LE_BCR9, reg);	return (0);}

/* * FreeBSD allows for Virtual Access Points * We need to check if the interface is a Virtual Interface Master * and if so, don't use it. * This check is made by virtue of being a IEEE80211 device but * returning the SSID gives an error. */intif_vimaster(const char *ifname){	int s, r;	struct ifmediareq ifmr;	if ((s = socket(PF_INET, SOCK_DGRAM, 0)) == -1)		return -1;	memset(&ifmr, 0, sizeof(ifmr));	strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));	r = ioctl(s, SIOCGIFMEDIA, &ifmr);	close(s);	if (r == -1)		return -1;	if (ifmr.ifm_status & IFM_AVALID &&	    IFM_TYPE(ifmr.ifm_active) == IFM_IEEE80211)	{		if (if_getssid1(ifname, NULL) == -1)			return 1;	}	return 0;}

intmc_mediachange(struct mc_softc *sc){	struct ifmedia *ifm = &sc->sc_media;	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)		return EINVAL;	switch (IFM_SUBTYPE(ifm->ifm_media)) {	case IFM_10_T:		mc_select_utp(sc);		break;	case IFM_10_5:		mc_select_aui(sc);		break;	default:		return EINVAL;	}	return 0;}

static voidset_port_mediaopt(struct cfg *cfg, char *argv[]){	etherswitch_port_t p;	int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];	int options;		bzero(&p, sizeof(p));	p.es_port = cfg->unit;	p.es_ifmr.ifm_ulist = ifm_ulist;	p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;	if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)		err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");	options = get_media_options(IFM_TYPE(ifm_ulist[0]), argv[1]);	if (options == -1)		errx(EX_USAGE, "invalid media options /"%s/"", argv[1]);	if (options & IFM_HDX) {		p.es_ifr.ifr_media &= ~IFM_FDX;		options &= ~IFM_HDX;	}	p.es_ifr.ifr_media |= options;	if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)		err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");}

//.........这里部分代码省略.........				exit(1);			}			hasBroadcast = true;			addFlags |= IFF_BROADCAST;			i++;		} else if (!strcmp(args[i], "mtu")) {			mtu = args[i + 1] ? strtol(args[i + 1], NULL, 0) : 0;			if (mtu <= 500) {				fprintf(stderr, "%s: Option 'mtu' expected valid max transfer "					"unit size/n", kProgramName);				exit(1);			}			i++;		} else if (!strcmp(args[i], "metric")) {			if (i + 1 >= argCount) {				fprintf(stderr, "%s: Option 'metric' exptected parameter/n",					kProgramName);				exit(1);			}			metric = strtol(args[i + 1], NULL, 0);			i++;		} else if (!strcmp(args[i], "media")) {			if (ioctl(socket, SIOCGIFMEDIA, &request,					sizeof(struct ifreq)) < 0) {				fprintf(stderr, "%s: Unable to detect media type/n",					kProgramName);				exit(1);			}			if (i + 1 >= argCount) {				fprintf(stderr, "%s: Option 'media' exptected parameter/n",					kProgramName);				exit(1);			}			if (!media_parse_subtype(args[i + 1], IFM_TYPE(request.ifr_media),					&media)) {				fprintf(stderr, "%s: Invalid parameter for option 'media': "					"'%s'/n", kProgramName, args[i + 1]);				exit(1);			}			i++;		} else if (!strcmp(args[i], "up") || !strcmp(args[i], "-down")) {			addFlags |= IFF_UP;		} else if (!strcmp(args[i], "down") || !strcmp(args[i], "-up")) {			removeFlags |= IFF_UP;		} else if (!strcmp(args[i], "bcast")) {			addFlags |= IFF_BROADCAST;		} else if (!strcmp(args[i], "-bcast")) {			removeFlags |= IFF_BROADCAST;		} else if (!strcmp(args[i], "promisc")) {			addFlags |= IFF_PROMISC;		} else if (!strcmp(args[i], "-promisc")) {			removeFlags |= IFF_PROMISC;		} else if (!strcmp(args[i], "allmulti")) {			addFlags |= IFF_ALLMULTI;		} else if (!strcmp(args[i], "-allmulti")) {			removeFlags |= IFF_ALLMULTI;		} else if (!strcmp(args[i], "loopback")) {			addFlags |= IFF_LOOPBACK;		} else if (!strcmp(args[i], "auto-config")) {			doAutoConfig = true;		} else			usage(1);		i++;	}

voidlist_interface(int socket, const char* name){	ifreq request;	if (!prepare_request(request, name))		return;	if (ioctl(socket, SIOCGIFINDEX, &request, sizeof(request)) < 0) {		fprintf(stderr, "%s: Interface /"%s/" does not exist./n", kProgramName,			name);		return;	}	printf("%s", name);	size_t length = strlen(name);	if (length < 8)		putchar('/t');	else		printf("/n/t");	// get link level interface for this interface	int linkSocket = ::socket(AF_LINK, SOCK_DGRAM, 0);	if (linkSocket < 0) {		printf("No link level: %s/n", strerror(errno));	} else {		const char *type = "unknown";		char address[256];		strcpy(address, "none");		if (ioctl(socket, SIOCGIFPARAM, &request, sizeof(struct ifreq)) == 0) {			prepare_request(request, request.ifr_parameter.device);			if (ioctl(linkSocket, SIOCGIFADDR, &request, sizeof(struct ifreq))					== 0) {				sockaddr_dl &link = *(sockaddr_dl *)&request.ifr_addr;				switch (link.sdl_type) {					case IFT_ETHER:					{						type = "Ethernet";						if (link.sdl_alen > 0) {							uint8 *mac = (uint8 *)LLADDR(&link);							sprintf(address, "%02x:%02x:%02x:%02x:%02x:%02x",								mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);						} else							strcpy(address, "not available");						break;					}					case IFT_LOOP:						type = "Local Loopback";						break;					case IFT_MODEM:						type = "Modem";						break;				}			}		}		printf("Hardware Type: %s, Address: %s/n", type, address);		close(linkSocket);	}	if (ioctl(socket, SIOCGIFMEDIA, &request, sizeof(struct ifreq)) == 0		&& (request.ifr_media & IFM_ACTIVE) != 0) {		// dump media state in case we're linked		const char* type = "unknown";		bool show = false;		for (int32 i = 0; kMediaTypes[i].type >= 0; i++) {			// loopback don't really have a media anyway			if (IFM_TYPE(request.ifr_media) == 0/*IFT_LOOP*/)				break;			// only check for generic or correct subtypes			if (kMediaTypes[i].type &&				kMediaTypes[i].type != IFM_TYPE(request.ifr_media))				continue;			for (int32 j = 0; kMediaTypes[i].subtypes[j].subtype >= 0; j++) {				if (kMediaTypes[i].subtypes[j].subtype == IFM_SUBTYPE(request.ifr_media)) {					// found a match					type = kMediaTypes[i].subtypes[j].pretty;					show = true;					break;				}			}		}		if (show)			printf("/tMedia Type: %s/n", type);	}	uint32 flags = 0;	if (ioctl(socket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0)		flags = request.ifr_flags;	for (int32 i = 0; kFamilies[i].family >= 0; i++) {		int familySocket = ::socket(kFamilies[i].family, SOCK_DGRAM, 0);		if (familySocket < 0)			continue;//.........这里部分代码省略.........

static intmonitor_mode(pcap_t *p, int set){	int sock;	struct ifmediareq req;	int *media_list;	int i;	int can_do;	struct ifreq ifr;	sock = socket(AF_INET, SOCK_DGRAM, 0);	if (sock == -1) {		snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "can't open socket: %s",		    pcap_strerror(errno));		return (PCAP_ERROR);	}	memset(&req, 0, sizeof req);	(void)strlcpy(req.ifm_name, p->opt.source, sizeof req.ifm_name);	/*	 * Find out how many media types we have.	 */	if (ioctl(sock, SIOCGIFMEDIA, &req) < 0) {		/*		 * Can't get the media types.		 */		switch (errno) {		case ENXIO:			/*			 * There's no such device.			 */			close(sock);			return (PCAP_ERROR_NO_SUCH_DEVICE);		case EINVAL:			/*			 * Interface doesn't support SIOC{G,S}IFMEDIA.			 */			close(sock);			return (PCAP_ERROR_RFMON_NOTSUP);		default:			snprintf(p->errbuf, PCAP_ERRBUF_SIZE,			    "SIOCGIFMEDIA 1: %s", pcap_strerror(errno));			close(sock);			return (PCAP_ERROR);		}	}	if (req.ifm_count == 0) {		/*		 * No media types.		 */		close(sock);		return (PCAP_ERROR_RFMON_NOTSUP);	}	/*	 * Allocate a buffer to hold all the media types, and	 * get the media types.	 */	media_list = (int *) calloc(req.ifm_count, sizeof(int));	if (media_list == NULL) {		snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",		    pcap_strerror(errno));		close(sock);		return (PCAP_ERROR);	}	req.ifm_ulist = media_list;	if (ioctl(sock, SIOCGIFMEDIA, &req) < 0) {		snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCGIFMEDIA: %s",		    pcap_strerror(errno));		free(media_list);		close(sock);		return (PCAP_ERROR);	}	/*	 * Look for an 802.11 "automatic" media type.	 * We assume that all 802.11 adapters have that media type,	 * and that it will carry the monitor mode supported flag.	 */	can_do = 0;	for (i = 0; i < req.ifm_count; i++) {		if (IFM_TYPE(media_list[i]) == IFM_IEEE80211		    && IFM_SUBTYPE(media_list[i]) == IFM_AUTO) {			/* OK, does it do monitor mode? */			if (media_list[i] & IFM_IEEE80211_MONITOR) {				can_do = 1;				break;			}		}	}	free(media_list);	if (!can_do) {		/*		 * This adapter doesn't support monitor mode.		 */		close(sock);//.........这里部分代码省略.........

static voidmedia_status(int s){	struct ifmediareq ifmr;	int *media_list, i;	(void) memset(&ifmr, 0, sizeof(ifmr));	(void) strncpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name));	if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {		/*		 * Interface doesn't support SIOC{G,S}IFMEDIA.		 */		return;	}	if (ifmr.ifm_count == 0) {		warnx("%s: no media types?", name);		return;	}	media_list = (int *)malloc(ifmr.ifm_count * sizeof(int));	if (media_list == NULL)		err(1, "malloc");	ifmr.ifm_ulist = media_list;	if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)		err(1, "SIOCGIFMEDIA");	printf("/tmedia: ");	print_media_word(ifmr.ifm_current, 1);	if (ifmr.ifm_active != ifmr.ifm_current) {		putchar(' ');		putchar('(');		print_media_word(ifmr.ifm_active, 0);		putchar(')');	}	putchar('/n');	if (ifmr.ifm_status & IFM_AVALID) {		printf("/tstatus: ");		switch (IFM_TYPE(ifmr.ifm_active)) {		case IFM_ETHER:		case IFM_ATM:			if (ifmr.ifm_status & IFM_ACTIVE)				printf("active");			else				printf("no carrier");			break;		case IFM_FDDI:		case IFM_TOKEN:			if (ifmr.ifm_status & IFM_ACTIVE)				printf("inserted");			else				printf("no ring");			break;		case IFM_IEEE80211:			if (ifmr.ifm_status & IFM_ACTIVE) {				/* NB: only sta mode associates */				if (IFM_OPMODE(ifmr.ifm_active) == IFM_IEEE80211_STA)					printf("associated");				else					printf("running");			} else				printf("no carrier");			break;		}		putchar('/n');	}	if (ifmr.ifm_count > 0 && supmedia) {		printf("/tsupported media:/n");		for (i = 0; i < ifmr.ifm_count; i++) {			printf("/t/t");			print_media_word_ifconfig(media_list[i]);			putchar('/n');		}	}	free(media_list);}