int sac_exec_validate_key_1(uint8_t *key, uint32_t expected_size)
{
int ret;
uint8_t buffer[0xd8];
memset(buffer, 0, 0xd8);
memcpy(buffer, &expected_size, 4);
buffer[8] = 0;
buffer[9] = 0;
buffer[10] = 0;
buffer[11] = 0;
buffer[12] = 0;
buffer[13] = 0;
buffer[14] = 0;
buffer[15] = 0;
memcpy(buffer + 16, key, expected_size);
ret = exchange_data(SAC_CMD_VALIDATE_KEY_1, buffer, 0xd8, 0, 0, 0);
return ret;
}
int sac_exec_validate_key_3(uint8_t *key, uint32_t expected_size)
{
int ret;
uint8_t buffer[0x34];
memset(buffer, 0, 0x34);
memcpy(buffer, &expected_size, 4);
memcpy(buffer + 4, key, expected_size);
ret = exchange_data(SAC_CMD_VALIDATE_KEY_3, buffer, 0x34, 0, 0, 5000000);
return ret;
}
int sac_exec_decrypt_data(uint8_t *encrypted_buffer, uint32_t expected_size, uint8_t *decrypted_buffer)
{
int ret;
memset(sa->read_buffer, 0, 0x10);
memcpy(sa->read_buffer, &expected_size, 4);
memcpy(sa->read_buffer + 0x10, encrypted_buffer, expected_size);
ret = exchange_data(SAC_CMD_DECRYPT, sa->read_buffer, expected_size + 0x10, sa->write_buffer, expected_size + 4, 5000000);
memcpy(decrypted_buffer, sa->write_buffer + 4, expected_size);
return ret;
}
int sac_exec_generate_key_2(uint8_t *key, uint32_t expected_size, uint32_t *key_size)
{
uint32_t new_key_size;
uint8_t buffer[0xb4];
int ret;
memset(buffer, 0, 0xb4);
ret = exchange_data(SAC_CMD_GENERATE_KEY_2, 0, 0, buffer, 0xb4, 5000000);
new_key_size = buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3];
if (new_key_size <= expected_size)
{
memcpy(key, buffer + 4, new_key_size);
*key_size = new_key_size;
return ret;
}
return -1;
}
void update(tree_node *cur_node, int savings, int node1,
int node2)
{
tree_node *temp1, *temp2;
if (savings < cur_node->savings){
printf("\nError: illegal update call\n");
exit(1);
}
cur_node->savings = savings;
cur_node->node1 = node1;
cur_node->node2 = node2;
temp1 = cur_node;
temp2 = temp1->parent;
while ((temp2 != NULL) && (temp1->savings > temp2->savings)){
exchange_data(temp1, temp2);
temp1 = temp2;
temp2 = temp1->parent;
}
}
int main(void)
{
memset(clients, 0, sizeof(Client) * MAXCLIENTS);
signal(SIGCHLD, SIG_IGN);
//signal(SIGPIPE, ) // FIXME
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP. "| AI_ADDRCONFIG"
hints.ai_family = AF_UNSPEC; // AF_INET or AF_INET6 to force version
hints.ai_family = AF_INET6; // IPv4 addresses will be like ::ffff:127.0.0.1
struct addrinfo *servinfo;
getaddrinfo(NULL, PORT, &hints, &servinfo);
#if DEBUG
for(struct addrinfo *p = servinfo; p != NULL; p = p->ai_next)
{
char ipstr[INET6_ADDRSTRLEN];
inet_ntop(p->ai_family, get_in_addr(p->ai_addr), ipstr, sizeof(ipstr)); // convert the IP to a string
printf(" %s\n", ipstr);
}
#endif
struct addrinfo *servinfo2 = servinfo; //servinfo->ai_next;
char ipstr[INET6_ADDRSTRLEN];
inet_ntop(servinfo2->ai_family, get_in_addr(servinfo2->ai_addr), ipstr, sizeof(ipstr));
printf("Waiting for connections on [%s]:%s\n", ipstr, PORT);
int sockfd = socket(servinfo2->ai_family, servinfo2->ai_socktype, servinfo2->ai_protocol);
#if 1
int yes_1 = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes_1, sizeof(yes_1));
#endif
bind(sockfd, servinfo2->ai_addr, servinfo2->ai_addrlen);
freeaddrinfo(servinfo); // all done with this structure
setnonblocking(sockfd);
listen(sockfd, 10);
int efd = epoll_create1(0);
struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = sockfd;
epoll_ctl(efd, EPOLL_CTL_ADD, sockfd, &event);
struct epoll_event events[MAXEVENTS];
for(;;)
{
int nfd = epoll_wait(efd, events, MAXEVENTS, -1);
for(int n = 0; n < nfd; ++n)
{
if(events[n].data.fd == sockfd) // listener
{
int idx = new_client();
struct sockaddr_storage their_addr; // connector's address information
socklen_t addr_size = sizeof(their_addr);
clients[idx].socket = accept(sockfd, (struct sockaddr *)&their_addr, &addr_size);
setnonblocking(clients[idx].socket); // maybe try accept4(2)
char ipstr[INET6_ADDRSTRLEN];
inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr), ipstr, sizeof(ipstr));
printf("Got a connection from %s [%d]\n", ipstr, clients[idx].socket);
const char hello_msg[] = "<rembash2>\n";
send(clients[idx].socket, hello_msg, sizeof(hello_msg) - 1, 0);
struct itimerspec new_value;
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
new_value.it_value.tv_sec = now.tv_sec + 10;
new_value.it_value.tv_nsec = now.tv_nsec;
new_value.it_interval.tv_sec = 0;
new_value.it_interval.tv_nsec = 0;
clients[idx].timer = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
timerfd_settime(clients[idx].timer, TFD_TIMER_ABSTIME, &new_value, NULL);
EventData ed;
ed.fd = clients[idx].socket;
ed.idx = idx;
EventUnion eu;
eu.d = ed;
event.events = EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLET;
event.data.u64 = eu.u64;
epoll_ctl(efd, EPOLL_CTL_ADD, ed.fd, &event);
ed.fd = clients[idx].timer;
eu.d = ed;
event.events = EPOLLIN | EPOLLET;
event.data.u64 = eu.u64;
epoll_ctl(efd, EPOLL_CTL_ADD, ed.fd, &event);
}
else // client socket or pty or timer
{
char buf[BUFFERSIZE];
EventUnion eu;
eu.u64 = events[n].data.u64;
if(!clients[eu.d.idx].isvalid)
{
printf("Something bad happend on file [%d] for client [%d]\n", eu.d.fd, eu.d.idx);
continue;
}
if (eu.d.fd == clients[eu.d.idx].timer)
{
printf("Time out for [%d]\n", eu.d.idx);
if(clients[eu.d.idx].state == 0)
{
const char timer_msg[] = "TIMEOUT !\n";
send(clients[eu.d.idx].socket, timer_msg, sizeof(timer_msg) - 1, 0);
printf("Client [%d] disconnected.\n", eu.d.idx);
close(clients[eu.d.idx].socket);
clients[eu.d.idx].isvalid = 0;
}
continue;
}
if(clients[eu.d.idx].state == 0)
{
// assert(eu.d.fd == clients[eu.d.idx].socket)
int nbytes = recv(eu.d.fd, buf, 255, 0); // it's not 100% guaranteed to work! must use readline.
if(nbytes < 1)
{
printf("Client [%d] disconnected.\n", eu.d.idx);
close(eu.d.fd);
clients[eu.d.idx].isvalid = 0;
continue;
}
buf[nbytes - 1] = '\0';
printf("Received %s from [%d]\n", buf, eu.d.fd);
if(strcmp(buf, SECRET) != 0)
{
const char secret_msg[] = "WRONG SECRET KEY !\n";
send(eu.d.fd, secret_msg, sizeof(secret_msg) - 1, 0);
printf("Shared key check failed for [%d]\n", eu.d.idx);
printf("Client [%d] disconnected.\n", eu.d.idx);
close(eu.d.fd);
clients[eu.d.idx].isvalid = 0;
continue;
}
const char ok_msg[] = "<ok>\n";
send(eu.d.fd, ok_msg, sizeof(ok_msg) - 1, 0);
clients[eu.d.idx].state = 1;
clients[eu.d.idx].pid = forkpty(&clients[eu.d.idx].pty, NULL, NULL, NULL);
if(clients[eu.d.idx].pid == 0) // child
{
close(sockfd); // child doesn't need the listener
close(efd); // child doesn't need epoll
setsid();
execl("/bin/bash", "bash", NULL);
_exit(0);
return 0;
}
else
{
EventData ed;
ed.fd = clients[eu.d.idx].pty;
ed.idx = eu.d.idx;
EventUnion eu;
eu.d = ed;
event.events = EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLET;
event.data.u64 = eu.u64;
epoll_ctl(efd, EPOLL_CTL_ADD, ed.fd, &event);
const char ready_msg[] = "<ready>\n";
send(clients[eu.d.idx].socket, ready_msg, sizeof(ready_msg) - 1, 0);
}
} // if(client->state == 0)
else // if(client->state == 1)
{
// FIXME: EPOLLHUP or EPOLLRDHUP ?!!
if((events[n].events & EPOLLERR) || (events[n].events & EPOLLHUP))
{
printf("Client [%d] disconnected.\n", eu.d.idx);
close(clients[eu.d.idx].socket);
close(clients[eu.d.idx].pty);
kill(clients[eu.d.idx].pid, SIGTERM);
clients[eu.d.idx].isvalid = 0;
continue;
}
else if(events[i].events & EPOLLIN)
{
int bytes_available = 0;
ioctl(eu.d.fd, FIONREAD, &bytes_available);
exchange_data(eu.d.fd, eu.d.idx);
}
else if(events[i].events & EPOLLOUT)
{
exchange_data(eu.d.fd == clients[eu.d.idx].socket ? clients[eu.d.idx].pty : clients[eu.d.idx].socket, eu.d.idx);
}
else
{
printf("Client [%d] ???.\n", eu.d.idx);
}
}
} // if(events[n].data.fd == sockfd)
} // for(int n = 0; n < nfd; ++n)
} // for(;;)
return 0;
}
void data_store_csv::setup() {
double tm1 = get_time();
std::stringstream err;
if (m_master) {
std::cerr << "starting data_store_csv::setup() for role: "
<< m_reader->get_role() << "\n"
<< "calling generic_data_store::setup()\n";
}
generic_data_store::setup();
build_index_owner();
if (! m_in_memory) {
err << __FILE__ << " " << __LINE__ << " :: "
<< "not yet implemented";
throw lbann_exception(err.str());
}
else {
//sanity check
csv_reader *reader = dynamic_cast<csv_reader*>(m_reader);
if (reader == nullptr) {
err << __FILE__ << " " << __LINE__ << " :: "
<< "dynamic_cast<data_reader_csv*>(m_reader) failed";
throw lbann_exception(err.str());
}
m_csv_reader = reader;
if (m_np != reader->get_num_parallel_readers() && ! is_subsidiary_store()) {
err << __FILE__ << " " << __LINE__ << " :: "
<< "num_parallel_readers(): " << reader->get_num_parallel_readers()
<< " m_np: " << m_np
<< "; for this data_store num_readers must be the same as procs per model;\n"
<< " if this isn't acceptable, please notify Dave Hysom so he can fix.\n"
<< "reader role: " << m_reader->get_role();
throw lbann_exception(err.str());
}
if (m_master) {
std::vector<DataType> v = reader->fetch_line_label_response(0);
m_vector_size = v.size();
}
m_comm->world_broadcast<int>(0, m_vector_size);
if (is_subsidiary_store()) {
return;
}
if (m_master) std::cerr << "calling get_minibatch_index_vector\n";
get_minibatch_index_vector();
if (m_master) std::cerr << "calling exchange_mb_indices()\n";
exchange_mb_indices();
if (m_master) std::cerr << "calling get_my_datastore_indices\n";
get_my_datastore_indices();
if (m_master) std::cerr << "calling populate_datastore()\n";
populate_datastore();
if (m_master) std::cerr << "calling exchange_data()\n";
exchange_data();
}
if (m_master) {
std::cerr << "TIME for data_store_csv setup: " << get_time() - tm1 << "\n";
}
}
int sac_exec_exit(void)
{
return exchange_data(1, 0, 0, 0, 0, 5000000);
}
int sac_exec_initialize(void)
{
uint8_t buffer[1] = { 0 };
return exchange_data(0, buffer, 1, 0, 0, 5000000);
}
int net_read(int fd)
{
conn_t *current_conn = global_conn_list[fd];
if (!current_conn)
{
fprintf(stderr, "conn_t object not exists.\n");
return -1;
}
buf_t *rbuf = current_conn->rbuf;
if (!rbuf)
{
fprintf(stderr, "rbuf object not exists.\n");
return -2;
}
ssize_t n;
read_again:
//ssize_t read(int fd, void *buf, size_t count);
if ((n = read(fd, rbuf->data + rbuf->payload_length, rbuf->size - rbuf->payload_length)) < 0)
{
// failed
if (errno == EINTR)
{
goto read_again;
}
// FIXME: How to do?
fprintf(stderr, "Receive data on connection %d failed: %s\n", fd, strerror(errno));
return -3;
}
else if (n == 0)
{
// Connection closed by peer.
fprintf(stdout, "Connection closed by peer.\n");
close(fd);
destroy_conn_object(global_conn_list[fd]);
global_conn_list[fd] = NULL;
net_unregister_read(fd);
net_unregister_write(fd);
net_unregister_except(fd);
return 0;
}
else
{
fprintf(stdout, "Received %d bytes on connection %d.\n", n, fd);
rbuf->payload_length += n;
#ifdef _DEBUG_
fprintf(stdout, "[DEBUG]Connection %d: rbuf->size = %lu, rbuf->payload_length = %lu\n", fd, rbuf->size, rbuf->payload_length);
#endif
if (rbuf->payload_length >= rbuf->size)
{
// Allocate more memory
int newsize = rbuf->size * 2;
char *newdata = utils_safe_malloc(newsize);
if (!newdata)
{
// FIXME: allocate memory failed.
fprintf(stderr, "Allocate more memory for connection %d failed\n", fd);
}
else
{
//void *memcpy(void *dest, const void *src, size_t n);
memcpy(newdata, rbuf->data, rbuf->payload_length);
utils_safe_free(rbuf->data);
rbuf->data = newdata;
rbuf->size = newsize;
}
}
}
//parse_data(fd);
exchange_data(fd);
return 0;
}
