void
udp_ctlinput(netmsg_t msg)
{
struct sockaddr *sa = msg->ctlinput.nm_arg;
struct ip *ip = msg->ctlinput.nm_extra;
int cmd = msg->ctlinput.nm_cmd, cpuid;
inp_notify_t notify;
struct in_addr faddr;
notify = udp_get_inpnotify(cmd, sa, &ip, &cpuid);
if (notify == NULL)
goto done;
faddr = ((struct sockaddr_in *)sa)->sin_addr;
if (ip) {
const struct udphdr *uh;
struct inpcb *inp;
if (cpuid != mycpuid)
goto done;
uh = (const struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
inp = in_pcblookup_hash(&udbinfo[mycpuid], faddr, uh->uh_dport,
ip->ip_src, uh->uh_sport, 0, NULL);
if (inp != NULL && inp->inp_socket != NULL)
notify(inp, inetctlerrmap[cmd]);
} else if (msg->ctlinput.nm_direct) {
if (cpuid != ncpus && cpuid != mycpuid)
goto done;
if (mycpuid >= ncpus2)
goto done;
in_pcbnotifyall(&udbinfo[mycpuid], faddr, inetctlerrmap[cmd],
notify);
} else {
struct netmsg_udp_notify *nm;
ASSERT_IN_NETISR(0);
nm = kmalloc(sizeof(*nm), M_LWKTMSG, M_INTWAIT);
netmsg_init(&nm->base, NULL, &netisr_afree_rport,
0, udp_notifyall_oncpu);
nm->nm_faddr = faddr;
nm->nm_arg = inetctlerrmap[cmd];
nm->nm_notify = notify;
lwkt_sendmsg(netisr_cpuport(0), &nm->base.lmsg);
}
done:
lwkt_replymsg(&msg->lmsg, 0);
}
static int
udp_getcred(SYSCTL_HANDLER_ARGS)
{
struct sockaddr_in addrs[2];
struct ucred cred0, *cred = NULL;
struct inpcb *inp;
int error, cpu, origcpu;
error = priv_check(req->td, PRIV_ROOT);
if (error)
return (error);
error = SYSCTL_IN(req, addrs, sizeof addrs);
if (error)
return (error);
origcpu = mycpuid;
cpu = udp_addrcpu(addrs[1].sin_addr.s_addr, addrs[1].sin_port,
addrs[0].sin_addr.s_addr, addrs[0].sin_port);
lwkt_migratecpu(cpu);
inp = in_pcblookup_hash(&udbinfo[cpu],
addrs[1].sin_addr, addrs[1].sin_port,
addrs[0].sin_addr, addrs[0].sin_port, TRUE, NULL);
if (inp == NULL || inp->inp_socket == NULL) {
error = ENOENT;
} else if (inp->inp_socket->so_cred != NULL) {
cred0 = *(inp->inp_socket->so_cred);
cred = &cred0;
}
lwkt_migratecpu(origcpu);
if (error)
return error;
return SYSCTL_OUT(req, cred, sizeof(struct ucred));
}
static int
tcp_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
struct sockaddr_in *sin, struct sockaddr_in *if_sin)
{
struct inpcb *inp = tp->t_inpcb, *oinp;
struct socket *so = inp->inp_socket;
struct route *ro = &inp->inp_route;
oinp = in_pcblookup_hash(&tcbinfo[mycpu->gd_cpuid],
sin->sin_addr, sin->sin_port,
(inp->inp_laddr.s_addr != INADDR_ANY ?
inp->inp_laddr : if_sin->sin_addr),
inp->inp_lport, 0, NULL);
if (oinp != NULL) {
m_freem(m);
return (EADDRINUSE);
}
if (inp->inp_laddr.s_addr == INADDR_ANY)
inp->inp_laddr = if_sin->sin_addr;
inp->inp_faddr = sin->sin_addr;
inp->inp_fport = sin->sin_port;
inp->inp_cpcbinfo = &tcbinfo[mycpu->gd_cpuid];
in_pcbinsconnhash(inp);
/*
* We are now on the inpcb's owner CPU, if the cached route was
* freed because the rtentry's owner CPU is not the current CPU
* (e.g. in tcp_connect()), then we try to reallocate it here with
* the hope that a rtentry may be cloned from a RTF_PRCLONING
* rtentry.
*/
if (!(inp->inp_socket->so_options & SO_DONTROUTE) && /*XXX*/
ro->ro_rt == NULL) {
bzero(&ro->ro_dst, sizeof(struct sockaddr_in));
ro->ro_dst.sa_family = AF_INET;
ro->ro_dst.sa_len = sizeof(struct sockaddr_in);
((struct sockaddr_in *)&ro->ro_dst)->sin_addr =
sin->sin_addr;
rtalloc(ro);
}
/*
* Now that no more errors can occur, change the protocol processing
* port to the current thread (which is the correct thread).
*
* Create TCP timer message now; we are on the tcpcb's owner
* CPU/thread.
*/
tcp_create_timermsg(tp, &curthread->td_msgport);
/*
* Compute window scaling to request. Use a larger scaling then
* needed for the initial receive buffer in case the receive buffer
* gets expanded.
*/
if (tp->request_r_scale < TCP_MIN_WINSHIFT)
tp->request_r_scale = TCP_MIN_WINSHIFT;
while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
(TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.ssb_hiwat
) {
tp->request_r_scale++;
}
soisconnecting(so);
tcpstat.tcps_connattempt++;
tp->t_state = TCPS_SYN_SENT;
tcp_callout_reset(tp, tp->tt_keep, tcp_keepinit, tcp_timer_keep);
tp->iss = tcp_new_isn(tp);
tcp_sendseqinit(tp);
if (m) {
ssb_appendstream(&so->so_snd, m);
m = NULL;
if (flags & PRUS_OOB)
tp->snd_up = tp->snd_una + so->so_snd.ssb_cc;
}
/*
* Close the send side of the connection after
* the data is sent if flagged.
*/
if ((flags & (PRUS_OOB|PRUS_EOF)) == PRUS_EOF) {
socantsendmore(so);
tp = tcp_usrclosed(tp);
}
return (tcp_output(tp));
}
