int pkt_set_multicast_list (const void *listbuf, int len)
{
_pkt_errno = PDERR_NO_MULTICAST;
ARGSUSED (listbuf);
ARGSUSED (len);
return (0);
}
void _call_trace (const char *from, const char *module, unsigned line, const char *to)
{
ARGSUSED (from);
ARGSUSED (module);
ARGSUSED (line);
ARGSUSED (to);
}
int W32_CALL setprotoent_r (int stayopen, struct protoent *buffer)
{
UNFINISHED();
ARGSUSED (stayopen);
ARGSUSED (buffer);
return (-1);
}
/**
* Traverse 'adapters_list' and select 1st device with an IPv4
* address. Assuming that device is a physical adapter we can use.
*/
static BOOL find_adapter (char *aname, size_t size)
{
#if defined(USE_DYN_PACKET)
ARGSUSED (aname);
ARGSUSED (size);
return (TRUE); /**\todo Use IPhlpAPI function to return list of adapters */
#else
const ADAPTER_INFO *ai;
int i;
for (ai = PacketGetAdInfo(); ai; ai = ai->Next)
{
for (i = 0; i < ai->NNetworkAddresses; i++)
{
const npf_if_addr *if_addr = ai->NetworkAddresses + i;
const struct sockaddr_in *ip_addr = (const struct sockaddr_in*) &if_addr->IPAddress;
if (ip_addr->sin_family == AF_INET)
{
StrLcpy (aname, ai->Name, size);
return (TRUE);
}
}
}
return (FALSE);
#endif
}
int W32_CALL gethostent_r (struct hostent *result,
struct hostent *buffer)
{
UNFINISHED();
ARGSUSED (result);
ARGSUSED (buffer);
return (-1);
}
/*
* Don't think we need to support this since we can use promiscous mode
*/
int pkt_get_multicast_list (mac_address *listbuf, int *len)
{
_pkt_errno = PDERR_NO_MULTICAST;
*len = 0;
ARGSUSED (listbuf);
ARGSUSED (len);
return (0);
}
/*
* getprotobyY_r..
*/
int W32_CALL getprotobynumber_r (int proto,
struct protoent *result,
struct protoent *buffer)
{
UNFINISHED();
ARGSUSED (proto);
ARGSUSED (result);
ARGSUSED (buffer);
return (-1);
}
int W32_CALL getprotobyname_r (const char *name,
struct protoent *result,
struct protoent *buffer)
{
UNFINISHED();
ARGSUSED (name);
ARGSUSED (result);
ARGSUSED (buffer);
return (-1);
}
int W32_CALL getservbyport_r (int port, const char *proto,
struct servent *result,
struct servent *buffer)
{
UNFINISHED();
ARGSUSED (port);
ARGSUSED (proto);
ARGSUSED (result);
ARGSUSED (buffer);
return (-1);
}
/*
* getservbyY_r..
*/
int W32_CALL getservbyname_r (const char *name, const char *proto,
struct servent *result,
struct servent *buffer)
{
UNFINISHED();
ARGSUSED (name);
ARGSUSED (proto);
ARGSUSED (result);
ARGSUSED (buffer);
return (-1);
}
/**
* Format MAC-header for protocols without MAC-headers.
* Nothing done here.
*/
static void *null_mac_format (void *mac_buf, const void *mac_dest, WORD type)
{
union link_Packet *buf = (union link_Packet*) mac_buf;
SIO_TRACE (("null_mac_format"));
memset (&buf->ip.head, 0, sizeof(buf->ip.head));
ARGSUSED (mac_dest);
ARGSUSED (type);
proto = IP4_TYPE;
return (void*) (&buf->ip.head);
}
pcap_t *pcap_open_live (char *device,
int snaplen,
int promisc_mode,
int timeout_ms,
char *errbuf)
{
fprintf (stderr, "\7Link pcap library before Watt-32 library\n");
ARGSUSED (device);
ARGSUSED (snaplen);
ARGSUSED (promisc_mode);
ARGSUSED (timeout_ms);
ARGSUSED (errbuf);
return (NULL);
}
struct hostent * W32_CALL gethostbyname_r (const char *name,
struct hostent *result,
char *buffer, int buf_len,
int *p_errno)
{
UNFINISHED();
*p_errno = ERANGE;
SOCK_ERRNO (ERANGE);
ARGSUSED (name);
ARGSUSED (result);
ARGSUSED (buffer);
ARGSUSED (buf_len);
return (NULL);
}
int W32_CALL getsockname (int s, struct sockaddr *name, int *namelen)
{
Socket *socket = _socklist_find (s);
int sa_len;
SOCK_PROLOGUE (socket, "\ngetsockname:%d", s);
sa_len = (socket->so_family == AF_INET6) ? sizeof(struct sockaddr_in6) :
sizeof(struct sockaddr_in);
if (!name || !namelen || (*namelen < sa_len))
{
SOCK_DEBUGF ((", EINVAL"));
SOCK_ERRNO (EINVAL);
if (namelen)
*namelen = 0;
return (-1);
}
if (!socket->local_addr)
{
SOCK_DEBUGF ((", EINVAL"));
SOCK_ERRNO (EINVAL); /* according to HP/UX manpage */
return (-1);
}
VERIFY_RW (name, *namelen);
*namelen = sa_len;
memcpy (name, socket->local_addr, sa_len);
#if defined(USE_IPV6)
if (socket->so_family == AF_INET6)
{
const struct sockaddr_in6 *la = (const struct sockaddr_in6*)socket->local_addr;
SOCK_DEBUGF ((", %s (%d)", _inet6_ntoa(&la->sin6_addr), ntohs(la->sin6_port)));
ARGSUSED (la);
}
else
#endif
{
const struct sockaddr_in *la = socket->local_addr;
SOCK_DEBUGF ((", %s (%d)", inet_ntoa(la->sin_addr), ntohs(la->sin_port)));
ARGSUSED (la);
}
return (0);
}
int W32_CALL getpeername (int s, struct sockaddr *name, int *namelen)
{
Socket *socket = _socklist_find (s);
int sa_len;
SOCK_PROLOGUE (socket, "\ngetpeername:%d", s);
sa_len = (socket->so_family == AF_INET6) ? sizeof(struct sockaddr_in6) :
sizeof(struct sockaddr_in);
if (!name || !namelen || (*namelen < sa_len))
{
SOCK_DEBUGF ((", EINVAL"));
SOCK_ERRNO (EINVAL);
if (namelen)
*namelen = 0;
return (-1);
}
if (!(socket->so_state & SS_ISCONNECTED))
{
SOCK_DEBUGF ((", ENOTCONN"));
SOCK_ERRNO (ENOTCONN);
return (-1);
}
VERIFY_RW (name, *namelen);
*namelen = sa_len;
memcpy (name, socket->remote_addr, *namelen);
#if defined(USE_IPV6)
if (socket->so_family == AF_INET6)
{
const struct sockaddr_in6 *ra = (const struct sockaddr_in6*)socket->remote_addr;
SOCK_DEBUGF ((", %s (%d)", _inet6_ntoa(&ra->sin6_addr), ntohs(ra->sin6_port)));
ARGSUSED (ra);
}
else
#endif
{
const struct sockaddr_in *ra = socket->remote_addr;
SOCK_DEBUGF ((", %s (%d)", inet_ntoa(ra->sin_addr), ntohs(ra->sin_port)));
ARGSUSED (ra);
}
return (0);
}
void _prolog_trace (const char *func)
{
#if 0
if (ctrace_on)
(*_printf) ("%s()\n", func);
#endif
ARGSUSED (func);
}
static int udp_loopback (udp_Header *udp, unsigned udp_len)
{
if (intel16(udp->dstPort) == IPPORT_ECHO)
{
/** \todo UDP loopback handler should handle ECHO protocol */
}
else if (intel16(udp->dstPort) == IPPORT_DISCARD)
{
/** \todo UDP loopback handler should handle DISCARD protocol */
}
ARGSUSED (udp_len);
return (0);
}
/*
* Watch out for "ICMP port unreachable".
*/
static void udp_callback (_udp_Socket *s, int icmp_type, int icmp_code)
{
if (s->ip_type == UDP_PROTO && s == (_udp_Socket*)sock &&
(s->locflags & LF_GOT_ICMP) && icmp_type == ICMP_UNREACH)
{
/* In lack of a better way, pretend we got a FIN.
* This causes sock_wait_input() below to break it's loop.
*/
s->locflags |= LF_GOT_FIN;
s->err_msg = icmp_type_str [ICMP_UNREACH];
}
ARGSUSED (icmp_code);
}
static int udp_loopback (udp_Header *udp, unsigned udp_len)
{
if (intel16(udp->dstPort) == IPPORT_ECHO)
{
/* !!to-do */
}
else if (intel16(udp->dstPort) == IPPORT_DISCARD)
{
/* !!to-do */
}
ARGSUSED (udp_len);
return (0);
}
/*
* gethostbyY_r..
*/
int W32_CALL gethostbyaddr_r (const char *addr, int addr_len, int addr_type,
struct hostent *result,
struct hostent *buffer,
int buf_len, int *p_errno)
{
struct hostent *he;
if (!result || !buffer)
{
*p_errno = EINVAL;
return (-1);
}
he = gethostbyaddr (addr, addr_len, addr_type);
*p_errno = h_errno;
if (!he)
return (-1);
memcpy (result, he, sizeof(*result));
ARGSUSED (buf_len);
return (0);
}
/*
* Check 'my_ip' against the IPv4 address(es) Winsock is using for
* this adapter.
*/
BOOL pkt_check_address (DWORD my_ip)
{
#if !defined(USE_DYN_PACKET)
const ADAPTER_INFO *ai;
int i;
if (!_pkt_inf)
return (TRUE);
ai = (const ADAPTER_INFO*) _pkt_inf->adapter_info;
for (i = 0; i < ai->NNetworkAddresses; i++)
{
const npf_if_addr *if_addr = ai->NetworkAddresses + i;
const struct sockaddr_in *ip_addr = (const struct sockaddr_in*) &if_addr->IPAddress;
if (ip_addr->sin_addr.s_addr == htonl(my_ip))
return (FALSE);
}
#else
ARGSUSED (my_ip);
#endif
return (TRUE); /* Okay, no possible conflict */
}
/*
* TCP transmitter
*/
static int tcp_transmit (Socket *socket, const void *buf, int len, int flags)
{
sock_type *sk = (sock_type*)socket->tcp_sock;
tcp_tick (sk);
tcp_Retransmitter (1);
if (sk->tcp.state < tcp_StateESTAB || sk->tcp.state >= tcp_StateLASTACK)
{
socket->so_state |= SS_CANTSENDMORE;
SOCK_DEBUGF ((socket, ", ENOTCONN (%s)", /* !! or EPIPE */
(sk->tcp.locflags & LF_GOT_FIN) ?
"got FIN" : "can't send"));
SOCK_ERR (ENOTCONN);
return (-1);
}
if (socket->so_state & SS_NBIO)
{
int in_len = len;
if (check_non_block_tx(socket,&len) < 0)
{
SOCK_DEBUGF ((socket, ", EWOULDBLOCK"));
SOCK_ERR (EWOULDBLOCK);
return (-1);
}
if (in_len != len)
SOCK_DEBUGF ((socket, " [%d]", len)); /* trace "len=x [y]" */
}
SOCK_DEBUGF ((socket, ", %s (%d) / TCP",
inet_ntoa(socket->remote_addr->sin_addr),
ntohs(socket->remote_addr->sin_port)));
#if 0
/* Must wait for room in send buffer
*/
if ((flags & MSG_WAITALL) || len > sock_tbleft(sk))
len = sock_write (sk, (BYTE*)buf, len);
else len = sock_fastwrite (sk, (BYTE*)buf, len);
#else
/* This is more efficient. The above sock_fastwrite() would
* effectively turn off Nagle's algorithm.
*/
ARGSUSED (flags);
len = sock_write (sk, (BYTE*)buf, len);
#endif
if (len <= 0) /* error in tcp_write() */
{
if (sk->tcp.state != tcp_StateESTAB)
{
SOCK_DEBUGF ((socket, ", ENOTCONN"));
SOCK_ERR (ENOTCONN); /* maybe EPIPE? */
}
else
{
SOCK_DEBUGF ((socket, ", ENETDOWN"));
SOCK_ERR (ENETDOWN);
}
return (-1);
}
return (len);
}
char *pcap_geterr (pcap_t *pcap)
{
ARGSUSED (pcap);
return (NULL);
}
/*
* Form all types of queries.
* Returns the size of the result or -1.
*/
int res_mkquery (
int op, /* opcode of query */
const char *dname, /* domain name */
int Class, /* class of query */
int type, /* type of query */
const u_char *data, /* resource record data */
int datalen, /* length of data */
const u_char *newrr_in, /* new rr for modify or append */
u_char *buf, /* buffer to put query */
int buflen) /* size of buffer */
{
struct rrec *newrr = (struct rrec *) newrr_in;
HEADER *hp;
u_char *cp;
u_char *dnptrs[20];
u_char **dpp, **lastdnptr;
int n;
if ((_res.options & RES_INIT) == 0 && res_init() == -1)
{
h_errno = NETDB_INTERNAL;
return (-1);
}
if (_res.options & RES_DEBUG)
(*_printf) (";; res_mkquery(%d, %s, %d, %d)\n", op, dname, Class, type);
/* Initialize header fields.
*/
if (!buf || buflen < HFIXEDSZ)
return (-1);
memset (buf, 0, HFIXEDSZ);
hp = (HEADER*) buf;
hp->id = htons (++_res.id);
hp->opcode = op;
hp->rd = (_res.options & RES_RECURSE) != 0;
hp->rcode = NOERROR;
cp = buf + HFIXEDSZ;
buflen -= HFIXEDSZ;
dpp = dnptrs;
*dpp++ = buf;
*dpp++ = NULL;
lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
/* perform opcode specific processing
*/
switch (op)
{
case STATUS: /** \todo Handle STATUS case */
return (-1);
case QUERY:
/* fallthrough */
case NS_NOTIFY_OP: /* Notify secondary server of SOA change */
buflen -= QFIXEDSZ;
if (buflen < 0)
return (-1);
if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
return (-1);
cp += n;
buflen -= n;
__putshort (type, cp);
cp += INT16SZ;
__putshort (Class, cp);
cp += INT16SZ;
hp->qdcount = htons (1);
if (op == QUERY || !data)
break;
/*
* Make an additional record for completion domain.
*/
buflen -= RRFIXEDSZ;
n = dn_comp ((char*)data, cp, buflen, dnptrs, lastdnptr);
if (n < 0)
return (-1);
cp += n;
buflen -= n;
__putshort (T_NULL, cp);
cp += INT16SZ;
__putshort (Class, cp);
cp += INT16SZ;
__putlong (0, cp);
cp += INT32SZ;
__putshort (0, cp);
cp += INT16SZ;
hp->arcount = htons (1);
break;
case IQUERY:
/*
* Initialize answer section
*/
if (buflen < 1 + RRFIXEDSZ + datalen)
return (-1);
*cp++ = '\0'; /* no domain name */
__putshort (type, cp);
cp += INT16SZ;
__putshort (Class, cp);
cp += INT16SZ;
__putlong (0, cp);
cp += INT32SZ;
__putshort (datalen, cp);
cp += INT16SZ;
if (datalen)
{
memcpy (cp,data,datalen);
cp += datalen;
}
hp->ancount = htons (1);
break;
#if ALLOW_UPDATES
/*
* For UPDATEM/UPDATEMA, do UPDATED/UPDATEDA followed by UPDATEA
* (Record to be modified is followed by its replacement in msg.)
*/
case UPDATEM:
case UPDATEMA:
case UPDATED:
/*
* The res code for UPDATED and UPDATEDA is the same; user
* calls them differently: specifies data for UPDATED; server
* ignores data if specified for UPDATEDA.
*/
case UPDATEDA:
buflen -= RRFIXEDSZ + datalen;
if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
return (-1);
cp += n;
__putshort (type, cp);
cp += INT16SZ;
__putshort (Class, cp);
cp += INT16SZ;
__putlong (0, cp);
cp += INT32SZ;
__putshort (datalen, cp);
cp += INT16SZ;
if (datalen)
{
memcpy (cp,data,datalen);
cp += datalen;
}
if (op == UPDATED || op == UPDATEDA)
{
hp->ancount = 0;
break;
}
/* Else UPDATEM/UPDATEMA, so drop into code for UPDATEA
*/
case UPDATEA: /* Add new resource record */
buflen -= RRFIXEDSZ + datalen;
if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
return (-1);
cp += n;
__putshort (newrr->r_type, cp);
cp += INT16SZ;
__putshort (newrr->r_class, cp);
cp += INT16SZ;
__putlong (0, cp);
cp += INT32SZ;
__putshort (newrr->r_size, cp);
cp += INT16SZ;
if (newrr->r_size)
{
memcpy (cp,newrr->r_data,newrr->r_size);
cp += newrr->r_size;
}
hp->ancount = 0;
break;
#endif
default:
return (-1);
}
#if ALLOW_UPDATES == 0
ARGSUSED (newrr);
ARGSUSED (newrr_in);
#endif
return (cp - buf);
}
const char *pkt_strerror (int code)
{
ARGSUSED (code);
return (NULL);
}
/**
* Our low-level capture thread.
*
* Loop waiting for packet(s) in PacketReceivePacket(). In
* _pkt_release() the receive event-handle (adapter->Readvent) is
* set. This causes WaitForSingleObject() in PacketReceivePacket()
* to return. It is vital that the ADAPTER object isn't deallocated
* before PacketReceivePacket() returns.
*
* The return-value is > 0 if thread exited on it's own. Otherwise
* it is 0 (from GetExitCodeThread).
*/
DWORD __stdcall pkt_recv_thread (void *arg)
{
int rc = 0;
while (1)
{
const ADAPTER *adapter;
const BYTE *pkt, *pkt_end;
size_t cap_len, hdr_len;
int total_len, chunk;
PACKET npf_pkt;
if (!_pkt_inf || _pkt_inf->stop_thread) /* signals closure */
{
rc = 1;
break;
}
adapter = (const ADAPTER*) _pkt_inf->adapter;
npf_pkt.Length = _pkt_inf->npf_buf_size;
npf_pkt.Buffer = _pkt_inf->npf_buf;
if (!PacketReceivePacket(adapter, &npf_pkt, TRUE))
{
rc = 2;
break;
}
total_len = npf_pkt.ulBytesReceived;
ENTER_CRIT();
for (pkt = npf_pkt.Buffer, pkt_end = (BYTE*)npf_pkt.Buffer + total_len, chunk = 1;
pkt < pkt_end;
pkt += Packet_WORDALIGN(cap_len+hdr_len), chunk++)
{
struct pkt_ringbuf *q;
struct pkt_rx_element *head;
struct bpf_hdr *bp;
q = &_pkt_inf->pkt_queue;
bp = (struct bpf_hdr*) pkt;
cap_len = bp->bh_caplen;
hdr_len = bp->bh_hdrlen;
num_rx_bytes += bp->bh_datalen;
TCP_CONSOLE_MSG (2, ("pkt_recv_thread(): total_len %d, "
"chunk %d, cap_len %d, in-idx %d\n",
total_len, chunk, cap_len, q->in_index));
if (cap_len > ETH_MAX)
{
_pkt_inf->error = "Large size";
STAT (macstats.num_too_large++);
}
else
if (pktq_in_index(q) == q->out_index) /* queue is full, drop it */
q->num_drop++;
else
{
int pad_len, buf_max;
head = (struct pkt_rx_element*) pktq_in_buf (q);
memcpy (head->rx_buf, pkt + hdr_len, cap_len);
head->tstamp_put = bp->bh_tstamp;
head->rx_length = cap_len;
/* zero-pad up to ETH_MAX (don't destroy marker at end)
*/
buf_max = q->buf_size - RX_ELEMENT_HEAD_SIZE - 4;
pad_len = min (ETH_MAX, buf_max - cap_len);
if (pad_len > 0)
memset (&head->rx_buf[cap_len], 0, pad_len);
pktq_inc_in (q);
}
}
LEAVE_CRIT();
}
TCP_CONSOLE_MSG (2, ("pkt_recv_thread(): rc %d\n", rc));
fflush (stdout);
ARGSUSED (arg);
thr_stopped = TRUE;
return (rc);
}
/**
* Select async (overlapping) tx-mode. NOT YET.
*/
static void set_txmode (const char *value)
{
ARGSUSED (value);
}
int pkt_set_addr (const void *eth)
{
ARGSUSED (eth);
return (0);
}
int W32_CALL endhostent_r (struct hostent *buffer)
{
UNFINISHED();
ARGSUSED (buffer);
return (-1);
}
int W32_CALL endprotoent_r (struct protoent *buffer)
{
UNFINISHED();
ARGSUSED (buffer);
return (-1);
}
