Attachment #18102 for bug #32646

View | Details | Raw Unified | Return to bug 32646
Collapse All | Expand All

Lines 18-22 Link Here

(-)Makefile (+1 lines)
18	MAN= gifconfig.8	18	MAN= gifconfig.8
19		19
20	CFLAGS+= -DINET6	20	CFLAGS+= -DINET6
		21	WARNS?= 2
21		22
22	.include <bsd.prog.mk>	23	.include <bsd.prog.mk>




#define	NEXTARG		0xffffff

static struct	cmd {
	const char *c_name;
	int	c_parameter;		/* NEXTARG means next argv */
	void	(*c_func) __P((char *, int));
} cmds[] = {

void in6_status __P((int));
#endif
void ether_status __P((int));
void Perror __P((const char *));
void in_getaddr __P((char *, int));
#ifdef INET6
void in6_getaddr __P((char *, int));
void in6_getprefix __P((char *, int));
#endif
void printb __P((const char *, unsigned int, const char *));
int prefix __P((void *, int));

char ntop_buf[INET6_ADDRSTRLEN];

/* Known address families */
struct afswtch {
	const char *af_name;
	short af_af;
	void (*af_status) __P((int));
	void (*af_getaddr) __P((char *, int));

	{ "inet6", AF_INET6, in6_status, in6_getaddr, in6_getprefix,
	     SIOCSIFPHYADDR_IN6, C(in6_addreq), C(in6_ifr) },
#endif
	/* XXX not real!! */
	{ "ether", AF_INET, ether_status, NULL, NULL, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0 }
};

struct afswtch *afp = NULL;	/*the address family being set or asked about*/

{
	char psrcaddr[256];
	char pdstaddr[256];
	int flag = NI_NUMERICHOST;
	const char *af;
#ifndef SIOCGLIFPHYADDR
	u_long srccmd, dstcmd;
	struct ifreq *ifrp;

		af = "inet";
#endif /* INET6 */
		if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
		    psrcaddr, sizeof(psrcaddr), 0, 0, flag) != 0)
			psrcaddr[0] = '\0';
	}
	if (0 <= ioctl(s, dstcmd, (caddr_t)ifrp)) {
		if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
		    pdstaddr, sizeof(pdstaddr), 0, 0, flag) != 0)
			pdstaddr[0] = '\0';
	}
	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);

#endif /* INET6 */
		}
		if (getnameinfo((struct sockaddr *)&iflr.addr, iflr.addr.ss_len,
		    psrcaddr, sizeof(psrcaddr), 0, 0, flag) != 0)
			psrcaddr[0] = '\0';
		if (getnameinfo((struct sockaddr *)&iflr.dstaddr,
		    iflr.dstaddr.ss_len, pdstaddr, sizeof(pdstaddr), 0, 0,
		    flag) != 0)
			pdstaddr[0] = '\0';
	}
	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);

in_status(force)
	int force;
{
	struct sockaddr_in *addr, null_sin;
#if 0
	char *inet_ntoa();
#endif
	
	memset(&null_sin, 0, sizeof(null_sin));

	addr = (struct sockaddr_in *)info.rti_info[RTAX_IFA];
	if (!addr || addr->sin_family != AF_INET) {
		if (!force)
			return;
		/* warnx("%s has no AF_INET IFA address!", name); */
		addr = &null_sin;
	}
	printf("\tinet %s ", inet_ntoa(addr->sin_addr));

	if (flags & IFF_POINTOPOINT) {
		/* note RTAX_BRD overlap with IFF_BROADCAST */
		addr = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
		if (!addr)
			addr = &null_sin;
		printf("--> %s ", inet_ntoa(addr->sin_addr));
	}

	addr = (struct sockaddr_in *)info.rti_info[RTAX_NETMASK];
	if (!addr)
		addr = &null_sin;
	printf("netmask 0x%x ", (u_int32_t)ntohl(addr->sin_addr.s_addr));

	if (flags & IFF_BROADCAST) {
		/* note RTAX_BRD overlap with IFF_POINTOPOINT */
		addr = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
		if (addr && addr->sin_addr.s_addr != 0)
			printf("broadcast %s", inet_ntoa(addr->sin_addr));
	}
	putchar('\n');
}

in6_status(force)
	int force;
{
	struct sockaddr_in6 *addr, null_sin;
	char hostname[NI_MAXHOST];
	int niflags = NI_NUMERICHOST;


	niflags |= NI_WITHSCOPEID;
#endif

	addr = (struct sockaddr_in6 *)info.rti_info[RTAX_IFA];
	if (!addr || addr->sin6_family != AF_INET6) {
		if (!force)
			return;
		/* warnx("%s has no AF_INET6 IFA address!", name); */
		addr = &null_sin;
	}
#ifdef __KAME__
	if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
		addr->sin6_scope_id =
			ntohs(*(u_int16_t *)&addr->sin6_addr.s6_addr[2]);
		addr->sin6_addr.s6_addr[2] = 0;
		addr->sin6_addr.s6_addr[3] = 0;
	}
#endif
	getnameinfo((struct sockaddr *)addr, addr->sin6_len,
		    hostname, sizeof(hostname), 0, 0, niflags);
	printf("\tinet6 %s ", hostname);

	if (flags & IFF_POINTOPOINT) {
		/* note RTAX_BRD overlap with IFF_BROADCAST */
		addr = (struct sockaddr_in6 *)info.rti_info[RTAX_BRD];
		/*
		 * some of ther interfaces do not have valid destination
		 * address.
		 */
		if (addr->sin6_family == AF_INET6) {
#ifdef __KAME__
			if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
				addr->sin6_scope_id =
					ntohs(*(u_int16_t *)&addr->sin6_addr.s6_addr[2]);
				addr->sin6_addr.s6_addr[2] = 0;
				addr->sin6_addr.s6_addr[3] = 0;
			}
#endif
			getnameinfo((struct sockaddr *)addr, addr->sin6_len,
				    hostname, sizeof(hostname), 0, 0, niflags);
			printf("--> %s ", hostname);
		}
	}

	addr = (struct sockaddr_in6 *)info.rti_info[RTAX_NETMASK];
	if (!addr)
		addr = &null_sin;
	printf(" prefixlen %d ", prefix(&addr->sin6_addr,
		sizeof(struct in6_addr)));

	putchar('\n');


void
Perror(cmd)
	const char *cmd;
{
	switch (errno) {


SIN(addreq.ifra_addr), SIN(addreq.ifra_dstaddr)};

void
in_getaddr(str, which)
	char *str;
	int which;
{
	register struct sockaddr_in *addr = sintab[which];
	struct hostent *hp;
	struct netent *np;

	addr->sin_len = sizeof(*addr);
	addr->sin_family = AF_INET;

	if (inet_aton(str, &addr->sin_addr))
		;
	else if ((hp = gethostbyname(str)) != NULL)
		bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length);
	else if ((np = getnetbyname(str)) != NULL)
		addr->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
	else
		errx(1, "%s: bad value", str);
}

#ifdef INET6

SIN6(in6_addreq.ifra_addr), SIN6(in6_addreq.ifra_dstaddr)};

void
in6_getaddr(str, which)
	char *str;
	int which;
{
	register struct sockaddr_in6 *addr = sin6tab[which];

	addr->sin6_len = sizeof(*addr);
	addr->sin6_family = AF_INET6;

        if (inet_pton(AF_INET6, str, &addr->sin6_addr) != 1)
		errx(1, "%s: bad value", str);
}

void

	char *plen;
	int which;
{
	register struct sockaddr_in6 *addr = sin6tab[which];
	register u_char *cp;
	int len = atoi(plen);

	if ((len < 0) || (len > 128))
		errx(1, "%s: bad value", plen);
	addr->sin6_len = sizeof(*addr);
	addr->sin6_family = AF_INET6;
	if ((len == 0) || (len == 128)) {
		memset(&addr->sin6_addr, -1, sizeof(struct in6_addr));
		return;
	}
	for (cp = (u_char *)&addr->sin6_addr; len > 7; len -= 8)
		*cp++ = -1;
	*cp = (-1) << (8 - len);
}

 * Print a value a la the %b format of the kernel's printf
 */
void
printb(str, v, bits)
	const char *str;
	register unsigned int v;
	register const char *bits;
{
	register int i, any = 0;
	register char c;

	if (bits && *bits == 8)
		printf("%s=%o", str, v & 0xffff);
	else
		printf("%s=%x", str, v & 0xffff);
	bits++;
	if (bits) {
		putchar('<');

        void *val;
        int size;
{
        register u_char *nam = (u_char *)val;
        register int byte, bit, plen = 0;

        for (byte = 0; byte < size; byte++, plen += 8)
                if (nam[byte] != 0xff)
                        break;
	if (byte == size)
		return (plen);
	for (bit = 7; bit != 0; bit--, plen++)
                if (!(nam[byte] & (1 << bit)))
                        break;
        for (; bit != 0; bit--)
                if (nam[byte] & (1 << bit))
                        return(0);
        byte++;
        for (; byte < size; byte++)
                if (nam[byte])
                        return(0);
        return (plen);
}

Lines 5-8 Link Here

(-)Makefile (+2 lines)
5	DPADD= ${LIBEDIT} ${LIBTERMCAP}	5	DPADD= ${LIBEDIT} ${LIBTERMCAP}
6	LDADD= -ledit -ltermcap	6	LDADD= -ledit -ltermcap
7		7
		8	WARNS?= 2
		9
8	.include <bsd.prog.mk>	10	.include <bsd.prog.mk>





struct cmdtab {
	int command;
	const char *name;
	unsigned min;
	const char *args;
} cmdtab[] = {
{ CMD_CLOSE,    "close",        1, "" },
{ CMD_DEBUG,    "debug",        1, "on | off" },

{ CMD_STOP,     "stop",         3, "" },
{ CMD_VOLUME,   "volume",       1, "<l> <r> | left | right | mute | mono | stereo" },
{ CMD_CDID,     "cdid",         2, "" },
{ 0, NULL, 0, NULL }
};

struct cd_toc_entry     toc_buffer[100];

int             play_blocks __P((int blk, int len));
int             run __P((int cmd, char *arg));
char            *parse __P((char *buf, int *cmd));
void            help __P((void));
void            usage __P((void));
char            *use_cdrom_instead __P((const char *));
const char      *strstatus __P((int));
static u_int    dbprog_discid __P((void));
const char      *cdcontrol_prompt __P((void));

void help ()
{
	struct cmdtab *c;
	const char *s;
	char n;
	int i;

	for (c=cmdtab; c->name; ++c) {

	exit (1);
}

char *use_cdrom_instead(const char *old_envvar)
{
	char *device;


int play (char *arg)
{
	struct ioc_toc_header h;
	unsigned int n;
	int rc, start, end = 0, istart = 1, iend = 1;

	rc = ioctl (fd, CDIOREADTOCHEADER, &h);


	return (play_track (trk, 1, n, 1));
}

const char *strstatus (int sts)
{
	switch (sts) {
	case ASTS_INVALID:   return ("invalid");

	return id ? 0 : 1;
}

int info (char *arg __unused)
{
	struct ioc_toc_header h;
	int rc, i, n;

{
	struct cmdtab *c;
	char *p;
	unsigned int len;

	for (p=buf; isspace (*p); p++)
		continue;

Return to bug 32646

Lines 78-86 Link Here

(-)cdcontrol.c (-10 / +18 lines)
78		78
79	struct cmdtab {	79	struct cmdtab {
80	int command;	80	int command;
81	char *name;	81	const char *name;
82	unsigned min;	82	unsigned min;
83	char *args;	83	const char *args;
84	} cmdtab[] = {	84	} cmdtab[] = {
85	{ CMD_CLOSE, "close", 1, "" },	85	{ CMD_CLOSE, "close", 1, "" },
86	{ CMD_DEBUG, "debug", 1, "on \| off" },	86	{ CMD_DEBUG, "debug", 1, "on \| off" },
Lines 103-109 Link Here
103	{ CMD_STOP, "stop", 3, "" },	103	{ CMD_STOP, "stop", 3, "" },
104	{ CMD_VOLUME, "volume", 1, "<l> <r> \| left \| right \| mute \| mono \| stereo" },	104	{ CMD_VOLUME, "volume", 1, "<l> <r> \| left \| right \| mute \| mono \| stereo" },
105	{ CMD_CDID, "cdid", 2, "" },	105	{ CMD_CDID, "cdid", 2, "" },
106	{ 0, }	106	{ 0, NULL, 0, NULL }
107	};	107	};
108		108
109	struct cd_toc_entry toc_buffer[100];	109	struct cd_toc_entry toc_buffer[100];
Lines 133-143 Link Here
133	int play_blocks __P((int blk, int len));	133	int play_blocks __P((int blk, int len));
134	int run __P((int cmd, char *arg));	134	int run __P((int cmd, char *arg));
135	char parse __P((char buf, int *cmd));	135	char parse __P((char buf, int *cmd));
		136	void help __P((void));
		137	void usage __P((void));
		138	char use_cdrom_instead __P((const char ));
		139	const char *strstatus __P((int));
		140	static u_int dbprog_discid __P((void));
		141	const char *cdcontrol_prompt __P((void));
136		142
137	void help ()	143	void help ()
138	{	144	{
139	struct cmdtab *c;	145	struct cmdtab *c;
140	char *s, n;	146	const char *s;
		147	char n;
141	int i;	148	int i;
142		149
143	for (c=cmdtab; c->name; ++c) {	150	for (c=cmdtab; c->name; ++c) {
Lines 165-171 Link Here
165	exit (1);	172	exit (1);
166	}	173	}
167		174
168	char use_cdrom_instead(char old_envvar)	175	char use_cdrom_instead(const char old_envvar)
169	{	176	{
170	char *device;	177	char *device;
171		178
Lines 427-433 Link Here
427	int play (char *arg)	434	int play (char *arg)
428	{	435	{
429	struct ioc_toc_header h;	436	struct ioc_toc_header h;
430	int rc, n, start, end = 0, istart = 1, iend = 1;	437	unsigned int n;
		438	int rc, start, end = 0, istart = 1, iend = 1;
431		439
432	rc = ioctl (fd, CDIOREADTOCHEADER, &h);	440	rc = ioctl (fd, CDIOREADTOCHEADER, &h);
433		441
Lines 736-742 Link Here
736	return (play_track (trk, 1, n, 1));	744	return (play_track (trk, 1, n, 1));
737	}	745	}
738		746
739	char *strstatus (int sts)	747	const char *strstatus (int sts)
740	{	748	{
741	switch (sts) {	749	switch (sts) {
742	case ASTS_INVALID: return ("invalid");	750	case ASTS_INVALID: return ("invalid");
Lines 905-911 Link Here
905	return id ? 0 : 1;	913	return id ? 0 : 1;
906	}	914	}
907		915
908	int info (char *arg)	916	int info (char *arg __unused)
909	{	917	{
910	struct ioc_toc_header h;	918	struct ioc_toc_header h;
911	int rc, i, n;	919	int rc, i, n;
Lines 1146-1152 Link Here
1146	{	1154	{
1147	struct cmdtab *c;	1155	struct cmdtab *c;
1148	char *p;	1156	char *p;
1149	int len;	1157	unsigned int len;
1150		1158
1151	for (p=buf; isspace (*p); p++)	1159	for (p=buf; isspace (*p); p++)
1152	continue;	1160	continue;

Lines 112-118 Link Here

(-)gifconfig.c (-84 / +85 lines)
112	#define NEXTARG 0xffffff	112	#define NEXTARG 0xffffff
113		113
114	static struct cmd {	114	static struct cmd {
115	char *c_name;	115	const char *c_name;
116	int c_parameter; /* NEXTARG means next argv */	116	int c_parameter; /* NEXTARG means next argv */
117	void (c_func) __P((char , int));	117	void (c_func) __P((char , int));
118	} cmds[] = {	118	} cmds[] = {
Lines 137-156 Link Here
137	void in6_status __P((int));	137	void in6_status __P((int));
138	#endif	138	#endif
139	void ether_status __P((int));	139	void ether_status __P((int));
140	void Perror __P((char *));	140	void Perror __P((const char *));
141	void in_getaddr __P((char *, int));	141	void in_getaddr __P((char *, int));
142	#ifdef INET6	142	#ifdef INET6
143	void in6_getaddr __P((char *, int));	143	void in6_getaddr __P((char *, int));
144	void in6_getprefix __P((char *, int));	144	void in6_getprefix __P((char *, int));
145	#endif	145	#endif
146	void printb __P((char , unsigned int, char ));	146	void printb __P((const char , unsigned int, const char ));
147	int prefix __P((void *, int));	147	int prefix __P((void *, int));
148		148
149	char ntop_buf[INET6_ADDRSTRLEN];	149	char ntop_buf[INET6_ADDRSTRLEN];
150		150
151	/* Known address families */	151	/* Known address families */
152	struct afswtch {	152	struct afswtch {
153	char *af_name;	153	const char *af_name;
154	short af_af;	154	short af_af;
155	void (*af_status) __P((int));	155	void (*af_status) __P((int));
156	void (af_getaddr) __P((char , int));	156	void (af_getaddr) __P((char , int));
Lines 166-173 Link Here
166	{ "inet6", AF_INET6, in6_status, in6_getaddr, in6_getprefix,	166	{ "inet6", AF_INET6, in6_status, in6_getaddr, in6_getprefix,
167	SIOCSIFPHYADDR_IN6, C(in6_addreq), C(in6_ifr) },	167	SIOCSIFPHYADDR_IN6, C(in6_addreq), C(in6_ifr) },
168	#endif	168	#endif
169	{ "ether", AF_INET, ether_status, NULL, NULL }, /* XXX not real!! */	169	/* XXX not real!! */
170	{ 0, 0, 0, 0, 0 }	170	{ "ether", AF_INET, ether_status, NULL, NULL, 0, 0, 0 },
		171	{ 0, 0, 0, 0, 0, 0, 0, 0 }
171	};	172	};
172		173
173	struct afswtch afp = NULL; /the address family being set or asked about*/	174	struct afswtch afp = NULL; /the address family being set or asked about*/
Lines 564-571 Link Here
564	{	565	{
565	char psrcaddr[256];	566	char psrcaddr[256];
566	char pdstaddr[256];	567	char pdstaddr[256];
567	int flags = NI_NUMERICHOST;	568	int flag = NI_NUMERICHOST;
568	char *af;	569	const char *af;
569	#ifndef SIOCGLIFPHYADDR	570	#ifndef SIOCGLIFPHYADDR
570	u_long srccmd, dstcmd;	571	u_long srccmd, dstcmd;
571	struct ifreq *ifrp;	572	struct ifreq *ifrp;
Lines 605-616 Link Here
605	af = "inet";	606	af = "inet";
606	#endif /* INET6 */	607	#endif /* INET6 */
607	if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,	608	if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
608	psrcaddr, sizeof(psrcaddr), 0, 0, flags) != 0)	609	psrcaddr, sizeof(psrcaddr), 0, 0, flag) != 0)
609	psrcaddr[0] = '\0';	610	psrcaddr[0] = '\0';
610	}	611	}
611	if (0 <= ioctl(s, dstcmd, (caddr_t)ifrp)) {	612	if (0 <= ioctl(s, dstcmd, (caddr_t)ifrp)) {
612	if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,	613	if (getnameinfo(&ifrp->ifr_addr, ifrp->ifr_addr.sa_len,
613	pdstaddr, sizeof(pdstaddr), 0, 0, flags) != 0)	614	pdstaddr, sizeof(pdstaddr), 0, 0, flag) != 0)
614	pdstaddr[0] = '\0';	615	pdstaddr[0] = '\0';
615	}	616	}
616	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);	617	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);
Lines 636-646 Link Here
636	#endif /* INET6 */	637	#endif /* INET6 */
637	}	638	}
638	if (getnameinfo((struct sockaddr *)&iflr.addr, iflr.addr.ss_len,	639	if (getnameinfo((struct sockaddr *)&iflr.addr, iflr.addr.ss_len,
639	psrcaddr, sizeof(psrcaddr), 0, 0, flags) != 0)	640	psrcaddr, sizeof(psrcaddr), 0, 0, flag) != 0)
640	psrcaddr[0] = '\0';	641	psrcaddr[0] = '\0';
641	if (getnameinfo((struct sockaddr *)&iflr.dstaddr,	642	if (getnameinfo((struct sockaddr *)&iflr.dstaddr,
642	iflr.dstaddr.ss_len, pdstaddr, sizeof(pdstaddr), 0, 0,	643	iflr.dstaddr.ss_len, pdstaddr, sizeof(pdstaddr), 0, 0,
643	flags) != 0)	644	flag) != 0)
644	pdstaddr[0] = '\0';	645	pdstaddr[0] = '\0';
645	}	646	}
646	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);	647	printf("\tphysical address %s %s --> %s\n", af, psrcaddr, pdstaddr);
Lines 651-690 Link Here
651	in_status(force)	652	in_status(force)
652	int force;	653	int force;
653	{	654	{
654	struct sockaddr_in *sin, null_sin;	655	struct sockaddr_in *addr, null_sin;
655	#if 0	656	#if 0
656	char *inet_ntoa();	657	char *inet_ntoa();
657	#endif	658	#endif
658		659
659	memset(&null_sin, 0, sizeof(null_sin));	660	memset(&null_sin, 0, sizeof(null_sin));
660		661
661	sin = (struct sockaddr_in *)info.rti_info[RTAX_IFA];	662	addr = (struct sockaddr_in *)info.rti_info[RTAX_IFA];
662	if (!sin \|\| sin->sin_family != AF_INET) {	663	if (!addr \|\| addr->sin_family != AF_INET) {
663	if (!force)	664	if (!force)
664	return;	665	return;
665	/* warnx("%s has no AF_INET IFA address!", name); */	666	/* warnx("%s has no AF_INET IFA address!", name); */
666	sin = &null_sin;	667	addr = &null_sin;
667	}	668	}
668	printf("\tinet %s ", inet_ntoa(sin->sin_addr));	669	printf("\tinet %s ", inet_ntoa(addr->sin_addr));
669		670
670	if (flags & IFF_POINTOPOINT) {	671	if (flags & IFF_POINTOPOINT) {
671	/* note RTAX_BRD overlap with IFF_BROADCAST */	672	/* note RTAX_BRD overlap with IFF_BROADCAST */
672	sin = (struct sockaddr_in *)info.rti_info[RTAX_BRD];	673	addr = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
673	if (!sin)	674	if (!addr)
674	sin = &null_sin;	675	addr = &null_sin;
675	printf("--> %s ", inet_ntoa(sin->sin_addr));	676	printf("--> %s ", inet_ntoa(addr->sin_addr));
676	}	677	}
677		678
678	sin = (struct sockaddr_in *)info.rti_info[RTAX_NETMASK];	679	addr = (struct sockaddr_in *)info.rti_info[RTAX_NETMASK];
679	if (!sin)	680	if (!addr)
680	sin = &null_sin;	681	addr = &null_sin;
681	printf("netmask 0x%x ", (u_int32_t)ntohl(sin->sin_addr.s_addr));	682	printf("netmask 0x%x ", (u_int32_t)ntohl(addr->sin_addr.s_addr));
682		683
683	if (flags & IFF_BROADCAST) {	684	if (flags & IFF_BROADCAST) {
684	/* note RTAX_BRD overlap with IFF_POINTOPOINT */	685	/* note RTAX_BRD overlap with IFF_POINTOPOINT */
685	sin = (struct sockaddr_in *)info.rti_info[RTAX_BRD];	686	addr = (struct sockaddr_in *)info.rti_info[RTAX_BRD];
686	if (sin && sin->sin_addr.s_addr != 0)	687	if (addr && addr->sin_addr.s_addr != 0)
687	printf("broadcast %s", inet_ntoa(sin->sin_addr));	688	printf("broadcast %s", inet_ntoa(addr->sin_addr));
688	}	689	}
689	putchar('\n');	690	putchar('\n');
690	}	691	}
Lines 694-700 Link Here
694	in6_status(force)	695	in6_status(force)
695	int force;	696	int force;
696	{	697	{
697	struct sockaddr_in6 *sin, null_sin;	698	struct sockaddr_in6 *addr, null_sin;
698	char hostname[NI_MAXHOST];	699	char hostname[NI_MAXHOST];
699	int niflags = NI_NUMERICHOST;	700	int niflags = NI_NUMERICHOST;
700		701
Lines 703-753 Link Here
703	niflags \|= NI_WITHSCOPEID;	704	niflags \|= NI_WITHSCOPEID;
704	#endif	705	#endif
705		706
706	sin = (struct sockaddr_in6 *)info.rti_info[RTAX_IFA];	707	addr = (struct sockaddr_in6 *)info.rti_info[RTAX_IFA];
707	if (!sin \|\| sin->sin6_family != AF_INET6) {	708	if (!addr \|\| addr->sin6_family != AF_INET6) {
708	if (!force)	709	if (!force)
709	return;	710	return;
710	/* warnx("%s has no AF_INET6 IFA address!", name); */	711	/* warnx("%s has no AF_INET6 IFA address!", name); */
711	sin = &null_sin;	712	addr = &null_sin;
712	}	713	}
713	#ifdef __KAME__	714	#ifdef __KAME__
714	if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {	715	if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
715	sin->sin6_scope_id =	716	addr->sin6_scope_id =
716	ntohs((u_int16_t )&sin->sin6_addr.s6_addr[2]);	717	ntohs((u_int16_t )&addr->sin6_addr.s6_addr[2]);
717	sin->sin6_addr.s6_addr[2] = 0;	718	addr->sin6_addr.s6_addr[2] = 0;
718	sin->sin6_addr.s6_addr[3] = 0;	719	addr->sin6_addr.s6_addr[3] = 0;
719	}	720	}
720	#endif	721	#endif
721	getnameinfo((struct sockaddr *)sin, sin->sin6_len,	722	getnameinfo((struct sockaddr *)addr, addr->sin6_len,
722	hostname, sizeof(hostname), 0, 0, niflags);	723	hostname, sizeof(hostname), 0, 0, niflags);
723	printf("\tinet6 %s ", hostname);	724	printf("\tinet6 %s ", hostname);
724		725
725	if (flags & IFF_POINTOPOINT) {	726	if (flags & IFF_POINTOPOINT) {
726	/* note RTAX_BRD overlap with IFF_BROADCAST */	727	/* note RTAX_BRD overlap with IFF_BROADCAST */
727	sin = (struct sockaddr_in6 *)info.rti_info[RTAX_BRD];	728	addr = (struct sockaddr_in6 *)info.rti_info[RTAX_BRD];
728	/*	729	/*
729	* some of ther interfaces do not have valid destination	730	* some of ther interfaces do not have valid destination
730	* address.	731	* address.
731	*/	732	*/
732	if (sin->sin6_family == AF_INET6) {	733	if (addr->sin6_family == AF_INET6) {
733	#ifdef __KAME__	734	#ifdef __KAME__
734	if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {	735	if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
735	sin->sin6_scope_id =	736	addr->sin6_scope_id =
736	ntohs((u_int16_t )&sin->sin6_addr.s6_addr[2]);	737	ntohs((u_int16_t )&addr->sin6_addr.s6_addr[2]);
737	sin->sin6_addr.s6_addr[2] = 0;	738	addr->sin6_addr.s6_addr[2] = 0;
738	sin->sin6_addr.s6_addr[3] = 0;	739	addr->sin6_addr.s6_addr[3] = 0;
739	}	740	}
740	#endif	741	#endif
741	getnameinfo((struct sockaddr *)sin, sin->sin6_len,	742	getnameinfo((struct sockaddr *)addr, addr->sin6_len,
742	hostname, sizeof(hostname), 0, 0, niflags);	743	hostname, sizeof(hostname), 0, 0, niflags);
743	printf("--> %s ", hostname);	744	printf("--> %s ", hostname);
744	}	745	}
745	}	746	}
746		747
747	sin = (struct sockaddr_in6 *)info.rti_info[RTAX_NETMASK];	748	addr = (struct sockaddr_in6 *)info.rti_info[RTAX_NETMASK];
748	if (!sin)	749	if (!addr)
749	sin = &null_sin;	750	addr = &null_sin;
750	printf(" prefixlen %d ", prefix(&sin->sin6_addr,	751	printf(" prefixlen %d ", prefix(&addr->sin6_addr,
751	sizeof(struct in6_addr)));	752	sizeof(struct in6_addr)));
752		753
753	putchar('\n');	754	putchar('\n');
Lines 778-784 Link Here
778		779
779	void	780	void
780	Perror(cmd)	781	Perror(cmd)
781	char *cmd;	782	const char *cmd;
782	{	783	{
783	switch (errno) {	784	switch (errno) {
784		785
Lines 800-824 Link Here
800	SIN(addreq.ifra_addr), SIN(addreq.ifra_dstaddr)};	801	SIN(addreq.ifra_addr), SIN(addreq.ifra_dstaddr)};
801		802
802	void	803	void
803	in_getaddr(s, which)	804	in_getaddr(str, which)
804	char *s;	805	char *str;
805	int which;	806	int which;
806	{	807	{
807	register struct sockaddr_in *sin = sintab[which];	808	register struct sockaddr_in *addr = sintab[which];
808	struct hostent *hp;	809	struct hostent *hp;
809	struct netent *np;	810	struct netent *np;
810		811
811	sin->sin_len = sizeof(*sin);	812	addr->sin_len = sizeof(*addr);
812	sin->sin_family = AF_INET;	813	addr->sin_family = AF_INET;
813		814
814	if (inet_aton(s, &sin->sin_addr))	815	if (inet_aton(str, &addr->sin_addr))
815	;	816	;
816	else if ((hp = gethostbyname(s)) != NULL)	817	else if ((hp = gethostbyname(str)) != NULL)
817	bcopy(hp->h_addr, (char *)&sin->sin_addr, hp->h_length);	818	bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length);
818	else if ((np = getnetbyname(s)) != NULL)	819	else if ((np = getnetbyname(str)) != NULL)
819	sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);	820	addr->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
820	else	821	else
821	errx(1, "%s: bad value", s);	822	errx(1, "%s: bad value", str);
822	}	823	}
823		824
824	#ifdef INET6	825	#ifdef INET6
Lines 827-843 Link Here
827	SIN6(in6_addreq.ifra_addr), SIN6(in6_addreq.ifra_dstaddr)};	828	SIN6(in6_addreq.ifra_addr), SIN6(in6_addreq.ifra_dstaddr)};
828		829
829	void	830	void
830	in6_getaddr(s, which)	831	in6_getaddr(str, which)
831	char *s;	832	char *str;
832	int which;	833	int which;
833	{	834	{
834	register struct sockaddr_in6 *sin = sin6tab[which];	835	register struct sockaddr_in6 *addr = sin6tab[which];
835		836
836	sin->sin6_len = sizeof(*sin);	837	addr->sin6_len = sizeof(*addr);
837	sin->sin6_family = AF_INET6;	838	addr->sin6_family = AF_INET6;
838		839
839	if (inet_pton(AF_INET6, s, &sin->sin6_addr) != 1)	840	if (inet_pton(AF_INET6, str, &addr->sin6_addr) != 1)
840	errx(1, "%s: bad value", s);	841	errx(1, "%s: bad value", str);
841	}	842	}
842		843
843	void	844	void
Lines 845-863 Link Here
845	char *plen;	846	char *plen;
846	int which;	847	int which;
847	{	848	{
848	register struct sockaddr_in6 *sin = sin6tab[which];	849	register struct sockaddr_in6 *addr = sin6tab[which];
849	register u_char *cp;	850	register u_char *cp;
850	int len = atoi(plen);	851	int len = atoi(plen);
851		852
852	if ((len < 0) \|\| (len > 128))	853	if ((len < 0) \|\| (len > 128))
853	errx(1, "%s: bad value", plen);	854	errx(1, "%s: bad value", plen);
854	sin->sin6_len = sizeof(*sin);	855	addr->sin6_len = sizeof(*addr);
855	sin->sin6_family = AF_INET6;	856	addr->sin6_family = AF_INET6;
856	if ((len == 0) \|\| (len == 128)) {	857	if ((len == 0) \|\| (len == 128)) {
857	memset(&sin->sin6_addr, -1, sizeof(struct in6_addr));	858	memset(&addr->sin6_addr, -1, sizeof(struct in6_addr));
858	return;	859	return;
859	}	860	}
860	for (cp = (u_char *)&sin->sin6_addr; len > 7; len -= 8)	861	for (cp = (u_char *)&addr->sin6_addr; len > 7; len -= 8)
861	*cp++ = -1;	862	*cp++ = -1;
862	*cp = (-1) << (8 - len);	863	*cp = (-1) << (8 - len);
863	}	864	}
Lines 867-884 Link Here
867	* Print a value a la the %b format of the kernel's printf	868	* Print a value a la the %b format of the kernel's printf
868	*/	869	*/
869	void	870	void
870	printb(s, v, bits)	871	printb(str, v, bits)
871	char *s;	872	const char *str;
872	register unsigned int v;	873	register unsigned int v;
873	register char *bits;	874	register const char *bits;
874	{	875	{
875	register int i, any = 0;	876	register int i, any = 0;
876	register char c;	877	register char c;
877		878
878	if (bits && *bits == 8)	879	if (bits && *bits == 8)
879	printf("%s=%o", s, v & 0xffff);	880	printf("%s=%o", str, v & 0xffff);
880	else	881	else
881	printf("%s=%x", s, v & 0xffff);	882	printf("%s=%x", str, v & 0xffff);
882	bits++;	883	bits++;
883	if (bits) {	884	if (bits) {
884	putchar('<');	885	putchar('<');
Lines 903-925 Link Here
903	void *val;	904	void *val;
904	int size;	905	int size;
905	{	906	{
906	register u_char name = (u_char )val;	907	register u_char nam = (u_char )val;
907	register int byte, bit, plen = 0;	908	register int byte, bit, plen = 0;
908		909
909	for (byte = 0; byte < size; byte++, plen += 8)	910	for (byte = 0; byte < size; byte++, plen += 8)
910	if (name[byte] != 0xff)	911	if (nam[byte] != 0xff)
911	break;	912	break;
912	if (byte == size)	913	if (byte == size)
913	return (plen);	914	return (plen);
914	for (bit = 7; bit != 0; bit--, plen++)	915	for (bit = 7; bit != 0; bit--, plen++)
915	if (!(name[byte] & (1 << bit)))	916	if (!(nam[byte] & (1 << bit)))
916	break;	917	break;
917	for (; bit != 0; bit--)	918	for (; bit != 0; bit--)
918	if (name[byte] & (1 << bit))	919	if (nam[byte] & (1 << bit))
919	return(0);	920	return(0);
920	byte++;	921	byte++;
921	for (; byte < size; byte++)	922	for (; byte < size; byte++)
922	if (name[byte])	923	if (nam[byte])
923	return(0);	924	return(0);
924	return (plen);	925	return (plen);
925	}	926	}