Exemplo n.º 1
0
static int
ethers(int argc, char *argv[])
{
	char		hostname[MAXHOSTNAMELEN], *hp;
	int		i, rv = RV_OK;
	struct ether_addr ea, *eap;

	if (argc == 2) {
		fprintf(stderr, "%s: Enumeration not supported on ethers\n",
		    __progname);
		rv = RV_NOENUM;
	} else {
		for (i = 2; i < argc; i++) {
			if ((eap = ether_aton(argv[i])) == NULL) {
				eap = &ea;
				hp = argv[i];
				if (ether_hostton(hp, eap) != 0) {
					rv = RV_NOTFOUND;
					break;
				}
			} else {
				hp = hostname;
				if (ether_ntohost(hp, eap) != 0) {
					rv = RV_NOTFOUND;
					break;
				}
			}
			ETHERSPRINT;
		}
	}
	return rv;
}
static void
_addressToString(const u_int8_t *address, char *buffer)
{
    if (ether_ntohost(buffer, (struct ether_addr *) address) == -1) {
        sprintf(buffer, "%2.2hhx:%2.2hhx:%2.2hhx:%2.2hhx:%2.2hhx:%2.2hhx",
                address[0], address[1], address[2],
                address[3], address[4], address[5]);
    }
}
Exemplo n.º 3
0
void testValues() {
    f = 2;
    
    char buf[255];
    struct ether_addr addr;
    ether_ntohost(buf, &addr);

    //@ assert f == 2;
    //@ assert vacuous: \false;
}
Exemplo n.º 4
0
Arquivo: rarpd.c Projeto: OPSF/uClinux
struct rarp_map *rarp_lookup(int ifindex, int hatype,
			     int halen, unsigned char *lladdr)
{
	struct rarp_map *r;

	for (r=rarp_db; r; r=r->next) {
		if (r->arp_type != hatype && r->arp_type != -1)
			continue;
		if (r->lladdr_len != halen)
			continue;
		if (r->ifindex != ifindex && r->ifindex != 0)
			continue;
		if (memcmp(r->lladdr, lladdr, halen) == 0)
			break;
	}

	if (r == NULL) {
		if (hatype == ARPHRD_ETHER && halen == 6) {
			struct ifaddr *ifa;
			struct hostent *hp;
			char ename[256];
			static struct rarp_map emap = {
				NULL,
				0,
				ARPHRD_ETHER,
				6,
			};

			if (ether_ntohost(ename, lladdr) != 0 ||
			    (hp = gethostbyname(ename)) == NULL) {
				if (verbose)
					syslog(LOG_INFO, "not found in /etc/ethers");
				return NULL;
			}
			if (hp->h_addrtype != AF_INET) {
				syslog(LOG_ERR, "no IP address");
				return NULL;
			}
			ifa = select_ipaddr(ifindex, &emap.ipaddr, (__u32 **)hp->h_addr_list);
			if (ifa) {
				memcpy(emap.lladdr, lladdr, 6);
				if (only_ethers || bootable(emap.ipaddr))
					return &emap;
				if (verbose)
					syslog(LOG_INFO, "not bootable");
			}
		}
	}
	return r;
}
Exemplo n.º 5
0
/*
 * Answer the RARP request in 'pkt', on the interface 'ii'.  'pkt' has
 * already been checked for validity.  The reply is overlaid on the request.
 */
void
rarp_process(struct if_info *ii, u_char *pkt)
{
	char    ename[HOST_NAME_MAX+1];
	u_int32_t  target_ipaddr;
	struct ether_header *ep;
	struct ether_addr *ea;
	struct hostent *hp;
	struct	in_addr in;
	struct if_addr *ia;

	ep = (struct ether_header *) pkt;
	ea = (struct ether_addr *) &ep->ether_shost;

	debug("%s", ether_ntoa(ea));
	if (ether_ntohost(ename, ea) != 0) {
		debug("ether_ntohost failed");
		return;
	}
	if ((hp = gethostbyname(ename)) == 0) {
		debug("gethostbyname (%s) failed", ename);
		return;
	}

	/* Choose correct address from list. */
	if (hp->h_addrtype != AF_INET) {
		error(FATAL, "cannot handle non IP addresses");
		/* NOTREACHED */
	}
	for (target_ipaddr = 0, ia = ii->ii_addrs; ia; ia = ia->ia_next) {
		target_ipaddr = choose_ipaddr((u_int32_t **) hp->h_addr_list,
		    ia->ia_ipaddr & ia->ia_netmask, ia->ia_netmask);
		if (target_ipaddr)
			break;
	}

	if (target_ipaddr == 0) {
		for (ia = ii->ii_addrs; ia; ia = ia->ia_next) {
			in.s_addr = ia->ia_ipaddr & ia->ia_netmask;
			error(NONFATAL, "cannot find %s on net %s",
			    ename, inet_ntoa(in));
		}
		return;
	}
	if (tflag == 0 || rarp_bootable(htonl(target_ipaddr)))
		rarp_reply(ii, ia, ep, target_ipaddr, hp);
	debug("reply sent");
}
Exemplo n.º 6
0
/*
 * ethers
 */
static int
ethers(int argc, char *argv[])
{
	char		hostname[MAXHOSTNAMELEN + 1], *hp;
	struct ether_addr ea, *eap;
	int		i, rv;

	assert(argc > 1);
	assert(argv != NULL);

#define ETHERSPRINT	printf("%-17s  %s\n", ether_ntoa(eap), hp)

	rv = RV_OK;
	if (argc == 2) {
		fprintf(stderr, "Enumeration not supported on ethers\n");
		rv = RV_NOENUM;
	} else {
		for (i = 2; i < argc; i++) {
			if ((eap = ether_aton(argv[i])) == NULL) {
				eap = &ea;
				hp = argv[i];
				if (ether_hostton(hp, eap) != 0) {
					rv = RV_NOTFOUND;
					break;
				}
			} else {
				hp = hostname;
				if (ether_ntohost(hp, eap) != 0) {
					rv = RV_NOTFOUND;
					break;
				}
			}
			ETHERSPRINT;
		}
	}
	return rv;
}
Exemplo n.º 7
0
Arquivo: rarpd.c Projeto: afett/rarpd
/*
   This may (and will) block.
   Use local /etc/ethers and /etc/hosts
   to avoid NIS and DNS queries.
 */
int resolve(struct ether_addr *addr, struct in_addr *in_addr)
{
	char hostname[4096];
	memset(hostname, 0, sizeof(hostname));
	/*
	   This is not really safe, at the time of writing glibc uses
	   a 1024 byte buffer for the answer internally ...  We could
	   parse /etc/ethers by ourselves but then we would loose
	   nsswitch support. Alas RARP support without NIS is no fun :-(
	*/
	int ret = ether_ntohost(hostname, addr);
	if (ret != 0) {
		XLOG_DEBUG("failed to lookup %s", ether_ntoa(addr));
		return -1;
	}

	XLOG_DEBUG("lookup for %s returned %s", ether_ntoa(addr), hostname);

	struct addrinfo hints;
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET;
	hints.ai_flags = AI_ADDRCONFIG;

	struct addrinfo *ai = NULL;
	ret = getaddrinfo(hostname, NULL, &hints, &ai);
	if (ret != 0) {
		XLOG_DEBUG("could not resolve '%s': %s\n", hostname,
			ret == EAI_SYSTEM ? strerror(errno) : gai_strerror(ret));
		return -1;
	}

	struct sockaddr_in *sa = (struct sockaddr_in *)(ai->ai_addr);
	memcpy(in_addr, &(sa->sin_addr), sizeof(struct in_addr));

	return 0;
}
Exemplo n.º 8
0
int main(int argc, char **argv)
{
    int i;
    ethernet_t *ep;
    nwio_ethopt_t ethopt;
    nwio_ethstat_t ethstat;
    char hostname[1024];
    struct hostent *hostent;
    struct sigaction sa;
    nwio_ipconf_t ipconf;
    asynchio_t asyn;
    ssize_t n;
    ipaddr_t ip_addr;
    rarp46_t rarp46;
    int fd;
    int n_eths;

    program= argv[0];
    asyn_init(&asyn);

    debug= 0;
    i= 1;
    while (i < argc && argv[i][0] == '-') {
	char *opt= argv[i++]+1;

	if (opt[0] == '-' && opt[1] == 0) break;	/* -- */

	while (*opt != 0) switch (*opt++) {
	case 'd':
	    debug= 1;
	    if (between('0', *opt, '9')) debug= strtoul(opt, &opt, 10);
	    break;
	default:
	    usage();
	}
    }

    if ((n_eths= (argc - i)) == 0) usage();

#if __minix_vmd
    /* Minix-vmd can handle all nets at once using async I/O. */
    ethernets= allocate(n_eths * sizeof(ethernets[0]));
    for (i= 0; i < n_eths; i++) {
	ethernets[i].n= ifname2n(argv[argc - n_eths + i]);
    }
#else
    /* Minix forks n-1 times to handle each net in a process each. */
    for (i= 0; i < n_eths; i++) {
	if (i+1 < n_eths) {
	    switch (fork()) {
	    case -1:	fatal("fork()");
	    case 0:		break;
	    default:	continue;
	    }
	}
	ethernets= allocate(1 * sizeof(ethernets[0]));
	ethernets[0].n= ifname2n(argv[argc - n_eths + i]);
    }
    n_eths= 1;
#endif

    sa.sa_handler= onsig;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags= 0;
    sigaction(SIGUSR1, &sa, NULL);
    sigaction(SIGUSR2, &sa, NULL);

    for (i= 0; i < n_eths; i++) {
	ep= &ethernets[i];
	if ((ep->eth_fd= open(ethdev(ep->n), O_RDWR)) < 0) fatal(ethdev(ep->n));

	if (ioctl(ep->eth_fd, NWIOGETHSTAT, &ethstat) < 0) {
	    fprintf(stderr, "%s: %s: Unable to get eth statistics: %s\n",
		program, ethdev(ep->n), strerror(errno));
	    exit(1);
	}
	ep->eth_addr= ethstat.nwes_addr;
	if (debug >= 1) {
	    printf("%s: Ethernet address is %s\n",
		ethdev(ep->n), ether_ntoa(&ep->eth_addr));
	}

	ethopt.nweo_flags= NWEO_COPY | NWEO_EN_LOC | NWEO_EN_BROAD |
		NWEO_TYPESPEC;
	ethopt.nweo_type= HTONS(ETH_RARP_PROTO);

	if (ioctl(ep->eth_fd, NWIOSETHOPT, &ethopt) < 0) {
	    fprintf(stderr, "%s: %s: Unable to set eth options: %s\n",
		program, ethdev(ep->n), strerror(errno));
	    exit(1);
	}

	/* What are my address and netmask? */
	if ((fd= open(ipdev(ep->n), O_RDWR)) < 0) fatal(ipdev(ep->n));
	if (ioctl(fd, NWIOGIPCONF, &ipconf) < 0) fatal(ipdev(ep->n));

	ep->ip_addr= ipconf.nwic_ipaddr;
	ep->ip_mask= ipconf.nwic_netmask;
	close(fd);
	if (debug >= 1) {
	    printf("%s: IP address is %s / ",
		ipdev(ep->n), inet_ntoa(ep->ip_addr));
	    printf("%s\n", inet_ntoa(ep->ip_mask));
	}
    }

    /* Wait for RARP requests, reply, repeat. */
    for(;;) {
	fflush(NULL);

	/* Wait for a RARP request. */
	for (i= 0; i < n_eths; i++) {
	    ep= &ethernets[i];

	    n= asyn_read(&asyn, ep->eth_fd, ep->packet, sizeof(ep->packet));
	    if (n != -1) break;
	    if (errno != EINPROGRESS) {
		report(ethdev(ep->n));
		sleep(10);
	    }
	}

	/* RARP request? */
	if (i < n_eths
	    && n >= sizeof(rarp46)
	    && (memcpy(&rarp46, ep->packet, sizeof(rarp46)), 1)
	    && rarp46.a46_hdr == HTONS(RARP_ETHERNET)
	    && rarp46.a46_pro == HTONS(ETH_IP_PROTO)
	    && rarp46.a46_hln == 6
	    && rarp46.a46_pln == 4
	    && rarp46.a46_op == HTONS(RARP_REQUEST)
	) {
	    if ((ether_ntohost(hostname, &rarp46.a46_tha) == 0
		  || (rarp46.a46_tha.ea_addr[0] == 'v'
		    && (memcpy(&ip_addr, rarp46.a46_tha.ea_addr+2, 4), 1)
		    && (hostent= gethostbyaddr((char*) &ip_addr,
						4, AF_INET)) != NULL
		    && addhostname(hostname, hostent->h_name,
						rarp46.a46_tha.ea_addr[1])))
		&& (hostent= gethostbyname(hostname)) != NULL
		&& hostent->h_addrtype == AF_INET
	    ) {
		/* Host is found in the ethers file and the DNS, or the
		 * ethernet address denotes a special additional address
		 * used for implementing a TCP/IP stack in user space.
		 */
		for (i= 0; hostent->h_addr_list[i] != NULL; i++) {
		    memcpy(&ip_addr, hostent->h_addr_list[i], sizeof(ipaddr_t));

		    /* Check if the address is on this network. */
		    if (((ip_addr ^ ep->ip_addr) & ep->ip_mask) == 0) break;
		}

		if (hostent->h_addr_list[i] != NULL) {
		    rarp_reply(ep, hostname, ip_addr, rarp46.a46_tha);
		} else {
		    if (debug >= 2) {
			printf("%s: Host '%s' (%s) is on the wrong net\n",
			    ethdev(ep->n),
			    hostname, ether_ntoa(&rarp46.a46_tha));
		    }
		}
	    } else {
		if (debug >= 2) {
		    printf("%s: RARP request from unknown host '%s'\n",
			ethdev(ep->n), ether_ntoa(&rarp46.a46_tha));
		}
	    }
	}

	/* Wait for another request. */
	if (asyn_wait(&asyn, 0, NULL) < 0) {
	    report("asyn_wait()");
	    sleep(10);
	}
    }
}
Exemplo n.º 9
0
void runFailure() {
    char buf[255];
    struct ether_addr addr;
    ether_ntohost(NULL, &addr);
}
Exemplo n.º 10
0
void runSuccess() {
    char buf[255];
    struct ether_addr addr;
    ether_ntohost(buf, &addr);
}
Exemplo n.º 11
0
void runFailure2() {
    char buf[254];
    struct ether_addr addr;
    ether_ntohost(buf, &addr);
}
Exemplo n.º 12
0
void runFailure1() {
    char buf[255];
    struct ether_addr addr;
    ether_ntohost(buf, NULL);
}