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); }