/**
* Connects the given socket to the address.
* @param sd The socket handle to connect
* @param addr The address to connect to
* @param addrlen The length of the address details.
* @return 0 on success.
*/
sock_result_t socket_connect(sock_handle_t sd, const sockaddr_t *addr, long addrlen)
{
wiced_result_t result = WICED_INVALID_SOCKET;
socket_t* socket = from_handle(sd);
tcp_socket_t* tcp_socket = tcp(socket);
if (tcp_socket) {
std::lock_guard<socket_t> lk(*socket);
result = wiced_tcp_bind(tcp_socket, WICED_ANY_PORT);
if (result==WICED_SUCCESS) {
// WICED callbacks are broken
//wiced_tcp_register_callbacks(tcp(socket), socket_t::notify_connected, socket_t::notify_received, socket_t::notify_disconnected, (void*)socket);
SOCKADDR_TO_PORT_AND_IPADDR(addr, addr_data, port, ip_addr);
unsigned timeout = 5*1000;
result = wiced_tcp_connect(tcp_socket, &ip_addr, port, timeout);
if (result==WICED_SUCCESS) {
tcp_socket->connected();
} else {
// Work around WICED bug that doesn't set connection handler to NULL after deleting
// it, leading to deleting the same memory twice and a crash
// WICED/network/LwIP/WICED/tcpip.c:920
tcp_socket->conn_handler = NULL;
}
}
}
return as_sock_result(result);
}
static int parse_ipv6(void *data, uint64_t nh_off, void *data_end)
{
struct ipv6hdr *ip6h;
struct iphdr *iph;
uint64_t ihl_len = sizeof(struct ipv6hdr);
uint64_t nexthdr;
ip6h = data + nh_off;
if (ip6h + 1 > data_end)
return 0;
nexthdr = ip6h->nexthdr;
if (nexthdr == IPPROTO_IPIP) {
iph = data + nh_off + ihl_len;
if (iph + 1 > data_end)
return 0;
ihl_len += iph->ihl * 4;
nexthdr = iph->protocol;
} else if (nexthdr == IPPROTO_IPV6) {
ip6h = data + nh_off + ihl_len;
if (ip6h + 1 > data_end)
return 0;
ihl_len += sizeof(struct ipv6hdr);
nexthdr = ip6h->nexthdr;
}
if (nexthdr == IPPROTO_TCP)
return tcp(data, nh_off + ihl_len, data_end);
else if (nexthdr == IPPROTO_UDP)
return udp(data, nh_off + ihl_len, data_end);
return 0;
}
sock_result_t socket_send_ex(sock_handle_t sd, const void* buffer, socklen_t len, uint32_t flags, system_tick_t timeout, void* reserved)
{
sock_result_t result = SOCKET_INVALID;
socket_t* socket = from_handle(sd);
uint16_t bytes_sent = 0;
if (is_open(socket)) {
std::lock_guard<socket_t> lk(*socket);
wiced_result_t wiced_result = WICED_TCPIP_INVALID_SOCKET;
if (is_tcp(socket)) {
wiced_tcp_send_flags_t wiced_flags = timeout == 0 ? WICED_TCP_SEND_FLAG_NONBLOCK : WICED_TCP_SEND_FLAG_NONE;
bytes_sent = (uint16_t)len;
wiced_result = wiced_tcp_send_buffer_ex(tcp(socket), buffer, &bytes_sent, wiced_flags, timeout);
}
else if (is_client(socket)) {
tcp_server_client_t* server_client = client(socket);
size_t written = 0;
wiced_result = server_client->write(buffer, len, &written, flags, timeout);
bytes_sent = (uint16_t)written;
}
if (!wiced_result)
DEBUG("Write %d bytes to socket %d result=%d", (int)len, (int)sd, wiced_result);
result = wiced_result ? as_sock_result(wiced_result) : bytes_sent;
}
return result;
}
static int parse_ipv4(void *data, uint64_t nh_off, void *data_end)
{
struct iphdr *iph;
uint64_t ihl_len;
iph = data + nh_off;
if (iph + 1 > data_end)
return 0;
if (ip_is_fragment(iph))
return 0;
ihl_len = iph->ihl * 4;
if (iph->protocol == IPPROTO_IPIP) {
iph = data + nh_off + ihl_len;
if (iph + 1 > data_end)
return 0;
ihl_len += iph->ihl * 4;
}
if (iph->protocol == IPPROTO_TCP)
return tcp(data, nh_off + ihl_len, data_end);
else if (iph->protocol == IPPROTO_UDP)
return udp(data, nh_off + ihl_len, data_end);
return 0;
}
/* -----------------------------------------------------------------------------------------------------------*/
void ip( int packet_lenght , char *buffer )
{
struct ETH_header *ETH_packet; // ETH_struct anlegen
ETH_packet = (struct ETH_header *)&buffer[0];
struct IP_header *IP_packet; // IP_struct anlegen
IP_packet = ( struct IP_header *)&buffer[ETHERNET_HEADER_LENGTH];
// checke mal ob dat überhaupt für uns ist
// if ( IP_packet->IP_DestinationIP != myIP || IP_packet->IP_DestinationIP != 0xffffffff ) return;
// if ( ( IP_packet->IP_Flags_Fragmentoffset & htons( FRAGMENTOFFSET_bm ) ) == 0 )
// {
switch ( IP_packet->IP_Protocol )
{
case 0x01: if ( IP_packet->IP_DestinationIP != myIP ) return;
icmp( packet_lenght , buffer);
break;
#if defined(TCP)
case 0x06: if ( IP_packet->IP_DestinationIP != myIP ) return;
tcp( packet_lenght , buffer );
break;
#endif
#if defined(UDP)
case 0x11: udp( packet_lenght , buffer );
break;
#endif
default: break;
}
// }
}
/**
* Create a new socket handle.
* @param family Must be {@code AF_INET}
* @param type Either SOCK_DGRAM or SOCK_STREAM
* @param protocol Either IPPROTO_UDP or IPPROTO_TCP
* @return
*/
sock_handle_t socket_create(uint8_t family, uint8_t type, uint8_t protocol, uint16_t port, network_interface_t nif)
{
if (family!=AF_INET || !((type==SOCK_DGRAM && protocol==IPPROTO_UDP) || (type==SOCK_STREAM && protocol==IPPROTO_TCP)))
return SOCKET_INVALID;
sock_handle_t result = SOCKET_INVALID;
socket_t* socket = new socket_t();
if (socket) {
wiced_result_t wiced_result;
socket->set_type((protocol==IPPROTO_UDP ? socket_t::UDP : socket_t::TCP));
if (protocol==IPPROTO_TCP) {
wiced_result = wiced_tcp_create_socket(tcp(socket), wiced_wlan_interface(nif));
}
else {
wiced_result = wiced_udp_create_socket(udp(socket), port, wiced_wlan_interface(nif));
}
if (wiced_result!=WICED_SUCCESS) {
socket->set_type(socket_t::NONE);
delete socket;
result = as_sock_result(wiced_result);
}
else {
SocketListLock lock(list_for(socket));
add_socket(socket);
result = as_sock_result(socket);
}
}
return result;
}
wiced_tcp_socket_t* as_wiced_tcp_socket(socket_t* socket)
{
if (is_tcp(socket)) {
return tcp(socket);
}
else if (is_client(socket)) {
return socket->s.tcp_client->get_socket();
}
return NULL;
}
void
test_case_set::append(const unsigned test_case_num, const u_int32_t num_msgs,
const std::size_t min_data_size, const std::size_t max_data_size, const bool auto_deq,
const std::size_t min_xid_size, const std::size_t max_xid_size,
const test_case::transient_t transient, const test_case::external_t external,
const std::string& comment)
{
test_case::shared_ptr tcp(new test_case(test_case_num, num_msgs, min_data_size,
max_data_size, auto_deq, min_xid_size, max_xid_size, transient, external, comment));
append(tcp);
}
sock_result_t socket_shutdown(sock_handle_t sd, int how)
{
sock_result_t result = WICED_ERROR;
socket_t* socket = from_handle(sd);
if (socket && is_open(socket) && is_tcp(socket)) {
std::lock_guard<socket_t> lk(*socket);
result = wiced_tcp_close_shutdown(tcp(socket), (wiced_tcp_shutdown_flags_t)how);
LOG_DEBUG(TRACE, "socket shutdown %x %x", sd, how);
}
return result;
}
bool fetch( std::string const &key,
std::string *a,std::set<std::string> *tags,
time_t *timeout_out,
uint64_t *gen)
{
std::string buffer;
if(!a) a=&buffer;
time_t tmp_timeout;
if(!timeout_out) timeout_out=&tmp_timeout;
uint64_t generation;
if(!gen) gen=&generation;
if(!l1_.get()) {
if(tcp()->fetch(key,*a,tags,*timeout_out,*gen,false)==tcp_cache::found)
return true;
return false;
}
std::set<std::string> tmp_triggers;
if(!tags) tags=&tmp_triggers;
if(l1_->fetch(key,a,tags,timeout_out,gen)) {
int res = tcp()->fetch(key,*a,tags,*timeout_out,*gen,true);
if(res==tcp_cache::up_to_date)
return true;
if(res==tcp_cache::not_found) {
l1_->remove(key);
return false;
}
l1_->store(key,*a,*tags,*timeout_out,gen);
return true;
}
else {
if(tcp()->fetch(key,*a,tags,*timeout_out,*gen,false)==tcp_cache::found) {
l1_->store(key,*a,*tags,*timeout_out,gen);
return true;
}
return false;
}
}
wiced_result_t socket_t::notify_disconnected(wiced_tcp_socket_t*, void* socket) {
if (socket && 0) {
// replace with unique_lock once the multithreading changes have been incorporated
SocketListLock lock(clients);
if (exists_socket((socket_t*)socket)) {
tcp_socket_t* tcp_socket = tcp((socket_t*)socket);
if (tcp_socket)
tcp_socket->notify_disconnected();
}
}
return WICED_SUCCESS;
}
int sendTcpWaitResp(CTSockCB & cb, char *p, int iLen, char *pResp, ADDR *a, void *pBase)
{
CTSockTcp tcp(cb);
tcp.createSock();
if(tcp._connect(a)<0)return -1;
tcp._send(p,iLen);
pResp[0]=0;
int l=tcp._recv(pResp,4096,20);
if(l==0 && *pResp)l=strlen(pResp);
if(l<0)return -2;
return l;
}
void contactPublishers(const std::string &topic,
const std::vector<std::string> &node_uris,
const SubscriptionCallback &callback) {
for (int i = 0; i < node_uris.size(); ++i) {
const std::string &endpoint = node_uris.at(i);
std::string addr = endpoint.substr(0, endpoint.find(":"));
int port = atoi(endpoint.substr(endpoint.find(":") + 1).c_str());
TransportTCPPtr tcp(new TransportTCP(ps_));
tcp->connect(addr, port);
ros2_proto::TopicRequest req_rep;
req_rep.request.topic = topic;
msc_.call(tcp, "requestTopic", req_rep,
boost::bind(&MasterRegistration::handleCallback, this, _1, callback));
}
}
/**
* Receives data from a socket.
* @param sd
* @param buffer
* @param len
* @param _timeout
* @return The number of bytes read. -1 if the end of the stream is reached.
*/
sock_result_t socket_receive(sock_handle_t sd, void* buffer, socklen_t len, system_tick_t _timeout)
{
sock_result_t bytes_read = -1;
socket_t* socket = from_handle(sd);
if (is_open(socket)) {
std::lock_guard<socket_t> lk(*socket);
if (is_tcp(socket)) {
tcp_socket_t* tcp_socket = tcp(socket);
tcp_packet_t& packet = tcp_socket->packet;
bytes_read = read_packet_and_dispose(packet, buffer, len, tcp_socket, _timeout);
}
else if (is_client(socket)) {
tcp_server_client_t* server_client = client(socket);
bytes_read = read_packet_and_dispose(server_client->packet, buffer, len, server_client->get_socket(), _timeout);
}
}
if (bytes_read<0)
DEBUG("socket_receive on %d returned %d", sd, bytes_read);
return bytes_read;
}
void startup(void)
{
printf("System is Starting...\n");
printf("Initializing Serial Port...\n");
if(roboLinkInit()>0)
{
printf("RoboLink is Ready.\n");
}
else
{
printf("RoboLink Init Failed.\n");
}
boost::thread udp(&udpServerTask);
printf("UDP Server is Running!\n");
boost::thread tcp(&tcpServerTask);
printf("TCP Server is Running!\n");
boost::thread control(&roboControlLoop);
printf("Robot Control Loop is Running!!");
triZero();
}
/* -----------------------------------------------------------------------------------------------------------*/
void ip( unsigned int packet_lenght , unsigned char *buffer )
{
struct ETH_header *ETH_packet; // ETH_struct anlegen
ETH_packet = (struct ETH_header *)&buffer[0];
struct IP_header *IP_packet; // IP_struct anlegen
IP_packet = ( struct IP_header *)&buffer[ETHERNET_HEADER_LENGTH];
// checke mal ob dat überhaupt für uns ist
// if ( IP_packet->IP_DestinationIP != myIP || IP_packet->IP_DestinationIP != 0xffffffff ) return;
switch ( IP_packet->IP_Protocol )
{
case 0x01: if (( IP_packet->IP_DestinationIP != myIP )&&( IP_packet->IP_DestinationIP !=myBroadcast)) return;
icmp( packet_lenght , buffer);
break;
case 0x06: if ( IP_packet->IP_DestinationIP != myIP ) return;
tcp( packet_lenght , buffer );
break;
case 0x11: udp( packet_lenght , buffer );
break;
}
}
void TcpServerTest::Run()
{
const char* sIP = NULL;
unsigned int uPort = 8877;
char sBuf[4096] = {0};
unsigned int uBufSize = sizeof(sBuf);
unsigned int uSigNo;
TcpServer tcp(sIP, uPort);
if (tcp.IsInitPass() == false) {
ERR_PRINT("Initialize TCP server failed!\n");
return;
}
while (true) {
if (SigUtil::Wait(0, &uSigNo)) {
if ((uSigNo == SIGINT) || (uSigNo == SIGTERM)) {
ERR_PRINT("Signal %s received. Terminating.\n", SigUtil::GetSignalString(uSigNo));
break;
}
}
if (tcp.Wait(100)) {
tcp.Accept();
}
if (tcp.WaitClient(0) == false) {
continue;
}
if (tcp.Recv(sBuf, uBufSize) == false) {
tcp.CloseClient();
continue;
}
DBG_PRINT("Received data: %s\n", sBuf);
}
}
/// Construct to represent the IPv6 TCP protocol.
static tcp v6()
{
return tcp(PF_INET6);
}
/// Construct to represent the IPv4 TCP protocol.
static tcp v4()
{
return tcp(PF_INET);
}
/// Construct to represent the IPv6 TCP protocol.
static tcp v6()
{
return tcp(BOOST_ASIO_OS_DEF(AF_INET6));
}
/**
* We'll just chain a handful of packets, since testing every combination would take forever and
* the inner functions were tested above anyway.
* The chain is V6 SYN --> V4 SYN --> V6 RST --> V6 SYN.
*
* TODO (test) see test_ipv4_udp().
*/
bool test_tcp( void )
{
struct sk_buff *skb;
struct session_entry *session;
struct tuple tuple;
bool success = true;
/* V6 SYN */
skb = init_packet_type_for_test( PACKET_TYPE_V6_SYN );
if (!skb)
goto failure;
if (!init_tuple_for_test_ipv6( &tuple, IPPROTO_TCP ))
goto failure;
success &= assert_equals_int(NF_ACCEPT, tcp( skb, &tuple ), "Closed-result");
session = session_get(&tuple);
success &= assert_not_null(session, "Closed-session");
if (session)
success &= assert_equals_u8(V6_INIT, session->state, "Closed-state");
kfree_skb(skb);
/* V4 SYN */
skb = init_packet_type_for_test( PACKET_TYPE_V4_SYN );
if (!skb)
goto failure;
if (!init_tuple_for_test_ipv4( &tuple, IPPROTO_TCP ))
goto failure;
success &= assert_equals_int(NF_ACCEPT, tcp( skb, &tuple ), "V6 init-result");
session = session_get(&tuple);
success &= assert_not_null(session, "V6 init-session");
if (session)
success &= assert_equals_u8(ESTABLISHED, session->state, "V6 init-state");
kfree_skb(skb);
/* V6 RST */
skb = init_packet_type_for_test( PACKET_TYPE_V6_RST );
if (!skb)
goto failure;
if (!init_tuple_for_test_ipv6( &tuple, IPPROTO_TCP ))
goto failure;
success &= assert_equals_int(NF_ACCEPT, tcp( skb, &tuple ), "Established-result");
session = session_get(&tuple);
success &= assert_not_null(session, "Established-session");
if (session)
success &= assert_equals_u8(TRANS, session->state, "Established-state");
kfree_skb(skb);
/* V6 SYN */
skb = init_packet_type_for_test( PACKET_TYPE_V6_SYN );
if (!skb)
goto failure;
if (!init_tuple_for_test_ipv6( &tuple, IPPROTO_TCP ))
goto failure;
success &= assert_equals_int(NF_ACCEPT, tcp( skb, &tuple ), "Trans-result");
session = session_get(&tuple);
success &= assert_not_null(session, "Trans-session");
if (session)
success &= assert_equals_u8(ESTABLISHED, session->state, "Trans-state");
kfree_skb(skb);
return success;
failure:
kfree_skb(skb);
return false;
}
void
ip(struct pktinfo *pktinfo)
{
register const struct ip *ipv4 = NULL;
register int ipv4_p = 0; /* next header */
const struct in_addr *ipv4_src = NULL;
const struct in_addr *ipv4_dst = NULL;
struct addr_4 addr_ipv4;
struct udphdr *udphdr = NULL;
struct tcphdr *tcphdr = NULL;
struct pktinfo n_hdr;
u_int32_t src = 0;
u_int32_t dst = 0;
char *addr = NULL;
const u_char *pkt = pktinfo->pkt;
bpf_u_int32 len = pktinfo->len;
ipv4 = (const struct ip *)pkt;
/* next header type code */
ipv4_p = ipv4->ip_p;
/* IPv4 address */
ipv4_src = &ipv4->ip_src;
ipv4_dst = &ipv4->ip_dst;
src = htonl(ipv4_src->s_addr);
dst = htonl(ipv4_dst->s_addr);
addr_ipv4.src = src;
addr_ipv4.dst = dst;
len -= sizeof(struct ip);
pkt += sizeof(struct ip);
n_hdr.len = len;
n_hdr.pkt = pkt;
addr_ipv4.p_tcp = NULL;
addr_ipv4.p_udp = NULL;
addr_ipv4.nxtflag = 0;
if (ipv4_p == IPPROTO_TCP) {
tcphdr = (struct tcphdr *)pkt;
addr_ipv4.p_tcp = tcphdr;
addr_ipv4.nxtflag = 1;
}
else if (ipv4_p == IPPROTO_UDP) {
udphdr = (struct udphdr *)pkt;
addr_ipv4.p_udp = udphdr;
addr_ipv4.nxtflag = 2;
}
addr = v4_addr(&addr_ipv4, encap);
encap ++;
switch(ipv4_p) {
case IPPROTO_IPV4 : /* IP header */
ip(&n_hdr);
break;
case IPPROTO_TCP : /* tcp */
if (rflag != 1)
tcp(&n_hdr);
break;
case IPPROTO_UDP : /* user datagram protocol */
if (bflag != 1)
udp(&n_hdr);
break;
case IPPROTO_IPV6 : /* IP6 header */
ipv6(&n_hdr);
break;
default:
} /* end of switch */
} /* end of ip() */
void ContextTCP::doit()
{
tcp()->accept(pkt_);
}
/// Construct to represent the IPv4 TCP protocol.
static tcp v4()
{
return tcp(AUTOBOOST_ASIO_OS_DEF(AF_INET));
}
virtual void stats(unsigned &keys,unsigned &triggers)
{
tcp()->stats(keys,triggers);
}
/**
* Main F&U routine. Called during the processing of every packet.
*
* Decides if "skb" should be processed, updating binding and session information.
*
* @param[in] skb packet being translated.
* @param[in] tuple skb's summary.
* @return indicator of what should happen to skb.
*/
verdict filtering_and_updating(struct packet *pkt, struct tuple *in_tuple)
{
struct ipv6hdr *hdr_ip6;
verdict result = VERDICT_CONTINUE;
log_debug("Step 2: Filtering and Updating");
switch (pkt_l3_proto(pkt)) {
case L3PROTO_IPV6:
/* ICMP errors should not be filtered or affect the tables. */
if (pkt_is_icmp6_error(pkt)) {
log_debug("Packet is ICMPv6 error; skipping step...");
return VERDICT_CONTINUE;
}
/* Get rid of hairpinning loops and unwanted packets. */
hdr_ip6 = pkt_ip6_hdr(pkt);
if (pool6_contains(&hdr_ip6->saddr)) {
log_debug("Hairpinning loop. Dropping...");
inc_stats(pkt, IPSTATS_MIB_INADDRERRORS);
return VERDICT_DROP;
}
if (!pool6_contains(&hdr_ip6->daddr)) {
log_debug("Packet was rejected by pool6; dropping...");
inc_stats(pkt, IPSTATS_MIB_INADDRERRORS);
return VERDICT_DROP;
}
break;
case L3PROTO_IPV4:
/* ICMP errors should not be filtered or affect the tables. */
if (pkt_is_icmp4_error(pkt)) {
log_debug("Packet is ICMPv4 error; skipping step...");
return VERDICT_CONTINUE;
}
/* Get rid of unexpected packets */
if (!pool4_contains(pkt_ip4_hdr(pkt)->daddr)) {
log_debug("Packet was rejected by pool4; dropping...");
inc_stats(pkt, IPSTATS_MIB_INADDRERRORS);
return VERDICT_DROP;
}
break;
}
/* Process packet, according to its protocol. */
switch (pkt_l4_proto(pkt)) {
case L4PROTO_UDP:
switch (pkt_l3_proto(pkt)) {
case L3PROTO_IPV6:
result = ipv6_simple(pkt, in_tuple);
break;
case L3PROTO_IPV4:
result = ipv4_simple(pkt, in_tuple);
break;
}
break;
case L4PROTO_TCP:
result = tcp(pkt, in_tuple);
break;
case L4PROTO_ICMP:
switch (pkt_l3_proto(pkt)) {
case L3PROTO_IPV6:
if (config_get_filter_icmpv6_info()) {
log_debug("Packet is ICMPv6 info (ping); dropping due to policy.");
inc_stats(pkt, IPSTATS_MIB_INDISCARDS);
return VERDICT_DROP;
}
result = ipv6_simple(pkt, in_tuple);
break;
case L3PROTO_IPV4:
result = ipv4_simple(pkt, in_tuple);
break;
}
break;
case L4PROTO_OTHER:
WARN(true, "Unknown layer 4 protocol (%d)...", pkt_l4_proto(pkt));
break;
}
log_debug("Done: Step 2.");
return result;
}
/*
* ipv4 stack
*
* code: PKT_UP, send to up layer
* PKT_ENQ, in out queue
* PKT_DROP, drop the packet
*/
int upv4(pcs *pc, struct packet **m0)
{
struct packet *m = *m0;
struct packet *p = NULL;
ethdr *eh = (ethdr *)(m->data);
u_int *si, *di;
if (eh->type == htons(ETHERTYPE_IPV6))
return upv6(pc, m0);
/* not ipv4 or arp */
if ((eh->type != htons(ETHERTYPE_IP)) &&
(eh->type != htons(ETHERTYPE_ARP)))
return PKT_DROP;
if (etherIsMulticast(eh->src))
return PKT_DROP;
if (memcmp(eh->dst, pc->ip4.mac, ETH_ALEN) == 0 &&
((u_short*)m->data)[6] == htons(ETHERTYPE_IP)) {
iphdr *ip = (iphdr *)(eh + 1);
if (ntohs(ip->len) > pc->mtu) {
p = icmpReply(m, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG);
if (p) {
fix_dmac(pc, p);
if (pc->ip4.flags & IPF_FRAG) {
p = ipfrag(p, pc->mtu);
}
enq(&pc->oq, p);
}
return PKT_ENQ;
}
if (ntohs(ip->frag) & (IP_MF | IP_OFFMASK)) {
m = ipreass(m);
if (m == NULL)
return PKT_ENQ;
else
*m0 = m;
ip = (iphdr *)(m->data + sizeof(ethdr));
}
/* ping me, reply */
if (ip->proto == IPPROTO_ICMP) {
icmphdr *icmp = (icmphdr *)(ip + 1);
if (ip->dip != pc->ip4.ip)
return PKT_DROP;
/* other type will be sent to application */
if (icmp->type != ICMP_ECHO)
return PKT_UP;
p = icmpReply(m, ICMP_ECHOREPLY, 0);
if (p != NULL) {
enq(&pc->bgoq, p);
}
return PKT_ENQ;
} else if (ip->proto == IPPROTO_UDP) {
udpiphdr *ui;
char *data = NULL;
ui = (udpiphdr *)ip;
if (IN_MULTICAST(ip->dip))
return PKT_DROP;
/* dhcp packet */
if (ui->ui_sport == htons(67) && ui->ui_dport == htons(68))
return PKT_UP;
if (ip->dip != pc->ip4.ip)
return PKT_DROP;
/* dns response */
if (ui->ui_sport == htons(53))
return PKT_UP;
data = ((char*)(ui + 1));
/* udp echo reply */
if (memcmp(data, eh->dst, ETH_ALEN) == 0)
return PKT_UP;
else {
struct packet *p;
if (ip->ttl == 1)
p = icmpReply(m, ICMP_UNREACH, ICMP_UNREACH_PORT);
else
p = udpReply(m);
if (p != NULL) {
enq(&pc->bgoq, p);
}
}
/* anyway tell caller to drop this packet */
return PKT_DROP;
} else if (ip->proto == IPPROTO_TCP) {
if (ip->dip != pc->ip4.ip)
return PKT_DROP;
return tcp(pc, m);
}
} else if (eh->type == htons(ETHERTYPE_ARP)) {
arphdr *ah = (arphdr *)(eh + 1);
si = (u_int *)ah->sip;
di = (u_int *)ah->dip;
/* arp reply */
if (ah->op == htons(ARPOP_REQUEST) &&
di[0] == pc->ip4.ip) {
save_eaddr(pc, si[0], ah->sea);
ah->op = htons(ARPOP_REPLY);
memcpy(ah->dea, ah->sea, ETH_ALEN);
memcpy(ah->sea, pc->ip4.mac, ETH_ALEN);
di[0] = si[0];
si[0] = pc->ip4.ip;
encap_ehead(m->data, pc->ip4.mac, eh->src,
ETHERTYPE_ARP);
enq(&pc->oq, m);
return PKT_ENQ;
} else if (ah->op == htons(ARPOP_REPLY) &&
sameNet(di[0], pc->ip4.ip, pc->ip4.cidr)) {
save_eaddr(pc, si[0], ah->sea);
}
return PKT_DROP;
} else if (strncmp((const char *)eh->dst, (const char *)pc->ip4.mac,
ETH_ALEN) != 0)
return PKT_DROP;
return PKT_UP;
}
void callMaster(const std::string &method, const M &req_rep,
const typename ServiceResponseT<M>::Callback &cb) {
TransportTCPPtr tcp(new TransportTCP(ps_));
tcp->connect(master_.addr(), master_.port());
msc_.call(tcp, method, req_rep, cb);
}
void callMaster(const std::string &method, const M &req_rep) {
TransportTCPPtr tcp(new TransportTCP(ps_));
tcp->connect(master_.addr(), master_.port());
msc_.call(tcp, method, req_rep,
boost::bind(&MasterRegistration::emptyCallback<M>, this, _1));
}
/// Construct to represent the IPv4 TCP protocol.
static tcp v4()
{
return tcp(ASIO_OS_DEF(AF_INET));
}
