/* Name: insert_socket
* Notes: See the insert_[socket|core|thread] description above
*/
struct cpu_socket *insert_socket(struct cpu_socket *s, struct rawsyscpu *r)
{
struct cpu_socket *slist; /* for walking through list */
struct cpu_socket *slast; /* Ordered list insert (last item) */
struct cpu_socket *thiss; /* The item we are working with */
/* If the linked list is empty, then make it the new list */
if ( NULL == s )
{
if ( NULL == (thiss = new_socket(r->physical_package_id)) )
return(NULL);
return(thiss);
}
/* See if the value is in the list now. This is:
1. Likely to be a hit (it is likely in the list)
2. A very in-expensive lookup
*/
slist = s;
while ( slist )
{
if ( slist->id == r->physical_package_id )
{
return(s); /* got it, return list unmodified */
}
slist = slist->next;
}
if ( NULL == (thiss = new_socket(r->physical_package_id)) )
return(NULL);
/*** ordered insert ***/
/* Insert at top */
if ( s->id > thiss->id )
{
thiss->next = s;
return(thiss);
}
/* insert in middle */
slist = s->next;
slast = s;
while (slist)
{
if ( slist->id > thiss->id )
{
thiss->next = slast->next;
slast->next = thiss;
return(s);
}
slast = slist;
slist = slist->next;
}
/* if we got here append at end */
slast->next = thiss;
return(s);
}
static void yield_accept(boost::asio::yield_context yield,
boost::system::error_code &ec,
boost::shared_ptr<boost::asio::ip::tcp::acceptor> ptr_)
{
auto s = new_socket();
ptr_->async_accept(*s, yield[ec]);
}
void new_connection(TCPsocket sock) {
TCPsocket tmp;
struct socket_node *socket;
IPaddress *ip;
/* accept the connection temporarily */
tmp = SDLNet_TCP_Accept(sock);
if (!tmp)
do_error(SDLNet_GetError());
/* are we full or game already started? */
if (get_active_players() + 1 > NUM_PLAYERS || current_turn)
SDLNet_TCP_Close(tmp);
else {
/* nope! */
socket = new_socket(SOCKET_CLIENT);
socket->sock = tmp;
if (SDLNet_TCP_AddSocket(sockset, tmp) < 0)
do_error(SDLNet_GetError());
ip = SDLNet_TCP_GetPeerAddress(tmp);
if (!ip)
do_error(SDLNet_GetError());
if (SDLNet_ResolveIP(ip))
strcpy(socket->host, SDLNet_ResolveIP(ip));
else
sprintf(socket->host, "Unknown IP");
join_player(socket); /* add player to game */
}
}
int server_socket(int port) {
int sfd;
struct linger ling = {0, 0};
struct sockaddr_in addr;
int flags =1;
if ((sfd = new_socket()) == -1) {
return -1;
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr = settings.interface;
if (bind(sfd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
perror("bind()");
close(sfd);
return -1;
}
if (listen(sfd, 1024) == -1) {
perror("listen()");
close(sfd);
return -1;
}
return sfd;
}
int set_flags(char *dev, u_int flags, u_int mask)
{
struct ifreq ifr;
int s;
strcpy(ifr.ifr_name, dev);
if((s=new_socket(AF_INET)) < 0) {
error("Error while setting \"%s\" flags: Cannot open socket", dev);
return -1;
}
if(ioctl(s, SIOCGIFFLAGS, &ifr)) {
error("Error while setting \"%s\" flags: %s", dev, strerror(errno));
close(s);
return -1;
}
ifr.ifr_flags &= ~mask;
ifr.ifr_flags |= mask&flags;
if(ioctl(s, SIOCSIFFLAGS, &ifr)) {
error("Error while setting \"%s\" flags: %s", dev, strerror(errno));
close(s);
return -1;
}
close(s);
return 0;
}
asio::error_code accept(implementation_type& impl,
Socket& peer, endpoint_type* peer_endpoint, asio::error_code& ec)
{
// We cannot accept a socket that is already open.
if (peer.is_open())
{
ec = asio::error::already_open;
return ec;
}
std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
peer_endpoint ? &addr_len : 0, ec));
// On success, assign new connection to peer socket object.
if (new_socket.get() != invalid_socket)
{
if (peer_endpoint)
peer_endpoint->resize(addr_len);
if (!peer.assign(impl.protocol_, new_socket.get(), ec))
new_socket.release();
}
return ec;
}
/*
* set_dev_ip: Assign the given `ip' to the interface named `dev'
* On success 0 is returned, -1 otherwise.
*/
int set_dev_ip(inet_prefix ip, char *dev)
{
int s=-1;
if(ip.family == AF_INET) {
struct ifreq req;
if((s=new_socket(AF_INET)) < 0) {
error("Error while setting \"%s\" ip: Cannot open socket", dev);
return -1;
}
strncpy(req.ifr_name, dev, IFNAMSIZ);
inet_to_sockaddr(&ip, 0, &req.ifr_addr, 0);
if(ioctl(s, SIOCSIFADDR, &req)) {
error("Error while setting \"%s\" ip: %s", dev, strerror(errno));
close(s);
return -1;
}
} else if(ip.family == AF_INET6) {
struct in6_ifreq req6;
struct sockaddr_in6 sin6;
struct sockaddr *sa=(struct sockaddr *)&sin6;
if((s=new_socket(AF_INET6)) < 0) {
error("Error while setting \"%s\" ip: Cannot open socket", dev);
return -1;
}
req6.ifr6_ifindex=ll_name_to_index(dev);
req6.ifr6_prefixlen=0;
inet_to_sockaddr(&ip, 0, sa, 0);
memcpy(&req6.ifr6_addr, sin6.sin6_addr.s6_addr32, ip.len);
if(ioctl(s, SIOCSIFADDR, &req6)) {
error("Error while setting \"%s\" ip: %s", dev, strerror(errno));
close(s);
return -1;
}
}
close(s);
return 0;
}
int main(int argc, char * argv[])
{
if(argc < 2)
{
cout<<"please enter a file name\n";
exit(-1);
}
char * filename = argv[1];
FILE * comfile = fopen(filename,"r");
if(!comfile)
{
perror("failed to open command file");
exit(-1);
}
map<int,int> ports = parseMembers();
map<int,int> nodeToSocket;
map<int, int>::const_iterator endports = ports.end();
for(map<int, int>::const_iterator it = ports.begin(); it != endports; it++)
{
nodeToSocket[it->first] = new_socket();
connect(nodeToSocket[it->first],it->second);
}
ports.clear();
s_send(nodeToSocket[0],"-1");
char com[BUFFER_SIZE];
char tmp[BUFFER_SIZE];
while(fgets(com, BUFFER_SIZE,comfile) != NULL){
strcpy(tmp,com);
unsigned int sleeptime = atoi(strtok(com,"\n:"));
sleeptime = sleeptime * 1000;
usleep(sleeptime);
int nodeID = atoi(strtok(NULL,"\n:"));
//locate the 2nd colon for commandID options
int i,j;
for(i = 0,j = 0; j < 2 && i < BUFFER_SIZE; i++){
if(tmp[i] == ':')
j++;
}
char * comAndOpt = tmp + i;
char moretmp[BUFFER_SIZE];
strcpy(moretmp,"0:C:");
strcat(moretmp,strtok(comAndOpt,"\n")); //strtok strips new line from command
//send comAndOpt to nodeID
printf("sending %s to %d\n",moretmp,nodeID);
s_send(nodeToSocket[nodeID],moretmp);
}
return 0;
}
// int main(int argc, char *argv[]) {
int main(void) {
const char *title = "Small Size League Simulator by RoboIME";
puts(title);
{
// Handle SIGINT (Ctrl+C)
struct sigaction sa;
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
}
// Create a world
struct World *world = new_world(&FIELD_2015);
// Add some robots
for (int i = 0; i < 6; i++) {
world_add_robot(world, i, TEAM_BLUE);
world_add_robot(world, i, TEAM_YELLOW);
}
// Create and bind socket
struct Socket *socket = new_socket(11002, "224.5.23.2");
socket_sender_bind(socket);
#define BUFFER_SIZE 10240
char buffer[BUFFER_SIZE];
int send_size;
int send_geometry = 0;
while (keep_going) {
world_step(world, 1.0 / 60, 10, 1.0 / 600);
// TODO: log errors
send_size = serialize_world(world, buffer, BUFFER_SIZE);
if (send_size > 0)
socket_send(socket, buffer, send_size);
if (send_geometry++ % 120 == 0) {
send_size = serialize_field(world_get_field(world), buffer, BUFFER_SIZE);
if (send_size > 0)
socket_send(socket, buffer, send_size);
}
// TODO: realtime update
// sleep for 16ms, prevents going too fast and intensive
nanosleep(&(struct timespec){.tv_nsec=16000000}, NULL);
}
int socket_server::bind_socket(struct request_bind * request, struct socket_message * result)
{
int id = request->id;
result->id = id;
result->opaque = request->opaque;
result->ud = 0;
struct socket * s = new_socket(id, request->fd, PROTOCOL_TCP, request->opaque, true);
if (s == nullptr) {
result->data = nullptr;
return SOCKET_ERROR;
}
nonblocking(request->fd);
s->type = SOCKET_TYPE_BIND;
result->data = (char *)"binding";
return SOCKET_OPEN;
}
static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) {
struct sockaddr_storage saddr;
socklen_t slen;
if (domain == AF_UNSPEC) {
handle->flags |= flags;
return 0;
}
if (uv__stream_fd(handle) != -1) {
if (flags & UV_HANDLE_BOUND) {
if (handle->flags & UV_HANDLE_BOUND) {
/* It is already bound to a port. */
handle->flags |= flags;
return 0;
}
/* Query to see if tcp socket is bound. */
slen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr));
if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen))
return -errno;
if ((saddr.ss_family == AF_INET6 &&
((struct sockaddr_in6*) &saddr)->sin6_port != 0) ||
(saddr.ss_family == AF_INET &&
((struct sockaddr_in*) &saddr)->sin_port != 0)) {
/* Handle is already bound to a port. */
handle->flags |= flags;
return 0;
}
/* Bind to arbitrary port */
if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen))
return -errno;
}
handle->flags |= flags;
return 0;
}
return new_socket(handle, domain, flags);
}
int main(int argc, char *argv[]) {
int sfd;
sfd = create_client_socket("127.0.0.1", "12345");
ClientSocket new_socket(sfd);
if (argc > 1) {
struct MSG_IdentifyConnection identify;
identify.type = MSG_IDENTIFY_CONNECTION;
identify.len = strlen(argv[1]) + sizeof(identify);
new_socket.txfifo_in( (unsigned char*) &identify, sizeof(identify));
new_socket.txfifo_in( (unsigned char*)argv[1], strlen(argv[1]));
}
eventloop();
exit(EXIT_SUCCESS);
}
/*
* get_dev_ip: fetches the ip currently assigned to the interface named `dev'
* and stores it to `ip'.
* On success 0 is returned, -1 otherwise.
*/
int get_dev_ip(inet_prefix *ip, int family, char *dev)
{
int s=-1;
int ret=0;
setzero(ip, sizeof(inet_prefix));
if((s=new_socket(family)) < 0) {
error("Error while setting \"%s\" ip: Cannot open socket", dev);
return -1;
}
if(family == AF_INET) {
struct ifreq req;
strncpy(req.ifr_name, dev, IFNAMSIZ);
req.ifr_addr.sa_family = family;
if(ioctl(s, SIOCGIFADDR, &req))
ERROR_FINISH(ret, -1, finish);
sockaddr_to_inet(&req.ifr_addr, ip, 0);
} else if(family == AF_INET6) {
struct in6_ifreq req6;
/*
* XXX: NOT TESTED
*/
req6.ifr6_ifindex=ll_name_to_index(dev);
req6.ifr6_prefixlen=0;
if(ioctl(s, SIOCGIFADDR, &req6))
ERROR_FINISH(ret, -1, finish);
inet_setip(ip, (u_int *)&req6.ifr6_addr, family);
}
finish:
if(s != -1)
close(s);
return ret;
}
int socket_server::listen_socket(struct request_listen * request, struct socket_message * result)
{
int id = request->id;
int listen_fd = request->fd;
struct socket * s = new_socket(id, listen_fd, PROTOCOL_TCP, request->opaque, false);
if (s == nullptr) {
goto _failed;
}
s->type = SOCKET_TYPE_PLISTEN;
return -1;
_failed:
close(listen_fd);
result->opaque = request->opaque;
result->id = id;
result->ud = 0;
result->data = nullptr;
slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
return SOCKET_ERROR;
}
static void server_listen_ai(server_t *server, struct addrinfo *ai)
{
struct linger ling = {0, 0};
int flags;
assert(server);
assert(ai);
assert(server->handle == INVALID_HANDLE);
assert(server->event == NULL);
// create the new socket. if that fails, free the memory we've already allocated, and return NULL.
server->handle = new_socket(ai);
assert(server->handle != INVALID_HANDLE);
flags = 1;
setsockopt(server->handle, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
setsockopt(server->handle, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
setsockopt(server->handle, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
if (bind(server->handle, ai->ai_addr, ai->ai_addrlen) == -1) {
close(server->handle);
server->handle = INVALID_HANDLE;
} else {
if (listen(server->handle, 1024) == -1) {
perror("listen()");
close(server->handle);
server->handle = INVALID_HANDLE;
}
else {
// Now that we are actually listening on the socket, we need to set the event.
assert(server->handle >= 0);
assert(server->event == NULL);
assert(server->sysdata->evbase);
server->event = event_new(server->sysdata->evbase, server->handle, EV_READ | EV_PERSIST, server_event_handler, (void *)server);
event_add(server->event, NULL);
}
}
assert((server->handle == INVALID_HANDLE && server->event == NULL) || (server->handle >= 0 && server->event));
}
int main(int ac, const char **av)
{
int r;
char buff[4242];
const t_socket *socket;
if (ac != 2)
return puts("Not enought arg.");
socket = new_socket(atoi(av[1]), "localhost", SOCK_CLIENT);
if (socket && socket->is_valid(deconst_cast(socket)))
{
socket->write(socket, "voi\n");
bzero(buff, 4242);
while ((r = read(0, buff, 4242)) > 0)
{
socket->write(socket, buff);
bzero(buff, 4242);
}
}
return 0;
}
static int server_socket(const int port, const bool is_udp) {
int sfd;
struct linger ling = {0, 0};
struct sockaddr_in addr;
int flags =1;
if ((sfd = new_socket(is_udp)) == -1) {
return -1;
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
if (is_udp) {
;//maximize_sndbuf(sfd);
} else {
setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
}
/*
* the memset call clears nonstandard fields in some impementations
* that otherwise mess things up.
*/
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr = settings.interf;
if (bind(sfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
perror("bind()");
close(sfd);
return -1;
}
if (!is_udp && listen(sfd, 1024) == -1) {
perror("listen()");
close(sfd);
return -1;
}
return sfd;
}
void run_server()
{
zctx_t *ctx;
void *socket;
int i, n, nclient;
char buf[256];
char data[256];
char client[256];
ctx = new_context();
socket = new_socket(ctx, ZMQ_ROUTER);
// socket = new_socket(ctx, ZMQ_REP);
assert_result(socket_bind(socket, host), 0);
// assert_result(zmq_bind(socket, host), 0);
log_printf(0, "my identity=%s\n", zsocket_identity(socket));
i = 0;
for (;;) {
log_printf(0, "Waiting %d\n", i);
nclient = zmq_recv(socket, client, sizeof(client), 0);
client[nclient] = 0;
log_printf(0, "From %s [%d]\n", client, nclient);
n = zmq_recv(socket, buf, sizeof(buf), 0);
buf[n] = 0;
if (n != 0) log_printf(0, "Missing EMPTY frame! buf=%s\n", buf);
n = zmq_recv(socket, buf, sizeof(buf), 0);
buf[n] = 0;
log_printf(0, "Got %s\n", buf);
zmq_send(socket, client, nclient, ZMQ_SNDMORE);
zmq_send(socket, NULL, 0, ZMQ_SNDMORE);
snprintf(data, sizeof(buf), "(%s) World %d", buf, i);
zmq_send(socket, data, strlen(data)+1, 0);
i++;
}
destroy_context(ctx);
}
int server_socket(int port) {
int sfd;
struct linger ling = {0, 0};
struct sockaddr_in addr;
int flags =1;
if ((sfd = new_socket()) == -1) {
return -1;
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
#if !defined(TCP_NOPUSH)
setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, &flags, sizeof(flags));
#endif
/*
* the memset call clears nonstandard fields in some impementations
* that otherwise mess things up.
*/
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr = settings.interface;
if (bind(sfd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
perror("bind()");
close(sfd);
return -1;
}
if (listen(sfd, 1024) == -1) {
perror("listen()");
close(sfd);
return -1;
}
return sfd;
}
/* starts server if address is NULL */
void server_connect(char *address, int port) {
IPaddress ip;
TCPsocket sock;
struct socket_node *socket;
if (port < 0 || port > 65535)
telegram("\nIllegal port.\n");
else if (SDLNet_ResolveHost(&ip, address, port) < 0) {
if (!address)
do_error(SDLNet_GetError());
else
telegram("\nFailed resolving host.\n");
}
else {
sock = SDLNet_TCP_Open(&ip);
if (!sock) {
if (!address)
do_error(SDLNet_GetError());
else
telegram("\nFailed connecting to the\nserver.\n");
}
else {
socket = new_socket(SOCKET_SERVER);
socket->sock = sock;
if (SDLNet_TCP_AddSocket(sockset, socket->sock) < 0)
do_error(SDLNet_GetError());
online = 1; /* we are online! */
if (!address) {
server = 1; /* and we are the server */
telegram("\nServer opened on port\n%d. Waiting for other\nplayers.\n", port);
}
else
telegram("\nConnected to server.\n");
}
}
}
int socket_server::report_accept(struct socket *s, struct socket_message *result)
{
union sockaddr_all u;
socklen_t len = sizeof(u);
int client_fd = accept(s->fd, &u.s, &len);
if (client_fd < 0) {
return 0;
}
int id = reserve_id();
if (id < 0) {
close(client_fd);
return 0;
}
keepalive(client_fd);
nonblocking(client_fd);
struct socket *ns = new_socket(id, client_fd, PROTOCOL_TCP, s->opaque, false);
if (ns == nullptr) {
close(client_fd);
return 0;
}
ns->type = SOCKET_TYPE_PACCEPT;
result->opaque = s->opaque;
result->id = s->id;
result->ud = id;
result->data = nullptr;
void * sin_addr = (u.s.sa_family == AF_INET) ? (void *)&u.v4.sin_addr : (void *)&u.v6.sin6_addr;
int sin_port = ntohs((u.s.sa_family == AF_INET) ? u.v4.sin_port : u.v6.sin6_port);
char tmp[INET6_ADDRSTRLEN];
if (inet_ntop(u.s.sa_family, sin_addr, tmp, sizeof(tmp))) {
snprintf(buffer, sizeof(buffer), "%s:%d", tmp, sin_port);
result->data = buffer;
}
return 1;
}
// Accept a new connection.
typename Protocol::socket accept(implementation_type& impl,
io_context* peer_io_context, endpoint_type* peer_endpoint,
asio::error_code& ec)
{
typename Protocol::socket peer(
peer_io_context ? *peer_io_context : io_context_);
std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
peer_endpoint ? &addr_len : 0, ec));
// On success, assign new connection to peer socket object.
if (new_socket.get() != invalid_socket)
{
if (peer_endpoint)
peer_endpoint->resize(addr_len);
peer.assign(impl.protocol_, new_socket.get(), ec);
if (!ec)
new_socket.release();
}
return peer;
}
void run_client()
{
zctx_t *ctx;
void *socket;
int i, n;
char buf[256];
char *me;
ctx = new_context();
socket = new_socket(ctx, ZMQ_REQ);
socket_connect(socket, host);
// zmq_connect(socket, host);
me = zsocket_identity(socket);
log_printf(0, "my identity=%s\n", me);
i = 0;
for (;;) {
log_printf(0, "Sending %d\n", i);
// zmq_send(socket, host, strlen(host), ZMQ_SNDMORE);
// zmq_send(socket, me, strlen(me), ZMQ_SNDMORE);
snprintf(buf, sizeof(buf), "Hello %d", i);
zmq_send(socket, buf, strlen(buf)+1, 0);
// zmq_recv(socket, buf, sizeof(buf), 0);
// log_printf(0, "From %s\n", buf);
n = zmq_recv(socket, buf, sizeof(buf), 0);
buf[n] = 0;
log_printf(0, "Got %s\n", buf);
sleep(1);
i++;
}
destroy_context(ctx);
}
static int server_socket(const char *interface,
int port,
enum network_transport transport,
FILE *portnumber_file){
/*
该函数主要作用：
1.监听端口，注册监听端口事件.
2.一旦有端口有数据，建立连接，将连接放到连接池中，conn_new为每一个连接注册时间监听
3.通知线程有连接需要处理
*/
int sfd;
struct linger ling = {0, 0};
struct addrinfo *ai;
struct addrinfo *next;
struct addrinfo hints = { .ai_flags = AI_PASSIVE,
.ai_family = AF_UNSPEC };
char port_buf[NI_MAXSERV];
int error;
int success = 0;
int flags =1;
hints.ai_socktype = SOCK_STREAM;
if (port == -1) {
port = 0;
}
snprintf(port_buf, sizeof(port_buf), "%d", port);
error= getaddrinfo(interface, port_buf, &hints, &ai);
if (error != 0) {
if (error != EAI_SYSTEM)
fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
else
perror("getaddrinfo()");
return 1;
}
for (next= ai; next; next= next->ai_next) {
conn *listen_conn_add;
if ((sfd = new_socket(next)) == -1) {
/* getaddrinfo can return "junk" addresses,
* we make sure at least one works before erroring.
*/
if (errno == EMFILE) {
/* ...unless we're out of fds */
perror("server_socket");
exit(EX_OSERR);
}
continue;
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
error = setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
if (error != 0)
perror("setsockopt");
error = setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
if (error != 0)
perror("setsockopt");
error = setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
if (error != 0)
perror("setsockopt");
if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1) {
if (errno != EADDRINUSE) {
perror("bind()");
close(sfd);
freeaddrinfo(ai);
return 1;
}
close(sfd);
continue;
} else {
success++;
if (!IS_UDP(transport) && listen(sfd, 1024) == -1) {
perror("listen()");
close(sfd);
freeaddrinfo(ai);
return 1;
}
if (portnumber_file != NULL &&
(next->ai_addr->sa_family == AF_INET ||
next->ai_addr->sa_family == AF_INET6)) {
union {
struct sockaddr_in in;
struct sockaddr_in6 in6;
} my_sockaddr;
socklen_t len = sizeof(my_sockaddr);
if (getsockname(sfd, (struct sockaddr*)&my_sockaddr, &len)==0) {
if (next->ai_addr->sa_family == AF_INET) {
fprintf(portnumber_file, "%s INET: %u\n",
IS_UDP(transport) ? "UDP" : "TCP",
ntohs(my_sockaddr.in.sin_port));
} else {
fprintf(portnumber_file, "%s INET6: %u\n",
IS_UDP(transport) ? "UDP" : "TCP",
ntohs(my_sockaddr.in6.sin6_port));
}
}
}
}
if (!(listen_conn_add = conn_new(sfd, conn_listening,
EV_READ | EV_PERSIST, 1,
transport, main_base))) {
fprintf(stderr, "failed to create listening connection\n");
exit(EXIT_FAILURE);
}
listen_conn_add->next = listen_conn;
listen_conn = listen_conn_add;
}
freeaddrinfo(ai);
/* Return zero iff we detected no errors in starting up connections */
return success == 0;
}
/* ---- example xml handler */
void* handler (SimpleXmlParser parser, SimpleXmlEvent event,
const char* szName, const char* szAttribute, const char* szValue)
{
static int nDepth= 0;
char *tmp;
char szHandlerName[32];
char szHandlerAttribute[32];
char *szHandlerValue;
//struct socket_data *news;
//struct core_data *newc;
//struct thread_data *newt;
int last_cid=0;
szHandlerValue=malloc(32);
memset(szHandlerValue,0,32);
if (szName != NULL) {
trim(szName, szHandlerName);
}
if (szAttribute != NULL) {
trim(szAttribute, szHandlerAttribute);
}
if (szValue != NULL) {
trim(szValue, szHandlerValue);
}
if (event == ADD_SUBTAG) {
fprintf(stderr,"depth: %d, val: %s\n",nDepth,szHandlerName);
fprintf(stderr, "%6li: %s add subtag (%s)\n",
simpleXmlGetLineNumber(parser), getIndent(nDepth), szHandlerName);
nDepth++;
} else if (event == ADD_ATTRIBUTE) {
// printf("attribute tag:%s %s=%s\n",szHandlerName, szHandlerAttribute, szHandlerValue);
fprintf(stderr, "%6li: %s ///add attribute to tag %s ([%s]=[%s])\n",
simpleXmlGetLineNumber(parser), getIndent(nDepth), szHandlerName, szHandlerAttribute, szHandlerValue);
if ( (!strcmp(szHandlerAttribute,"cache-level")) && (!strcmp(szHandlerValue,"3")) ) {
//attribute cache-level=3 detected: new L3 domain
fprintf(stderr,"\n* NEW SOCKET *\n");
new_socket(last_sid,last_sid);
push_socket_id(last_sid);
last_sid++;
level=3;
}
if ( (!strcmp(szHandlerAttribute,"name")) && (!strcmp(szHandlerValue,"SMT")) ) {
//attribute cache-level=2 detected: new L2 domain
fprintf(stderr,"\n * NEW CORE, Sock %d * \n", last_sid - 1);
//uncomment for noSMP:
//level=10;
//ucomment for SMP:
last_cid=pop_core_id();
new_core(0,last_cid,last_sid - 1);
} else if ( (!strcmp(szHandlerAttribute,"name")) && (!strcmp(szHandlerValue,"THREAD")) ) {
//attribute cache-level=2 detected: new L2 domain
fprintf(stderr,"\n* NEW THREAD, Sock %d *\n", last_sid - 1);
last_cid=pop_core_id();
new_thread(0,last_cid,last_sid - 1);
}
if ( (!strcmp(szHandlerAttribute,"level")) && (!strcmp(szHandlerValue,"3")) ) {
//no cpu count="2"/SMT/THREAD Routing!
level=300;
} else if ( (!strcmp(szHandlerAttribute,"level")) && (!strcmp(szHandlerValue,"2")) ) {
//attribute cache-level=2 detected: new L2 domain
fprintf(stderr,"\n* !NEW LOGICAL CORE %d!, Sock: %d*\n", last_cid,last_sid - 1);
//We have "cpu count="2" and SMT/THREAD flag name
level=200;
}
} else if (event == ADD_CONTENT) {
fprintf(stderr,"depth: %d, LEVEL %d, context for:[%s] [%s]\n",nDepth,level,szHandlerName, szHandlerValue);
if (level==200) {
if (!strcmp(szHandlerName,"cpu")) {
fprintf(stderr," !ROUTE LEVEL 10: Cores ID processed: %s, SOCKET: %d\n",szHandlerValue, last_sid - 1 );
while ((tmp = strsep(&szHandlerValue, ",")) != NULL) {
if (tmp[0] == '\0')
break; /* XXX */
trim_spaces(tmp);
// comment for no SMP?
push_core_id(atoi(tmp));
fprintf(stderr,"\n\n\nHA: [%d]\n\n\n",atoi(tmp));
// uncomment for no SMP:
// last_cid=pop_core_id();
// new_core(0,atoi(tmp),last_sid - 1);
}
// drop level
// level=9;
}
} else if (level==300) {
//no cpu count="2"/SMT/THREAD Routing!
if (!strcmp(szHandlerName,"cpu")) {
fprintf(stderr," !ROUTE LEVEL 10: Cores ID processed: %s, SOCKET: %d\n",szHandlerValue, last_sid - 1 );
while ((tmp = strsep(&szHandlerValue, ",")) != NULL) {
if (tmp[0] == '\0')
break; /* XXX */
trim_spaces(tmp);
// comment for no SMP?
push_core_id(atoi(tmp));
fprintf(stderr,"\n\n\nHA: [%d]\n\n\n",atoi(tmp));
// uncomment for no SMP:
last_cid=pop_core_id();
new_core(0,atoi(tmp),last_sid - 1);
}
// drop level
// level=9;
}
}
fprintf(stderr, "%6li: %s add content to tag %s (%s)\n",
simpleXmlGetLineNumber(parser), getIndent(nDepth), szHandlerName, szHandlerValue);
} else if (event == FINISH_ATTRIBUTES) {
fprintf(stderr,"finish for:%s\n",szHandlerName);
fprintf(stderr, "%6li: %s finish attributes (%s)\n",
simpleXmlGetLineNumber(parser), getIndent(nDepth), szHandlerName);
} else if (event == FINISH_TAG) {
fprintf(stderr,"finish for:%s\n",szHandlerName);
fprintf(stderr, "%6li: %s finish tag (%s)\n",
simpleXmlGetLineNumber(parser), getIndent(nDepth), szHandlerName);
nDepth--;
if (level==10) {
if (!strcmp(szHandlerName,"cpu"))
level=0;
}
}
//list_sockets();
return handler;
}
net_base(boost::shared_ptr<boost::asio::io_service> net_io)
:socket_(new_socket(net_io))
{
};
static int server_socket(const int port, const bool is_udp)
{
int sfd;
struct linger ling =
{ 0, 0 };
struct addrinfo *ai;
struct addrinfo *next;
struct addrinfo hints;
char port_buf[NI_MAXSERV];
int error;
int success = 0;
int flags = 1;
/*
* the memset call clears nonstandard fields in some impementations
* that otherwise mess things up.
*/
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
if (is_udp)
{
hints.ai_protocol = IPPROTO_UDP;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_family = AF_INET; /* This left here because of issues with OSX 10.5 */
}
else
{
hints.ai_family = AF_UNSPEC;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_socktype = SOCK_STREAM;
}
snprintf(port_buf, NI_MAXSERV, "%d", port);
error = getaddrinfo(settings.inter, port_buf, &hints, &ai);
if (error != 0)
{
if (error != EAI_SYSTEM)
fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
else
perror("getaddrinfo()");
return 1;
}
for (next = ai; next; next = next->ai_next)
{
conn *listen_conn_add;
if ((sfd = new_socket(next)) == -1)
{
freeaddrinfo(ai);
return 1;
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *) &flags, sizeof(flags));
if (is_udp)
{
maximize_sndbuf(sfd);
}
else
{
setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *) &flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *) &ling, sizeof(ling));
setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *) &flags, sizeof(flags));
}
if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1)
{
if (errno != EADDRINUSE)
{
perror("bind()");
close(sfd);
freeaddrinfo(ai);
return 1;
}
close(sfd);
continue;
}
else
{
success++;
if (!is_udp && listen(sfd, 1024) == -1)
{
perror("listen()");
close(sfd);
freeaddrinfo(ai);
return 1;
}
}
if (is_udp)
{
int c;
for (c = 0; c < settings.num_threads; c++)
{
/* this is guaranteed to hit all threads because we round-robin */
dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,
UDP_READ_BUFFER_SIZE, 1);
}
}
else
{
if (!(listen_conn_add = conn_new(sfd, conn_listening,
EV_READ | EV_PERSIST, 1, false, main_base)))
{
fprintf(stderr, "failed to create listening connection\n");
exit (EXIT_FAILURE);
}
listen_conn_add->next = listen_conn;
listen_conn = listen_conn_add;
}
}
freeaddrinfo(ai);
/* Return zero iff we detected no errors in starting up connections */
return success == 0;
}
int socket_server::open_socket(struct request_open * request, struct socket_message * result)
{
int id = request->id;
result->id = id;
result->opaque = request->opaque;
result->ud = 0;
result->data = nullptr;
struct socket *ns;
int status;
struct addrinfo ai_hints;
struct addrinfo * ai_list = nullptr;
struct addrinfo * ai_ptr = nullptr;
char port[16];
sprintf(port, "%d", request->port);
memset(&ai_hints, 0, sizeof(ai_hints));
ai_hints.ai_family = AF_UNSPEC;
ai_hints.ai_socktype = SOCK_STREAM;
ai_hints.ai_protocol = IPPROTO_TCP;
status = getaddrinfo(request->host, port, &ai_hints, &ai_list);
int sock = -1;
if (status != 0) {
goto _failed;
}
for (ai_ptr = ai_list; ai_list != nullptr; ai_ptr = ai_ptr->ai_next) {
sock = socket(ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (sock < 0) {
continue;
}
keepalive(sock);
nonblocking(sock);
status = connect(sock, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
if (status != 0 && errno != EINPROGRESS) {
close(sock);
sock = -1;
continue;
}
break;
}
if (sock < 0) {
goto _failed;
}
ns = new_socket(id, sock, PROTOCOL_TCP, request->opaque, true);
if (status == 0) {
ns-> type = SOCKET_TYPE_CONNECTED;
struct sockaddr * addr = ai_ptr->ai_addr;
void * sin_addr = (ai_ptr->ai_family == AF_INET) ? (void *)&((struct sockaddr_in *)addr)->sin_addr : (void *)&((struct sockaddr_in6 *)addr)->sin6_addr;
if (inet_ntop(ai_ptr->ai_family, sin_addr, buffer, sizeof(buffer))) {
result->data = buffer;
}
freeaddrinfo(ai_list);
return SOCKET_OPEN;
} else {
ns->type = SOCKET_TYPE_CONNECTING;
event_fd.write(ns->fd, ns, true);
}
freeaddrinfo(ai_list);
return -1;
_failed:
freeaddrinfo(ai_list);
slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
return SOCKET_ERROR;
}
int server_socket(const char *interface, int port, int backlog) {
int sfd;
struct linger ling;
struct addrinfo *ai;
struct addrinfo *next;
struct addrinfo hints;
char port_buf[NI_MAXSERV];
int error;
int success = 0;
int flags = 1;
ling.l_onoff = 0;
ling.l_linger = 0;
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_PASSIVE;
hints.ai_family = base_conf.support_ipv6 ? AF_UNSPEC : AF_INET;
hints.ai_socktype = SOCK_STREAM;
if (port == -1) {
port = 0;
}
snprintf(port_buf, sizeof(port_buf), "%d", port);
error= getaddrinfo(interface, port_buf, &hints, &ai);
if (error != 0) {
if (error != EAI_SYSTEM)
fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
else
perror("getaddrinfo()");
return 1;
}
for (next= ai; next; next= next->ai_next) {
conn *listen_conn_add;
if ((sfd = new_socket(next)) == -1) {
close(sfd);
freeaddrinfo(ai);
return 1;
}
#ifdef IPV6_V6ONLY
if (next->ai_family == AF_INET6) {
error = setsockopt(sfd, IPPROTO_IPV6, IPV6_V6ONLY,
(char *) &flags, sizeof(flags));
if (error != 0) {
perror("setsockopt");
close(sfd);
continue;
}
}
#endif
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
error = setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags,
sizeof(flags));
if (error != 0)
perror("setsockopt");
error = setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
if (error != 0)
perror("setsockopt");
error = setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags,
sizeof(flags));
if (error != 0)
perror("setsockopt");
if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1) {
perror("bind()");
close(sfd);
freeaddrinfo(ai);
return 1;
} else {
success++;
if (listen(sfd, backlog) == -1) {
perror("listen()");
close(sfd);
freeaddrinfo(ai);
return 1;
}
}
if (!(listen_conn_add = conn_new(sfd, conn_listening,
EV_READ | EV_PERSIST, get_main_thread()))) {
fprintf(stderr, "failed to create listening connection\n");
exit(EXIT_FAILURE);
}
listen_conn_add->host->assign(interface?interface:"0.0.0.0");
listen_conn_add->port = port;
listen_conn_add->next = listen_conn;
listen_conn = listen_conn_add;
}
freeaddrinfo(ai);
return success == 0;
}
//-----------------------------------------------------------------------------
// Initialise and return a server struct that we will use to control the nodes
// that we are connected to. We will bind the listening port on the socket.
//
// ** Will we ever need to listen on more than one port? How will we add that
// to the system? Currently, wont bother with it, but will include a
// 'next' pointer so that we can have a list of listeners. The problem
// will be with our list of nodes. All the servers would need to share
// the nodes list, and various other shared resources. This could be a
// little cumbersome, but possible.
//
//
server_t *server_new(int port, int maxconns, char *address)
{
server_t *ptr = NULL;
int i;
struct linger ling = {0, 0};
struct addrinfo *ai;
struct addrinfo *next;
struct addrinfo hints;
char port_buf[NI_MAXSERV];
int error;
int sfd;
int flags =1;
assert(port > 0);
assert(maxconns > 5);
assert(address == NULL || (address != NULL && address[0] != '\0'));
memset(&hints, 0, sizeof (hints));
hints.ai_flags = AI_PASSIVE|AI_ADDRCONFIG;
hints.ai_family = AF_UNSPEC;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_socktype = SOCK_STREAM;
snprintf(port_buf, NI_MAXSERV, "%d", port);
error = getaddrinfo(address, port_buf, &hints, &ai);
if (error != 0) {
if (error != EAI_SYSTEM)
fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
else
perror("getaddrinfo()");
return(NULL);
}
sfd = 0;
for (next= ai; next; next= next->ai_next) {
assert(sfd == 0);
// create the new socket. if that fails, free the memory we've already allocated, and return NULL.
sfd = new_socket(next);
if (sfd == INVALID_HANDLE) {
freeaddrinfo(ai);
return(NULL);
}
setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
setsockopt(sfd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
// setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1) {
if (errno != EADDRINUSE) {
perror("bind()");
close(sfd);
freeaddrinfo(ai);
return(NULL);
}
close(sfd);
sfd = INVALID_HANDLE;
continue;
} else {
if (listen(sfd, 1024) == -1) {
perror("listen()");
close(sfd);
freeaddrinfo(ai);
return(NULL);
}
}
}
freeaddrinfo(ai);
ptr = (server_t *) malloc(sizeof(server_t));
assert(ptr != NULL);
ptr->handle = sfd;
ptr->stats = NULL;
ptr->risp = NULL;
ptr->verbose = false;
// We will create an array of empty pointers for our nodes.
ptr->maxconns = maxconns;
ptr->nodes = (node_t **) malloc(sizeof(node_t *) * maxconns);
for (i=0; i<maxconns; i++) {
ptr->nodes[i] = NULL;
}
return(ptr);
}
