void cTCPLinkImpl::UpdateAddress(const sockaddr * a_Address, socklen_t a_AddrLen, AString & a_IP, UInt16 & a_Port)
{
// Based on the family specified in the address, use the correct datastructure to convert to IP string:
char IP[128];
switch (a_Address->sa_family)
{
case AF_INET: // IPv4:
{
const sockaddr_in * sin = reinterpret_cast<const sockaddr_in *>(a_Address);
evutil_inet_ntop(AF_INET, &(sin->sin_addr), IP, sizeof(IP));
a_Port = ntohs(sin->sin_port);
break;
}
case AF_INET6: // IPv6
{
const sockaddr_in6 * sin = reinterpret_cast<const sockaddr_in6 *>(a_Address);
evutil_inet_ntop(AF_INET6, &(sin->sin6_addr), IP, sizeof(IP));
a_Port = ntohs(sin->sin6_port);
break;
}
default:
{
LOGWARNING("%s: Unknown socket address family: %d", __FUNCTION__, a_Address->sa_family);
ASSERT(!"Unknown socket address family");
break;
}
}
a_IP.assign(IP);
}
char const *
endpoint_presentation(struct endpoint const *e)
{
static char name[INET6_ADDRSTRLEN];
switch (e->addr.ss_family)
{
case AF_INET:
{
struct sockaddr_in *sin = (struct sockaddr_in *)&e->addr;
char tmp[INET_ADDRSTRLEN];
evutil_inet_ntop(AF_INET, &sin->sin_addr, tmp, sizeof tmp);
evutil_snprintf(name, INET6_ADDRSTRLEN, "%s:%d", tmp, ntohs(sin->sin_port));
break;
}
case AF_INET6:
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&e->addr;
char tmp[INET6_ADDRSTRLEN];
evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, tmp, sizeof tmp);
evutil_snprintf(name, INET6_ADDRSTRLEN, "%s:%d", tmp, ntohs(sin6->sin6_port));
break;
}
default:
{
log_warnx("[ENDPOINT] presentation doesn't handle protocol", e->addr.ss_family);
}
}
return name;
}
/** Converts the SOCKET_ADDRESS structure received from the OS into an IP address string. */
static AString PrintAddress(SOCKET_ADDRESS & a_Addr)
{
char IP[128];
switch (a_Addr.lpSockaddr->sa_family)
{
case AF_INET:
{
auto sin = reinterpret_cast<const sockaddr_in *>(a_Addr.lpSockaddr);
evutil_inet_ntop(a_Addr.lpSockaddr->sa_family, &(sin->sin_addr), IP, sizeof(IP));
break;
}
case AF_INET6:
{
auto sin = reinterpret_cast<const sockaddr_in6 *>(a_Addr.lpSockaddr);
evutil_inet_ntop(a_Addr.lpSockaddr->sa_family, &(sin->sin6_addr), IP, sizeof(IP));
break;
}
default:
{
IP[0] = 0;
break;
}
}
return IP;
}
const char *
tr_address_to_string_with_buf (const tr_address * addr, char * buf, size_t buflen)
{
assert (tr_address_is_valid (addr));
if (addr->type == TR_AF_INET)
return evutil_inet_ntop (AF_INET, &addr->addr, buf, buflen);
else
return evutil_inet_ntop (AF_INET6, &addr->addr, buf, buflen);
}
static void dns_cb(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
struct evutil_addrinfo *ai;
struct timeval tv;
const char *host = ptr;
if (errcode) {
tmate_status_message("%s lookup failure. Retrying in %d seconds (%s)",
host, TMATE_DNS_RETRY_TIMEOUT,
evutil_gai_strerror(errcode));
tv.tv_sec = TMATE_DNS_RETRY_TIMEOUT;
tv.tv_usec = 0;
evtimer_assign(&tmate_session.ev_dns_retry, tmate_session.ev_base,
on_dns_retry, NULL);
evtimer_add(&tmate_session.ev_dns_retry, &tv);
return;
}
tmate_status_message("Connecting to %s...", host);
for (ai = addr; ai; ai = ai->ai_next) {
char buf[128];
const char *ip = NULL;
if (ai->ai_family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, 128);
} else if (ai->ai_family == AF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, 128);
}
tmate_debug("Trying server %s", ip);
/*
* Note: We don't deal with the client list. Clients manage it
* and free client structs when necessary.
*/
(void)tmate_ssh_client_alloc(&tmate_session, ip);
}
evutil_freeaddrinfo(addr);
/*
* XXX For some reason, freeing the DNS resolver makes MacOSX flip out...
* not sure what's going on...
* evdns_base_free(tmate_session.ev_dnsbase, 0);
* tmate_session.ev_dnsbase = NULL;
*/
}
char const* tr_address_to_string_with_buf(tr_address const* addr, char* buf, size_t buflen)
{
TR_ASSERT(tr_address_is_valid(addr));
if (addr->type == TR_AF_INET)
{
return evutil_inet_ntop(AF_INET, &addr->addr, buf, buflen);
}
else
{
return evutil_inet_ntop(AF_INET6, &addr->addr, buf, buflen);
}
}
int Socks5Req::parse(evbuffer *input) {
auto len = evbuffer_get_length(input);
if (len <= 6) return 1;
uint8_t buffer[512];
evbuffer_copyout(input, buffer, 6);
if (buffer[0] != 0x5) return -1;
switch (buffer[1]) {
case 0x1:
this->cmd = CONNECT;
break;
case 0x02:
this->cmd = BIND;
break;
case 0x03:
this->cmd = UDP;
break;
}
size_t addrlen = 0;
switch (buffer[3]) {
case 0x01: {
this->addressType = IPV4;
addrlen = 4;
if (len < 6 + addrlen) return 1;
evbuffer_remove(input, buffer, sizeof(buffer));
this->port = ntohs(*(uint16_t *)(buffer + 4 + addrlen));
evutil_inet_ntop(AF_INET, buffer + 4, this->addr, sizeof(this->addr));
} break;
case 0x03:
this->addressType = DOMAINNAME;
addrlen = buffer[4];
if (len < 6 + addrlen + 1) return 1;
evbuffer_remove(input, buffer, sizeof(buffer));
this->port = ntohs(*(uint16_t *)(buffer + 5 + addrlen));
memcpy(this->addr, buffer + 5, addrlen);
this->addr[addrlen] = '\0';
break;
case 0x04: {
this->addressType = IPV6;
addrlen = 16;
if (len < 6 + addrlen) return 1;
evbuffer_remove(input, buffer, sizeof(buffer));
this->port = ntohs(*(uint16_t *)(buffer + 4 + addrlen));
evutil_inet_ntop(AF_INET6, buffer + 4, this->addr, sizeof(this->addr));
} break;
}
return 0;
}
void cServerHandleImpl::Callback(evconnlistener * a_Listener, evutil_socket_t a_Socket, sockaddr * a_Addr, int a_Len, void * a_Self)
{
// Cast to true self:
cServerHandleImpl * Self = reinterpret_cast<cServerHandleImpl *>(a_Self);
ASSERT(Self != nullptr);
ASSERT(Self->m_SelfPtr != nullptr);
// Get the textual IP address and port number out of a_Addr:
char IPAddress[128];
UInt16 Port = 0;
switch (a_Addr->sa_family)
{
case AF_INET:
{
sockaddr_in * sin = reinterpret_cast<sockaddr_in *>(a_Addr);
evutil_inet_ntop(AF_INET, &(sin->sin_addr), IPAddress, ARRAYCOUNT(IPAddress));
Port = ntohs(sin->sin_port);
break;
}
case AF_INET6:
{
sockaddr_in6 * sin6 = reinterpret_cast<sockaddr_in6 *>(a_Addr);
evutil_inet_ntop(AF_INET6, &(sin6->sin6_addr), IPAddress, ARRAYCOUNT(IPAddress));
Port = ntohs(sin6->sin6_port);
break;
}
}
// Call the OnIncomingConnection callback to get the link callbacks to use:
cTCPLink::cCallbacksPtr LinkCallbacks = Self->m_ListenCallbacks->OnIncomingConnection(IPAddress, Port);
if (LinkCallbacks == nullptr)
{
// Drop the connection:
evutil_closesocket(a_Socket);
return;
}
// Create a new cTCPLink for the incoming connection:
cTCPLinkImplPtr Link = std::make_shared<cTCPLinkImpl>(a_Socket, LinkCallbacks, Self->m_SelfPtr, a_Addr, static_cast<socklen_t>(a_Len));
{
cCSLock Lock(Self->m_CS);
Self->m_Connections.push_back(Link);
} // Lock(m_CS)
LinkCallbacks->OnLinkCreated(Link);
Link->Enable(Link);
// Call the OnAccepted callback:
Self->m_ListenCallbacks->OnAccepted(*Link);
}
static bool HHVM_STATIC_METHOD(EventUtil, getSocketName, const Resource &socket, VRefParam address, VRefParam port){
evutil_socket_t fd = resource_to_fd(socket);
struct sockaddr sa;
socklen_t sa_len = sizeof(struct sockaddr);
long l_port = 0;
if (getsockname(fd, &sa, &sa_len)) {
raise_warning("Unable to retreive socket name.");
return false;
}
switch (sa.sa_family) {
case AF_INET:
{
struct sockaddr_in *sa_in = (struct sockaddr_in *) &sa;
char c_addr[INET_ADDRSTRLEN + 1];
if (evutil_inet_ntop(sa.sa_family, &sa_in->sin_addr, c_addr, sizeof(c_addr))) {
address = StringData::Make(c_addr, CopyString);
l_port = ntohs(sa_in->sin_port);
}
}
break;
#ifdef AF_INET6
case AF_INET6: {
struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *) &sa;
char c_addr6[INET6_ADDRSTRLEN + 1];
if (evutil_inet_ntop(sa.sa_family, &sa_in6->sin6_addr, c_addr6, sizeof(c_addr6))) {
address = StringData::Make(c_addr6, CopyString);
l_port = ntohs(sa_in6->sin6_port);
}
break;
}
#endif
#ifdef HAVE_SYS_UN_H
case AF_UNIX: {
struct sockaddr_un *ua = (struct sockaddr_un *) &sa;
address = StringData::Make(ua->sun_path, CopyString);
break;
}
#endif
default:
raise_warning("Unsupported address family.");
return false;
}
if(port.isReferenced()){
port = l_port;
}
return true;
}
static void
ipv6_query_cb(int result, char type, int count, int ttl,
void * const ips_, void * const app_context_)
{
char ip_s_buf[INET6_ADDRSTRLEN + 1U];
AppContext *app_context = app_context_;
struct in6_addr *ips = ips_;
const char *ip_s;
int i = 0;
(void) ttl;
if (result != DNS_ERR_NONE) {
query_cb_err_print(result);
}
assert(type == DNS_IPv6_AAAA);
assert(count >= 0);
while (i < count) {
ip_s = evutil_inet_ntop(AF_INET6, &ips[i], ip_s_buf, sizeof ip_s_buf);
if (ip_s != NULL) {
puts(ip_s);
}
i++;
}
event_base_loopexit(app_context->event_loop, NULL);
}
void diplay_socket_information(struct evhttp_bound_socket *handle) {
struct sockaddr_storage ss;
evutil_socket_t fd;
ev_socklen_t socklen = sizeof(ss);
char addrbuf[128];
void *inaddr;
const char *addr;
int got_port = -1;
fd = evhttp_bound_socket_get_fd(handle);
memset(&ss, 0, sizeof(ss));
if (getsockname(fd, (struct sockaddr *)&ss, &socklen)) {
perror("getsockname() failed");
exit(1);
}
if (ss.ss_family == AF_INET) {
got_port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
inaddr = &((struct sockaddr_in*)&ss)->sin_addr;
} else {
fprintf(stderr, "Weird address family %d\n", ss.ss_family);
exit(1);
}
addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf, sizeof(addrbuf));
if (addr) {
printf("Listening on %s:%d\n", addr, got_port);
evutil_snprintf(uri_root, sizeof(uri_root),
"http://%s:%d",addr,got_port);
} else {
fprintf(stderr, "evutil_inet_ntop failed\n");
exit(1);
}
}
static void
socks_accept_cb(struct evconnlistener *lis, evutil_socket_t fd,
struct sockaddr *addr, int len, void *ptr)
{
obfsproxyssh_client_t *client = ptr;
obfsproxyssh_t *state = client->state;
obfsproxyssh_client_session_t *session;
struct sockaddr_in *sa;
char addr_buf[INET_ADDRSTRLEN];
uint32_t tmp;
assert(lis == client->listener);
/*
* It is possible to defer allocating the session object till after the
* SOCKS protocol handling is done, but there isn't much point in doing
* so.
*/
session = calloc(1, sizeof(obfsproxyssh_client_session_t));
if (NULL == session) {
log_f(state, "SOCKS: Error: Failed to allocate session");
goto out_close;
}
session->socks_ev = bufferevent_socket_new(state->base, fd,
BEV_OPT_CLOSE_ON_FREE);
if (NULL == session->socks_ev) {
log_f(state, "SOCKS: Error: Failed to allocate bev");
free(session);
goto out_close;
}
bufferevent_setcb(session->socks_ev, socks_read_cb, NULL,
socks_event_cb, session);
bufferevent_enable(session->socks_ev, EV_READ | EV_WRITE);
sa = (struct sockaddr_in *) addr;
if (0 == state->unsafe_logging) {
tmp = ntohl(sa->sin_addr.s_addr);
tmp &= 0x000000ff;
session->socks_addr = bformat("xxx.xxx.xxx.%d:%d", tmp,
ntohs(sa->sin_port));
} else {
evutil_inet_ntop(AF_INET, &sa->sin_addr, addr_buf,
INET_ADDRSTRLEN);
session->socks_addr = bformat("%s:%d", addr_buf,
ntohs(sa->sin_port));
}
/* TODO: Set the timeout */
LIST_INSERT_HEAD(&client->sessions, session, entries);
session->client = client;
log_f(state, "SOCKS: %s Connect", bdata(session->socks_addr));
return;
out_close:
evutil_closesocket(fd);
}
void CDNSManager::LookupDNSCallback(int _errcode, struct evutil_addrinfo *_addr, void* _context)
{
DNS_RECORD_t* record = (DNS_RECORD_t*)_context;
if (_errcode)
{
LOG_ERROR_STREAM << "Fail to parse " << record->name << ": " << evutil_gai_strerror(_errcode);
}
else
{
record->address.clear();
record->visitTime = time(NULL);
record->status = MAIN_TABLE_RECORD_t::STATUS_e::STATUS_READY;
if (_addr->ai_canonname) record->cname = _addr->ai_canonname;
//
// get ip addresses
//
struct evutil_addrinfo *ai;
for (ai = _addr; ai; ai = ai->ai_next)
{
char buf[128] = { 0 };
const char* ipAddr = NULL;
if (ai->ai_family == AF_INET)
{
struct sockaddr_in* sin = (struct sockaddr_in *)ai->ai_addr;
ipAddr = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf));
}
else if (ai->ai_family == AF_INET6)
{
struct sockaddr_in6* sin6 = (struct sockaddr_in6 *)ai->ai_addr;
ipAddr = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf));
}
if (ipAddr)
{
record->address += ipAddr;
record->address += ", ";
}
}
evutil_freeaddrinfo(_addr);
}
if (--s_pendingLookupCount == 0)
event_base_loopexit(CDNSManager::GetInstance()->m_evbase, NULL);
}
char *
sock_ntop(const struct sockaddr *sa, socklen_t salen)
{
static char str[128]; /* Unix domain is largest */
switch (sa->sa_family) {
case AF_INET: {
struct sockaddr_in *sin = (struct sockaddr_in *) sa;
if (evutil_inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str)) == NULL)
return(NULL);
return(str);
}
#ifdef IPv6
case AF_INET6: {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
if (evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str) - 1) == NULL)
return(NULL);
return (str);
}
#endif
#ifndef WIN32
#ifdef AF_UNIX
case AF_UNIX: {
struct sockaddr_un *unp = (struct sockaddr_un *) sa;
/* OK to have no pathname bound to the socket: happens on
every connect() unless client calls bind() first. */
if (unp->sun_path[0] == 0)
strcpy(str, "(no pathname bound)");
else
snprintf(str, sizeof(str), "%s", unp->sun_path);
return(str);
}
#endif
#endif
default:
snprintf(str, sizeof(str), "sock_ntop: unknown AF_xxx: %d, len %d",
sa->sa_family, salen);
return(str);
}
return (NULL);
}
static void
accept_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *a, int slen, void *p)
{
/* Extract and display the address we're connect. */
struct sockaddr_storage ss;
ev_socklen_t socklen = sizeof(ss);
char addrbuf[128];
void *inaddr;
const char *addr;
int got_port = -1;
memset(&ss, 0, sizeof(ss));
if (getpeername(fd, (struct sockaddr *)&ss, &socklen)) {
perror("getpeerkname() failed");
return ;
}
if (ss.ss_family == AF_INET) {
got_port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
inaddr = &((struct sockaddr_in*)&ss)->sin_addr;
} else if (ss.ss_family == AF_INET6) {
got_port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
inaddr = &((struct sockaddr_in6*)&ss)->sin6_addr;
} else {
fprintf(stderr, "Weird address family %d\n",
ss.ss_family);
return;
}
addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf, sizeof(addrbuf));
if (addr) {
printf("connection from address %s:%d\n", addr, got_port);
} else {
fprintf(stderr, "evutil_inet_ntop failed\n");
return ;
}
struct bufferevent *b_out, *b_in;
/* Create two linked bufferevent objects: one to connect, one for the
* new connection */
b_in = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
b_out = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
assert(b_in && b_out);
if (bufferevent_socket_connect(b_out, (struct sockaddr*)&connect_to_addr, connect_to_addrlen) < 0)
{
perror("bufferevent_socket_connect");
bufferevent_free(b_out);
bufferevent_free(b_in);
return;
}
bufferevent_setcb(b_in, readcbin, NULL, eventcbin, b_out);
bufferevent_setcb(b_out, readcbout, NULL, eventcbout, b_in);
bufferevent_enable(b_in, EV_READ|EV_WRITE);
bufferevent_enable(b_out, EV_READ|EV_WRITE);
}
static char * addrinfo_to_string(struct evutil_addrinfo *ai) {
char *buf,*out;
const char *s=0;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
buf = safe_malloc(ADDRMAX);
if(ai->ai_family == AF_INET) {
sin = (struct sockaddr_in *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET,&sin->sin_addr,buf,ADDRMAX);
} else if (ai->ai_family == AF_INET6) {
sin6 = (struct sockaddr_in6 *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET6,&sin6->sin6_addr,buf,ADDRMAX);
}
out = strdup(s);
free(buf);
return out;
}
static void
regress_ipv6_parse(void *ptr)
{
#ifdef AF_INET6
int i, j;
for (i = 0; ipv6_entries[i].addr; ++i) {
char written[128];
struct ipv6_entry *ent = &ipv6_entries[i];
struct in6_addr in6;
int r;
r = evutil_inet_pton(AF_INET6, ent->addr, &in6);
if (r == 0) {
if (ent->status != BAD)
TT_FAIL(("%s did not parse, but it's a good address!",
ent->addr));
continue;
}
if (ent->status == BAD) {
TT_FAIL(("%s parsed, but we expected an error", ent->addr));
continue;
}
for (j = 0; j < 4; ++j) {
/* Can't use s6_addr32 here; some don't have it. */
ev_uint32_t u =
((ev_uint32_t)in6.s6_addr[j*4 ] << 24) |
((ev_uint32_t)in6.s6_addr[j*4+1] << 16) |
((ev_uint32_t)in6.s6_addr[j*4+2] << 8) |
((ev_uint32_t)in6.s6_addr[j*4+3]);
if (u != ent->res[j]) {
TT_FAIL(("%s did not parse as expected.", ent->addr));
continue;
}
}
if (ent->status == CANONICAL) {
const char *w = evutil_inet_ntop(AF_INET6, &in6, written,
sizeof(written));
if (!w) {
TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
continue;
}
if (strcmp(written, ent->addr)) {
TT_FAIL(("Tried to write out %s; got %s", ent->addr, written));
continue;
}
}
}
#else
TT_BLATHER(("Skipping IPv6 address parsing."));
#endif
}
void Spider_Url_Rinse::dns_callback(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
dns_cb_arg *arg = (dns_cb_arg *)ptr;
UrlPtr myurl = arg->url_ptr;
if (errcode)
{
LLOG(L_ERROR,"DNS parse error:%s -> %s\n", myurl->domain, evutil_gai_strerror(errcode));
}
else
{
struct evutil_addrinfo *ai=addr;
char buf[128];
const char *s = NULL;
if (addr->ai_family == AF_INET)
{
struct sockaddr_in *sin =(struct sockaddr_in *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, 128); /*从套接口内部数据类型转换为点分十进制 */
}
else if (addr->ai_family == AF_INET6)
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf,128);
}
if (s)
{
myurl->ip=strdup(s);
arg->pthis->put_url_to_executor(myurl);
arg->pthis->m_dns_database[std::string(myurl->domain)] = std::string(myurl->ip);
arg->pthis->record_domain(myurl->domain);
}
evutil_freeaddrinfo(addr);
}
if (--g_pending_requests == 0)
{
event_base_loopexit(arg->pthis->m_evbase, NULL);
}
}
static void showConn(struct IpTunnel_Connection* conn, String* txid, struct Admin* admin)
{
struct Allocator* alloc;
BufferAllocator_STACK(alloc, 1024);
Dict* d = Dict_new(alloc);
char ip6[40];
if (!Bits_isZero(conn->connectionIp6, 16)) {
Assert_always(evutil_inet_ntop(AF_INET6, conn->connectionIp6, ip6, 40));
Dict_putString(d, String_CONST("ip6Address"), String_CONST(ip6), alloc);
}
char ip4[16];
if (!Bits_isZero(conn->connectionIp4, 4)) {
Assert_always(evutil_inet_ntop(AF_INET, conn->connectionIp4, ip4, 16));
Dict_putString(d, String_CONST("ip4Address"), String_CONST(ip4), alloc);
}
Dict_putString(d, String_CONST("key"), Key_stringify(conn->header.nodeKey, alloc), alloc);
Dict_putInt(d, String_CONST("outgoing"), conn->isOutgoing, alloc);
Admin_sendMessage(d, txid, admin);
}
const char *
format_addr(const struct sockaddr *addr)
{
const char *r = NULL;
static char buf[256];
char tmp[256];
if (addr->sa_family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)addr;
r = evutil_inet_ntop(AF_INET, &sin->sin_addr, tmp,
sizeof(tmp));
if (r) {
if (sin->sin_port)
evutil_snprintf(buf, sizeof(buf), "%s:%hu",
tmp, ntohs(sin->sin_port));
else
strcpy(buf, tmp);
}
} else if (addr->sa_family == AF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
r = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, tmp,
sizeof(tmp));
if (r) {
if (sin6->sin6_port)
evutil_snprintf(buf, sizeof(buf), "[%s]:%hu",
tmp, ntohs(sin6->sin6_port));
else
strcpy(buf, tmp);
}
}
if (!r)
strcpy(buf, "???"); // XXX: Is this really a reasonable thing to return?
return buf;
}
static int http_get_address(struct evhttp_bound_socket *handle, char *buffer, int buflen)
{
/* Extract and display the address we're listening on. */
struct sockaddr_storage ss;
evutil_socket_t fd;
ev_socklen_t socklen = sizeof(ss);
char addrbuf[128];
void *inaddr;
const char *addr;
int got_port = -1;
memset(&ss, 0, sizeof(ss));
fd = evhttp_bound_socket_get_fd(handle);
if (getsockname(fd, (struct sockaddr *)&ss, &socklen))
{
return ERROR_FAIL;
}
if (ss.ss_family == AF_INET)
{
got_port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
inaddr = &((struct sockaddr_in*)&ss)->sin_addr;
}
else if (ss.ss_family == AF_INET6)
{
got_port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
inaddr = &((struct sockaddr_in6*)&ss)->sin6_addr;
}
else
{
fprintf(stderr, "Unexpected address family %d\n", ss.ss_family);
return ERROR_FAIL;
}
addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf, sizeof(addrbuf));
if (addr)
{
evutil_snprintf(buffer, buflen, "http://%s:%d", addr,got_port);
}
else
{
fprintf(stderr, "evutil_inet_ntop failed\n");
return ERROR_FAIL;
}
return S_OK;
}
void Conn::OnConnListenerCb(struct evconnlistener *evListener, evutil_socket_t evSocket, struct sockaddr *pAddrIn, int socklen, void *arg)
{
LOG_DEBUG("New connecter !");
char addr[64];
memset(addr, 0, socklen);
struct sockaddr_in* sIn = (struct sockaddr_in*)pAddrIn;
evutil_inet_ntop(AF_INET, (void*)&sIn->sin_addr, addr, socklen);
LOG_DEBUG("Peer IP is " << addr);
Conn *cn = (Conn*)arg;
cn->connAddr.assign(addr, strlen(addr));
struct bufferevent* pEvBuf = bufferevent_socket_new(cn->pEvbase, evSocket, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(pEvBuf, cn->OnReadCbAddr, NULL, cn->OnConnEventCb, (void*)cn);
bufferevent_enable(pEvBuf, EV_READ);
}
void Conn::init(const unsigned int conn_type, const char* ip, const unsigned int port)
{
this->conn_type = conn_type;
bzero(&sAddrIn, sizeof(sAddrIn));
sAddrIn.sin_family = AF_INET;
if(ip != NULL)
{
inet_pton(AF_INET, ip, &sAddrIn.sin_addr);
}
sAddrIn.sin_port = htons(port);
int outlen = sizeof(this->addr);
memset(this->addr, 0, outlen);
evutil_inet_ntop(AF_INET, (void*)&sAddrIn.sin_addr, this->addr, outlen);
}
static void
regress_ipv4_parse(void *ptr)
{
int i;
for (i = 0; ipv4_entries[i].addr; ++i) {
char written[128];
struct ipv4_entry *ent = &ipv4_entries[i];
struct in_addr in;
int r;
r = evutil_inet_pton(AF_INET, ent->addr, &in);
if (r == 0) {
if (ent->status != BAD) {
TT_FAIL(("%s did not parse, but it's a good address!",
ent->addr));
}
continue;
}
if (ent->status == BAD) {
TT_FAIL(("%s parsed, but we expected an error", ent->addr));
continue;
}
if (ntohl(in.s_addr) != ent->res) {
TT_FAIL(("%s parsed to %lx, but we expected %lx", ent->addr,
(unsigned long)ntohl(in.s_addr),
(unsigned long)ent->res));
continue;
}
if (ent->status == CANONICAL) {
const char *w = evutil_inet_ntop(AF_INET, &in, written,
sizeof(written));
if (!w) {
TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
continue;
}
if (strcmp(written, ent->addr)) {
TT_FAIL(("Tried to write out %s; got %s",
ent->addr, written));
continue;
}
}
}
}
static char*
announce_url_new (const tr_session * session, const tr_announce_request * req)
{
const char * str;
const unsigned char * ipv6;
struct evbuffer * buf = evbuffer_new ();
char escaped_info_hash[SHA_DIGEST_LENGTH*3 + 1];
tr_http_escape_sha1 (escaped_info_hash, req->info_hash);
evbuffer_expand (buf, 1024);
evbuffer_add_printf (buf, "%s"
"%c"
"info_hash=%s"
"&peer_id=%*.*s"
"&port=%d"
"&uploaded=%" PRIu64
"&downloaded=%" PRIu64
"&left=%" PRIu64
"&numwant=%d"
"&key=%x"
"&compact=1"
"&supportcrypto=1",
req->url,
strchr (req->url, '?') ? '&' : '?',
escaped_info_hash,
PEER_ID_LEN, PEER_ID_LEN, req->peer_id,
req->port,
req->up,
req->down,
req->leftUntilComplete,
req->numwant,
req->key);
if (session->encryptionMode == TR_ENCRYPTION_REQUIRED)
evbuffer_add_printf (buf, "&requirecrypto=1");
if (req->corrupt)
evbuffer_add_printf (buf, "&corrupt=%" PRIu64, req->corrupt);
str = get_event_string (req);
if (str && *str)
evbuffer_add_printf (buf, "&event=%s", str);
str = req->tracker_id_str;
if (str && *str)
evbuffer_add_printf (buf, "&trackerid=%s", str);
/* There are two incompatible techniques for announcing an IPv6 address.
BEP-7 suggests adding an "ipv6=" parameter to the announce URL,
while OpenTracker requires that peers announce twice, once over IPv4
and once over IPv6.
To be safe, we should do both: add the "ipv6=" parameter and
announce twice. At any rate, we're already computing our IPv6
address (for the LTEP handshake), so this comes for free. */
ipv6 = tr_globalIPv6 ();
if (ipv6) {
char ipv6_readable[INET6_ADDRSTRLEN];
evutil_inet_ntop (AF_INET6, ipv6, ipv6_readable, INET6_ADDRSTRLEN);
evbuffer_add_printf (buf, "&ipv6=");
tr_http_escape (buf, ipv6_readable, -1, true);
}
return evbuffer_free_to_str (buf);
}
int
main(int argc, char **argv)
{
struct event_base *base;
struct evhttp *http;
struct evhttp_bound_socket *handle;
unsigned short port = atoi(argv[1]);
#ifdef WIN32
WSADATA WSAData;
WSAStartup(0x101, &WSAData);
#else
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return (1);
#endif
base = event_base_new();
if (!base) {
fprintf(stderr, "Couldn't create an event_base: exiting\n");
return 1;
}
/* Create a new evhttp object to handle requests. */
http = evhttp_new(base);
if (!http) {
fprintf(stderr, "couldn't create evhttp. Exiting.\n");
return 1;
}
evhttp_set_cb(http, "/s2cover", s2cover_request_cb, NULL);
evhttp_set_cb(http, "/s2info", s2info_request_cb, NULL);
evhttp_set_cb(http, "/fetch", fetch_request_cb, NULL);
/* Now we tell the evhttp what port to listen on */
handle = evhttp_bind_socket_with_handle(http, "0.0.0.0", port);
if (!handle) {
fprintf(stderr, "couldn't bind to port %d. Exiting.\n",
(int)port);
return 1;
}
{
/* Extract and display the address we're listening on. */
struct sockaddr_storage ss;
evutil_socket_t fd;
ev_socklen_t socklen = sizeof(ss);
char addrbuf[128];
void *inaddr;
const char *addr;
int got_port = -1;
fd = evhttp_bound_socket_get_fd(handle);
memset(&ss, 0, sizeof(ss));
if (getsockname(fd, (struct sockaddr *)&ss, &socklen)) {
perror("getsockname() failed");
return 1;
}
if (ss.ss_family == AF_INET) {
got_port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
inaddr = &((struct sockaddr_in*)&ss)->sin_addr;
} else if (ss.ss_family == AF_INET6) {
got_port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
inaddr = &((struct sockaddr_in6*)&ss)->sin6_addr;
} else {
fprintf(stderr, "Weird address family %d\n",
ss.ss_family);
return 1;
}
addr = evutil_inet_ntop(ss.ss_family, inaddr, addrbuf,
sizeof(addrbuf));
if (addr) {
printf("HI Listening on %s:%d\n", addr, got_port);
evutil_snprintf(uri_root, sizeof(uri_root),
"http://%s:%d",addr,got_port);
} else {
fprintf(stderr, "evutil_inet_ntop failed\n");
return 1;
}
}
event_base_dispatch(base);
return 0;
}
static int
ssh_new_connection(obfsproxyssh_client_session_t *session,
struct sockaddr_in *addr, const char *args)
{
obfsproxyssh_t *state = session->client->state;
char addr_buf[INET_ADDRSTRLEN];
char *cached_arg;
uint32_t tmp;
bstring tmp_addr;
int rval;
evutil_inet_ntop(AF_INET, &addr->sin_addr, addr_buf, INET_ADDRSTRLEN);
tmp_addr = bformat("%s:%d", addr_buf, ntohs(addr->sin_port));
if (0 == state->unsafe_logging) {
tmp = ntohl(addr->sin_addr.s_addr);
tmp &= 0x000000ff;
session->ssh_addr = bformat("xxx.xxx.xxx.%d:%d", tmp,
ntohs(addr->sin_port));
} else {
session->ssh_addr = bstrcpy(tmp_addr);
}
log_f(state, "SOCKS: %s SOCKS 4 CONNECT -> %s",
bdata(session->socks_addr), bdata(session->ssh_addr));
cached_arg = client_arg_cache(session->client, tmp_addr, args);
bdestroy(tmp_addr);
rval = ssh_parse_args(session, cached_arg);
if (rval) {
log_f(state, "SOCKS: Error: %s Invalid arguments in CONNECT",
bdata(session->socks_addr));
return -1;
}
/* Note: Yes, this needs defered callbacks */
session->ssh_ev = bufferevent_socket_new(state->base, -1,
BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS);
if (NULL == session->ssh_ev) {
log_f(state, "SOCKS: Error: %s Failed to allocate ssh event",
bdata(session->socks_addr));
return -1;
}
bufferevent_setcb(session->ssh_ev, NULL, NULL, ssh_event_cb, session);
rval = bufferevent_socket_connect(session->ssh_ev,
(struct sockaddr *) addr, sizeof (struct sockaddr_in));
if (rval < 0) {
log_f(state, "SOCKS: Error: %s Failed to connect ssh socket",
bdata(session->socks_addr));
return -1;
}
session->ssh_session = libssh2_session_init_ex(NULL, NULL, NULL, session);
if (NULL == session->ssh_session) {
log_f(state, "SOCKS: Error: %s Failed to initialize libssh2 session",
bdata(session->socks_addr));
return -1;
}
libssh2_session_callback_set(session->ssh_session,
LIBSSH2_CALLBACK_RECV, libssh2_recv_cb);
libssh2_session_callback_set(session->ssh_session,
LIBSSH2_CALLBACK_SEND, libssh2_send_cb);
libssh2_session_set_blocking(session->ssh_session, 0);
rval = ssh_client_profile_set(session);
if (rval < 0) {
log_f(state, "SOCKS: Error: Failed to enable fingerprint resistance",
bdata(session->socks_addr));
return -1;
}
/*
* This only works with debug builds of libssh2 and creates an
* astronomical amount of log spam.
*/
#ifdef TRACE_LIBSSH2
if (1 == state->unsafe_logging) {
libssh2_trace(session->ssh_session, LIBSSH2_TRACE_SOCKET |
LIBSSH2_TRACE_TRANS | LIBSSH2_TRACE_KEX |
LIBSSH2_TRACE_AUTH | LIBSSH2_TRACE_CONN |
LIBSSH2_TRACE_ERROR);
libssh2_trace_sethandler(session->ssh_session, state,
libssh2_trace_cb);
}
#endif
return 0;
}
struct request_mngr_s *
create_request_mngr_from_evhtp_request_with_arg(evhtp_request_t *req,
void *arg,
const char *context) {
struct request_mngr_s *request_mngr;
if (!req)
return NULL;
/* Request administration object */
request_mngr = calloc(sizeof(struct request_mngr_s), 1);
if (request_mngr == NULL) {
syslog(LOG_ERR, "[%s][pid:%lu][threadid:%lu]"
"[msg=Error: out of memory]",
context,
(uint64_t)getpid(),
pthread_self()
);
return NULL;
}
request_mngr->mf_sock = malloc(sizeof(mf_sock_address_t));
if (request_mngr->mf_sock == NULL) {
syslog(LOG_ERR, "[%s][pid:%lu][threadid:%lu]"
"[msg=Error: out of memory]",
context,
(uint64_t)getpid(),
pthread_self()
);
return NULL;
}
/* Request administration */
request_mngr->paused = NO;
request_mngr->evhtp_req = req;
request_mngr->conn = req ? evhtp_request_get_connection(req) : NULL;
request_mngr->evhtp_thr = request_mngr->evhtp_req ?
get_request_thr(request_mngr->evhtp_req) : NULL;
request_mngr->service = arg ? (struct tq_service_s *)arg : NULL;
request_mngr->listener = request_mngr->service ?
request_mngr->service->parent_listener : NULL;
request_mngr->app = request_mngr->listener ? request_mngr->listener->app_thr : NULL;
request_mngr->pthr = pthread_self();
request_mngr->pid = (uint64_t)getpid();
request_mngr->accept_type = mimetype_normalizer_int(request_mngr->evhtp_req, "Accept");
request_mngr->accept_header = mimetype_normalizer_str(request_mngr->accept_type);
request_mngr->content_type = mimetype_normalizer_int(request_mngr->evhtp_req, "Content-Type");
request_mngr->contenttype_header = mimetype_normalizer_str(request_mngr->content_type);
request_mngr->xacml_req = NULL;
request_mngr->xacml_res = NULL;
request_mngr->mf_sock->sa = request_mngr->conn->saddr;
if (request_mngr->mf_sock->sa_stor->ss_family == AF_INET6) {
request_mngr->sin_port = request_mngr->mf_sock ?
ntohs(request_mngr->mf_sock->sa_in6->sin6_port) : 0;
} else {
request_mngr->sin_port = request_mngr->mf_sock ?
ntohs(request_mngr->mf_sock->sa_in->sin_port) : 0;
}
/* Normalizing flawed input for human readable strings */
if (request_mngr->accept_header == NULL) request_mngr->accept_header = "<empty Accept>";
if (request_mngr->contenttype_header == NULL) request_mngr->contenttype_header = "<empty Content-Type>";
/* Copy the IP address */
request_mngr->sin_ip_addr = calloc(GA_HTTP_IP_ADDRESS_LEN, 1);
if (request_mngr->sin_ip_addr == NULL) {
syslog(LOG_ERR, "[%s][pid:%lu][threadid:%lu]"
"[error=out of memory]",
context,
request_mngr->pid, request_mngr->pthr);
goto cleanup;
}
/* Extract the source IP */
if (request_mngr->mf_sock->sa_stor->ss_family == AF_INET6) {
evutil_inet_ntop(request_mngr->mf_sock->sa_stor->ss_family,
&(request_mngr->mf_sock->sa_in6->sin6_addr),
request_mngr->sin_ip_addr,
GA_HTTP_IP_ADDRESS_LEN);
} else {
evutil_inet_ntop(request_mngr->mf_sock->sa_stor->ss_family,
&(request_mngr->mf_sock->sa_in->sin_addr),
request_mngr->sin_ip_addr,
GA_HTTP_IP_ADDRESS_LEN);
}
return request_mngr;
cleanup:
delete_request_mngr(request_mngr);
return NULL;
}
int
tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, bool is_enabled, tr_port * public_port )
{
int ret;
if( is_enabled && ( nat->state == TR_NATPMP_DISCOVER ) )
{
int val = initnatpmp( &nat->natpmp );
logVal( "initnatpmp", val );
val = sendpublicaddressrequest( &nat->natpmp );
logVal( "sendpublicaddressrequest", val );
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
nat->has_discovered = true;
setCommandTime( nat );
}
if( ( nat->state == TR_NATPMP_RECV_PUB ) && canSendCommand( nat ) )
{
natpmpresp_t response;
const int val = readnatpmpresponseorretry( &nat->natpmp, &response );
logVal( "readnatpmpresponseorretry", val );
if( val >= 0 )
{
char str[128];
evutil_inet_ntop( AF_INET, &response.pnu.publicaddress.addr, str, sizeof( str ) );
tr_ninf( getKey( ), _( "Found public address \"%s\"" ), str );
nat->state = TR_NATPMP_IDLE;
}
else if( val != NATPMP_TRYAGAIN )
{
nat->state = TR_NATPMP_ERR;
}
}
if( ( nat->state == TR_NATPMP_IDLE ) || ( nat->state == TR_NATPMP_ERR ) )
{
if( nat->is_mapped && ( !is_enabled || ( nat->private_port != private_port ) ) )
nat->state = TR_NATPMP_SEND_UNMAP;
}
if( ( nat->state == TR_NATPMP_SEND_UNMAP ) && canSendCommand( nat ) )
{
const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP,
nat->private_port,
nat->public_port,
0 );
logVal( "sendnewportmappingrequest", val );
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_UNMAP;
setCommandTime( nat );
}
if( nat->state == TR_NATPMP_RECV_UNMAP )
{
natpmpresp_t resp;
const int val = readnatpmpresponseorretry( &nat->natpmp, &resp );
logVal( "readnatpmpresponseorretry", val );
if( val >= 0 )
{
const int private_port = resp.pnu.newportmapping.privateport;
tr_ninf( getKey( ), _( "no longer forwarding port %d" ), private_port );
if( nat->private_port == private_port )
{
nat->private_port = 0;
nat->public_port = 0;
nat->state = TR_NATPMP_IDLE;
nat->is_mapped = false;
}
}
else if( val != NATPMP_TRYAGAIN )
{
nat->state = TR_NATPMP_ERR;
}
}
if( nat->state == TR_NATPMP_IDLE )
{
if( is_enabled && !nat->is_mapped && nat->has_discovered )
nat->state = TR_NATPMP_SEND_MAP;
else if( nat->is_mapped && tr_time( ) >= nat->renew_time )
nat->state = TR_NATPMP_SEND_MAP;
}
if( ( nat->state == TR_NATPMP_SEND_MAP ) && canSendCommand( nat ) )
{
const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS );
logVal( "sendnewportmappingrequest", val );
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
setCommandTime( nat );
}
if( nat->state == TR_NATPMP_RECV_MAP )
{
natpmpresp_t resp;
const int val = readnatpmpresponseorretry( &nat->natpmp, &resp );
logVal( "readnatpmpresponseorretry", val );
if( val >= 0 )
{
nat->state = TR_NATPMP_IDLE;
nat->is_mapped = true;
nat->renew_time = tr_time( ) + ( resp.pnu.newportmapping.lifetime / 2 );
nat->private_port = resp.pnu.newportmapping.privateport;
nat->public_port = resp.pnu.newportmapping.mappedpublicport;
tr_ninf( getKey( ), _( "Port %d forwarded successfully" ), nat->private_port );
}
else if( val != NATPMP_TRYAGAIN )
{
nat->state = TR_NATPMP_ERR;
}
}
switch( nat->state )
{
case TR_NATPMP_IDLE:
*public_port = nat->public_port;
return nat->is_mapped ? TR_PORT_MAPPED : TR_PORT_UNMAPPED;
break;
case TR_NATPMP_DISCOVER:
ret = TR_PORT_UNMAPPED; break;
case TR_NATPMP_RECV_PUB:
case TR_NATPMP_SEND_MAP:
case TR_NATPMP_RECV_MAP:
ret = TR_PORT_MAPPING; break;
case TR_NATPMP_SEND_UNMAP:
case TR_NATPMP_RECV_UNMAP:
ret = TR_PORT_UNMAPPING; break;
default:
ret = TR_PORT_ERROR; break;
}
return ret;
}
void test_protocol()
{
/* get new string buffer */
cstring *version_msg_cstr = cstr_new_sz(256);
cstring *inv_msg_cstr = cstr_new_sz(256);
struct sockaddr_in test_sa, test_sa_check;
memset(&test_sa, 0, sizeof(test_sa));
memset(&test_sa_check, 0, sizeof(test_sa_check));
test_sa.sin_family = AF_INET;
struct sockaddr_in6 test_sa6, test_sa6_check;
test_sa6.sin6_family = AF_INET6;
test_sa6.sin6_port = htons(1024);
evutil_inet_pton(AF_INET, "10.0.0.1", &test_sa.sin_addr); // store IP in antelope
char i6buf[1024];
memset(&i6buf, 0, 1024);
evutil_inet_pton(AF_INET6, "::1", &test_sa6.sin6_addr);
btc_p2p_address ipv6Test;
btc_p2p_address_init(&ipv6Test);
btc_addr_to_p2paddr((struct sockaddr *)&test_sa6, &ipv6Test);
btc_p2paddr_to_addr(&ipv6Test, (struct sockaddr *)&test_sa6_check);
memset(&i6buf, 0, 1024);
u_assert_int_eq(test_sa6.sin6_port, test_sa6_check.sin6_port);
/* copy socket_addr to p2p addr */
btc_p2p_address fromAddr;
btc_p2p_address_init(&fromAddr);
btc_p2p_address toAddr;
btc_p2p_address_init(&toAddr);
btc_addr_to_p2paddr((struct sockaddr *)&test_sa, &toAddr);
btc_p2paddr_to_addr(&toAddr, (struct sockaddr *)&test_sa_check);
u_assert_int_eq(test_sa.sin_port, test_sa_check.sin_port);
evutil_inet_ntop(AF_INET, &test_sa_check.sin_addr, i6buf, 1024);
u_assert_str_eq(i6buf, "10.0.0.1");
/* create a inv message struct */
btc_p2p_inv_msg inv_msg, inv_msg_check;
memset(&inv_msg, 0, sizeof(inv_msg));
uint256 hash = {0};
btc_p2p_msg_inv_init(&inv_msg, 1, hash);
btc_p2p_msg_inv_ser(&inv_msg, inv_msg_cstr);
struct const_buffer buf_inv = {inv_msg_cstr->str, inv_msg_cstr->len};
u_assert_int_eq(btc_p2p_msg_inv_deser(&inv_msg_check, &buf_inv), true);
u_assert_int_eq(inv_msg_check.type, 1);
u_assert_mem_eq(inv_msg_check.hash, inv_msg.hash, sizeof(inv_msg.hash));
cstr_free(inv_msg_cstr, true);
/* create a version message struct */
btc_p2p_version_msg version_msg;
memset(&version_msg, 0, sizeof(version_msg));
/* create a serialized version message */
btc_p2p_msg_version_init(&version_msg, &fromAddr, &toAddr, "client", false);
btc_p2p_msg_version_ser(&version_msg, version_msg_cstr);
/* create p2p message */
cstring *p2p_msg = btc_p2p_message_new((unsigned const char *)&btc_chainparams_main.netmagic, BTC_MSG_VERSION, version_msg_cstr->str, version_msg_cstr->len);
struct const_buffer buf = {p2p_msg->str, p2p_msg->len};
btc_p2p_msg_hdr hdr;
btc_p2p_deser_msghdr(&hdr, &buf);
u_assert_mem_eq(hdr.netmagic, &btc_chainparams_main.netmagic, 4);
u_assert_str_eq(hdr.command, BTC_MSG_VERSION);
u_assert_int_eq(hdr.data_len, version_msg_cstr->len);
u_assert_int_eq(buf.len, hdr.data_len);
u_assert_int_eq(buf.len, hdr.data_len);
u_assert_mem_eq(buf.p, version_msg_cstr->str, hdr.data_len);
btc_p2p_version_msg v_msg_check;
u_assert_int_eq(btc_p2p_msg_version_deser(&v_msg_check, &buf), true);
u_assert_int_eq(v_msg_check.version, BTC_PROTOCOL_VERSION);
u_assert_str_eq(v_msg_check.useragent, "client");
u_assert_int_eq(v_msg_check.start_height, 0);
cstr_free(p2p_msg, true);
cstr_free(version_msg_cstr, true);
/* getheaders */
uint256 genesis_hash = {0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0xd6, 0x68, 0x9c, 0x08, 0x5a, 0xe1, 0x65, 0x83, 0x1e, 0x93, 0x4f, 0xf7, 0x63, 0xae, 0x46, 0xa2, 0xa6, 0xc1, 0x72, 0xb3, 0xf1, 0xb6, 0x0a, 0x8c, 0xe2, 0x6f};
vector *blocklocators = vector_new(1, NULL);
vector_add(blocklocators, genesis_hash);
cstring *getheader_msg = cstr_new_sz(256);
btc_p2p_msg_getheaders(blocklocators, NULL, getheader_msg);
p2p_msg = btc_p2p_message_new((unsigned const char *)&btc_chainparams_main.netmagic, BTC_MSG_GETHEADERS, getheader_msg->str, getheader_msg->len);
buf.p = p2p_msg->str;
buf.len = p2p_msg->len;
btc_p2p_deser_msghdr(&hdr, &buf);
u_assert_str_eq(hdr.command, BTC_MSG_GETHEADERS);
u_assert_int_eq(hdr.data_len, getheader_msg->len);
uint256 hashstop_check;
vector *blocklocators_check = vector_new(1, free);
btc_p2p_deser_msg_getheaders(blocklocators_check, hashstop_check, &buf);
u_assert_mem_eq(NULLHASH, hashstop_check, sizeof(hashstop_check));
uint8_t *hash_loc_0 = vector_idx(blocklocators_check, 0);
u_assert_mem_eq(genesis_hash, hash_loc_0, sizeof(genesis_hash));
/* cleanup */
cstr_free(getheader_msg, true);
vector_free(blocklocators, true);
vector_free(blocklocators_check, true);
cstr_free(p2p_msg, true);
}