static void
_synccmd(char*)
{
int i, fd;
char *s;
Fmt f;
if(!loggedin){
sendok("");
return;
}
fmtstrinit(&f);
fmtprint(&f, "delete mbox");
for(i=0; i<nmsg; i++)
if(msg[i].deleted)
fmtprint(&f, " %d", msg[i].upasnum);
s = fmtstrflush(&f);
if(strcmp(s, "delete mbox") != 0){ /* must have something to delete */
if((fd = open("../ctl", OWRITE)) < 0){
senderr("open ctl to delete messages: %r");
return;
}
if(write(fd, s, strlen(s)) < 0){
senderr("error deleting messages: %r");
return;
}
}
sendok("");
}
static int
stlscmd(char*)
{
int fd;
TLSconn conn;
if(didtls)
return senderr("tls already started");
if(!tlscert)
return senderr("don't have any tls credentials");
sendok("");
Bflush(&out);
memset(&conn, 0, sizeof conn);
conn.cert = tlscert;
conn.certlen = ntlscert;
if(debug)
conn.trace = trace;
fd = tlsServer(0, &conn);
if(fd < 0)
sysfatal("tlsServer: %r");
dup(fd, 0);
dup(fd, 1);
close(fd);
Binit(&in, 0, OREAD);
Binit(&out, 1, OWRITE);
didtls = 1;
return 0;
}
static int
retrcmd(char *arg)
{
int n;
Biobuf *b;
char buf[40], *p;
if(*arg == 0)
return senderr("RETR requires a message number");
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
snprint(buf, sizeof buf, "%d/raw", msg[n].upasnum);
if((b = Bopen(buf, OREAD)) == nil)
return senderr("message disappeared");
sendok("");
while((p = Brdstr(b, '\n', 1)) != nil){
if(p[0]=='.')
Bwrite(&out, ".", 1);
Bwrite(&out, p, strlen(p));
Bwrite(&out, "\r\n", 2);
free(p);
}
Bterm(b);
sendcrnl(".");
return 0;
}
static int
usercmd(char *arg)
{
if(loggedin)
return senderr("already authenticated");
if(*arg == 0)
return senderr("USER requires argument");
if(setuser(arg) < 0)
return -1;
return sendok("");
}
static int
topcmd(char *arg)
{
int done, i, lines, n;
char buf[40], *p;
Biobuf *b;
if(*arg == 0)
return senderr("TOP requires a message number");
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
arg = nextarg(arg);
if(*arg == 0)
return senderr("TOP requires a line count");
lines = atoi(arg);
if(lines < 0)
return senderr("bad args to TOP");
snprint(buf, sizeof buf, "%d/raw", msg[n].upasnum);
if((b = Bopen(buf, OREAD)) == nil)
return senderr("message disappeared");
sendok("");
while(p = Brdstr(b, '\n', 1)){
if(p[0]=='.')
Bputc(&out, '.');
Bwrite(&out, p, strlen(p));
Bwrite(&out, "\r\n", 2);
done = p[0]=='\0';
free(p);
if(done)
break;
}
for(i=0; i<lines; i++){
p = Brdstr(b, '\n', 1);
if(p == nil)
break;
if(p[0]=='.')
Bwrite(&out, ".", 1);
Bwrite(&out, p, strlen(p));
Bwrite(&out, "\r\n", 2);
free(p);
}
sendcrnl(".");
Bterm(b);
return 0;
}
static int
delecmd(char *arg)
{
int n;
if(*arg==0)
return senderr("DELE requires a message number");
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
msg[n].deleted = 1;
totalmsgs--;
totalbytes -= msg[n].bytes;
sendok("message %d deleted", n+1);
return 0;
}
static int
dologin(char *response)
{
AuthInfo *ai;
static int tries;
static uint32_t delaysecs = 5;
chs->user = user;
chs->resp = response;
chs->nresp = strlen(response);
if((ai = auth_response(chs)) == nil){
if(tries >= 20){
senderr("authentication failed: %r; server exiting");
exits(nil);
}
if(++tries == 3)
syslog(0, "pop3", "likely password guesser from %s",
peeraddr);
delaysecs *= 2;
if (delaysecs > 30*60)
delaysecs = 30*60; /* half-hour max. */
sleep(delaysecs * 1000); /* prevent beating on our auth server */
return senderr("authentication failed");
}
if(auth_chuid(ai, nil) < 0){
senderr("chuid failed: %r; server exiting");
exits(nil);
}
auth_freeAI(ai);
auth_freechal(chs);
chs = nil;
loggedin = 1;
if(newns(user, 0) < 0){
senderr("newns failed: %r; server exiting");
exits(nil);
}
syslog(0, "pop3", "user %s logged in", user);
enableaddr();
if(readmbox(box) < 0)
exits(nil);
return sendok("mailbox is %s", box);
}
static int
passcmd(char *arg)
{
DigestState *s;
uint8_t digest[MD5dlen];
char response[2*MD5dlen+1];
if(passwordinclear==0 && didtls==0)
return senderr("password in the clear disallowed");
/* use password to encode challenge */
if((chs = auth_challenge("proto=apop role=server")) == nil)
return senderr("couldn't get apop challenge");
/* hash challenge with secret and convert to ascii */
s = md5((uint8_t*)chs->chal, chs->nchal, 0, 0);
md5((uint8_t*)arg, strlen(arg), digest, s);
snprint(response, sizeof response, "%.*H", MD5dlen, digest);
return dologin(response);
}
static void
hello(void)
{
fmtinstall('H', encodefmt);
if((chs = auth_challenge("proto=apop role=server")) == nil){
senderr("auth server not responding, try later");
exits(nil);
}
sendok("POP3 server ready %s", chs->chal);
}
static int
setuser(char *arg)
{
char *p;
strcpy(box, "/mail/box/");
strecpy(box+strlen(box), box+sizeof box-7, arg);
strcpy(cbox, box);
cleanname(cbox);
if(strcmp(cbox, box) != 0)
return senderr("bad mailbox name");
strcat(box, "/mbox");
strecpy(user, user+sizeof user, arg);
if(p = strchr(user, '/'))
*p = '\0';
return 0;
}
static int
uidlcmd(char *arg)
{
int n;
if(*arg==0){
sendok("");
for(n=0; n<nmsg; n++){
if(msg[n].deleted)
continue;
sendcrnl("%d %s", n+1, msg[n].digest);
}
sendcrnl(".");
}else{
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
sendok("%d %s", n+1, msg[n].digest);
}
return 0;
}
static int
listcmd(char *arg)
{
int i, n;
if(*arg == 0){
sendok("+%d message%s (%d octets)", totalmsgs, totalmsgs==1 ? "":"s", totalbytes);
for(i=0; i<nmsg; i++){
if(msg[i].deleted)
continue;
sendcrnl("%d %d", i+1, msg[i].bytes);
}
sendcrnl(".");
}else{
n = atoi(arg)-1;
if(n < 0 || n >= nmsg || msg[n].deleted)
return senderr("no such message");
sendok("%d %d", n+1, msg[n].bytes);
}
return 0;
}
/*
* Ethernet output routine.
* Encapsulate a packet of type family for the local net.
* Use trailer local net encapsulation if enough data in first
* packet leaves a multiple of 512 bytes of data in remainder.
*/
int
ether_output(struct ifnet *ifp, struct mbuf *m,
const struct sockaddr *dst, struct route *ro)
{
short type;
int error = 0, hdrcmplt = 0;
u_char esrc[ETHER_ADDR_LEN], edst[ETHER_ADDR_LEN];
struct llentry *lle = NULL;
struct rtentry *rt0 = NULL;
struct ether_header *eh;
struct pf_mtag *t;
int loop_copy = 1;
int hlen; /* link layer header length */
if (ro != NULL) {
if (!(m->m_flags & (M_BCAST | M_MCAST)))
lle = ro->ro_lle;
rt0 = ro->ro_rt;
}
#ifdef MAC
error = mac_ifnet_check_transmit(ifp, m);
if (error)
senderr(error);
#endif
M_PROFILE(m);
if (ifp->if_flags & IFF_MONITOR)
senderr(ENETDOWN);
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
senderr(ENETDOWN);
hlen = ETHER_HDR_LEN;
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
if (lle != NULL && (lle->la_flags & LLE_VALID))
memcpy(edst, &lle->ll_addr.mac16, sizeof(edst));
else
error = arpresolve(ifp, rt0, m, dst, edst, &lle);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
type = htons(ETHERTYPE_IP);
break;
case AF_ARP:
{
struct arphdr *ah;
ah = mtod(m, struct arphdr *);
ah->ar_hrd = htons(ARPHRD_ETHER);
loop_copy = 0; /* if this is for us, don't do it */
switch(ntohs(ah->ar_op)) {
case ARPOP_REVREQUEST:
case ARPOP_REVREPLY:
type = htons(ETHERTYPE_REVARP);
break;
case ARPOP_REQUEST:
case ARPOP_REPLY:
default:
type = htons(ETHERTYPE_ARP);
break;
}
if (m->m_flags & M_BCAST)
bcopy(ifp->if_broadcastaddr, edst, ETHER_ADDR_LEN);
else
bcopy(ar_tha(ah), edst, ETHER_ADDR_LEN);
}
break;
#endif
#ifdef INET6
case AF_INET6:
if (lle != NULL && (lle->la_flags & LLE_VALID))
memcpy(edst, &lle->ll_addr.mac16, sizeof(edst));
else
error = nd6_storelladdr(ifp, m, dst, (u_char *)edst, &lle);
if (error)
return error;
type = htons(ETHERTYPE_IPV6);
break;
#endif
#ifdef IPX
case AF_IPX:
if (ef_outputp) {
error = ef_outputp(ifp, &m, dst, &type, &hlen);
if (error)
goto bad;
} else
type = htons(ETHERTYPE_IPX);
bcopy(&((const struct sockaddr_ipx *)dst)->sipx_addr.x_host,
edst, sizeof (edst));
break;
#endif
#ifdef NETATALK
case AF_APPLETALK:
{
struct at_ifaddr *aa;
if ((aa = at_ifawithnet((const struct sockaddr_at *)dst)) == NULL)
senderr(EHOSTUNREACH); /* XXX */
if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst)) {
ifa_free(&aa->aa_ifa);
return (0);
}
/*
* In the phase 2 case, need to prepend an mbuf for the llc header.
*/
if ( aa->aa_flags & AFA_PHASE2 ) {
struct llc llc;
ifa_free(&aa->aa_ifa);
M_PREPEND(m, LLC_SNAPFRAMELEN, M_NOWAIT);
if (m == NULL)
senderr(ENOBUFS);
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
llc.llc_control = LLC_UI;
bcopy(at_org_code, llc.llc_snap_org_code, sizeof(at_org_code));
llc.llc_snap_ether_type = htons( ETHERTYPE_AT );
bcopy(&llc, mtod(m, caddr_t), LLC_SNAPFRAMELEN);
type = htons(m->m_pkthdr.len);
hlen = LLC_SNAPFRAMELEN + ETHER_HDR_LEN;
} else {
ifa_free(&aa->aa_ifa);
type = htons(ETHERTYPE_AT);
}
break;
}
#endif /* NETATALK */
case pseudo_AF_HDRCMPLT:
{
const struct ether_header *eh;
hdrcmplt = 1;
eh = (const struct ether_header *)dst->sa_data;
(void)memcpy(esrc, eh->ether_shost, sizeof (esrc));
/* FALLTHROUGH */
case AF_UNSPEC:
loop_copy = 0; /* if this is for us, don't do it */
eh = (const struct ether_header *)dst->sa_data;
(void)memcpy(edst, eh->ether_dhost, sizeof (edst));
type = eh->ether_type;
break;
}
#ifdef MPLS
case AF_MPLS:
if (lle != NULL && (lle->la_flags & LLE_VALID))
bcopy(&lle->ll_addr.mac16 , edst, sizeof(edst));
else
error = mpls_arpresolve(ifp, rt0, m, dst, edst, &lle);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
if (m->m_flags & (M_BCAST | M_MCAST))
type = htons(ETHERTYPE_MPLS_MCAST);
else
type = htons(ETHERTYPE_MPLS);
break;
#endif /* MPLS */
default:
if_printf(ifp, "can't handle af%d\n", dst->sa_family);
senderr(EAFNOSUPPORT);
}
if (lle != NULL && (lle->la_flags & LLE_IFADDR)) {
update_mbuf_csumflags(m, m);
return (if_simloop(ifp, m, dst->sa_family, 0));
}
/*
* Add local net header. If no space in first mbuf,
* allocate another.
*/
M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT);
if (m == NULL)
senderr(ENOBUFS);
eh = mtod(m, struct ether_header *);
(void)memcpy(&eh->ether_type, &type,
sizeof(eh->ether_type));
(void)memcpy(eh->ether_dhost, edst, sizeof (edst));
if (hdrcmplt)
(void)memcpy(eh->ether_shost, esrc,
sizeof(eh->ether_shost));
else
(void)memcpy(eh->ether_shost, IF_LLADDR(ifp),
sizeof(eh->ether_shost));
/*
* If a simplex interface, and the packet is being sent to our
* Ethernet address or a broadcast address, loopback a copy.
* XXX To make a simplex device behave exactly like a duplex
* device, we should copy in the case of sending to our own
* ethernet address (thus letting the original actually appear
* on the wire). However, we don't do that here for security
* reasons and compatibility with the original behavior.
*/
if ((ifp->if_flags & IFF_SIMPLEX) && loop_copy &&
((t = pf_find_mtag(m)) == NULL || !t->routed)) {
if (m->m_flags & M_BCAST) {
struct mbuf *n;
/*
* Because if_simloop() modifies the packet, we need a
* writable copy through m_dup() instead of a readonly
* one as m_copy[m] would give us. The alternative would
* be to modify if_simloop() to handle the readonly mbuf,
* but performancewise it is mostly equivalent (trading
* extra data copying vs. extra locking).
*
* XXX This is a local workaround. A number of less
* often used kernel parts suffer from the same bug.
* See PR kern/105943 for a proposed general solution.
*/
if ((n = m_dup(m, M_NOWAIT)) != NULL) {
update_mbuf_csumflags(m, n);
(void)if_simloop(ifp, n, dst->sa_family, hlen);
} else
ifp->if_iqdrops++;
} else if (bcmp(eh->ether_dhost, eh->ether_shost,
ETHER_ADDR_LEN) == 0) {
update_mbuf_csumflags(m, m);
(void) if_simloop(ifp, m, dst->sa_family, hlen);
return (0); /* XXX */
}
}
/*
* Bridges require special output handling.
*/
if (ifp->if_bridge) {
BRIDGE_OUTPUT(ifp, m, error);
return (error);
}
#if defined(INET) || defined(INET6)
if (ifp->if_carp &&
(error = (*carp_output_p)(ifp, m, dst)))
goto bad;
#endif
/* Handle ng_ether(4) processing, if any */
if (IFP2AC(ifp)->ac_netgraph != NULL) {
KASSERT(ng_ether_output_p != NULL,
("ng_ether_output_p is NULL"));
if ((error = (*ng_ether_output_p)(ifp, &m)) != 0) {
bad: if (m != NULL)
m_freem(m);
return (error);
}
if (m == NULL)
return (0);
}
/* Continue with link-layer output */
return ether_output_frame(ifp, m);
}
/*
* Ethernet output routine.
* Encapsulate a packet of type family for the local net.
* Use trailer local net encapsulation if enough data in first
* packet leaves a multiple of 512 bytes of data in remainder.
*/
int
ether_output(struct ifnet *ifp, struct mbuf *m,
const struct sockaddr *dst, struct route *ro)
{
short type;
int error = 0, hdrcmplt = 0;
u_char edst[ETHER_ADDR_LEN];
struct llentry *lle = NULL;
struct rtentry *rt0 = NULL;
struct ether_header *eh;
struct pf_mtag *t;
int loop_copy = 1;
int hlen; /* link layer header length */
int is_gw = 0;
uint32_t pflags = 0;
if (ro != NULL) {
if (!(m->m_flags & (M_BCAST | M_MCAST))) {
lle = ro->ro_lle;
if (lle != NULL)
pflags = lle->la_flags;
}
rt0 = ro->ro_rt;
if (rt0 != NULL && (rt0->rt_flags & RTF_GATEWAY) != 0)
is_gw = 1;
}
#ifdef MAC
error = mac_ifnet_check_transmit(ifp, m);
if (error)
senderr(error);
#endif
M_PROFILE(m);
if (ifp->if_flags & IFF_MONITOR)
senderr(ENETDOWN);
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
senderr(ENETDOWN);
hlen = ETHER_HDR_LEN;
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
if (lle != NULL && (pflags & LLE_VALID) != 0)
memcpy(edst, &lle->ll_addr.mac16, sizeof(edst));
else
error = arpresolve(ifp, is_gw, m, dst, edst, &pflags);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
type = htons(ETHERTYPE_IP);
break;
case AF_ARP:
{
struct arphdr *ah;
ah = mtod(m, struct arphdr *);
ah->ar_hrd = htons(ARPHRD_ETHER);
loop_copy = 0; /* if this is for us, don't do it */
switch(ntohs(ah->ar_op)) {
case ARPOP_REVREQUEST:
case ARPOP_REVREPLY:
type = htons(ETHERTYPE_REVARP);
break;
case ARPOP_REQUEST:
case ARPOP_REPLY:
default:
type = htons(ETHERTYPE_ARP);
break;
}
if (m->m_flags & M_BCAST)
bcopy(ifp->if_broadcastaddr, edst, ETHER_ADDR_LEN);
else
bcopy(ar_tha(ah), edst, ETHER_ADDR_LEN);
}
break;
#endif
#ifdef INET6
case AF_INET6:
if (lle != NULL && (pflags & LLE_VALID))
memcpy(edst, &lle->ll_addr.mac16, sizeof(edst));
else
error = nd6_resolve(ifp, is_gw, m, dst, (u_char *)edst,
&pflags);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
type = htons(ETHERTYPE_IPV6);
break;
#endif
case pseudo_AF_HDRCMPLT:
{
const struct ether_header *eh;
hdrcmplt = 1;
/* FALLTHROUGH */
case AF_UNSPEC:
loop_copy = 0; /* if this is for us, don't do it */
eh = (const struct ether_header *)dst->sa_data;
(void)memcpy(edst, eh->ether_dhost, sizeof (edst));
type = eh->ether_type;
break;
}
default:
if_printf(ifp, "can't handle af%d\n", dst->sa_family);
senderr(EAFNOSUPPORT);
}
if ((pflags & LLE_IFADDR) != 0) {
update_mbuf_csumflags(m, m);
return (if_simloop(ifp, m, dst->sa_family, 0));
}
/*
* Add local net header. If no space in first mbuf,
* allocate another.
*/
M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT);
if (m == NULL)
senderr(ENOBUFS);
eh = mtod(m, struct ether_header *);
if (hdrcmplt == 0) {
memcpy(&eh->ether_type, &type, sizeof(eh->ether_type));
memcpy(eh->ether_dhost, edst, sizeof (edst));
memcpy(eh->ether_shost, IF_LLADDR(ifp),sizeof(eh->ether_shost));
}
/*
* If a simplex interface, and the packet is being sent to our
* Ethernet address or a broadcast address, loopback a copy.
* XXX To make a simplex device behave exactly like a duplex
* device, we should copy in the case of sending to our own
* ethernet address (thus letting the original actually appear
* on the wire). However, we don't do that here for security
* reasons and compatibility with the original behavior.
*/
if ((ifp->if_flags & IFF_SIMPLEX) && loop_copy &&
((t = pf_find_mtag(m)) == NULL || !t->routed)) {
if (m->m_flags & M_BCAST) {
struct mbuf *n;
/*
* Because if_simloop() modifies the packet, we need a
* writable copy through m_dup() instead of a readonly
* one as m_copy[m] would give us. The alternative would
* be to modify if_simloop() to handle the readonly mbuf,
* but performancewise it is mostly equivalent (trading
* extra data copying vs. extra locking).
*
* XXX This is a local workaround. A number of less
* often used kernel parts suffer from the same bug.
* See PR kern/105943 for a proposed general solution.
*/
if ((n = m_dup(m, M_NOWAIT)) != NULL) {
update_mbuf_csumflags(m, n);
(void)if_simloop(ifp, n, dst->sa_family, hlen);
} else
if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
} else if (bcmp(eh->ether_dhost, eh->ether_shost,
ETHER_ADDR_LEN) == 0) {
update_mbuf_csumflags(m, m);
(void) if_simloop(ifp, m, dst->sa_family, hlen);
return (0); /* XXX */
}
}
/*
* Bridges require special output handling.
*/
if (ifp->if_bridge) {
BRIDGE_OUTPUT(ifp, m, error);
return (error);
}
#if defined(INET) || defined(INET6)
if (ifp->if_carp &&
(error = (*carp_output_p)(ifp, m, dst)))
goto bad;
#endif
/* Handle ng_ether(4) processing, if any */
if (ifp->if_l2com != NULL) {
KASSERT(ng_ether_output_p != NULL,
("ng_ether_output_p is NULL"));
if ((error = (*ng_ether_output_p)(ifp, &m)) != 0) {
bad: if (m != NULL)
m_freem(m);
return (error);
}
if (m == NULL)
return (0);
}
/* Continue with link-layer output */
return ether_output_frame(ifp, m);
}
/*
* Ethernet output routine.
* Encapsulate a packet of type family for the local net.
* Use trailer local net encapsulation if enough data in first
* packet leaves a multiple of 512 bytes of data in remainder.
*/
int
ether_output(struct ifnet *ifp, struct mbuf *m,
const struct sockaddr *dst, struct route *ro)
{
int error = 0;
char linkhdr[ETHER_HDR_LEN], *phdr;
struct ether_header *eh;
struct pf_mtag *t;
int loop_copy = 1;
int hlen; /* link layer header length */
uint32_t pflags;
struct llentry *lle = NULL;
struct rtentry *rt0 = NULL;
int addref = 0;
phdr = NULL;
pflags = 0;
if (ro != NULL) {
/* XXX BPF uses ro_prepend */
if (ro->ro_prepend != NULL) {
phdr = ro->ro_prepend;
hlen = ro->ro_plen;
} else if (!(m->m_flags & (M_BCAST | M_MCAST))) {
if ((ro->ro_flags & RT_LLE_CACHE) != 0) {
lle = ro->ro_lle;
if (lle != NULL &&
(lle->la_flags & LLE_VALID) == 0) {
LLE_FREE(lle);
lle = NULL; /* redundant */
ro->ro_lle = NULL;
}
if (lle == NULL) {
/* if we lookup, keep cache */
addref = 1;
}
}
if (lle != NULL) {
phdr = lle->r_linkdata;
hlen = lle->r_hdrlen;
pflags = lle->r_flags;
}
}
rt0 = ro->ro_rt;
}
#ifdef MAC
error = mac_ifnet_check_transmit(ifp, m);
if (error)
senderr(error);
#endif
M_PROFILE(m);
if (ifp->if_flags & IFF_MONITOR)
senderr(ENETDOWN);
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
senderr(ENETDOWN);
if (phdr == NULL) {
/* No prepend data supplied. Try to calculate ourselves. */
phdr = linkhdr;
hlen = ETHER_HDR_LEN;
error = ether_resolve_addr(ifp, m, dst, ro, phdr, &pflags,
addref ? &lle : NULL);
if (addref && lle != NULL)
ro->ro_lle = lle;
if (error != 0)
return (error == EWOULDBLOCK ? 0 : error);
}
if ((pflags & RT_L2_ME) != 0) {
update_mbuf_csumflags(m, m);
return (if_simloop(ifp, m, dst->sa_family, 0));
}
loop_copy = pflags & RT_MAY_LOOP;
/*
* Add local net header. If no space in first mbuf,
* allocate another.
*
* Note that we do prepend regardless of RT_HAS_HEADER flag.
* This is done because BPF code shifts m_data pointer
* to the end of ethernet header prior to calling if_output().
*/
M_PREPEND(m, hlen, M_NOWAIT);
if (m == NULL)
senderr(ENOBUFS);
if ((pflags & RT_HAS_HEADER) == 0) {
eh = mtod(m, struct ether_header *);
memcpy(eh, phdr, hlen);
}
int
rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt,
u_int tableid)
{
int s = splsoftnet(); int error = 0;
struct rtentry *rt, *crt;
struct radix_node *rn;
struct radix_node_head *rnh;
struct ifaddr *ifa;
struct sockaddr *ndst;
struct sockaddr_rtlabel *sa_rl;
#define senderr(x) { error = x ; goto bad; }
if ((rnh = rt_gettable(info->rti_info[RTAX_DST]->sa_family, tableid)) ==
NULL)
senderr(EAFNOSUPPORT);
if (info->rti_flags & RTF_HOST)
info->rti_info[RTAX_NETMASK] = NULL;
switch (req) {
case RTM_DELETE:
if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) == NULL)
senderr(ESRCH);
rt = (struct rtentry *)rn;
#ifndef SMALL_KERNEL
/*
* if we got multipath routes, we require users to specify
* a matching RTAX_GATEWAY.
*/
if (rn_mpath_capable(rnh)) {
rt = rt_mpath_matchgate(rt,
info->rti_info[RTAX_GATEWAY]);
rn = (struct radix_node *)rt;
if (!rt)
senderr(ESRCH);
}
#endif
if ((rn = rnh->rnh_deladdr(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh, rn)) == NULL)
senderr(ESRCH);
rt = (struct rtentry *)rn;
/* clean up any cloned children */
if ((rt->rt_flags & RTF_CLONING) != 0)
rtflushclone(rnh, rt);
if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
panic ("rtrequest delete");
if (rt->rt_gwroute) {
rt = rt->rt_gwroute; RTFREE(rt);
(rt = (struct rtentry *)rn)->rt_gwroute = NULL;
}
if (rt->rt_parent) {
rt->rt_parent->rt_refcnt--;
rt->rt_parent = NULL;
}
#ifndef SMALL_KERNEL
if (rn_mpath_capable(rnh)) {
if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) != NULL &&
rn_mpath_next(rn) == NULL)
((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
}
#endif
rt->rt_flags &= ~RTF_UP;
if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
ifa->ifa_rtrequest(RTM_DELETE, rt, info);
rttrash++;
if (ret_nrt)
*ret_nrt = rt;
else if (rt->rt_refcnt <= 0) {
rt->rt_refcnt++;
rtfree(rt);
}
break;
case RTM_RESOLVE:
if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
senderr(EINVAL);
if ((rt->rt_flags & RTF_CLONING) == 0)
senderr(EINVAL);
ifa = rt->rt_ifa;
info->rti_flags = rt->rt_flags & ~(RTF_CLONING | RTF_STATIC);
info->rti_flags |= RTF_CLONED;
info->rti_info[RTAX_GATEWAY] = rt->rt_gateway;
if ((info->rti_info[RTAX_NETMASK] = rt->rt_genmask) == NULL)
info->rti_flags |= RTF_HOST;
goto makeroute;
case RTM_ADD:
if (info->rti_ifa == 0 && (error = rt_getifa(info)))
senderr(error);
ifa = info->rti_ifa;
makeroute:
rt = pool_get(&rtentry_pool, PR_NOWAIT);
if (rt == NULL)
senderr(ENOBUFS);
Bzero(rt, sizeof(*rt));
rt->rt_flags = RTF_UP | info->rti_flags;
LIST_INIT(&rt->rt_timer);
if (rt_setgate(rt, info->rti_info[RTAX_DST],
info->rti_info[RTAX_GATEWAY], tableid)) {
pool_put(&rtentry_pool, rt);
senderr(ENOBUFS);
}
ndst = rt_key(rt);
if (info->rti_info[RTAX_NETMASK] != NULL) {
rt_maskedcopy(info->rti_info[RTAX_DST], ndst,
info->rti_info[RTAX_NETMASK]);
} else
Bcopy(info->rti_info[RTAX_DST], ndst,
info->rti_info[RTAX_DST]->sa_len);
#ifndef SMALL_KERNEL
/* do not permit exactly the same dst/mask/gw pair */
if (rn_mpath_capable(rnh) &&
rt_mpath_conflict(rnh, rt, info->rti_info[RTAX_NETMASK],
info->rti_flags & RTF_MPATH)) {
if (rt->rt_gwroute)
rtfree(rt->rt_gwroute);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
senderr(EEXIST);
}
#endif
if (info->rti_info[RTAX_LABEL] != NULL) {
sa_rl = (struct sockaddr_rtlabel *)
info->rti_info[RTAX_LABEL];
rt->rt_labelid = rtlabel_name2id(sa_rl->sr_label);
}
ifa->ifa_refcnt++;
rt->rt_ifa = ifa;
rt->rt_ifp = ifa->ifa_ifp;
if (req == RTM_RESOLVE) {
/*
* Copy both metrics and a back pointer to the cloned
* route's parent.
*/
rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
rt->rt_parent = *ret_nrt; /* Back ptr. to parent. */
rt->rt_parent->rt_refcnt++;
}
rn = rnh->rnh_addaddr((caddr_t)ndst,
(caddr_t)info->rti_info[RTAX_NETMASK], rnh, rt->rt_nodes);
if (rn == NULL && (crt = rtalloc1(ndst, 0, tableid)) != NULL) {
/* overwrite cloned route */
if ((crt->rt_flags & RTF_CLONED) != 0) {
rtdeletemsg(crt, tableid);
rn = rnh->rnh_addaddr((caddr_t)ndst,
(caddr_t)info->rti_info[RTAX_NETMASK],
rnh, rt->rt_nodes);
}
RTFREE(crt);
}
if (rn == 0) {
IFAFREE(ifa);
if ((rt->rt_flags & RTF_CLONED) != 0 && rt->rt_parent)
rtfree(rt->rt_parent);
if (rt->rt_gwroute)
rtfree(rt->rt_gwroute);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
senderr(EEXIST);
}
#ifndef SMALL_KERNEL
if (rn_mpath_capable(rnh) &&
(rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) != NULL) {
if (rn_mpath_next(rn) == NULL)
((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
else
((struct rtentry *)rn)->rt_flags |= RTF_MPATH;
}
#endif
if (ifa->ifa_rtrequest)
ifa->ifa_rtrequest(req, rt, info);
if (ret_nrt) {
*ret_nrt = rt;
rt->rt_refcnt++;
}
if ((rt->rt_flags & RTF_CLONING) != 0) {
/* clean up any cloned children */
rtflushclone(rnh, rt);
}
if_group_routechange(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK]);
break;
}
bad:
splx(s);
return (error);
}
/*
* Ethernet output routine.
* Encapsulate a packet of type family for the local net.
* Assumes that ifp is actually pointer to ethercom structure.
*/
int
ssh_interceptor_ether_output(struct ifnet *ifp, struct mbuf *m0,
struct sockaddr *dst, struct rtentry *rt0)
{
u_int16_t etype = 0;
int s, error = 0, hdrcmplt = 0;
u_char esrc[6], edst[6];
struct mbuf *m = m0;
struct rtentry *rt;
struct mbuf *mcopy = (struct mbuf *)0;
struct ether_header *eh, ehd;
#ifdef INET
struct arphdr *ah;
#endif /* INET */
#ifdef NETATALK
struct at_ifaddr *aa;
#endif /* NETATALK */
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
senderr(ENETDOWN);
ifp->if_lastchange = time;
if ((rt = rt0) != NULL) {
if ((rt->rt_flags & RTF_UP) == 0) {
if ((rt0 = rt = rtalloc1(dst, 1)) != NULL) {
rt->rt_refcnt--;
if (rt->rt_ifp != ifp)
return (*rt->rt_ifp->if_output)
(ifp, m0, dst, rt);
} else
senderr(EHOSTUNREACH);
}
if ((rt->rt_flags & RTF_GATEWAY) && dst->sa_family != AF_NS) {
if (rt->rt_gwroute == 0)
goto lookup;
if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
rtfree(rt); rt = rt0;
lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
if ((rt = rt->rt_gwroute) == 0)
senderr(EHOSTUNREACH);
/* the "G" test below also prevents rt == rt0 */
if ((rt->rt_flags & RTF_GATEWAY) ||
(rt->rt_ifp != ifp)) {
rt->rt_refcnt--;
rt0->rt_gwroute = 0;
senderr(EHOSTUNREACH);
}
}
}
if (rt->rt_flags & RTF_REJECT)
if (rt->rt_rmx.rmx_expire == 0 ||
time.tv_sec < rt->rt_rmx.rmx_expire)
senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
}
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
if (m->m_flags & M_BCAST)
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)edst,
sizeof(edst));
else if (m->m_flags & M_MCAST) {
ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr,
(caddr_t)edst)
} else if (!arpresolve(ifp, rt, m, dst, edst))
return (0); /* if not yet resolved */
/* If broadcasting on a simplex interface, loopback a copy */
if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
mcopy = m_copy(m, 0, (int)M_COPYALL);
etype = htons(ETHERTYPE_IP);
break;
case AF_ARP:
ah = mtod(m, struct arphdr *);
if (m->m_flags & M_BCAST)
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)edst,
sizeof(edst));
else
bcopy((caddr_t)ar_tha(ah),
(caddr_t)edst, sizeof(edst));
ah->ar_hrd = htons(ARPHRD_ETHER);
switch(ntohs(ah->ar_op)) {
case ARPOP_REVREQUEST:
case ARPOP_REVREPLY:
etype = htons(ETHERTYPE_REVARP);
break;
case ARPOP_REQUEST:
case ARPOP_REPLY:
default:
etype = htons(ETHERTYPE_ARP);
}
break;
#endif
#ifdef INET6
case AF_INET6:
#ifdef OLDIP6OUTPUT
if (!nd6_resolve(ifp, rt, m, dst, (u_char *)edst))
return(0); /* if not yet resolves */
#else
if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst)){
/* this must be impossible, so we bark */
printf("nd6_storelladdr failed\n");
return(0);
}
#endif /* OLDIP6OUTPUT */
etype = htons(ETHERTYPE_IPV6);
break;
#endif
#ifdef NETATALK
case AF_APPLETALK:
if (!aarpresolve(ifp, m, (struct sockaddr_at *)dst, edst)) {
#ifdef NETATALKDEBUG
printf("aarpresolv failed\n");
#endif /* NETATALKDEBUG */
return (0);
}
/*
* ifaddr is the first thing in at_ifaddr
*/
aa = (struct at_ifaddr *) at_ifawithnet(
(struct sockaddr_at *)dst, ifp);
if (aa == NULL)
goto bad;
/*
* In the phase 2 case, we need to prepend an mbuf for the
* llc header. Since we must preserve the value of m,
* which is passed to us by value, we m_copy() the first
* mbuf, and use it for our llc header.
*/
if (aa->aa_flags & AFA_PHASE2) {
struct llc llc;
M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
llc.llc_control = LLC_UI;
bcopy(at_org_code, llc.llc_snap_org_code,
sizeof(llc.llc_snap_org_code));
llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
} else {
etype = htons(ETHERTYPE_ATALK);
}
break;
#endif /* NETATALK */
#ifdef NS
case AF_NS:
etype = htons(ETHERTYPE_NS);
bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
(caddr_t)edst, sizeof (edst));
if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
return (looutput(ifp, m, dst, rt));
/* If broadcasting on a simplex interface, loopback a copy */
if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
mcopy = m_copy(m, 0, (int)M_COPYALL);
break;
#endif
#ifdef IPX
case AF_IPX:
etype = htons(ETHERTYPE_IPX);
bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
(caddr_t)edst, sizeof (edst));
/* If broadcasting on a simplex interface, loopback a copy */
if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
mcopy = m_copy(m, 0, (int)M_COPYALL);
break;
#endif
#ifdef ISO
case AF_ISO: {
int snpalen;
struct llc *l;
struct sockaddr_dl *sdl;
if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
} else {
error = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
(char *)edst, &snpalen);
if (error)
goto bad; /* Not Resolved */
}
/* If broadcasting on a simplex interface, loopback a copy */
if (*edst & 1)
m->m_flags |= (M_BCAST|M_MCAST);
if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
(mcopy = m_copy(m, 0, (int)M_COPYALL))) {
M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
if (mcopy) {
eh = mtod(mcopy, struct ether_header *);
bcopy((caddr_t)edst,
(caddr_t)eh->ether_dhost, sizeof (edst));
bcopy(LLADDR(ifp->if_sadl),
(caddr_t)eh->ether_shost, sizeof (edst));
}
}
M_PREPEND(m, 3, M_DONTWAIT);
if (m == NULL)
return (0);
l = mtod(m, struct llc *);
l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
l->llc_control = LLC_UI;
#ifdef ARGO_DEBUG
if (argo_debug[D_ETHER]) {
int i;
printf("unoutput: sending pkt to: ");
for (i=0; i<6; i++)
printf("%x ", edst[i] & 0xff);
printf("\n");
}
#endif
} break;
#endif /* ISO */
#ifdef LLC
/* case AF_NSAP: */
case AF_CCITT: {
struct sockaddr_dl *sdl =
(struct sockaddr_dl *) rt -> rt_gateway;
if (sdl && sdl->sdl_family == AF_LINK
&& sdl->sdl_alen > 0) {
bcopy(LLADDR(sdl), (char *)edst,
sizeof(edst));
} else goto bad; /* Not a link interface ? Funny ... */
if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1) &&
(mcopy = m_copy(m, 0, (int)M_COPYALL))) {
M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
if (mcopy) {
eh = mtod(mcopy, struct ether_header *);
bcopy((caddr_t)edst,
(caddr_t)eh->ether_dhost, sizeof (edst));
bcopy(LLADDR(ifp->if_sadl),
(caddr_t)eh->ether_shost, sizeof (edst));
}
}
#ifdef LLC_DEBUG
{
int i;
struct llc *l = mtod(m, struct llc *);
printf("ether_output: sending LLC2 pkt to: ");
for (i=0; i<6; i++)
printf("%x ", edst[i] & 0xff);
printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
m->m_pkthdr.len, l->llc_dsap & 0xff, l->llc_ssap &0xff,
l->llc_control & 0xff);
}
#endif /* LLC_DEBUG */
} break;
/*
* Ethernet output routine.
* Encapsulate a packet of type family for the local net.
* Assumes that ifp is actually pointer to arpcom structure.
*/
int
ether_output(struct ifnet *ifp0, struct mbuf *m0, struct sockaddr *dst,
struct rtentry *rt0)
{
u_int16_t etype;
int s, len, error = 0;
u_char edst[ETHER_ADDR_LEN];
u_char *esrc;
struct mbuf *m = m0;
struct rtentry *rt;
struct mbuf *mcopy = NULL;
struct ether_header *eh;
struct arpcom *ac = (struct arpcom *)ifp0;
short mflags;
struct ifnet *ifp = ifp0;
#ifdef DIAGNOSTIC
if (ifp->if_rdomain != rtable_l2(m->m_pkthdr.ph_rtableid)) {
printf("%s: trying to send packet on wrong domain. "
"if %d vs. mbuf %d, AF %d\n", ifp->if_xname,
ifp->if_rdomain, rtable_l2(m->m_pkthdr.ph_rtableid),
dst->sa_family);
}
#endif
#if NTRUNK > 0
/* restrict transmission on trunk members to bpf only */
if (ifp->if_type == IFT_IEEE8023ADLAG &&
(m_tag_find(m, PACKET_TAG_DLT, NULL) == NULL))
senderr(EBUSY);
#endif
#if NCARP > 0
if (ifp->if_type == IFT_CARP) {
ifp = ifp->if_carpdev;
ac = (struct arpcom *)ifp;
if ((ifp0->if_flags & (IFF_UP|IFF_RUNNING)) !=
(IFF_UP|IFF_RUNNING))
senderr(ENETDOWN);
}
#endif /* NCARP > 0 */
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
senderr(ENETDOWN);
if ((rt = rt0) != NULL) {
if ((rt->rt_flags & RTF_UP) == 0) {
if ((rt0 = rt = rtalloc1(dst, RT_REPORT,
m->m_pkthdr.ph_rtableid)) != NULL)
rt->rt_refcnt--;
else
senderr(EHOSTUNREACH);
}
if (rt->rt_flags & RTF_GATEWAY) {
if (rt->rt_gwroute == NULL)
goto lookup;
if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
rtfree(rt);
rt = rt0;
lookup:
rt->rt_gwroute = rtalloc1(rt->rt_gateway,
RT_REPORT, ifp->if_rdomain);
if ((rt = rt->rt_gwroute) == NULL)
senderr(EHOSTUNREACH);
}
}
if (rt->rt_flags & RTF_REJECT)
if (rt->rt_rmx.rmx_expire == 0 ||
time_second < rt->rt_rmx.rmx_expire)
senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
}
esrc = ac->ac_enaddr;
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
if (!arpresolve(ac, rt, m, dst, edst))
return (0); /* if not yet resolved */
/* If broadcasting on a simplex interface, loopback a copy */
if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
!m->m_pkthdr.pf.routed)
mcopy = m_copy(m, 0, (int)M_COPYALL);
etype = htons(ETHERTYPE_IP);
break;
#endif
#ifdef INET6
case AF_INET6:
if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst))
return (0); /* it must be impossible, but... */
etype = htons(ETHERTYPE_IPV6);
break;
#endif
#ifdef MPLS
case AF_MPLS:
if (rt)
dst = rt_key(rt);
else
senderr(EHOSTUNREACH);
if (!ISSET(ifp->if_xflags, IFXF_MPLS))
senderr(ENETUNREACH);
switch (dst->sa_family) {
case AF_LINK:
if (((struct sockaddr_dl *)dst)->sdl_alen <
sizeof(edst))
senderr(EHOSTUNREACH);
memcpy(edst, LLADDR((struct sockaddr_dl *)dst),
sizeof(edst));
break;
case AF_INET:
if (!arpresolve(ac, rt, m, dst, edst))
return (0); /* if not yet resolved */
break;
default:
senderr(EHOSTUNREACH);
}
/* XXX handling for simplex devices in case of M/BCAST ?? */
if (m->m_flags & (M_BCAST | M_MCAST))
etype = htons(ETHERTYPE_MPLS_MCAST);
else
etype = htons(ETHERTYPE_MPLS);
break;
#endif /* MPLS */
case pseudo_AF_HDRCMPLT:
eh = (struct ether_header *)dst->sa_data;
esrc = eh->ether_shost;
/* FALLTHROUGH */
case AF_UNSPEC:
eh = (struct ether_header *)dst->sa_data;
memcpy(edst, eh->ether_dhost, sizeof(edst));
/* AF_UNSPEC doesn't swap the byte order of the ether_type. */
etype = eh->ether_type;
break;
default:
printf("%s: can't handle af%d\n", ifp->if_xname,
dst->sa_family);
senderr(EAFNOSUPPORT);
}
/* XXX Should we feed-back an unencrypted IPsec packet ? */
if (mcopy)
(void) looutput(ifp, mcopy, dst, rt);
#if NCARP > 0
if (ifp0 != ifp && ifp0->if_type == IFT_CARP)
esrc = carp_get_srclladdr(ifp0, esrc);
#endif
if (ether_addheader(&m, ifp, etype, esrc, edst) == -1)
senderr(ENOBUFS);
#if NBRIDGE > 0
/*
* Interfaces that are bridgeports need special handling for output.
*/
if (ifp->if_bridgeport) {
struct m_tag *mtag;
/*
* Check if this packet has already been sent out through
* this bridgeport, in which case we simply send it out
* without further bridge processing.
*/
for (mtag = m_tag_find(m, PACKET_TAG_BRIDGE, NULL); mtag;
mtag = m_tag_find(m, PACKET_TAG_BRIDGE, mtag)) {
#ifdef DEBUG
/* Check that the information is there */
if (mtag->m_tag_len != sizeof(caddr_t)) {
error = EINVAL;
goto bad;
}
#endif
if (!memcmp(&ifp->if_bridgeport, mtag + 1,
sizeof(caddr_t)))
break;
}
if (mtag == NULL) {
/* Attach a tag so we can detect loops */
mtag = m_tag_get(PACKET_TAG_BRIDGE, sizeof(caddr_t),
M_NOWAIT);
if (mtag == NULL) {
error = ENOBUFS;
goto bad;
}
memcpy(mtag + 1, &ifp->if_bridgeport, sizeof(caddr_t));
m_tag_prepend(m, mtag);
error = bridge_output(ifp, m, NULL, NULL);
return (error);
}
}
#endif
mflags = m->m_flags;
len = m->m_pkthdr.len;
s = splnet();
/*
* Queue message on interface, and start output if interface
* not yet active.
*/
IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
if (error) {
/* mbuf is already freed */
splx(s);
return (error);
}
ifp->if_obytes += len;
#if NCARP > 0
if (ifp != ifp0)
ifp0->if_obytes += len;
#endif /* NCARP > 0 */
if (mflags & M_MCAST)
ifp->if_omcasts++;
if_start(ifp);
splx(s);
return (error);
bad:
if (m)
m_freem(m);
return (error);
}
static int
readmbox(char *box)
{
int fd, i, n, nd, lines, pid;
char buf[100], err[Errlen];
char *p;
Biobuf *b;
Dir *d, *draw;
Msg *m;
Waitmsg *w;
unmount(nil, "/mail/fs");
switch(pid = fork()){
case -1:
return senderr("can't fork to start upas/fs");
case 0:
close(0);
close(1);
open("/dev/null", OREAD);
open("/dev/null", OWRITE);
execl("/bin/upas/fs", "upas/fs", "-np", "-f", box, nil);
snprint(err, sizeof err, "upas/fs: %r");
_exits(err);
break;
default:
break;
}
if((w = wait()) == nil || w->pid != pid || w->msg[0] != '\0'){
if(w && w->pid==pid)
return senderr("%s", w->msg);
else
return senderr("can't initialize upas/fs");
}
free(w);
if(chdir("/mail/fs/mbox") < 0)
return senderr("can't initialize upas/fs: %r");
if((fd = open(".", OREAD)) < 0)
return senderr("cannot open /mail/fs/mbox: %r");
nd = dirreadall(fd, &d);
close(fd);
if(nd < 0)
return senderr("cannot read from /mail/fs/mbox: %r");
msg = mallocz(sizeof(Msg)*nd, 1);
if(msg == nil)
return senderr("out of memory");
if(nd == 0)
return 0;
qsort(d, nd, sizeof(d[0]), dircmp);
for(i=0; i<nd; i++){
m = &msg[nmsg];
m->upasnum = atoi(d[i].name);
sprint(buf, "%d/digest", m->upasnum);
if((fd = open(buf, OREAD)) < 0)
continue;
n = readn(fd, m->digest, sizeof m->digest - 1);
close(fd);
if(n < 0)
continue;
m->digest[n] = '\0';
/*
* We need the number of message lines so that we
* can adjust the byte count to include \r's.
* Upas/fs gives us the number of lines in the raw body
* in the lines file, but we have to count rawheader ourselves.
* There is one blank line between raw header and raw body.
*/
sprint(buf, "%d/rawheader", m->upasnum);
if((b = Bopen(buf, OREAD)) == nil)
continue;
lines = 0;
for(;;){
p = Brdline(b, '\n');
if(p == nil){
if((n = Blinelen(b)) == 0)
break;
Bseek(b, n, 1);
}else
lines++;
}
Bterm(b);
lines++;
sprint(buf, "%d/lines", m->upasnum);
if((fd = open(buf, OREAD)) < 0)
continue;
n = readn(fd, buf, sizeof buf - 1);
close(fd);
if(n < 0)
continue;
buf[n] = '\0';
lines += atoi(buf);
sprint(buf, "%d/raw", m->upasnum);
if((draw = dirstat(buf)) == nil)
continue;
m->bytes = lines+draw->length;
free(draw);
nmsg++;
totalmsgs++;
totalbytes += m->bytes;
}
return 0;
}
void
main(int argc, char **argv)
{
int fd;
char *arg, cmdbuf[1024];
Cmd *c;
rfork(RFNAMEG);
Binit(&in, 0, OREAD);
Binit(&out, 1, OWRITE);
ARGBEGIN{
case 'a':
loggedin = 1;
if(readmbox(EARGF(usage())) < 0)
exits(nil);
break;
case 'd':
debug++;
if((fd = create(EARGF(usage()), OWRITE, 0666)) >= 0 && fd != 2){
dup(fd, 2);
close(fd);
}
break;
case 'p':
passwordinclear = 1;
break;
case 'r':
strecpy(tmpaddr, tmpaddr+sizeof tmpaddr, EARGF(usage()));
if(arg = strchr(tmpaddr, '!'))
*arg = '\0';
peeraddr = tmpaddr;
break;
case 't':
tlscert = readcert(EARGF(usage()), &ntlscert);
if(tlscert == nil){
senderr("cannot read TLS certificate: %r");
exits(nil);
}
break;
}ARGEND
/* do before TLS */
if(peeraddr == nil)
peeraddr = remoteaddr(0,0);
hello();
while(Bflush(&out), getcrnl(cmdbuf, sizeof cmdbuf) > 0){
arg = nextarg(cmdbuf);
for(c=cmdtab; c->name; c++)
if(cistrcmp(c->name, cmdbuf) == 0)
break;
if(c->name == 0){
senderr("unknown command %s", cmdbuf);
continue;
}
if(c->needauth && !loggedin){
senderr("%s requires authentication", cmdbuf);
continue;
}
(*c->f)(arg);
}
exits(nil);
}
/*
* FDDI output routine.
* Encapsulate a packet of type family for the local net.
* Use trailer local net encapsulation if enough data in first
* packet leaves a multiple of 512 bytes of data in remainder.
* Assumes that ifp is actually pointer to arpcom structure.
*/
static int
fddi_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
struct route *ro)
{
u_int16_t type;
int loop_copy = 0, error = 0, hdrcmplt = 0;
u_char esrc[FDDI_ADDR_LEN], edst[FDDI_ADDR_LEN];
struct fddi_header *fh;
#if defined(INET) || defined(INET6)
struct llentry *lle;
#endif
#ifdef MAC
error = mac_ifnet_check_transmit(ifp, m);
if (error)
senderr(error);
#endif
if (ifp->if_flags & IFF_MONITOR)
senderr(ENETDOWN);
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
senderr(ENETDOWN);
getmicrotime(&ifp->if_lastchange);
switch (dst->sa_family) {
#ifdef INET
case AF_INET: {
struct rtentry *rt0 = NULL;
if (ro != NULL)
rt0 = ro->ro_rt;
error = arpresolve(ifp, rt0, m, dst, edst, &lle);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
type = htons(ETHERTYPE_IP);
break;
}
case AF_ARP:
{
struct arphdr *ah;
ah = mtod(m, struct arphdr *);
ah->ar_hrd = htons(ARPHRD_ETHER);
loop_copy = -1; /* if this is for us, don't do it */
switch (ntohs(ah->ar_op)) {
case ARPOP_REVREQUEST:
case ARPOP_REVREPLY:
type = htons(ETHERTYPE_REVARP);
break;
case ARPOP_REQUEST:
case ARPOP_REPLY:
default:
type = htons(ETHERTYPE_ARP);
break;
}
if (m->m_flags & M_BCAST)
bcopy(ifp->if_broadcastaddr, edst, FDDI_ADDR_LEN);
else
bcopy(ar_tha(ah), edst, FDDI_ADDR_LEN);
}
break;
#endif /* INET */
#ifdef INET6
case AF_INET6:
error = nd6_storelladdr(ifp, m, dst, (u_char *)edst, &lle);
if (error)
return (error); /* Something bad happened */
type = htons(ETHERTYPE_IPV6);
break;
#endif /* INET6 */
#ifdef IPX
case AF_IPX:
type = htons(ETHERTYPE_IPX);
bcopy(&((const struct sockaddr_ipx *)dst)->sipx_addr.x_host,
edst, FDDI_ADDR_LEN);
break;
#endif /* IPX */
#ifdef NETATALK
case AF_APPLETALK: {
struct at_ifaddr *aa;
if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst))
return (0);
/*
* ifaddr is the first thing in at_ifaddr
*/
if ((aa = at_ifawithnet((const struct sockaddr_at *)dst)) == 0)
goto bad;
/*
* In the phase 2 case, we need to prepend an mbuf for the llc header.
* Since we must preserve the value of m, which is passed to us by
* value, we m_copy() the first mbuf, and use it for our llc header.
*/
if (aa->aa_flags & AFA_PHASE2) {
struct llc llc;
M_PREPEND(m, LLC_SNAPFRAMELEN, M_WAITOK);
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
llc.llc_control = LLC_UI;
bcopy(at_org_code, llc.llc_snap.org_code, sizeof(at_org_code));
llc.llc_snap.ether_type = htons(ETHERTYPE_AT);
bcopy(&llc, mtod(m, caddr_t), LLC_SNAPFRAMELEN);
type = 0;
} else {
type = htons(ETHERTYPE_AT);
}
ifa_free(&aa->aa_ifa);
break;
}
#endif /* NETATALK */
case pseudo_AF_HDRCMPLT:
{
const struct ether_header *eh;
hdrcmplt = 1;
eh = (const struct ether_header *)dst->sa_data;
bcopy(eh->ether_shost, esrc, FDDI_ADDR_LEN);
/* FALLTHROUGH */
}
case AF_UNSPEC:
{
const struct ether_header *eh;
loop_copy = -1;
eh = (const struct ether_header *)dst->sa_data;
bcopy(eh->ether_dhost, edst, FDDI_ADDR_LEN);
if (*edst & 1)
m->m_flags |= (M_BCAST|M_MCAST);
type = eh->ether_type;
break;
}
case AF_IMPLINK:
{
fh = mtod(m, struct fddi_header *);
error = EPROTONOSUPPORT;
switch (fh->fddi_fc & (FDDIFC_C|FDDIFC_L|FDDIFC_F)) {
case FDDIFC_LLC_ASYNC: {
/* legal priorities are 0 through 7 */
if ((fh->fddi_fc & FDDIFC_Z) > 7)
goto bad;
break;
}
case FDDIFC_LLC_SYNC: {
/* FDDIFC_Z bits reserved, must be zero */
if (fh->fddi_fc & FDDIFC_Z)
goto bad;
break;
}
case FDDIFC_SMT: {
/* FDDIFC_Z bits must be non zero */
if ((fh->fddi_fc & FDDIFC_Z) == 0)
goto bad;
break;
}
default: {
/* anything else is too dangerous */
goto bad;
}
}
error = 0;
if (fh->fddi_dhost[0] & 1)
m->m_flags |= (M_BCAST|M_MCAST);
goto queue_it;
}
default:
if_printf(ifp, "can't handle af%d\n", dst->sa_family);
senderr(EAFNOSUPPORT);
}
/*
* Add LLC header.
*/
if (type != 0) {
struct llc *l;
M_PREPEND(m, LLC_SNAPFRAMELEN, M_NOWAIT);
if (m == 0)
senderr(ENOBUFS);
l = mtod(m, struct llc *);
l->llc_control = LLC_UI;
l->llc_dsap = l->llc_ssap = LLC_SNAP_LSAP;
l->llc_snap.org_code[0] =
l->llc_snap.org_code[1] =
l->llc_snap.org_code[2] = 0;
l->llc_snap.ether_type = htons(type);
}
/*
* Add local net header. If no space in first mbuf,
* allocate another.
*/
M_PREPEND(m, FDDI_HDR_LEN, M_NOWAIT);
if (m == 0)
senderr(ENOBUFS);
fh = mtod(m, struct fddi_header *);
fh->fddi_fc = FDDIFC_LLC_ASYNC|FDDIFC_LLC_PRIO4;
bcopy((caddr_t)edst, (caddr_t)fh->fddi_dhost, FDDI_ADDR_LEN);
queue_it:
if (hdrcmplt)
bcopy((caddr_t)esrc, (caddr_t)fh->fddi_shost, FDDI_ADDR_LEN);
else
bcopy(IF_LLADDR(ifp), (caddr_t)fh->fddi_shost,
FDDI_ADDR_LEN);
/*
* If a simplex interface, and the packet is being sent to our
* Ethernet address or a broadcast address, loopback a copy.
* XXX To make a simplex device behave exactly like a duplex
* device, we should copy in the case of sending to our own
* ethernet address (thus letting the original actually appear
* on the wire). However, we don't do that here for security
* reasons and compatibility with the original behavior.
*/
if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
struct mbuf *n;
n = m_copy(m, 0, (int)M_COPYALL);
(void) if_simloop(ifp, n, dst->sa_family,
FDDI_HDR_LEN);
} else if (bcmp(fh->fddi_dhost, fh->fddi_shost,
FDDI_ADDR_LEN) == 0) {
(void) if_simloop(ifp, m, dst->sa_family,
FDDI_HDR_LEN);
return (0); /* XXX */
}
}
error = (ifp->if_transmit)(ifp, m);
if (error)
ifp->if_oerrors++;
return (error);
bad:
ifp->if_oerrors++;
if (m)
m_freem(m);
return (error);
}
static int
ieee1394_output(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst,
const struct rtentry *rt)
{
uint16_t etype = 0;
struct mbuf *m;
int hdrlen, error = 0;
struct mbuf *mcopy = NULL;
struct ieee1394_hwaddr *hwdst, baddr;
const struct ieee1394_hwaddr *myaddr;
#ifdef INET
struct arphdr *ah;
#endif /* INET */
struct m_tag *mtag;
int unicast;
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
senderr(ENETDOWN);
/*
* If the queueing discipline needs packet classification,
* do it before prepending link headers.
*/
IFQ_CLASSIFY(&ifp->if_snd, m0, dst->sa_family);
/*
* For unicast, we make a tag to store the lladdr of the
* destination. This might not be the first time we have seen
* the packet (for instance, the arp code might be trying to
* re-send it after receiving an arp reply) so we only
* allocate a tag if there isn't one there already. For
* multicast, we will eventually use a different tag to store
* the channel number.
*/
unicast = !(m0->m_flags & (M_BCAST | M_MCAST));
if (unicast) {
mtag =
m_tag_find(m0, MTAG_FIREWIRE_HWADDR, NULL);
if (!mtag) {
mtag = m_tag_get(MTAG_FIREWIRE_HWADDR,
sizeof (struct ieee1394_hwaddr), M_NOWAIT);
if (!mtag) {
error = ENOMEM;
goto bad;
}
m_tag_prepend(m0, mtag);
}
hwdst = (struct ieee1394_hwaddr *)(mtag + 1);
} else {
hwdst = &baddr;
}
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
if (unicast &&
(error = arpresolve(ifp, rt, m0, dst, hwdst,
sizeof(*hwdst))) != 0)
return error == EWOULDBLOCK ? 0 : error;
/* if broadcasting on a simplex interface, loopback a copy */
if ((m0->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
mcopy = m_copy(m0, 0, M_COPYALL);
etype = htons(ETHERTYPE_IP);
break;
case AF_ARP:
ah = mtod(m0, struct arphdr *);
ah->ar_hrd = htons(ARPHRD_IEEE1394);
etype = htons(ETHERTYPE_ARP);
break;
#endif /* INET */
#ifdef INET6
case AF_INET6:
if (unicast && (!nd6_storelladdr(ifp, rt, m0, dst,
hwdst->iha_uid, IEEE1394_ADDR_LEN))) {
/* something bad happened */
return 0;
}
etype = htons(ETHERTYPE_IPV6);
break;
#endif /* INET6 */
case pseudo_AF_HDRCMPLT:
case AF_UNSPEC:
/* TODO? */
default:
printf("%s: can't handle af%d\n", ifp->if_xname,
dst->sa_family);
senderr(EAFNOSUPPORT);
break;
}
if (mcopy)
looutput(ifp, mcopy, dst, rt);
myaddr = (const struct ieee1394_hwaddr *)CLLADDR(ifp->if_sadl);
if (ifp->if_bpf) {
struct ieee1394_bpfhdr h;
if (unicast)
memcpy(h.ibh_dhost, hwdst->iha_uid, 8);
else
memcpy(h.ibh_dhost,
((const struct ieee1394_hwaddr *)
ifp->if_broadcastaddr)->iha_uid, 8);
memcpy(h.ibh_shost, myaddr->iha_uid, 8);
h.ibh_type = etype;
bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m0);
}
if ((ifp->if_flags & IFF_SIMPLEX) &&
unicast &&
memcmp(hwdst, myaddr, IEEE1394_ADDR_LEN) == 0)
return looutput(ifp, m0, dst, rt);
/*
* XXX:
* The maximum possible rate depends on the topology.
* So the determination of maxrec and fragmentation should be
* called from the driver after probing the topology map.
*/
if (unicast) {
hdrlen = IEEE1394_GASP_LEN;
hwdst->iha_speed = 0; /* XXX */
} else
hdrlen = 0;
if (hwdst->iha_speed > myaddr->iha_speed)
hwdst->iha_speed = myaddr->iha_speed;
if (hwdst->iha_maxrec > myaddr->iha_maxrec)
hwdst->iha_maxrec = myaddr->iha_maxrec;
if (hwdst->iha_maxrec > (8 + hwdst->iha_speed))
hwdst->iha_maxrec = 8 + hwdst->iha_speed;
if (hwdst->iha_maxrec < 8)
hwdst->iha_maxrec = 8;
m0 = ieee1394_fragment(ifp, m0, (2<<hwdst->iha_maxrec) - hdrlen, etype);
if (m0 == NULL)
senderr(ENOBUFS);
while ((m = m0) != NULL) {
m0 = m->m_nextpkt;
error = if_transmit_lock(ifp, m);
if (error) {
/* mbuf is already freed */
goto bad;
}
}
return 0;
bad:
while (m0 != NULL) {
m = m0->m_nextpkt;
m_freem(m0);
m0 = m;
}
return error;
}
/*
* ARCnet output routine.
* Encapsulate a packet of type family for the local net.
* Assumes that ifp is actually pointer to arccom structure.
*/
int
arc_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
struct route *ro)
{
struct arc_header *ah;
int error;
u_int8_t atype, adst;
int loop_copy = 0;
int isphds;
#if defined(INET) || defined(INET6)
struct llentry *lle;
#endif
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
return(ENETDOWN); /* m, m1 aren't initialized yet */
error = 0;
switch (dst->sa_family) {
#ifdef INET
case AF_INET:
/*
* For now, use the simple IP addr -> ARCnet addr mapping
*/
if (m->m_flags & (M_BCAST|M_MCAST))
adst = arcbroadcastaddr; /* ARCnet broadcast address */
else if (ifp->if_flags & IFF_NOARP)
adst = ntohl(SIN(dst)->sin_addr.s_addr) & 0xFF;
else {
error = arpresolve(ifp, ro ? ro->ro_rt : NULL,
m, dst, &adst, &lle);
if (error)
return (error == EWOULDBLOCK ? 0 : error);
}
atype = (ifp->if_flags & IFF_LINK0) ?
ARCTYPE_IP_OLD : ARCTYPE_IP;
break;
case AF_ARP:
{
struct arphdr *ah;
ah = mtod(m, struct arphdr *);
ah->ar_hrd = htons(ARPHRD_ARCNET);
loop_copy = -1; /* if this is for us, don't do it */
switch(ntohs(ah->ar_op)) {
case ARPOP_REVREQUEST:
case ARPOP_REVREPLY:
atype = ARCTYPE_REVARP;
break;
case ARPOP_REQUEST:
case ARPOP_REPLY:
default:
atype = ARCTYPE_ARP;
break;
}
if (m->m_flags & M_BCAST)
bcopy(ifp->if_broadcastaddr, &adst, ARC_ADDR_LEN);
else
bcopy(ar_tha(ah), &adst, ARC_ADDR_LEN);
}
break;
#endif
#ifdef INET6
case AF_INET6:
error = nd6_storelladdr(ifp, m, dst, (u_char *)&adst, &lle);
if (error)
return (error);
atype = ARCTYPE_INET6;
break;
#endif
#ifdef IPX
case AF_IPX:
adst = SIPX(dst)->sipx_addr.x_host.c_host[5];
atype = ARCTYPE_IPX;
if (adst == 0xff)
adst = arcbroadcastaddr;
break;
#endif
case AF_UNSPEC:
loop_copy = -1;
ah = (struct arc_header *)dst->sa_data;
adst = ah->arc_dhost;
atype = ah->arc_type;
if (atype == ARCTYPE_ARP) {
atype = (ifp->if_flags & IFF_LINK0) ?
ARCTYPE_ARP_OLD: ARCTYPE_ARP;
#ifdef ARCNET_ALLOW_BROKEN_ARP
/*
* XXX It's not clear per RFC826 if this is needed, but
* "assigned numbers" say this is wrong.
* However, e.g., AmiTCP 3.0Beta used it... we make this
* switchable for emergency cases. Not perfect, but...
*/
if (ifp->if_flags & IFF_LINK2)
mtod(m, struct arphdr *)->ar_pro = atype - 1;
#endif
}
break;
default:
if_printf(ifp, "can't handle af%d\n", dst->sa_family);
senderr(EAFNOSUPPORT);
}
isphds = arc_isphds(atype);
M_PREPEND(m, isphds ? ARC_HDRNEWLEN : ARC_HDRLEN, M_DONTWAIT);
if (m == 0)
senderr(ENOBUFS);
ah = mtod(m, struct arc_header *);
ah->arc_type = atype;
ah->arc_dhost = adst;
ah->arc_shost = ARC_LLADDR(ifp);
if (isphds) {
ah->arc_flag = 0;
ah->arc_seqid = 0;
}
if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
(void) if_simloop(ifp, n, dst->sa_family, ARC_HDRLEN);
} else if (ah->arc_dhost == ah->arc_shost) {
(void) if_simloop(ifp, m, dst->sa_family, ARC_HDRLEN);
return (0); /* XXX */
}
}
BPF_MTAP(ifp, m);
error = ifp->if_transmit(ifp, m);
return (error);
bad:
if (m)
m_freem(m);
return (error);
}
/*
* atm_output: ATM output routine
* inputs:
* "ifp" = ATM interface to output to
* "m0" = the packet to output
* "dst" = the sockaddr to send to (either IP addr, or raw VPI/VCI)
* "ro" = the route to use
* returns: error code [0 == ok]
*
* note: special semantic: if (dst == NULL) then we assume "m" already
* has an atm_pseudohdr on it and just send it directly.
* [for native mode ATM output] if dst is null, then
* ro->ro_rt must also be NULL.
*/
int
atm_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
struct route *ro)
{
u_int16_t etype = 0; /* if using LLC/SNAP */
int error = 0, sz;
struct atm_pseudohdr atmdst, *ad;
struct mbuf *m = m0;
struct atmllc *atmllc;
struct atmllc *llc_hdr = NULL;
u_int32_t atm_flags;
#ifdef MAC
error = mac_ifnet_check_transmit(ifp, m);
if (error)
senderr(error);
#endif
if (!((ifp->if_flags & IFF_UP) &&
(ifp->if_drv_flags & IFF_DRV_RUNNING)))
senderr(ENETDOWN);
/*
* check for non-native ATM traffic (dst != NULL)
*/
if (dst) {
switch (dst->sa_family) {
#if defined(INET) || defined(INET6)
case AF_INET:
case AF_INET6:
{
if (dst->sa_family == AF_INET6)
etype = ETHERTYPE_IPV6;
else
etype = ETHERTYPE_IP;
if (!atmresolve(ro->ro_rt, m, dst, &atmdst)) {
m = NULL;
/* XXX: atmresolve already free'd it */
senderr(EHOSTUNREACH);
/* XXX: put ATMARP stuff here */
/* XXX: watch who frees m on failure */
}
}
break;
#endif /* INET || INET6 */
case AF_UNSPEC:
/*
* XXX: bpfwrite. assuming dst contains 12 bytes
* (atm pseudo header (4) + LLC/SNAP (8))
*/
bcopy(dst->sa_data, &atmdst, sizeof(atmdst));
llc_hdr = (struct atmllc *)(dst->sa_data +
sizeof(atmdst));
break;
default:
printf("%s: can't handle af%d\n", ifp->if_xname,
dst->sa_family);
senderr(EAFNOSUPPORT);
}
/*
* must add atm_pseudohdr to data
*/
sz = sizeof(atmdst);
atm_flags = ATM_PH_FLAGS(&atmdst);
if (atm_flags & ATM_PH_LLCSNAP)
sz += 8; /* sizeof snap == 8 */
M_PREPEND(m, sz, M_NOWAIT);
if (m == 0)
senderr(ENOBUFS);
ad = mtod(m, struct atm_pseudohdr *);
*ad = atmdst;
if (atm_flags & ATM_PH_LLCSNAP) {
atmllc = (struct atmllc *)(ad + 1);
if (llc_hdr == NULL) {
bcopy(ATMLLC_HDR, atmllc->llchdr,
sizeof(atmllc->llchdr));
/* note: in host order */
ATM_LLC_SETTYPE(atmllc, etype);
}
else
bcopy(llc_hdr, atmllc, sizeof(struct atmllc));
}
}
if (ng_atm_output_p != NULL) {
if ((error = (*ng_atm_output_p)(ifp, &m)) != 0) {
if (m != NULL)
m_freem(m);
return (error);
}
if (m == NULL)
return (0);
}
/*
* Queue message on interface, and start output if interface
* not yet active.
*/
if (!IF_HANDOFF_ADJ(&ifp->if_snd, m, ifp,
-(int)sizeof(struct atm_pseudohdr)))
return (ENOBUFS);
return (error);
bad:
if (m)
m_freem(m);
return (error);
}
int
rtrequest1(int req, struct rt_addrinfo *info, u_int8_t prio,
struct rtentry **ret_nrt, u_int tableid)
{
int s = splsoftnet(); int error = 0;
struct rtentry *rt, *crt;
struct radix_node *rn;
struct radix_node_head *rnh;
struct ifaddr *ifa;
struct sockaddr *ndst;
struct sockaddr_rtlabel *sa_rl, sa_rl2;
#ifdef MPLS
struct sockaddr_mpls *sa_mpls;
#endif
#define senderr(x) { error = x ; goto bad; }
if ((rnh = rt_gettable(info->rti_info[RTAX_DST]->sa_family, tableid)) ==
NULL)
senderr(EAFNOSUPPORT);
if (info->rti_flags & RTF_HOST)
info->rti_info[RTAX_NETMASK] = NULL;
switch (req) {
case RTM_DELETE:
if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) == NULL)
senderr(ESRCH);
rt = (struct rtentry *)rn;
#ifndef SMALL_KERNEL
/*
* if we got multipath routes, we require users to specify
* a matching RTAX_GATEWAY.
*/
if (rn_mpath_capable(rnh)) {
rt = rt_mpath_matchgate(rt,
info->rti_info[RTAX_GATEWAY], prio);
rn = (struct radix_node *)rt;
if (!rt)
senderr(ESRCH);
}
#endif
if ((rn = rnh->rnh_deladdr(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh, rn)) == NULL)
senderr(ESRCH);
rt = (struct rtentry *)rn;
/* clean up any cloned children */
if ((rt->rt_flags & RTF_CLONING) != 0)
rtflushclone(rnh, rt);
if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
panic ("rtrequest delete");
if (rt->rt_gwroute) {
rt = rt->rt_gwroute; RTFREE(rt);
(rt = (struct rtentry *)rn)->rt_gwroute = NULL;
}
if (rt->rt_parent) {
rt->rt_parent->rt_refcnt--;
rt->rt_parent = NULL;
}
#ifndef SMALL_KERNEL
if (rn_mpath_capable(rnh)) {
if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) != NULL &&
rn_mpath_next(rn, 0) == NULL)
((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
}
#endif
rt->rt_flags &= ~RTF_UP;
if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
ifa->ifa_rtrequest(RTM_DELETE, rt, info);
rttrash++;
if (ret_nrt)
*ret_nrt = rt;
else if (rt->rt_refcnt <= 0) {
rt->rt_refcnt++;
rtfree(rt);
}
break;
case RTM_RESOLVE:
if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
senderr(EINVAL);
if ((rt->rt_flags & RTF_CLONING) == 0)
senderr(EINVAL);
ifa = rt->rt_ifa;
info->rti_flags = rt->rt_flags & ~(RTF_CLONING | RTF_STATIC);
info->rti_flags |= RTF_CLONED;
info->rti_info[RTAX_GATEWAY] = rt->rt_gateway;
if ((info->rti_info[RTAX_NETMASK] = rt->rt_genmask) == NULL)
info->rti_flags |= RTF_HOST;
info->rti_info[RTAX_LABEL] =
rtlabel_id2sa(rt->rt_labelid, &sa_rl2);
goto makeroute;
case RTM_ADD:
if (info->rti_ifa == 0 && (error = rt_getifa(info, tableid)))
senderr(error);
ifa = info->rti_ifa;
makeroute:
rt = pool_get(&rtentry_pool, PR_NOWAIT | PR_ZERO);
if (rt == NULL)
senderr(ENOBUFS);
rt->rt_flags = info->rti_flags;
if (prio == 0)
prio = ifa->ifa_ifp->if_priority + RTP_STATIC;
rt->rt_priority = prio; /* init routing priority */
if ((LINK_STATE_IS_UP(ifa->ifa_ifp->if_link_state) ||
ifa->ifa_ifp->if_link_state == LINK_STATE_UNKNOWN) &&
ifa->ifa_ifp->if_flags & IFF_UP)
rt->rt_flags |= RTF_UP;
else {
rt->rt_flags &= ~RTF_UP;
rt->rt_priority |= RTP_DOWN;
}
LIST_INIT(&rt->rt_timer);
if (rt_setgate(rt, info->rti_info[RTAX_DST],
info->rti_info[RTAX_GATEWAY], tableid)) {
pool_put(&rtentry_pool, rt);
senderr(ENOBUFS);
}
ndst = rt_key(rt);
if (info->rti_info[RTAX_NETMASK] != NULL) {
rt_maskedcopy(info->rti_info[RTAX_DST], ndst,
info->rti_info[RTAX_NETMASK]);
} else
Bcopy(info->rti_info[RTAX_DST], ndst,
info->rti_info[RTAX_DST]->sa_len);
#ifndef SMALL_KERNEL
/* do not permit exactly the same dst/mask/gw pair */
if (rn_mpath_capable(rnh) &&
rt_mpath_conflict(rnh, rt, info->rti_info[RTAX_NETMASK],
info->rti_flags & RTF_MPATH)) {
if (rt->rt_gwroute)
rtfree(rt->rt_gwroute);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
senderr(EEXIST);
}
#endif
if (info->rti_info[RTAX_LABEL] != NULL) {
sa_rl = (struct sockaddr_rtlabel *)
info->rti_info[RTAX_LABEL];
rt->rt_labelid = rtlabel_name2id(sa_rl->sr_label);
}
#ifdef MPLS
/* We have to allocate additional space for MPLS infos */
if (info->rti_info[RTAX_SRC] != NULL ||
info->rti_info[RTAX_DST]->sa_family == AF_MPLS) {
struct rt_mpls *rt_mpls;
sa_mpls = (struct sockaddr_mpls *)
info->rti_info[RTAX_SRC];
rt->rt_llinfo = (caddr_t)malloc(sizeof(struct rt_mpls),
M_TEMP, M_NOWAIT|M_ZERO);
if (rt->rt_llinfo == NULL) {
if (rt->rt_gwroute)
rtfree(rt->rt_gwroute);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
senderr(ENOMEM);
}
rt_mpls = (struct rt_mpls *)rt->rt_llinfo;
if (sa_mpls != NULL)
rt_mpls->mpls_label = sa_mpls->smpls_label;
rt_mpls->mpls_operation = info->rti_mpls;
/* XXX: set experimental bits */
rt->rt_flags |= RTF_MPLS;
}
#endif
ifa->ifa_refcnt++;
rt->rt_ifa = ifa;
rt->rt_ifp = ifa->ifa_ifp;
if (req == RTM_RESOLVE) {
/*
* Copy both metrics and a back pointer to the cloned
* route's parent.
*/
rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
rt->rt_priority = (*ret_nrt)->rt_priority;
rt->rt_parent = *ret_nrt; /* Back ptr. to parent. */
rt->rt_parent->rt_refcnt++;
}
rn = rnh->rnh_addaddr((caddr_t)ndst,
(caddr_t)info->rti_info[RTAX_NETMASK], rnh, rt->rt_nodes,
rt->rt_priority);
if (rn == NULL && (crt = rtalloc1(ndst, 0, tableid)) != NULL) {
/* overwrite cloned route */
if ((crt->rt_flags & RTF_CLONED) != 0) {
rtdeletemsg(crt, tableid);
rn = rnh->rnh_addaddr((caddr_t)ndst,
(caddr_t)info->rti_info[RTAX_NETMASK],
rnh, rt->rt_nodes, rt->rt_priority);
}
RTFREE(crt);
}
if (rn == 0) {
IFAFREE(ifa);
if ((rt->rt_flags & RTF_CLONED) != 0 && rt->rt_parent)
rtfree(rt->rt_parent);
if (rt->rt_gwroute)
rtfree(rt->rt_gwroute);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
senderr(EEXIST);
}
#ifndef SMALL_KERNEL
if (rn_mpath_capable(rnh) &&
(rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK], rnh)) != NULL &&
(rn = rn_mpath_prio(rn, prio)) != NULL) {
if (rn_mpath_next(rn, 0) == NULL)
((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
else
((struct rtentry *)rn)->rt_flags |= RTF_MPATH;
}
#endif
if (ifa->ifa_rtrequest)
ifa->ifa_rtrequest(req, rt, info);
if (ret_nrt) {
*ret_nrt = rt;
rt->rt_refcnt++;
}
if ((rt->rt_flags & RTF_CLONING) != 0) {
/* clean up any cloned children */
rtflushclone(rnh, rt);
}
if_group_routechange(info->rti_info[RTAX_DST],
info->rti_info[RTAX_NETMASK]);
break;
}
bad:
splx(s);
return (error);
}
__private_extern__ errno_t
arp_route_to_gateway_route(const struct sockaddr *net_dest, route_t hint0,
route_t *out_route)
{
struct timeval timenow;
route_t rt = hint0, hint = hint0;
errno_t error = 0;
*out_route = NULL;
/*
* Next hop determination. Because we may involve the gateway route
* in addition to the original route, locking is rather complicated.
* The general concept is that regardless of whether the route points
* to the original route or to the gateway route, this routine takes
* an extra reference on such a route. This extra reference will be
* released at the end.
*
* Care must be taken to ensure that the "hint0" route never gets freed
* via rtfree(), since the caller may have stored it inside a struct
* route with a reference held for that placeholder.
*/
if (rt != NULL) {
unsigned int ifindex;
RT_LOCK_SPIN(rt);
ifindex = rt->rt_ifp->if_index;
RT_ADDREF_LOCKED(rt);
if (!(rt->rt_flags & RTF_UP)) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
/* route is down, find a new one */
hint = rt = rtalloc1_scoped((struct sockaddr *)
(size_t)net_dest, 1, 0, ifindex);
if (hint != NULL) {
RT_LOCK_SPIN(rt);
ifindex = rt->rt_ifp->if_index;
} else {
senderr(EHOSTUNREACH);
}
}
/*
* We have a reference to "rt" by now; it will either
* be released or freed at the end of this routine.
*/
RT_LOCK_ASSERT_HELD(rt);
if (rt->rt_flags & RTF_GATEWAY) {
struct rtentry *gwrt = rt->rt_gwroute;
struct sockaddr_in gw;
/* If there's no gateway rt, look it up */
if (gwrt == NULL) {
gw = *((struct sockaddr_in *)rt->rt_gateway);
RT_UNLOCK(rt);
goto lookup;
}
/* Become a regular mutex */
RT_CONVERT_LOCK(rt);
/*
* Take gwrt's lock while holding route's lock;
* this is okay since gwrt never points back
* to "rt", so no lock ordering issues.
*/
RT_LOCK_SPIN(gwrt);
if (!(gwrt->rt_flags & RTF_UP)) {
struct rtentry *ogwrt;
rt->rt_gwroute = NULL;
RT_UNLOCK(gwrt);
gw = *((struct sockaddr_in *)rt->rt_gateway);
RT_UNLOCK(rt);
rtfree(gwrt);
lookup:
gwrt = rtalloc1_scoped(
(struct sockaddr *)&gw, 1, 0, ifindex);
RT_LOCK(rt);
/*
* Bail out if the route is down, no route
* to gateway, circular route, or if the
* gateway portion of "rt" has changed.
*/
if (!(rt->rt_flags & RTF_UP) ||
gwrt == NULL || gwrt == rt ||
!equal(SA(&gw), rt->rt_gateway)) {
if (gwrt == rt) {
RT_REMREF_LOCKED(gwrt);
gwrt = NULL;
}
RT_UNLOCK(rt);
if (gwrt != NULL)
rtfree(gwrt);
senderr(EHOSTUNREACH);
}
/* Remove any existing gwrt */
ogwrt = rt->rt_gwroute;
if ((rt->rt_gwroute = gwrt) != NULL)
RT_ADDREF(gwrt);
/* Clean up "rt" now while we can */
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
rt = gwrt;
/* Now free the replaced gwrt */
if (ogwrt != NULL)
rtfree(ogwrt);
/* If still no route to gateway, bail out */
if (rt == NULL)
senderr(EHOSTUNREACH);
} else {
RT_ADDREF_LOCKED(gwrt);
RT_UNLOCK(gwrt);
/* Clean up "rt" now while we can */
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
rt = gwrt;
}
/* rt == gwrt; if it is now down, give up */
RT_LOCK_SPIN(rt);
if (!(rt->rt_flags & RTF_UP)) {
RT_UNLOCK(rt);
senderr(EHOSTUNREACH);
}
}
if (rt->rt_flags & RTF_REJECT) {
getmicrotime(&timenow);
if (rt->rt_rmx.rmx_expire == 0 ||
timenow.tv_sec < rt->rt_rmx.rmx_expire) {
RT_UNLOCK(rt);
senderr(rt == hint ? EHOSTDOWN : EHOSTUNREACH);
}
}
/* Become a regular mutex */
RT_CONVERT_LOCK(rt);
/* Caller is responsible for cleaning up "rt" */
*out_route = rt;
}
return (0);
bad:
/* Clean up route (either it is "rt" or "gwrt") */
if (rt != NULL) {
RT_LOCK_SPIN(rt);
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
}
return (error);
}