void
sctp_hash_init()
{
int i;
if (sctp_conn_hash_size & (sctp_conn_hash_size - 1)) {
/* Not a power of two. Round up to nearest power of two */
for (i = 0; i < 31; i++) {
if (sctp_conn_hash_size < (1 << i))
break;
}
sctp_conn_hash_size = 1 << i;
}
if (sctp_conn_hash_size < SCTP_CONN_HASH_SIZE) {
sctp_conn_hash_size = SCTP_CONN_HASH_SIZE;
cmn_err(CE_CONT, "using sctp_conn_hash_size = %u\n",
sctp_conn_hash_size);
}
sctp_conn_fanout =
(sctp_tf_t *)kmem_zalloc(sctp_conn_hash_size *
sizeof (sctp_tf_t), KM_SLEEP);
for (i = 0; i < sctp_conn_hash_size; i++) {
mutex_init(&sctp_conn_fanout[i].tf_lock, NULL,
MUTEX_DEFAULT, NULL);
}
for (i = 0; i < A_CNT(sctp_listen_fanout); i++) {
mutex_init(&sctp_listen_fanout[i].tf_lock, NULL,
MUTEX_DEFAULT, NULL);
}
for (i = 0; i < A_CNT(sctp_bind_fanout); i++) {
mutex_init(&sctp_bind_fanout[i].tf_lock, NULL,
MUTEX_DEFAULT, NULL);
}
}
int
_init(void)
{
mactype_register_t *mtrp;
int err;
if ((mtrp = mactype_alloc(MACTYPE_VERSION)) == NULL)
return (ENOTSUP);
mtrp->mtr_ident = MAC_PLUGIN_IDENT_ETHER;
mtrp->mtr_ops = &mac_ether_type_ops;
mtrp->mtr_mactype = DL_ETHER;
mtrp->mtr_nativetype = DL_ETHER;
mtrp->mtr_addrlen = ETHERADDRL;
mtrp->mtr_brdcst_addr = ether_brdcst;
mtrp->mtr_stats = ether_stats;
mtrp->mtr_statcount = A_CNT(ether_stats);
mtrp->mtr_mapping = mac_ether_mapping;
mtrp->mtr_mappingcount = A_CNT(mac_ether_mapping);
if ((err = mactype_register(mtrp)) == 0) {
if ((err = mod_install(&mac_ether_modlinkage)) != 0)
(void) mactype_unregister(MAC_PLUGIN_IDENT_ETHER);
}
mactype_free(mtrp);
return (err);
}
/*
* convert an ICMP6 "type" field to a printable string.
*/
static char *
pr_type6(uchar_t type)
{
static struct icmptype_table ttab6[] = {
{ICMP6_DST_UNREACH, "Dest Unreachable"},
{ICMP6_PACKET_TOO_BIG, "Packet Too Big"},
{ICMP6_TIME_EXCEEDED, "Time Exceeded"},
{ICMP6_PARAM_PROB, "Param Problem"},
{ICMP6_ECHO_REQUEST, "Echo Request"},
{ICMP6_ECHO_REPLY, "Echo Reply"},
{MLD_LISTENER_QUERY, "Multicast Listener Query"},
{MLD_LISTENER_REPORT, "Multicast Listener Report"},
{MLD_LISTENER_REDUCTION, "Multicast Listener Done"},
{ND_ROUTER_SOLICIT, "Router Solicitation"},
{ND_ROUTER_ADVERT, "Router Advertisement"},
{ND_NEIGHBOR_SOLICIT, "Neighbor Solicitation"},
{ND_NEIGHBOR_ADVERT, "Neighbor Advertisement"},
{ND_REDIRECT, "Redirect Message"}
};
int i = 0;
for (i = 0; i < A_CNT(ttab6); i++) {
if (ttab6[i].type == type)
return (ttab6[i].message);
}
return ("OUT-OF-RANGE");
}
void
sctp_hash_destroy()
{
int i;
for (i = 0; i < sctp_conn_hash_size; i++) {
mutex_destroy(&sctp_conn_fanout[i].tf_lock);
}
kmem_free(sctp_conn_fanout, sctp_conn_hash_size * sizeof (sctp_tf_t));
for (i = 0; i < A_CNT(sctp_listen_fanout); i++) {
mutex_destroy(&sctp_listen_fanout[i].tf_lock);
}
for (i = 0; i < A_CNT(sctp_bind_fanout); i++) {
mutex_destroy(&sctp_bind_fanout[i].tf_lock);
}
}
/*
* Convert an ICMP "type" field to a printable string.
*/
static char *
pr_type(int icmp_type)
{
static struct icmptype_table ttab[] = {
{ICMP_ECHOREPLY, "Echo Reply"},
{1, "ICMP 1"},
{2, "ICMP 2"},
{ICMP_UNREACH, "Dest Unreachable"},
{ICMP_SOURCEQUENCH, "Source Quench"},
{ICMP_REDIRECT, "Redirect"},
{6, "ICMP 6"},
{7, "ICMP 7"},
{ICMP_ECHO, "Echo"},
{ICMP_ROUTERADVERT, "Router Advertisement"},
{ICMP_ROUTERSOLICIT, "Router Solicitation"},
{ICMP_TIMXCEED, "Time Exceeded"},
{ICMP_PARAMPROB, "Parameter Problem"},
{ICMP_TSTAMP, "Timestamp"},
{ICMP_TSTAMPREPLY, "Timestamp Reply"},
{ICMP_IREQ, "Info Request"},
{ICMP_IREQREPLY, "Info Reply"},
{ICMP_MASKREQ, "Netmask Request"},
{ICMP_MASKREPLY, "Netmask Reply"}
};
int i;
for (i = 0; i < A_CNT(ttab); i++) {
if (ttab[i].type == icmp_type)
return (ttab[i].message);
}
return ("OUT-OF-RANGE");
}
void
nl7c_nca_init(void)
{
if (! nca_g_nd) {
if (! nca_param_register(nca_param_arr, A_CNT(nca_param_arr)))
cmn_err(CE_WARN,
"nl7c: /dev/nca ndd initialization failed.");
}
}
static const dispatch_t *
sctp_lookup_asconf_dispatch(int id)
{
int i;
for (i = 0; i < A_CNT(sctp_asconf_dispatch_tbl); i++) {
if (sctp_asconf_dispatch_tbl[i].id == id) {
return (sctp_asconf_dispatch_tbl + i);
}
}
return (&sctp_asconf_default_dispatch);
}
static boolean_t
nca_param_register(ncaparam_t *ncapa, int cnt)
{
for (; cnt-- > 0; ncapa++) {
if (ncapa->param_name && ncapa->param_name[0]) {
if (!nd_load(&nca_g_nd, ncapa->param_name,
nca_param_get, nca_param_set,
(caddr_t)ncapa)) {
goto error;
}
}
}
if (!nd_load(&nca_g_nd, "nca_version", nca_version_get, nil(pfi_t),
nil(caddr_t))) {
goto error;
}
if (!nd_load(&nca_g_nd, "nca_logd_version", nca_logd_version_get,
nil(pfi_t), nil(caddr_t))) {
goto error;
}
if (!nd_load(&nca_g_nd, "nca_logging_on", nca_logging_on_get,
nca_logging_on_set, nil(caddr_t))) {
goto error;
}
if (!nd_load(&nca_g_nd, "uri_time_to_live", nl7c_uri_ttl_get,
nl7c_uri_ttl_set, nil(caddr_t))) {
goto error;
}
if (!nd_load(&nca_g_nd, "nca_httpd_version", nca_httpd_version_get,
nil(pfi_t), nil(caddr_t))) {
goto error;
}
if (!nd_load(&nca_g_nd, "httpd_door_instance", nca_httpd_door_inst_get,
nil(pfi_t), nil(caddr_t))) {
nd_free(&nca_g_nd);
return (B_FALSE);
}
ncapa = nca_ip_obsolete_arr;
cnt = A_CNT(nca_ip_obsolete_arr);
for (; cnt-- > 0; ncapa++) {
if (ncapa->param_name && ncapa->param_name[0]) {
if (!nd_load(&nca_g_nd, ncapa->param_name,
nca_ip_obsolete, NULL, (caddr_t)ncapa)) {
goto error;
}
}
}
ncapa = nca_tcp_obsolete_arr;
cnt = A_CNT(nca_tcp_obsolete_arr);
for (; cnt-- > 0; ncapa++) {
if (ncapa->param_name && ncapa->param_name[0]) {
if (!nd_load(&nca_g_nd, ncapa->param_name,
nca_tcp_obsolete, NULL, (caddr_t)ncapa)) {
goto error;
}
}
}
ncapa = nca_nca_obsolete_arr;
cnt = A_CNT(nca_nca_obsolete_arr);
for (; cnt-- > 0; ncapa++) {
if (ncapa->param_name && ncapa->param_name[0]) {
if (!nd_load(&nca_g_nd, ncapa->param_name,
nca_nca_obsolete, NULL, (caddr_t)ncapa)) {
goto error;
}
}
}
return (B_TRUE);
error:
nd_free(&nca_g_nd);
return (B_FALSE);
}
mod_set_uint32, mod_get_uint32,
{ 1, 16, 2}, {2} },
/*
* sctp_wroff_xtra is the extra space in front of SCTP/IP header
* for link layer header. It has to be a multiple of 8.
*/
{ "_wroff_xtra", MOD_PROTO_SCTP,
mod_set_aligned, mod_get_uint32,
{0, 256, 32}, {32} },
{ "extra_priv_ports", MOD_PROTO_SCTP,
mod_set_extra_privports, mod_get_extra_privports,
{1, ULP_MAX_PORT, 0}, {0} },
{ "_listener_limit_conf", MOD_PROTO_SCTP,
NULL, sctp_listener_conf_get, {0}, {0} },
{ "_listener_limit_conf_add", MOD_PROTO_SCTP,
sctp_listener_conf_add, NULL, {0}, {0} },
{ "_listener_limit_conf_del", MOD_PROTO_SCTP,
sctp_listener_conf_del, NULL, {0}, {0} },
{ "?", MOD_PROTO_SCTP, NULL, mod_get_allprop, {0}, {0} },
{ NULL, 0, NULL, NULL, {0}, {0} }
};
int sctp_propinfo_count = A_CNT(sctp_propinfo_tbl);
boolean_t
sctp_nd_init()
{
return (sctp_param_register(sctp_param_arr, A_CNT(sctp_param_arr)));
}
/*
* Check out the packet to see if it came from us. This logic is necessary
* because ALL readers of the ICMP socket get a copy of ALL ICMP packets
* which arrive ('tis only fair). This permits multiple copies of this
* program to be run without having intermingled output (or statistics!).
*/
void
check_reply(struct addrinfo *ai_dst, struct msghdr *msg, int cc,
ushort_t udp_src_port)
{
struct ip *ip;
struct icmp *icp;
struct udphdr *up;
union any_in_addr dst_addr;
uchar_t *buf;
int32_t *intp;
struct sockaddr_in *from;
struct timeval *tp;
struct timeval tv;
int hlen, hlen1;
int64_t triptime;
boolean_t valid_reply = _B_FALSE;
boolean_t reply_matched_current_target; /* Is the source address of */
/* this reply same as where */
/* we're sending currently? */
boolean_t last_reply_from_targetaddr = _B_FALSE; /* Is this stats, */
/* probe all with npackets>0 */
/* and we received reply for */
/* the last probe sent to */
/* targetaddr */
int cc_left;
char tmp_buf[INET6_ADDRSTRLEN];
static char *unreach[] = {
"Net Unreachable",
"Host Unreachable",
"Protocol Unreachable",
"Port Unreachable",
"Fragmentation needed and DF set",
"Source Route Failed",
/* The following are from RFC1700 */
"Net Unknown",
"Host Unknown",
"Source Host Isolated",
"Dest Net Prohibited",
"Dest Host Prohibited",
"Net Unreachable for TOS",
"Host Unreachable for TOS",
"Communication Administratively Prohibited",
"Host Precedence Violation",
"Precedence Cutoff in Effect"
};
static char *redirect[] = {
"Net",
"Host",
"TOS Net",
"TOS Host"
};
static char *timexceed[] = {
"Time exceeded in transit",
"Time exceeded during reassembly"
};
boolean_t print_newline = _B_FALSE;
int i;
/* decompose msghdr into useful pieces */
buf = (uchar_t *)msg->msg_iov->iov_base;
from = (struct sockaddr_in *)msg->msg_name;
/* LINTED */
intp = (int32_t *)buf;
(void) gettimeofday(&tv, (struct timezone *)NULL);
/* LINTED */
ip = (struct ip *)buf;
hlen = ip->ip_hl << 2;
if ((cc < sizeof (struct ip)) || (cc < hlen + ICMP_MINLEN)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
return;
}
cc -= hlen;
/* LINTED */
icp = (struct icmp *)(buf + hlen);
if (ip->ip_p == 0) {
/*
* Assume that we are running on a pre-4.3BSD system
* such as SunOS before 4.0
*/
/* LINTED */
icp = (struct icmp *)buf;
}
cc_left = cc - ICMP_MINLEN;
switch (icp->icmp_type) {
case ICMP_UNREACH:
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
/* check if we have enough of the packet to work on */
if ((cc_left < sizeof (struct ip)) ||
(cc_left < hlen1 + sizeof (struct udphdr))) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
/* get the UDP packet */
cc_left -= hlen1 + sizeof (struct udphdr);
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
/* check to see if this is what we sent */
if (icp->icmp_code == ICMP_UNREACH_PORT &&
ip->ip_p == IPPROTO_UDP &&
udp_src_port == up->uh_sport &&
use_udp) {
valid_reply = _B_TRUE;
} else {
valid_reply = _B_FALSE;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(up->uh_dport));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_PORT + 1) == ntohs(up->uh_dport)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
/* stats mode doesn't print 'alive' messages */
if (valid_reply && !stats) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
(void) inet_ntop(AF_INET, (void *)&ip->ip_dst,
tmp_buf, sizeof (tmp_buf));
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
dst_addr.addr = ip->ip_dst;
if (valid_reply) {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
Printf("udp_port=%d. ", ntohs(up->uh_dport));
print_newline = _B_TRUE;
} else if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(unreach)) {
Printf("ICMP %d Unreachable from gateway %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s from gateway %s\n",
unreach[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
if (ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) {
Printf(" port %d ", ntohs(up->uh_dport));
}
print_newline = _B_TRUE;
}
/* if we are timing and the reply has a timeval */
if (valid_reply && datalen >= sizeof (struct timeval) &&
cc_left >= sizeof (struct timeval)) {
/* LINTED */
tp = (struct timeval *)((char *)up +
sizeof (struct udphdr));
(void) tvsub(&tv, tp);
triptime = (int64_t)tv.tv_sec * MICROSEC + tv.tv_usec;
Printf("time=" TIMEFORMAT " ms", triptime/1000.0);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
print_newline = _B_TRUE;
}
if (print_newline)
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_REDIRECT:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(redirect)) {
Printf("ICMP %d redirect from gateway %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s redirect from gateway %s\n",
redirect[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" to %s",
pr_name((char *)&icp->icmp_gwaddr, AF_INET));
Printf(" for %s\n",
pr_name((char *)&ip->ip_dst, AF_INET));
}
break;
case ICMP_ECHOREPLY:
if (ntohs(icp->icmp_id) == ident) {
if (!use_udp && !use_icmp_ts)
valid_reply = _B_TRUE;
else
valid_reply = _B_FALSE;
} else {
return;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(icp->icmp_seq));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_ICMP_SEQ + 1) ==
ntohs(icp->icmp_seq)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
if (!stats && valid_reply) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
/*
* If we are using send_reply, the real
* target address is not the src address of the
* replies. Use icmp_seq to find out where this
* probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(
ntohs(icp->icmp_seq), &dst_addr);
(void) inet_ntop(AF_INET,
(void *)&dst_addr.addr,
tmp_buf, sizeof (tmp_buf));
} else {
(void) inet_ntop(AF_INET,
(void *)&from->sin_addr,
tmp_buf, sizeof (tmp_buf));
}
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
/*
* If we are using send_reply, the real target address is
* not the src address of the replies. Use icmp_seq to find out
* where this probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(ntohs(icp->icmp_seq), &dst_addr);
Printf("%d bytes from %s: ", cc,
pr_name((char *)&dst_addr.addr, AF_INET));
} else {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf("icmp_seq=%d. ", ntohs(icp->icmp_seq));
if (valid_reply && datalen >= sizeof (struct timeval) &&
cc_left >= sizeof (struct timeval)) {
/* LINTED */
tp = (struct timeval *)&icp->icmp_data[0];
(void) tvsub(&tv, tp);
triptime = (int64_t)tv.tv_sec * MICROSEC + tv.tv_usec;
Printf("time=" TIMEFORMAT " ms", triptime/1000.0);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
}
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_SOURCEQUENCH:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
Printf("ICMP Source Quench from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
/*
* if it's a UDP or TCP packet, we need at least first
* 4 bytes of it to see the src/dst ports
*/
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_PARAMPROB:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
switch (icp->icmp_code) {
case ICMP_PARAMPROB_OPTABSENT:
Printf("ICMP Missing a Required Option "
"parameter problem from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" option type = %d", icp->icmp_pptr);
break;
case ICMP_PARAMPROB_BADLENGTH:
Printf("ICMP Bad Length parameter problem "
"from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" in byte %d", icp->icmp_pptr);
if (icp->icmp_pptr <= hlen1) {
Printf(" (value 0x%x)",
*((char *)ip + icp->icmp_pptr));
}
break;
case 0:
default:
Printf("ICMP Parameter Problem from %s\n",
pr_name((char *)&from->sin_addr, AF_INET));
Printf(" in byte %d", icp->icmp_pptr);
if (icp->icmp_pptr <= hlen1) {
Printf(" (value 0x%x)",
*((char *)ip + icp->icmp_pptr));
}
break;
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
/*
* if it's a UDP or TCP packet, we need at least first
* 4 bytes of it to see the src/dst ports
*/
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_TIMXCEED:
if (cc_left < sizeof (struct ip)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
ip = &icp->icmp_ip;
hlen1 = ip->ip_hl << 2;
dst_addr.addr = ip->ip_dst;
if (is_a_target(ai_dst, &dst_addr) || verbose) {
if (icp->icmp_code >= A_CNT(timexceed)) {
Printf("ICMP %d time exceeded from %s\n",
icp->icmp_code,
pr_name((char *)&from->sin_addr, AF_INET));
} else {
Printf("ICMP %s from %s\n",
timexceed[icp->icmp_code],
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf(" for %s from %s", pr_protocol(ip->ip_p),
pr_name((char *)&ip->ip_src, AF_INET));
Printf(" to %s", pr_name((char *)&ip->ip_dst, AF_INET));
if ((ip->ip_p == IPPROTO_TCP ||
ip->ip_p == IPPROTO_UDP) &&
(cc_left >= hlen1 + 4)) {
/* LINTED */
up = (struct udphdr *)((uchar_t *)ip + hlen1);
Printf(" port %d", ntohs(up->uh_dport));
}
(void) putchar('\n');
}
break;
case ICMP_TSTAMPREPLY:
/* the packet should have enough space to store timestamps */
if (cc_left < sizeof (struct id_ts)) {
if (verbose) {
Printf("packet too short (%d bytes) from %s\n",
cc, pr_name((char *)&from->sin_addr,
AF_INET));
}
return;
}
if (ntohs(icp->icmp_id) == ident) {
if (use_icmp_ts)
valid_reply = _B_TRUE;
else
valid_reply = _B_FALSE;
} else {
return;
}
if (valid_reply) {
/*
* For this valid reply, if we are still sending to
* this target IP address, we'd like to do some
* updates to targetaddr, so hold SIGALRMs.
*/
(void) sighold(SIGALRM);
is_alive = _B_TRUE;
nreceived++;
reply_matched_current_target =
seq_match(current_targetaddr->starting_seq_num,
current_targetaddr->num_sent,
ntohs(icp->icmp_seq));
if (reply_matched_current_target) {
current_targetaddr->got_reply = _B_TRUE;
nreceived_last_target++;
/*
* Determine if stats, probe-all, and
* npackets != 0, and this is the reply for
* the last probe we sent to current target
* address.
*/
if (stats && probe_all && npackets > 0 &&
((current_targetaddr->starting_seq_num +
current_targetaddr->num_probes - 1) %
(MAX_ICMP_SEQ + 1) ==
ntohs(icp->icmp_seq)) &&
(current_targetaddr->num_probes ==
current_targetaddr->num_sent))
last_reply_from_targetaddr = _B_TRUE;
} else {
/*
* If it's just probe_all and we just received
* a reply from a target address we were
* probing and had timed out (now we are probing
* some other target address), we ignore
* this reply.
*/
if (probe_all && !stats) {
valid_reply = _B_FALSE;
/*
* Only if it's verbose, we get a
* message regarding this reply,
* otherwise we are done here.
*/
if (!verbose) {
(void) sigrelse(SIGALRM);
return;
}
}
}
}
if (!stats && valid_reply) {
/*
* if we are still sending to the same target address,
* then stop it, because we know it's alive.
*/
if (reply_matched_current_target) {
(void) alarm(0); /* cancel alarm */
(void) sigset(SIGALRM, SIG_IGN);
current_targetaddr->probing_done = _B_TRUE;
}
(void) sigrelse(SIGALRM);
if (!probe_all) {
Printf("%s is alive\n", targethost);
} else {
/*
* If we are using send_reply, the real
* target address is not the src address of the
* replies. Use icmp_seq to find out where this
* probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(
ntohs(icp->icmp_seq), &dst_addr);
(void) inet_ntop(AF_INET,
(void *)&dst_addr.addr,
tmp_buf, sizeof (tmp_buf));
} else {
(void) inet_ntop(AF_INET,
(void *)&from->sin_addr,
tmp_buf, sizeof (tmp_buf));
}
if (nflag) {
Printf("%s is alive\n", tmp_buf);
} else {
Printf("%s (%s) is alive\n",
targethost, tmp_buf);
}
}
if (reply_matched_current_target) {
/*
* Let's get things going again, but now
* ping will start sending to next target IP
* address.
*/
send_scheduled_probe();
(void) sigset(SIGALRM, sigalrm_handler);
schedule_sigalrm();
}
return;
} else {
/*
* If we are not moving to next targetaddr, let's
* release the SIGALRM now. We don't want to stall in
* the middle of probing a targetaddr if the pr_name()
* call (see below) takes longer.
*/
if (!last_reply_from_targetaddr)
(void) sigrelse(SIGALRM);
/* else, we'll release it later */
}
/*
* If we are using send_reply, the real target address is
* not the src address of the replies. Use icmp_seq to find out
* where this probe was sent to.
*/
if (send_reply) {
(void) find_dstaddr(ntohs(icp->icmp_seq), &dst_addr);
Printf("%d bytes from %s: ", cc,
pr_name((char *)&dst_addr.addr, AF_INET));
} else {
Printf("%d bytes from %s: ", cc,
pr_name((char *)&from->sin_addr, AF_INET));
}
Printf("icmp_seq=%d. ", ntohs(icp->icmp_seq));
Printf("orig = %lu, recv = %lu, xmit = %lu ",
(ulong_t)ntohl(icp->icmp_otime),
(ulong_t)ntohl(icp->icmp_rtime),
(ulong_t)ntohl(icp->icmp_ttime));
if (valid_reply) {
/*
* icp->icmp_otime is the time passed since midnight.
* Therefore we need to adjust tv value, which is
* the time passed since Jan 1, 1970.
*/
triptime = (tv.tv_sec % (24LL * 60 * 60)) * MILLISEC +
(tv.tv_usec / (MICROSEC/MILLISEC));
triptime -= ntohl(icp->icmp_otime);
if (triptime < 0)
triptime += 24LL * 60 * 60 * MILLISEC;
Printf("time=%d. ms", (int)triptime);
triptime *= (MICROSEC/MILLISEC);
tsum += triptime;
tsum2 += triptime*triptime;
if (triptime < tmin)
tmin = triptime;
if (triptime > tmax)
tmax = triptime;
}
(void) putchar('\n');
/*
* If it's stats, probe-all, npackets > 0, and we received reply
* for the last probe sent to this target address, then we
* don't need to wait anymore, let's move on to next target
* address, now!
*/
if (last_reply_from_targetaddr) {
(void) alarm(0); /* cancel alarm */
current_targetaddr->probing_done = _B_TRUE;
(void) sigrelse(SIGALRM);
send_scheduled_probe();
schedule_sigalrm();
}
break;
case ICMP_ROUTERADVERT:
case ICMP_ROUTERSOLICIT:
/* Router discovery messages */
return;
case ICMP_ECHO:
case ICMP_TSTAMP:
case ICMP_IREQ:
case ICMP_MASKREQ:
/* These were never passed out from the SunOS 4.X kernel. */
return;
case ICMP_IREQREPLY:
case ICMP_MASKREPLY:
/* Replies for information and address mask requests */
return;
default:
if (verbose) {
Printf("%d bytes from %s:\n", cc,
pr_name((char *)&from->sin_addr, AF_INET));
Printf("icmp_type=%d (%s) ",
icp->icmp_type, pr_type(icp->icmp_type));
Printf("icmp_code=%d\n", icp->icmp_code);
for (i = 0; i < 12; i++) {
Printf("x%2.2x: x%8.8x\n",
i * sizeof (int32_t), *intp++);
}
}
break;
}
buf += sizeof (struct ip);
hlen -= sizeof (struct ip);
/* if verbose and there exists IP options */
if (verbose && hlen > 0)
pr_options((uchar_t *)buf, hlen);
}
{0, UINT32_MAX, 100*SECONDS}, {100*SECONDS} },
/* tunable - 60 */
{ "extra_priv_ports", MOD_PROTO_TCP,
mod_set_extra_privports, mod_get_extra_privports,
{1, ULP_MAX_PORT, 0}, {0} },
{ "_1948_phrase", MOD_PROTO_TCP,
tcp_set_1948phrase, NULL, {0}, {0} },
{ "_listener_limit_conf", MOD_PROTO_TCP,
NULL, tcp_listener_conf_get, {0}, {0} },
{ "_listener_limit_conf_add", MOD_PROTO_TCP,
tcp_listener_conf_add, NULL, {0}, {0} },
{ "_listener_limit_conf_del", MOD_PROTO_TCP,
tcp_listener_conf_del, NULL, {0}, {0} },
{ "_iss_incr", MOD_PROTO_TCP,
mod_set_uint32, mod_get_uint32,
{1, ISS_INCR, ISS_INCR},
{ISS_INCR} },
{ "?", MOD_PROTO_TCP, NULL, mod_get_allprop, {0}, {0} },
{ NULL, 0, NULL, NULL, {0}, {0} }
};
int tcp_propinfo_count = A_CNT(tcp_propinfo_tbl);
