void accept_cb(EV_P_ ev_io *w, int revents)
{
listen_ctx_t *listener = (listen_ctx_t *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
server_t *server = new_server(serverfd, listener->method);
server->listener = listener;
// SSR beg
server->obfs_plugin = new_obfs_class(listener->obfs_name);
if (server->obfs_plugin) {
server->obfs = server->obfs_plugin->new_obfs();
}
server->protocol_plugin = new_obfs_class(listener->protocol_name);
if (server->protocol_plugin) {
server->protocol = server->protocol_plugin->new_obfs();
}
// SSR end
ev_io_start(EV_A_ & server->recv_ctx->io);
}
static void init_controller(int port, int nrouters, int nworkers) {
if (!new_server(port, &listen_fd, NULL))
err(true, "Cannot set up server on port %u", port);
#if RPT >= 2
report(2, "Listening socket has descriptor %d", listen_fd);
#endif
router_addr_set = word_set_new();
new_conn_map = word_keyvalue_new();
router_fd_set = word_set_new();
worker_fd_set = word_set_new();
client_fd_set = word_set_new();
init_cmd();
add_cmd("status", do_controller_status_cmd,
" | Determine status of connected nodes");
add_cmd("flush", do_controller_flush_cmd,
" | Flush state of all agents");
add_cmd("collect", do_controller_collect_cmd,
" | Initiate garbage collection");
add_quit_helper(quit_controller);
need_routers = nrouters;
need_workers = nworkers;
worker_cnt = nworkers;
stat_message_cnt = 0;
flush_requestor_fd = -1;
stat_messages = calloc_or_fail(worker_cnt, sizeof(chunk_ptr),
"init_controller");
gc_state = GC_READY;
need_worker_cnt = 0;
need_client_fd_set = NULL;
defer_client_fd_set = NULL;
gc_generation = 0;
}
static void accept_cb (EV_P_ ev_io *w, int revents)
{
struct listen_ctx *listener = (struct listen_ctx *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1)
{
ERROR("accept");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
if (verbose)
{
LOGD("accept a connection.");
}
struct server *server = new_server(serverfd, listener);
ev_io_start(EV_A_ &server->recv_ctx->io);
ev_timer_start(EV_A_ &server->recv_ctx->watcher);
}
// main loop
int main( int argc, char **argv )
{
printf("Hello world\n");
Management manager = new_manager();
// add actions to the manager
action_add_to_manager( manager );
// add rooms to manager
room_add_to_manager( manager );
Server server = new_server();
if( start_server( server, 5555 ) < 0 ){
return 1;
}
environment_loop( server, manager );
/* ---------------------------------------
* Clean up
*/
close_server( server );
destroy_server( server );
destroy_manager( manager );
return 0;
}
void transmission_tower(ZNotice_t *notice,
char *packet,
int pak_len)
{
ZNotice_t gack;
Code_t ret;
struct sockaddr_in gsin;
nclt++;
if (notice->z_kind == HMCTL) {
if (!strcmp(notice->z_opcode, CLIENT_FLUSH)) {
if (noflushflag)
syslog(LOG_INFO, "Client requested hm flush (disabled).");
else {
send_flush_notice(HM_FLUSH);
deactivated = 1;
}
} else if (!strcmp(notice->z_opcode, CLIENT_NEW_SERVER)) {
new_server((char *)NULL);
} else {
syslog (LOG_INFO, "Bad control notice from client.");
}
return;
} else {
if (notice->z_kind != UNSAFE) {
gack = *notice;
gack.z_kind = HMACK;
gack.z_message_len = 0;
gack.z_multinotice = "";
gsin = cli_sin;
gsin.sin_port = from.sin_port;
if (gack.z_port == 0)
gack.z_port = from.sin_port;
DPR2 ("Client Port = %u\n", ntohs(gack.z_port));
notice->z_port = gack.z_port;
if ((ret = ZSetDestAddr(&gsin)) != ZERR_NONE) {
Zperr(ret);
com_err("hm", ret, "setting destination");
}
/* Bounce ACK to library */
if ((ret = send_outgoing(&gack)) != ZERR_NONE) {
Zperr(ret);
com_err("hm", ret, "sending raw notice");
}
}
}
if (!no_server) {
DPR2 ("Server Port = %u\n", ntohs(serv_sin.sin_port));
if ((ret = ZSetDestAddr(&serv_sin)) != ZERR_NONE) {
Zperr(ret);
com_err("hm", ret, "setting destination");
}
if ((ret = ZSendPacket(packet, pak_len, 0)) != ZERR_NONE) {
Zperr(ret);
com_err("hm", ret, "while sending raw notice");
}
}
if (add_notice_to_queue(notice, packet, &gsin, pak_len) != ZERR_NONE)
syslog(LOG_INFO, "Hey! Insufficient memory to add notice to queue!");
}
static void accept_cb(EV_P_ ev_io *w, int revents)
{
struct listen_ctx *listener = (struct listen_ctx *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
int index = rand() % listener->remote_num;
struct sockaddr *remote_addr = listener->remote_addr[index];
int remotefd = socket(remote_addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (remotefd < 0) {
ERROR("socket");
return;
}
#ifdef ANDROID
if (vpn) {
if (protect_socket(remotefd) == -1) {
ERROR("protect_socket");
close(remotefd);
return;
}
}
#endif
setsockopt(remotefd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(remotefd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
// Setup
setnonblocking(remotefd);
#ifdef SET_INTERFACE
if (listener->iface) {
setinterface(remotefd, listener->iface);
}
#endif
struct server *server = new_server(serverfd, listener->method);
struct remote *remote = new_remote(remotefd, listener->timeout);
server->destaddr = listener->tunnel_addr;
server->remote = remote;
remote->server = server;
connect(remotefd, remote_addr, get_sockaddr_len(remote_addr));
// listen to remote connected event
ev_io_start(EV_A_ & remote->send_ctx->io);
ev_timer_start(EV_A_ & remote->send_ctx->watcher);
}
static void accept_cb (EV_P_ ev_io *w, int revents)
{
struct listen_ctx *listener = (struct listen_ctx *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1)
{
ERROR("accept");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
struct addrinfo hints, *res;
int sockfd;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
int index = rand() % listener->remote_num;
int err = getaddrinfo(listener->remote_host[index], listener->remote_port, &hints, &res);
if (err)
{
ERROR("getaddrinfo");
return;
}
sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (sockfd < 0)
{
ERROR("socket");
close(sockfd);
freeaddrinfo(res);
return;
}
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
// Setup
setnonblocking(sockfd);
#ifdef SET_INTERFACE
if (listener->iface) setinterface(sockfd, listener->iface);
#endif
struct server *server = new_server(serverfd, listener->method);
struct remote *remote = new_remote(sockfd, listener->timeout);
server->remote = remote;
remote->server = server;
connect(sockfd, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
// listen to remote connected event
ev_io_start(EV_A_ &remote->send_ctx->io);
ev_timer_start(EV_A_ &remote->send_ctx->watcher);
}
/*
* kern_return_t
* bootstrap_create_server(mach_port_t bootstrap_port,
* cmd_t server_cmd,
* integer_t server_uid,
* boolean_t on_demand,
* mach_port_t *server_portp)
*
* Returns send rights to server_port of service. At this point, the
* server appears active, so nothing will try to launch it. The server_port
* can be used to delare services associated with this server by calling
* bootstrap_create_service() and passing server_port as the bootstrap port.
*
* Errors: Returns appropriate kernel errors on rpc failure.
* Returns BOOTSTRAP_NOT_PRIVILEGED, if bootstrap port invalid.
*/
kern_return_t
x_bootstrap_create_server(
mach_port_t bootstrap_port,
cmd_t server_cmd,
int server_uid,
boolean_t on_demand,
audit_token_t client_audit_token,
mach_port_t *server_portp)
{
server_t *serverp;
struct auditinfo audit_info;
bootstrap_info_t *bootstrap;
uid_t client_euid;
bootstrap = lookup_bootstrap_by_port(bootstrap_port);
debug("Server create attempt: \"%s\" bootstrap %x",
server_cmd, bootstrap_port);
/* No forwarding allowed for this call - security risk (we run as root) */
if (!bootstrap || !active_bootstrap(bootstrap)) {
debug("Server create: \"%s\": invalid bootstrap %x",
server_cmd, bootstrap_port);
return BOOTSTRAP_NOT_PRIVILEGED;
}
/* get the identity of the requestor and set up audit_info of server */
audit_token_to_au32(client_audit_token,
&audit_info.ai_auid,
&client_euid,
NULL /* egid */,
NULL /* ruid */,
NULL /* rgid */,
NULL /* pid */,
&audit_info.ai_asid,
&audit_info.ai_termid);
if (client_euid != 0 && client_euid != server_uid) {
notice("Server create: \"%s\": insufficient privilege for specified uid (euid-%d != requested-%d)",
server_cmd, client_euid, server_uid);
return BOOTSTRAP_NOT_PRIVILEGED;
}
serverp = new_server(
bootstrap,
server_cmd,
server_uid,
(on_demand) ? DEMAND : RESTARTABLE,
audit_info);
setup_server(serverp);
info("New server %x in bootstrap %x: \"%s\"",
serverp->port, bootstrap_port, server_cmd);
*server_portp = serverp->port;
return BOOTSTRAP_SUCCESS;
}
static void accept_cb(EV_P_ ev_io *w, int revents)
{
listen_ctx_t *listener = (listen_ctx_t *)w;
struct sockaddr_storage destaddr;
int err;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
err = getdestaddr(serverfd, &destaddr);
if (err) {
ERROR("getdestaddr");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
int index = rand() % listener->remote_num;
struct sockaddr *remote_addr = listener->remote_addr[index];
int remotefd = socket(remote_addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (remotefd < 0) {
ERROR("socket");
return;
}
setsockopt(remotefd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(remotefd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
// Setup
setnonblocking(remotefd);
server_t *server = new_server(serverfd, listener->method);
remote_t *remote = new_remote(remotefd, listener->timeout);
server->remote = remote;
remote->server = server;
server->destaddr = destaddr;
connect(remotefd, remote_addr, get_sockaddr_len(remote_addr));
// listen to remote connected event
ev_io_start(EV_A_ & remote->send_ctx->io);
ev_io_start(EV_A_ & server->recv_ctx->io);
ev_timer_start(EV_A_ & remote->send_ctx->watcher);
}
void viagra_cmd_jupe(char *jserver, char *who, char *reason)
{
char rbuf[256];
snprintf(rbuf, sizeof(rbuf), "Juped by %s%s%s", who,
reason ? ": " : "", reason ? reason : "");
if (findserver(servlist, jserver))
viagra_cmd_squit(jserver, rbuf);
viagra_cmd_server(jserver, 2, rbuf);
new_server(me_server, jserver, rbuf, SERVER_JUPED, NULL);
}
int main(int argc, char* argv[]) {
#ifdef _DEBUG
Config::DEBUG = true;
#else
Config::DEBUG = false;
#endif
Log("[[[[[[[[[[Developed By Tsume]]]]]]]]]]\n");
setTitle(" - Connections: 0");
Config cfg;
CDatabase db(&cfg);
LoginServer login;
WorldServer world;
ZoneServer zone;
int s_index = 0;
try {
if (db.Connect())
{
if (argc > 1) {
new_server(getType(argv[1]), &cfg, &db, s_index++, &login);
if (argc > 2) {
new_server(getType(argv[2]), &cfg, &db, s_index++, &world);
}
if (argc > 3) {
new_server(getType(argv[3]), &cfg, &db, s_index++, &zone);
}
}
else {
new_server(0, &cfg, &db, s_index++, &login);
new_server(1, &cfg, &db, s_index++, &world);
new_server(2, &cfg, &db, s_index++, &zone);
Config::DEBUG = true;
}
bool running = true;
while (running) {
if (Config::DEBUG) Log("Pinging SQL server to keep connection alive...");
if (!db.ConnectionAlive()) {
Log("Connection to database lost!!");
break;
}
std::this_thread::sleep_for(std::chrono::minutes(2));
}
}
Log("Stopping...");
}
catch (std::exception& e) {
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
int main(void) {
int clientfd;
setup_signals();
printf("*** Creating a server...\n");
if ((serverfd = new_server("server1.example.com")) < 0) {
perror("Couldn't create server");
exit(EXIT_FAILURE);
}
printf("*** Created!\n"
" This is an echo server.\n"
" Anything received will be echoed back to the client.\n\n");
/* Accept a client */
if ((clientfd = accept_client(serverfd)) < 0) {
perror("Couldn't accept client");
destroy_server(serverfd);
exit(EXIT_FAILURE);
}
printf("*** Accepted incoming connection request.\n");
static char buf[512+1];
int n;
while ((n = recv_info(clientfd, buf, sizeof(buf)-1)) > 0) {
buf[n] = '\0';
if (!strcmp(buf, "__QUIT__NOW__\n")) {
printf("*** Got disconnect request from client, leaving...\n");
disconnect_from(clientfd);
break;
}
printf("*** Received: %s", buf);
if (send_info(clientfd, buf, n) < 0) {
perror("Error sending message to client");
} else {
printf("*** Sent: %s", buf);
}
}
printf("*** Goodbye\n");
destroy_server(serverfd);
return 0;
}
/*
* Function: get the reply from either the surname server or other firstname servers
*
* Parameters: pointer to the list of registered users, the buffer, the length of the buffer, the host entity of the surname server, the port of the latter
* and the surname which location is wanted to know
*
* Return: the reply to the query made by the user of the schat application
*
*/
char* do_qry(list* start, char* buffer, int n, struct hostent *h, int surport, char* surname) {
char *bufferIn;
int send_len;
user User;
completename Complete;
server Server;
/* Stored wanted User */
Complete = encontra_nomes(buffer, n);
if(strcmp(surname, Complete.last) == 0){
/* The wanted User is in this snp */
if(getuser(start, Complete.first, Complete.last) != 0){
User = get_localization(start, Complete.first);
/* The +3 is there for 2 semicolon and one dot */
send_len = (strlen("RPL ")+strlen(User.name)+strlen(User.surname)+strlen(User.ip)+strlen(User.port)+3);
bufferIn = (char*)malloc(sizeof(char)*send_len);
sprintf(bufferIn, "RPL %s.%s;%s;%s", User.name, User.surname, User.ip, User.port);
}else{
/* User requested has a valid surname for this server but not an existent first name */
return "NOK User not registered therefore his location is impossible to reach";
}
}else{
bufferIn = do_qry_sa(h, surport, Complete.last);
if(strcmp(bufferIn,"SRPL") == 0){
return "NOK Server not found in the sa";
}
Server = new_server(bufferIn, strlen(bufferIn));
bufferIn = do_qry_snp(Server.ip, Server.port, Complete.first, Complete.last);
if(strcmp(bufferIn,"") == 0){
write(1, "User not found\n", strlen("User not found\n"));
return "NOK user not found";
}
/* return the reply*/
write(1, "User found: ", strlen("User found: "));
write(1, bufferIn, strlen(bufferIn));
write(1, "\n", 1);
}
return bufferIn;
}
void
plexus_cmd_connect (int servernum)
{
me_server = new_server (NULL, ServerName, ServerDesc, SERVER_ISME, NULL);
if (servernum == 1)
plexus_cmd_pass (RemotePassword);
else if (servernum == 2)
plexus_cmd_pass (RemotePassword2);
else if (servernum == 3)
plexus_cmd_pass (RemotePassword3);
plexus_cmd_capab ();
plexus_cmd_server (ServerName, 1, ServerDesc);
plexus_cmd_svinfo ();
}
void viagra_cmd_connect(int servernum)
{
me_server =
new_server(NULL, ServerName, ServerDesc, SERVER_ISME, NULL);
if (servernum == 1) {
viagra_cmd_pass(RemotePassword);
} else if (servernum == 2) {
viagra_cmd_pass(RemotePassword2);
} else if (servernum == 3) {
viagra_cmd_pass(RemotePassword3);
}
viagra_cmd_capab();
viagra_cmd_server(ServerName, 1, ServerDesc);
viagra_cmd_svinfo();
viagra_cmd_burst();
}
void accept_cb(EV_P_ ev_io *w, int revents)
{
struct listen_ctx *listener = (struct listen_ctx *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
setnonblocking(serverfd);
#ifdef SO_NOSIGPIPE
int opt = 1;
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
struct server *server = new_server(serverfd, listener->method);
server->listener = listener;
ev_io_start(EV_A_ & server->recv_ctx->io);
}
//FIXME: move the stateful stuff to state.c, only the connection relavent stuff should be here
void
server_connect(char *host, char *port)
{
connection_thread *ct;
server *tmp, *s = NULL;
/* Check if server matching host:port already exists */
if ((tmp = server_head) != NULL) {
do {
if (!strcmp(tmp->host, host) && !strcmp(tmp->port, port)) {
s = tmp;
break;
}
} while ((tmp = tmp->next) != server_head);
}
/* Check if server is already connected */
if (s && s->soc >= 0) {
channel_set_current(s->channel);
newlinef(s->channel, 0, "-!!-", "Already connected to %s:%s", host, port);
return;
}
if (s == NULL)
s = new_server(host, port);
channel_set_current(s->channel);
if ((ct = calloc(1, sizeof(*ct))) == NULL)
fatal("calloc");
ct->socket = -1;
ct->socket_tmp = -1;
ct->host = s->host;
ct->port = s->port;
s->connecting = ct;
newlinef(s->channel, 0, "--", "Connecting to '%s' port %s", host, port);
if ((pthread_create(&ct->tid, NULL, threaded_connect, ct)))
fatal("pthread_create");
}
static void accept_cb(EV_P_ ev_io *w, int revents)
{
struct sockaddr_storage destaddr;
int err;
struct sockaddr_in addr;
int len = sizeof(struct sockaddr_in);
printf("w->fd=%d\n", w->fd);
int serverfd = accept(w->fd, (struct sockaddr*)&addr, &len);
printf("accept_cb serverfd=%d\n", serverfd);
if (-1 == serverfd)
{
perror("serverfd is error\n");
return;
}
//err = getdestaddr(serverfd, &destaddr);
//if (err){
// printf("getdestaddr error\n");
// return;
//}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
printf("accept_cb serverfd2=%d\n", serverfd);
//ev_io rcv_io;
//ev_io snd_io;
server_t *server = new_server(serverfd);
//ev_io_init(&rcv_io, server_recv_cb, serverfd, EV_READ);
//ev_io_init(&snd_io, server_send_cb, serverfd, EV_WRITE);
//ev_io_start(EV_A_ & rcv_io);
ev_io_start(EV_A_ &server->recv_ctx->io);
}
session *
new_ircwindow (server *serv, char *name, int type)
{
session *sess;
switch (type)
{
case SESS_SERVER:
serv = new_server ();
if (prefs.use_server_tab)
{
register unsigned int oldh = prefs.hideuserlist;
prefs.hideuserlist = 1;
sess = new_session (serv, name, SESS_SERVER);
prefs.hideuserlist = oldh;
} else
{
sess = new_session (serv, name, SESS_CHANNEL);
}
serv->server_session = sess;
serv->front_session = sess;
break;
case SESS_DIALOG:
sess = new_session (serv, name, type);
if (prefs.logging)
log_open (sess);
break;
default:
/* case SESS_CHANNEL:
case SESS_NOTICES:
case SESS_SNOTICES:*/
sess = new_session (serv, name, type);
break;
}
irc_init (sess);
plugin_emit_dummy_print (sess, "Open Context");
return sess;
}
static void
accept_cb(EV_P_ ev_io *w, int revents)
{
listen_ctx_t *listener = (listen_ctx_t *)w;
struct sockaddr_storage destaddr;
int err;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
err = getdestaddr(serverfd, &destaddr);
if (err) {
ERROR("getdestaddr");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
int index = rand() % listener->remote_num;
struct sockaddr *remote_addr = listener->remote_addr[index];
int remotefd = socket(remote_addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (remotefd == -1) {
ERROR("socket");
return;
}
// Set flags
setsockopt(remotefd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(remotefd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
// Enable TCP keepalive feature
int keepAlive = 1;
int keepIdle = 40;
int keepInterval = 20;
int keepCount = 5;
setsockopt(remotefd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepAlive, sizeof(keepAlive));
setsockopt(remotefd, SOL_TCP, TCP_KEEPIDLE, (void *)&keepIdle, sizeof(keepIdle));
setsockopt(remotefd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepInterval, sizeof(keepInterval));
setsockopt(remotefd, SOL_TCP, TCP_KEEPCNT, (void *)&keepCount, sizeof(keepCount));
// Set non blocking
setnonblocking(remotefd);
// Enable MPTCP
if (listener->mptcp == 1) {
int err = setsockopt(remotefd, SOL_TCP, MPTCP_ENABLED, &opt, sizeof(opt));
if (err == -1) {
ERROR("failed to enable multipath TCP");
}
}
server_t *server = new_server(serverfd, listener->method);
remote_t *remote = new_remote(remotefd, listener->timeout);
server->remote = remote;
remote->server = server;
server->destaddr = destaddr;
int r = connect(remotefd, remote_addr, get_sockaddr_len(remote_addr));
if (r == -1 && errno != CONNECT_IN_PROGRESS) {
ERROR("connect");
close_and_free_remote(EV_A_ remote);
close_and_free_server(EV_A_ server);
return;
}
// listen to remote connected event
ev_io_start(EV_A_ & remote->send_ctx->io);
ev_timer_start(EV_A_ & remote->send_ctx->watcher);
ev_io_start(EV_A_ & server->recv_ctx->io);
}
// Start main loop
int core_loop(void (* server_event)(BSP_CALLBACK *))
{
BSP_THREAD *t = get_thread(MAIN_THREAD);
if (!t)
{
trigger_exit(BSP_RTN_FATAL, "Main thread lost!");
}
// Servers
BSP_VALUE *val = object_get_hash_str(runtime_settings, "servers");
BSP_OBJECT *vobj = value_get_object(val);
BSP_STRING *vstr = NULL;
if (vobj && OBJECT_TYPE_ARRAY == vobj->type)
{
struct bsp_conf_server_t srv;
BSP_OBJECT *vsrv = NULL;
size_t varr_size = object_size(vobj), i;
reset_object(vobj);
for (i = 0; i < varr_size; i ++)
{
val = object_get_array(vobj, i);
vsrv = value_get_object(val);
if (vsrv && OBJECT_TYPE_HASH == vsrv->type)
{
// Default value
memset(&srv, 0, sizeof(struct bsp_conf_server_t));
srv.server_inet = INET_TYPE_ANY;
srv.server_sock = SOCK_TYPE_ANY;
srv.def_client_type = CLIENT_TYPE_DATA;
srv.def_data_type = DATA_TYPE_PACKET;
val = object_get_hash_str(vsrv, "name");
vstr = value_get_string(val);
srv.server_name = bsp_strndup(STR_STR(vstr), STR_LEN(vstr));
val = object_get_hash_str(vsrv, "inet");
vstr = value_get_string(val);
if (vstr)
{
if (0 == strncasecmp(STR_STR(vstr), "ipv6", 4))
{
srv.server_inet = INET_TYPE_IPV6;
}
else if (0 == strncasecmp(STR_STR(vstr), "ipv4", 4))
{
srv.server_inet = INET_TYPE_IPV4;
}
else if (0 == strncasecmp(STR_STR(vstr), "local", 5))
{
srv.server_inet = INET_TYPE_LOCAL;
}
}
val = object_get_hash_str(vsrv, "sock");
vstr = value_get_string(val);
if (vstr)
{
if (0 == strncasecmp(STR_STR(vstr), "tcp", 3))
{
srv.server_sock = SOCK_TYPE_TCP;
}
else if (0 == strncasecmp(STR_STR(vstr), "udp", 3))
{
srv.server_sock = SOCK_TYPE_UDP;
}
}
val = object_get_hash_str(vsrv, "addr");
vstr = value_get_string(val);
srv.server_addr = bsp_strndup(STR_STR(vstr), STR_LEN(vstr));
val = object_get_hash_str(vsrv, "port");
srv.server_port = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "heartbeat_check");
srv.heartbeat_check = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "debug_input");
srv.debug_hex_input = value_get_boolean(val);
val = object_get_hash_str(vsrv, "debug_output");
srv.debug_hex_input = value_get_boolean(val);
val = object_get_hash_str(vsrv, "max_clients");
srv.max_clients = (int) value_get_int(val);
val = object_get_hash_str(vsrv, "max_packet_length");
srv.max_packet_length = (size_t) value_get_int(val);
val = object_get_hash_str(vsrv, "websocket");
if (value_get_boolean(val))
{
srv.def_client_type = CLIENT_TYPE_WEBSOCKET_HANDSHAKE;
}
val = object_get_hash_str(vsrv, "data_type");
vstr = value_get_string(val);
if (vstr && 0 == strncasecmp(STR_STR(vstr), "stream", 6))
{
srv.def_data_type = DATA_TYPE_STREAM;
}
// Add server
BSP_SERVER *s;
int srv_fds[MAX_SERVER_PER_CREATION], srv_ct, fd_type;
int nfds = MAX_SERVER_PER_CREATION;
nfds = new_server(srv.server_addr, srv.server_port, srv.server_inet, srv.server_sock, srv_fds, &nfds);
for (srv_ct = 0; srv_ct < nfds; srv_ct ++)
{
fd_type = FD_TYPE_SOCKET_SERVER;
s = (BSP_SERVER *) get_fd(srv_fds[srv_ct], &fd_type);
if (s)
{
s->name = srv.server_name;
s->heartbeat_check = srv.heartbeat_check;
s->def_client_type = srv.def_client_type;
s->def_data_type = srv.def_data_type;
s->max_packet_length = srv.max_packet_length;
s->max_clients = srv.max_clients;
s->debug_hex_input = srv.debug_hex_input;
s->debug_hex_output = srv.debug_hex_output;
add_server(s);
}
else
{
bsp_free(srv.server_name);
}
}
}
}
}
// Server event
if (server_event)
{
core_settings.on_srv_events = server_event;
}
// Create 1 Hz clock
BSP_TIMER *tmr = new_timer(BASE_CLOCK_SEC, BASE_CLOCK_USEC, -1);
tmr->on_timer = base_timer;
core_settings.main_timer = tmr;
dispatch_to_thread(tmr->fd, MAIN_THREAD);
start_timer(tmr);
// Let's go
load_bootstrap();
trace_msg(TRACE_LEVEL_CORE, "Core : Main thread loop started");
thread_process((void *) t);
return BSP_RTN_SUCCESS;
}
static void
accept_cb(EV_P_ ev_io *w, int revents)
{
struct listen_ctx *listener = (struct listen_ctx *)w;
int serverfd = accept(listener->fd, NULL, NULL);
if (serverfd == -1) {
ERROR("accept");
return;
}
setnonblocking(serverfd);
int opt = 1;
setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
int index = rand() % listener->remote_num;
struct sockaddr *remote_addr = listener->remote_addr[index];
int remotefd = socket(remote_addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (remotefd == -1) {
ERROR("socket");
return;
}
#ifdef ANDROID
if (vpn) {
int not_protect = 0;
if (remote_addr->sa_family == AF_INET) {
struct sockaddr_in *s = (struct sockaddr_in *)remote_addr;
if (s->sin_addr.s_addr == inet_addr("127.0.0.1"))
not_protect = 1;
}
if (!not_protect) {
if (protect_socket(remotefd) == -1) {
ERROR("protect_socket");
close(remotefd);
return;
}
}
}
#endif
setsockopt(remotefd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
setsockopt(remotefd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif
if (listener->mptcp == 1) {
int err = setsockopt(remotefd, SOL_TCP, MPTCP_ENABLED, &opt, sizeof(opt));
if (err == -1) {
ERROR("failed to enable multipath TCP");
}
}
// Setup
setnonblocking(remotefd);
#ifdef SET_INTERFACE
if (listener->iface) {
if (setinterface(remotefd, listener->iface) == -1)
ERROR("setinterface");
}
#endif
server_t *server = new_server(serverfd, listener->method);
remote_t *remote = new_remote(remotefd, listener->timeout);
server->destaddr = listener->tunnel_addr;
server->remote = remote;
remote->server = server;
int r = connect(remotefd, remote_addr, get_sockaddr_len(remote_addr));
if (r == -1 && errno != CONNECT_IN_PROGRESS) {
ERROR("connect");
close_and_free_remote(EV_A_ remote);
close_and_free_server(EV_A_ server);
return;
}
// listen to remote connected event
ev_io_start(EV_A_ & remote->send_ctx->io);
ev_timer_start(EV_A_ & remote->send_ctx->watcher);
}
int main(int argc, char *argv[]) {
/*
First up: initialize HeavyThing, and like our previous
examples, we are not interested in argc/argv from inside
our assembler environment:
An interesting sidenote here: because HeavyThing has normal
function definitions for memcpy, memcmp, etc, those get
preferentially linked instead of the libc versions, and so
during our C++ initialization, those HeavyThing functions
were already called. Fortunately for us in this case, those
functions do not require any HeavyThing global state.
*/
ht$init_args(0, 0);
/*
We need a default/generic io layer for our top level
*/
void **iolayer = io$new();
/*
Set its virtual method table to our own:
*/
iolayer[0] = epoll_methods;
/*
Next in the layers is our ssh server layer, and its argument
as 0 specifies to use /etc/ssh host keys
*/
void *sshserver = ssh$new_server(0);
if (!sshserver) {
std::cerr << "SSH host key error" << std::endl;
exit(1);
}
/*
Unlike our authless version, set our authentication callback
*/
ssh$set_authcb(sshserver, ssh_authenticate);
/*
We have to link the iolayer with the ssh layer:
*/
io$link((void *)iolayer, sshserver);
/*
And our lowest layer is a real epoll object with defaults
*/
void *listener = epoll$new((vmethod_t)epoll$default_vtable, 0);
/*
Link that to our sshserver
*/
io$link(sshserver, listener);
/*
Setup an IPv4 socket address for our listener, noting that
sockaddr_in_size from epoll.inc is 16 bytes. Listener port
== 8001:
*/
unsigned char addrbuf[16];
inaddr_any(addrbuf, 8001);
/*
Now we can pass that off to our epoll layer. The HeavyThing's
epoll$inbound will return false if bind failure:
*/
if (!epoll$inbound(addrbuf, sizeof(addrbuf), (void *)iolayer)) {
std::cerr << "INADDR_ANY:8001 bind failure." << std::endl;
exit(1);
}
/*
Dump a banner to stdout so that we know all is well
*/
std::cout << "Simple SSH chat server listening on port 8001." << std::endl;
/*
Pass control (indefinitely) to HeavyThing's epoll layer.
*/
epoll$run();
/*
Not reached.
*/
}
