DTerr DeviceNetworkSockets::resolve_host (NetworkAddress &ip, const std::string &host, DTushort port)
{
std::string real_host = Globals::substitute_global(host);
struct addrinfo hints, *res;
// get address info
::bzero(&hints, sizeof(hints));
#if defined(DT3_USE_IPV6) && DT3_USE_IPV6
hints.ai_family = AF_UNSPEC;
#else
hints.ai_family = AF_INET;
#endif
hints.ai_socktype = SOCK_STREAM;
DTint err = ::getaddrinfo( (host.size() == 0) ? NULL : real_host.c_str(), MoreStrings::cast_to_string(port).c_str(), &hints, &res);
if (err != 0) {
return DT3_ERR_NET_UNKNOWN;
}
// save the results for freeing later
if (res != NULL) {
ip.set_network_address(address_to_string(res->ai_addr));
::freeaddrinfo(res);
return DT3_ERR_NONE;
} else {
::freeaddrinfo(res);
return DT3_ERR_NET_UNKNOWN;
}
}
DTerr DeviceNetworkSockets::udp_recv (NetworkPacket &packet, const NetworkSocket &socket)
{
if (socket.is_empty())
return DT3_ERR_NONE;
DTint socket_raw = *reinterpret_cast<DTint*>(socket.network_socket_data());
struct sockaddr from;
socklen_t from_size = sizeof(from);
DTsize size = ::recvfrom( socket_raw,
packet.data(),
(DTuint) packet.data_size(),
0,
&from,
&from_size
);
if (size > 0) {
packet.set_network_address( address_to_string(&from) );
packet.set_data_size(size);
} else {
switch (errno) {
case EWOULDBLOCK: return DT3_ERR_NET_WOULD_BLOCK;
default: return DT3_ERR_NET_UNKNOWN;
};
}
return DT3_ERR_NONE;
}
DTerr DeviceNetworkSockets::tcp_accept (NetworkSocket &connection_socket, NetworkAddress &ip, const NetworkSocket &listen_socket)
{
if (listen_socket.is_empty())
return DT3_ERR_NONE;
DTint listen_socket_raw = *reinterpret_cast<DTint*>(listen_socket.network_socket_data());
struct sockaddr_storage sast;
struct sockaddr *sa = (struct sockaddr *) &sast;
socklen_t sas = sizeof(sast);
DTint connection_socket_raw = ::accept(listen_socket_raw, (sockaddr *) sa, &sas);
if (connection_socket_raw < 0) {
if (errno == EWOULDBLOCK) {
return DT3_ERR_NET_WOULD_BLOCK;
}
LOG_MESSAGE << "TCPAccept: accept: " << strerror(errno) << " (" << (DTuint) errno << ")";
return DT3_ERR_NET_UNKNOWN;
}
// set up non-blocking reads and writes
DTint val = ::fcntl(connection_socket_raw, F_GETFL, 0);
::fcntl(connection_socket_raw, F_SETFL, val | O_NONBLOCK);
connection_socket.set_network_socket_data((DTubyte*) &connection_socket_raw, sizeof(connection_socket_raw));
ip.set_network_address(address_to_string( (const struct sockaddr *) sa));
return DT3_ERR_NONE;
}
// Initializes event-driven connection listener on 127.0.0.1:port,
// with given accept and error callbacks.
// Returns pointer to listener or 0 on error
struct evconnlistener *listener_init_local(struct event_base *base, int port,
evconnlistener_cb accept_cb, void *state,
evconnlistener_errorcb error_cb /* optional */)
{
if (error_cb == NULL) {
error_cb = listener_default_error_cb;
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); // i.e., 127.0.0.1
sin.sin_port = htons(port);
struct evconnlistener *listener;
listener = evconnlistener_new_bind(base, accept_cb, state,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
return 0;
}
evconnlistener_set_error_cb(listener, error_cb);
char addr[255];
address_to_string(&sin, addr, sizeof(addr));
LogInfo("listener", "Listening on %s", addr);
return listener;
}
// Printing stuff
std::string Player::toString()
{
std::string out("[");
out += name;
out += "@";
out += address_to_string();
out += "]";
return out;
}
void CoAPWrapper::get_default_con(CoAPCallback &callback, std::string &con)
{
#ifndef INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN 40
#endif
unsigned char addr[INET6_ADDRSTRLEN+8];
coap_address_t *remote = (coap_address_t *)callback.peer_;
memset(addr, 0, sizeof(addr));
address_to_string(remote, addr, INET6_ADDRSTRLEN+8);
con = std::string("coap://") + std::string((char*)addr);
}
// FIXME: find another place for this function
void set_or_update_DRx_breakpoint(BP *bp, CONTEXT *ctx, unsigned DRx_no)
{
oassert (bp->a->resolved);
if (utils_c_debug)
{
strbuf sb=STRBUF_INIT;
address_to_string(bp->a, &sb);
L ("%s(): begin. setting DRx-breakpoint %d for %s at 0x" PRI_ADR_HEX "\n",
__func__, DRx_no, sb.buf, bp->a->abs_address);
strbuf_deinit (&sb);
};
if (bp->t==BP_type_BPF || bp->t==BP_type_BPX)
CONTEXT_setDRx_and_DR7 (ctx, DRx_no, bp->a->abs_address);
else if (bp->t==BP_type_BPM)
BPM_set_or_update_DRx_breakpoint(bp->u.bpm, bp->a->abs_address, DRx_no, ctx);
else
{
oassert(0);
fatal_error();
};
if (utils_c_debug)
L ("%s() end\n", __func__);
};
void handle_BPM(process *p, thread *t, int bp_no, CONTEXT *ctx, MemoryCache *mc)
{
BP *bp=breakpoints[bp_no];
BPM *bpm=bp->u.bpm;
address a=bp->a->abs_address;
bool b;
REG val;
const char* v_type;
switch (bpm->width)
{
case 1:
{
v_type="BYTE";
byte tmp;
b=MC_ReadByte (mc, a, &tmp);
oassert(b);
val=tmp;
};
break;
case 2:
{
v_type="WORD";
wyde tmp;
b=MC_ReadWyde (mc, a, &tmp);
oassert(b);
val=tmp;
};
break;
case 4:
{
v_type="DWORD";
DWORD tmp;
b=MC_ReadTetrabyte (mc, a, &tmp);
oassert(b);
val=tmp;
};
break;
case 8:
{
#ifdef _WIN64
v_type="QWORD";
DWORD64 tmp;
b=MC_ReadOctabyte (mc, a, &tmp);
oassert(b);
val=tmp;
#else
oassert (0);
#endif
};
break;
default:
oassert(0);
fatal_error();
};
strbuf sb_sym=STRBUF_INIT, sb_bp_adr=STRBUF_INIT;
address PC=CONTEXT_get_PC(ctx);
process_get_sym (p, PC, true, true, &sb_sym);
address_to_string(bp->a, &sb_bp_adr);
dump_PID_if_need(p); dump_TID_if_need(p, t);
L ("(%d) some code at %s (0x" PRI_ADR_HEX ") %s %s variable at %s (it contain 0x" PRI_REG_HEX
" after execution of that instruction)\n",
bp_no, sb_sym.buf, PC, bpm->t==BPM_type_RW ? "reading or writting" : "writting",
v_type, sb_bp_adr.buf, val);
//MC_WriteOctabyte(mc, bp->a->abs_address, 0); // can be option?
strbuf_deinit(&sb_bp_adr);
strbuf_deinit(&sb_sym);
};
