static int send_challenge_ack(int fd, unsigned char digest[16], unsigned ms)
{
char *s;
char buf[DEFBUF_SIZ];
int siz = 2 + 1 + 16;
int res;
s = buf;
put16be(s,siz - 2);
put8(s, 'a');
memcpy(s, digest, 16);
if ((res = ei_write_fill_t(fd, buf, siz, ms)) != siz) {
EI_TRACE_ERR0("recv_challenge_reply",
"-> SEND_CHALLENGE_ACK socket write failed");
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
if (ei_tracelevel >= 3) {
char buffer[33];
EI_TRACE_CONN1("recv_challenge_reply",
"-> SEND_CHALLENGE_ACK (ok) digest = %s",hex((char *)digest,buffer));
}
return 0;
}
static int send_status(int fd, char *status, unsigned ms)
{
char *buf, *s;
char dbuf[DEFBUF_SIZ];
int siz = strlen(status) + 1 + 2;
int res;
buf = (siz > DEFBUF_SIZ) ? malloc(siz) : dbuf;
if (!buf) {
erl_errno = ENOMEM;
return -1;
}
s = buf;
put16be(s,siz - 2);
put8(s, 's');
memcpy(s, status, strlen(status));
if ((res = ei_write_fill_t(fd, buf, siz, ms)) != siz) {
EI_TRACE_ERR0("send_status","-> SEND_STATUS socket write failed");
if (buf != dbuf)
free(buf);
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
EI_TRACE_CONN1("send_status","-> SEND_STATUS (%s)",status);
if (buf != dbuf)
free(buf);
return 0;
}
static int recv_challenge_ack(int fd,
unsigned our_challenge,
char cookie[], unsigned ms)
{
char dbuf[DEFBUF_SIZ];
char *buf = dbuf;
int is_static = 1;
int buflen = DEFBUF_SIZ;
int rlen;
char *s;
char tag;
char her_digest[16], expected_digest[16];
erl_errno = EIO; /* Default */
if ((rlen = read_2byte_package(fd, &buf, &buflen, &is_static, ms)) != 17) {
EI_TRACE_ERR1("recv_challenge_ack",
"<- RECV_CHALLENGE_ACK socket read failed (%d)",rlen);
goto error;
}
s = buf;
if ((tag = get8(s)) != 'a') {
EI_TRACE_ERR2("recv_challenge_ack",
"<- RECV_CHALLENGE_ACK incorrect tag, "
"expected 'a' got '%c' (%u)",tag,tag);
goto error;
}
memcpy(her_digest, s, 16);
gen_digest(our_challenge, cookie, (unsigned char *)expected_digest);
if (memcmp(her_digest, expected_digest, 16)) {
EI_TRACE_ERR0("recv_challenge_ack",
"<- RECV_CHALLENGE_ACK authorization failure");
goto error;
}
if (!is_static)
free(buf);
if (ei_tracelevel >= 3) {
char buffer[33];
EI_TRACE_CONN1("recv_challenge_ack",
"<- RECV_CHALLENGE_ACK (ok) digest = %s",hex(her_digest,buffer));
}
erl_errno = 0;
return 0;
error:
if (!is_static)
free(buf);
return -1;
}
/* stop the specified node */
int ei_unpublish_tmo(const char *alive, unsigned ms)
{
char buf[EPMDBUF];
char *s = (char*)buf;
int len = 1 + strlen(alive);
int fd, res;
if (len > sizeof(buf)-3) {
erl_errno = ERANGE;
return -1;
}
put16be(s,len);
put8(s,EI_EPMD_STOP_REQ);
strcpy(s, alive);
/* FIXME can't connect, return success?! At least commen whats up */
if ((fd = ei_epmd_connect_tmo(NULL,ms)) < 0) return fd;
if ((res = ei_write_fill_t(fd, buf, len+2,ms)) != len+2) {
closesocket(fd);
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
EI_TRACE_CONN1("ei_unpublish_tmo","-> STOP %s",alive);
if ((res = ei_read_fill_t(fd, buf, 7, ms)) != 7) {
closesocket(fd);
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
closesocket(fd);
buf[7]=(char)0; /* terminate the string */
if (!strcmp("STOPPED",(char *)buf)) {
EI_TRACE_CONN0("ei_unpublish_tmo","<- STOPPED (success)");
return 0;
}
else if (!strcmp("NOEXIST",(char *)buf)) {
EI_TRACE_ERR0("ei_unpublish_tmo","<- NOEXIST (failure)");
erl_errno = EIO;
return -1;
}
else {
EI_TRACE_ERR0("ei_unpublish_tmo","<- unknown (failure)");
erl_errno = EIO;
return -1; /* this shouldn't happen */
}
return 0;
}
int ei_accept_tmo(ei_cnode* ec, int lfd, ErlConnect *conp, unsigned ms)
{
int fd;
struct sockaddr_in cli_addr;
int cli_addr_len=sizeof(struct sockaddr_in);
unsigned her_version, her_flags;
ErlConnect her_name;
erl_errno = EIO; /* Default error code */
EI_TRACE_CONN0("ei_accept","<- ACCEPT waiting for connection");
if ((fd = ei_accept_t(lfd, (struct sockaddr*) &cli_addr,
&cli_addr_len, ms )) < 0) {
EI_TRACE_ERR0("ei_accept","<- ACCEPT socket accept failed");
erl_errno = (fd == -2) ? ETIMEDOUT : EIO;
goto error;
}
EI_TRACE_CONN0("ei_accept","<- ACCEPT connected to remote");
if (recv_name(fd, &her_version, &her_flags, &her_name, ms)) {
EI_TRACE_ERR0("ei_accept","<- ACCEPT initial ident failed");
goto error;
}
if (her_version <= 4) {
EI_TRACE_ERR0("ei_accept","<- ACCEPT remote version not compatible");
goto error;
}
else {
unsigned our_challenge;
unsigned her_challenge;
unsigned char our_digest[16];
if (send_status(fd,"ok", ms))
goto error;
our_challenge = gen_challenge();
if (send_challenge(fd, ec->thisnodename,
our_challenge, her_version, ms))
goto error;
if (recv_challenge_reply(fd, our_challenge,
ec->ei_connect_cookie,
&her_challenge, ms))
goto error;
gen_digest(her_challenge, ec->ei_connect_cookie, our_digest);
if (send_challenge_ack(fd, our_digest, ms))
goto error;
put_ei_socket_info(fd, her_version, null_cookie, ec);
}
if (conp)
*conp = her_name;
EI_TRACE_CONN1("ei_accept","<- ACCEPT (ok) remote = %s",her_name.nodename);
erl_errno = 0; /* No error */
return fd;
error:
EI_TRACE_ERR0("ei_accept","<- ACCEPT failed");
closesocket(fd);
return ERL_ERROR;
} /* ei_accept */
/* ip_addr is now in network byte order
*
* first we have to get hold of the portnumber to
* the node through epmd at that host
*
*/
int ei_xconnect_tmo(ei_cnode* ec, Erl_IpAddr adr, char *alivename, unsigned ms)
{
struct in_addr *ip_addr=(struct in_addr *) adr;
int rport = 0; /*uint16 rport = 0;*/
int sockd;
int one = 1;
int dist = 0;
ErlConnect her_name;
unsigned her_flags, her_version;
erl_errno = EIO; /* Default error code */
EI_TRACE_CONN1("ei_xconnect","-> CONNECT attempt to connect to %s",
alivename);
if ((rport = ei_epmd_port_tmo(ip_addr,alivename,&dist, ms)) < 0) {
EI_TRACE_ERR0("ei_xconnect","-> CONNECT can't get remote port");
/* ei_epmd_port_tmo() has set erl_errno */
return ERL_NO_PORT;
}
/* we now have port number to enode, try to connect */
if((sockd = cnct((uint16)rport, ip_addr, sizeof(struct in_addr),ms)) < 0) {
EI_TRACE_ERR0("ei_xconnect","-> CONNECT socket connect failed");
/* cnct() has set erl_errno */
return ERL_CONNECT_FAIL;
}
EI_TRACE_CONN0("ei_xconnect","-> CONNECT connected to remote");
/* FIXME why connect before checking 'dist' output from ei_epmd_port() ?! */
if (dist <= 4) {
EI_TRACE_ERR0("ei_xconnect","-> CONNECT remote version not compatible");
goto error;
}
else {
unsigned our_challenge, her_challenge;
unsigned char our_digest[16];
if (send_name(sockd, ec->thisnodename, (unsigned) dist, ms))
goto error;
if (recv_status(sockd, ms))
goto error;
if (recv_challenge(sockd, &her_challenge, &her_version,
&her_flags, &her_name, ms))
goto error;
our_challenge = gen_challenge();
gen_digest(her_challenge, ec->ei_connect_cookie, our_digest);
if (send_challenge_reply(sockd, our_digest, our_challenge, ms))
goto error;
if (recv_challenge_ack(sockd, our_challenge,
ec->ei_connect_cookie, ms))
goto error;
put_ei_socket_info(sockd, dist, null_cookie, ec); /* FIXME check == 0 */
}
setsockopt(sockd, IPPROTO_TCP, TCP_NODELAY, (char *)&one, sizeof(one));
setsockopt(sockd, SOL_SOCKET, SO_KEEPALIVE, (char *)&one, sizeof(one));
EI_TRACE_CONN1("ei_xconnect","-> CONNECT (ok) remote = %s",alivename);
erl_errno = 0;
return sockd;
error:
EI_TRACE_ERR0("ei_xconnect","-> CONNECT failed");
closesocket(sockd);
return ERL_ERROR;
} /* ei_xconnect */
static int ei_epmd_r4_port (struct in_addr *addr, const char *alive,
int *dist, unsigned ms)
{
char buf[EPMDBUF];
char *s = buf;
int len = strlen(alive) + 1;
int fd;
int ntype;
int port;
int dist_high, dist_low, proto;
int res;
#if defined(VXWORKS)
char ntoabuf[32];
#endif
if (len > sizeof(buf) - 3)
{
erl_errno = ERANGE;
return -1;
}
put16be(s,len);
put8(s,EI_EPMD_PORT2_REQ);
strcpy(s,alive);
/* connect to epmd */
if ((fd = ei_epmd_connect_tmo(addr,ms)) < 0)
{
return -1;
}
if ((res = ei_write_fill_t(fd, buf, len+2, ms)) != len+2) {
closesocket(fd);
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
return -1;
}
#ifdef VXWORKS
/* FIXME use union/macro for level. Correct level? */
if (ei_tracelevel > 2) {
inet_ntoa_b(*addr,ntoabuf);
EI_TRACE_CONN2("ei_epmd_r4_port",
"-> PORT2_REQ alive=%s ip=%s",alive,ntoabuf);
}
#else
EI_TRACE_CONN2("ei_epmd_r4_port",
"-> PORT2_REQ alive=%s ip=%s",alive,inet_ntoa(*addr));
#endif
/* read first two bytes (response type, response) */
if ((res = ei_read_fill_t(fd, buf, 2, ms)) != 2) {
EI_TRACE_ERR0("ei_epmd_r4_port","<- CLOSE");
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
closesocket(fd);
return -2; /* version mismatch */
}
s = buf;
res = get8(s);
if (res != EI_EPMD_PORT2_RESP) { /* response type */
EI_TRACE_ERR1("ei_epmd_r4_port","<- unknown (%d)",res);
EI_TRACE_ERR0("ei_epmd_r4_port","-> CLOSE");
closesocket(fd);
erl_errno = EIO;
return -1;
}
/* got negative response */
if ((res = get8(s))) {
/* got negative response */
EI_TRACE_ERR1("ei_epmd_r4_port","<- PORT2_RESP result=%d (failure)",res);
closesocket(fd);
erl_errno = EIO;
return -1;
}
EI_TRACE_CONN1("ei_epmd_r4_port","<- PORT2_RESP result=%d (ok)",res);
/* expecting remaining 8 bytes */
if ((res = ei_read_fill_t(fd,buf,8,ms)) != 8) {
EI_TRACE_ERR0("ei_epmd_r4_port","<- CLOSE");
erl_errno = (res == -2) ? ETIMEDOUT : EIO;
closesocket(fd);
return -1;
}
closesocket(fd);
s = buf;
port = get16be(s);
ntype = get8(s);
proto = get8(s);
dist_high = get16be(s);
dist_low = get16be(s);
EI_TRACE_CONN5("ei_epmd_r4_port",
" port=%d ntype=%d proto=%d dist-high=%d dist-low=%d",
port,ntype,proto,dist_high,dist_low);
/* right network protocol? */
if (EI_MYPROTO != proto)
{
erl_errno = EIO;
return -1;
}
/* is there overlap in our distribution versions? */
if ((EI_DIST_HIGH < dist_low) || (EI_DIST_LOW > dist_high))
{
erl_errno = EIO;
return -1;
}
/* choose the highest common version */
/* i.e. min(his-max, my-max) */
*dist = (dist_high > EI_DIST_HIGH ? EI_DIST_HIGH : dist_high);
/* ignore the remaining fields */
return port;
}
