OpenSolaris_b135/stand/lib/inet/ethernet.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Ethernet routines. Includes ARP and Reverse ARP. Used for ethernet-like
* media also - so be sure NOT to use ETHERMTU as a mtu limit. macinit()
* will set this appropriately.
*/
#include <sys/types.h>
#include <socket_impl.h>
#include <socket_inet.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#include <sys/promif.h>
#include <sys/prom_plat.h>
#include <sys/salib.h>
#include <sys/bootdebug.h>
#include "ipv4.h"
#include "ipv4_impl.h"
#include "mac.h"
#include "mac_impl.h"
#include "ethernet_inet.h"
ether_addr_t etherbroadcastaddr = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
struct arp_packet {
struct ether_header arp_eh;
struct ether_arp arp_ea;
#define USED_SIZE (sizeof (struct ether_header) + sizeof (struct ether_arp))
char filler[ETHERMIN - sizeof (struct ether_arp)];
};
static char *
ether_print(ether_addr_t ea)
{
static char eprintbuf[20];
(void) sprintf(eprintbuf, "%x:%x:%x:%x:%x:%x", ea[0], ea[1], ea[2],
ea[3], ea[4], ea[5]);
return (eprintbuf);
}
/*
* Common ARP code. Broadcast the packet and wait for the right response.
*
* If rarp is called for, caller expects an IPv4 address in the target
* protocol address (tpa) field of the "out" argument.
*
* If arp is called for, caller expects a hardware address in the
* source hardware address (sha) field of the "out" argument.
*
* Returns TRUE if transaction succeeded, FALSE otherwise.
*
* The timeout argument is the number of milliseconds to wait for a
* response. An infinite timeout can be specified as 0xffffffff.
*/
static int
ether_comarp(struct arp_packet *out, uint32_t timeout)
{
struct arp_packet *in = (struct arp_packet *)mac_state.mac_buf;
int count, time, feedback, len, delay = 2;
char *ind = "-\\|/";
struct in_addr tmp_ia;
uint32_t wait_time;
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)&out->arp_eh.ether_dhost,
sizeof (ether_addr_t));
bcopy((caddr_t)mac_state.mac_addr_buf,
(caddr_t)&out->arp_eh.ether_shost, sizeof (ether_addr_t));
out->arp_ea.arp_hrd = htons(ARPHRD_ETHER);
out->arp_ea.arp_pro = htons(ETHERTYPE_IP);
out->arp_ea.arp_hln = sizeof (ether_addr_t);
out->arp_ea.arp_pln = sizeof (struct in_addr);
bcopy(mac_state.mac_addr_buf, (caddr_t)&out->arp_ea.arp_sha,
sizeof (ether_addr_t));
ipv4_getipaddr(&tmp_ia);
tmp_ia.s_addr = htonl(tmp_ia.s_addr);
bcopy((caddr_t)&tmp_ia, (caddr_t)out->arp_ea.arp_spa,
sizeof (struct in_addr));
feedback = 0;
wait_time = prom_gettime() + timeout;
for (count = 0; timeout == ~0U || prom_gettime() < wait_time; count++) {
if (count == ETHER_WAITCNT) {
if (out->arp_ea.arp_op == ARPOP_REQUEST) {
bcopy((caddr_t)out->arp_ea.arp_tpa,
(caddr_t)&tmp_ia, sizeof (struct in_addr));
printf(
"\nRequesting Ethernet address for: %s\n",
inet_ntoa(tmp_ia));
} else {
printf("\nRequesting Internet address for %s\n",
ether_print(out->arp_ea.arp_tha));
}
}
(void) prom_write(mac_state.mac_dev, (caddr_t)out,
sizeof (*out), 0, NETWORK);
if (count >= ETHER_WAITCNT)
printf("%c\b", ind[feedback++ % 4]); /* activity */
time = prom_gettime() + (delay * 1000); /* broadcast delay */
while (prom_gettime() <= time) {
len = prom_read(mac_state.mac_dev, mac_state.mac_buf,
mac_state.mac_mtu, 0, NETWORK);
if (len < USED_SIZE)
continue;
if (in->arp_ea.arp_pro != ntohs(ETHERTYPE_IP))
continue;
if (out->arp_ea.arp_op == ntohs(ARPOP_REQUEST)) {
if (in->arp_eh.ether_type !=
ntohs(ETHERTYPE_ARP))
continue;
if (in->arp_ea.arp_op != ntohs(ARPOP_REPLY))
continue;
if (bcmp((caddr_t)in->arp_ea.arp_spa,
(caddr_t)out->arp_ea.arp_tpa,
sizeof (struct in_addr)) != 0)
continue;
if (boothowto & RB_VERBOSE) {
bcopy((caddr_t)in->arp_ea.arp_spa,
(caddr_t)&tmp_ia,
sizeof (struct in_addr));
printf("Found %s @ %s\n",
inet_ntoa(tmp_ia),
ether_print(in->arp_ea.arp_sha));
}
/* copy hardware addr into "out" for caller */
bcopy((caddr_t)&in->arp_ea.arp_sha,
(caddr_t)&out->arp_ea.arp_sha,
sizeof (ether_addr_t));
return (TRUE);
} else { /* Reverse ARP */
if (in->arp_eh.ether_type !=
ntohs(ETHERTYPE_REVARP))
continue;
if (in->arp_ea.arp_op != ntohs(REVARP_REPLY))
continue;
if (bcmp((caddr_t)in->arp_ea.arp_tha,
(caddr_t)out->arp_ea.arp_tha,
sizeof (ether_addr_t)) != 0)
continue;
if (boothowto & RB_VERBOSE) {
bcopy((caddr_t)in->arp_ea.arp_tpa,
(caddr_t)&tmp_ia,
sizeof (struct in_addr));
printf("Internet address is: %s\n",
inet_ntoa(tmp_ia));
}
/* copy IP address into "out" for caller */
bcopy((caddr_t)in->arp_ea.arp_tpa,
(caddr_t)out->arp_ea.arp_tpa,
sizeof (struct in_addr));
return (TRUE);
}
}
delay = delay * 2; /* Double the request delay */
if (delay > 64) /* maximum delay is 64 seconds */
delay = 64;
}
return (FALSE);
}
/*
* ARP client side
* Broadcasts to determine MAC address given network order IP address.
* See RFC 826
*
* Returns TRUE if successful, FALSE otherwise.
*/
int
ether_arp(struct in_addr *ip, void *hap, uint32_t timeout)
{
ether_addr_t *ep = (ether_addr_t *)hap;
struct arp_packet out;
int result;
if (!initialized)
prom_panic("Ethernet device is not initialized.");
bzero((char *)&out, sizeof (struct arp_packet));
out.arp_eh.ether_type = htons(ETHERTYPE_ARP);
out.arp_ea.arp_op = htons(ARPOP_REQUEST);
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)&out.arp_ea.arp_tha,
sizeof (ether_addr_t));
bcopy((caddr_t)ip, (caddr_t)out.arp_ea.arp_tpa,
sizeof (struct in_addr));
result = ether_comarp(&out, timeout);
if (result && (ep != NULL)) {
bcopy((caddr_t)&out.arp_ea.arp_sha, (caddr_t)ep,
sizeof (ether_addr_t));
}
return (result);
}
/*
* Reverse ARP client side
* Determine our Internet address given our MAC address
* See RFC 903
*/
void
ether_revarp(void)
{
struct in_addr ip;
struct arp_packet out;
if (!initialized)
prom_panic("Ethernet device is not initialized.");
bzero((char *)&out, sizeof (struct arp_packet));
out.arp_eh.ether_type = htons(ETHERTYPE_REVARP);
out.arp_ea.arp_op = htons(REVARP_REQUEST);
bcopy(mac_state.mac_addr_buf, (caddr_t)&out.arp_ea.arp_tha,
sizeof (ether_addr_t));
/* Wait forever */
(void) ether_comarp(&out, 0xffffffff);
bcopy((caddr_t)&out.arp_ea.arp_tpa, (caddr_t)&ip,
sizeof (struct in_addr));
ip.s_addr = ntohl(ip.s_addr);
ipv4_setipaddr(&ip);
}
/* ARGSUSED */
int
ether_header_len(struct inetgram *igm)
{
return (sizeof (struct ether_header));
}
/*
* Handle a IP datagram addressed to our ethernet address or to the
* ethernet broadcast address. Also respond to ARP requests. Generates
* inetgrams as long as there's data and the mac level IP timeout timer
* hasn't expired. As soon as there is no data, we try for
* ETHER_INPUT_ATTEMPTS for more, then exit the loop, even if there is time
* left, since we expect to have data waiting for us when we're called, we just
* don't know how much.
*
* We workaround slow proms (some proms have hard sleeps for as much as 3msec)
* even though there are is data waiting.
*
* Returns the total number of MEDIA_LVL frames placed on the socket.
* Caller is expected to free up the inetgram resources.
*/
int
ether_input(int index)
{
struct inetgram *inp;
struct ether_header *eh;
int frames = 0; /* successful frames */
int attempts = 0; /* failed attempts after success */
int16_t len = 0, data_len;
uint32_t timeout, reltime;
uint32_t pre_pr, post_pr; /* prom_read interval */
#ifdef DEBUG
int failures = 0; /* total failures */
int total_attempts = 0; /* total prom_read */
int no_data = 0; /* no data in prom */
int arps = 0; /* arp requests processed */
uint32_t tot_pr = 0; /* prom_read time */
uint32_t tot_pc = 0; /* inetgram creation time */
uint32_t pre_pc;
uint32_t now;
#endif /* DEBUG */
if (!initialized)
prom_panic("Ethernet device is not initialized.");
if ((reltime = sockets[index].in_timeout) == 0)
reltime = mac_state.mac_in_timeout;
timeout = prom_gettime() + reltime;
do {
if (frames > ETHER_MAX_FRAMES) {
/* someone is trying a denial of service attack */
break;
}
/*
* The following is a workaround for a calvin prom (V2) bug
* where prom_read() returns a nonzero length, even when it's
* not read a packet. So we zero out the header to compensate.
*/
bzero(mac_state.mac_buf, sizeof (struct ether_header));
/*
* Prom_read() will return 0 or -2 if no data is present. A
* return value of -1 means an error has occurred. We adjust
* the timeout by calling the time spent in prom_read() "free".
* prom_read() returns the number of bytes actually read, but
* will only copy "len" bytes into our buffer. Adjust in
* case the MTU is wrong.
*/
pre_pr = prom_gettime();
len = prom_read(mac_state.mac_dev, mac_state.mac_buf,
mac_state.mac_mtu, 0, NETWORK);
post_pr = prom_gettime();
timeout += (post_pr - pre_pr);
#ifdef DEBUG
tot_pr += (post_pr - pre_pr);
total_attempts++;
#endif /* DEBUG */
if (len > mac_state.mac_mtu) {
dprintf("ether_input: adjusting MTU %d -> %d\n",
mac_state.mac_mtu, len);
bkmem_free(mac_state.mac_buf, mac_state.mac_mtu);
mac_state.mac_mtu = len;
mac_state.mac_buf = bkmem_alloc(mac_state.mac_mtu);
if (mac_state.mac_buf == NULL) {
prom_panic("ether_input: Cannot reallocate "
"netbuf memory.");
}
len = 0; /* pretend there was no data */
}
if (len == -1) {
#ifdef DEBUG
failures++;
#endif /* DEBUG */
break;
}
if (len == 0 || len == -2) {
if (frames != 0)
attempts++;
#ifdef DEBUG
no_data++;
#endif /* DEBUG */
continue;
}
eh = (struct ether_header *)mac_state.mac_buf;
if (eh->ether_type == ntohs(ETHERTYPE_IP) &&
len >= (sizeof (struct ether_header) +
sizeof (struct ip))) {
int offset;
#ifdef DEBUG
pre_pc = prom_gettime();
#endif /* DEBUG */
inp = (struct inetgram *)bkmem_zalloc(
sizeof (struct inetgram));
if (inp == NULL) {
errno = ENOMEM;
return (frames == 0 ? -1 : frames);
}
offset = sizeof (struct ether_header);
data_len = len - offset;
inp->igm_mp = allocb(data_len, 0);
if (inp->igm_mp == NULL) {
errno = ENOMEM;
bkmem_free((caddr_t)inp,
sizeof (struct inetgram));
return (frames == 0 ? -1 : frames);
}
bcopy((caddr_t)(mac_state.mac_buf + offset),
inp->igm_mp->b_rptr, data_len);
inp->igm_mp->b_wptr += data_len;
inp->igm_level = NETWORK_LVL;
add_grams(&sockets[index].inq, inp);
frames++;
attempts = 0;
#ifdef DEBUG
tot_pc += prom_gettime() - pre_pc;
#endif /* DEBUG */
continue;
}
if (eh->ether_type == ntohs(ETHERTYPE_ARP) &&
len >= (sizeof (struct ether_header) +
sizeof (struct ether_arp))) {
struct in_addr ip;
struct ether_arp *ea;
#ifdef DEBUG
printf("ether_input: ARP message received\n");
arps++;
#endif /* DEBUG */
ea = (struct ether_arp *)(mac_state.mac_buf +
sizeof (struct ether_header));
if (ea->arp_pro != ntohs(ETHERTYPE_IP))
continue;
ipv4_getipaddr(&ip);
ip.s_addr = ntohl(ip.s_addr);
if (ea->arp_op == ntohs(ARPOP_REQUEST) &&
ip.s_addr != INADDR_ANY &&
(bcmp((caddr_t)ea->arp_tpa, (caddr_t)&ip,
sizeof (struct in_addr)) == 0)) {
ea->arp_op = htons(ARPOP_REPLY);
bcopy((caddr_t)ea->arp_sha,
(caddr_t)&eh->ether_dhost,
sizeof (ether_addr_t));
bcopy(mac_state.mac_addr_buf,
(caddr_t)&eh->ether_shost,
mac_state.mac_addr_len);
bcopy((caddr_t)ea->arp_sha,
(caddr_t)ea->arp_tha,
sizeof (ether_addr_t));
bcopy((caddr_t)ea->arp_spa,
(caddr_t)ea->arp_tpa,
sizeof (struct in_addr));
bcopy(mac_state.mac_addr_buf,
(caddr_t)ea->arp_sha,
mac_state.mac_addr_len);
bcopy((caddr_t)&ip, (caddr_t)ea->arp_spa,
sizeof (struct in_addr));
(void) prom_write(mac_state.mac_dev,
mac_state.mac_buf,
sizeof (struct arp_packet),
0, NETWORK);
/* don't charge for ARP replies */
timeout += reltime;
}
}
} while (attempts < ETHER_INPUT_ATTEMPTS &&
#ifdef DEBUG
(now = prom_gettime()) < timeout);
#else
prom_gettime() < timeout);
#endif /* DEBUG */
#ifdef DEBUG
printf("ether_input(%d): T/S/N/A/F/P/M: %d/%d/%d/%d/%d/%d/%d "
"T/O: %d < %d = %s\n", index, total_attempts, frames, no_data,
arps, failures, tot_pr, tot_pc, now, timeout,
(now < timeout) ? "TRUE" : "FALSE");
#endif /* DEBUG */
return (frames);
}
/*
* Send out an ethernet datagram. We expect a IP frame appropriately fragmented
* at this level.
*
* Errno is set and -1 is returned if an error occurs. Number of bytes sent
* is returned on success.
*/
/* ARGSUSED */
int
ether_output(int index, struct inetgram *ogp)
{
int header_len, result;
struct ether_header eh;
struct ip *ip;
struct in_addr tmpip, ipdst, netid;
int broadcast = FALSE;
int size;
mblk_t *mp;
#ifdef DEBUG
printf("ether_output (%d): size %d\n", index,
ogp->igm_mp->b_wptr - ogp->igm_mp->b_rptr);
#endif
if (!initialized)
prom_panic("Ethernet device is not initialized.");
if (ogp->igm_level != MEDIA_LVL) {
dprintf("ether_output: frame type wrong: socket: %d\n",
index * SOCKETTYPE);
errno = EINVAL;
return (-1);
}
header_len = sizeof (struct ether_header);
mp = ogp->igm_mp;
size = mp->b_wptr - mp->b_rptr;
if (size > mac_state.mac_mtu) {
dprintf("ether_output: frame size too big: %d\n", size);
errno = E2BIG;
return (-1);
}
size += header_len;
ip = (struct ip *)(mp->b_rptr);
eh.ether_type = htons(ETHERTYPE_IP);
bcopy(mac_state.mac_addr_buf, (caddr_t)&eh.ether_shost,
mac_state.mac_addr_len);
bcopy((caddr_t)&ip->ip_dst, (caddr_t)&ipdst, sizeof (ipdst));
if (ipdst.s_addr == htonl(INADDR_BROADCAST))
broadcast = TRUE; /* limited broadcast */
if (!broadcast) {
struct in_addr mask;
ipv4_getnetid(&netid);
ipv4_getnetmask(&mask);
mask.s_addr = htonl(mask.s_addr);
netid.s_addr = htonl(netid.s_addr);
/*
* check for all-hosts directed broadcast for
* to its own subnet.
*/
if (mask.s_addr != htonl(INADDR_BROADCAST) &&
(ipdst.s_addr & ~mask.s_addr) == 0 &&
(ipdst.s_addr & mask.s_addr) == netid.s_addr) {
broadcast = TRUE; /* directed broadcast */
} else {
if (ogp->igm_router.s_addr != htonl(INADDR_ANY))
tmpip.s_addr = ogp->igm_router.s_addr;
else
tmpip.s_addr = ipdst.s_addr;
result = mac_get_arp(&tmpip, (void *)&eh.ether_dhost,
sizeof (ether_addr_t), mac_state.mac_arp_timeout);
if (!result) {
errno = ETIMEDOUT;
dprintf("ether_output: ARP request for %s "
"timed out.\n", inet_ntoa(tmpip));
return (-1);
}
}
}
if (broadcast) {
bcopy((caddr_t)etherbroadcastaddr,
(caddr_t)&eh.ether_dhost, sizeof (ether_addr_t));
}
/* add the ethernet header */
mp->b_rptr -= sizeof (eh);
bcopy((caddr_t)&eh, mp->b_rptr, sizeof (eh));
#ifdef DEBUG
printf("ether_output(%d): level(%d) frame(0x%x) len(%d)\n",
index, ogp->igm_level, mp->b_rptr, size);
#if DEBUG > 1
printf("Dump ethernet (%d): \n", size);
hexdump((char *)mp->b_rptr, size);
printf("\n");
#endif /* DEBUG > 1 */
#endif /* DEBUG */
return (prom_write(mac_state.mac_dev, (char *)mp->b_rptr, size,
0, NETWORK));
}