int AcServerHandle::Accept()
{
//static socklen_t s_addr_len = sizeof(sockaddr_in);
int client_fd;
sockaddr_in addr;
client_fd = net_accept(fd_, &addr);
if(client_fd < 1) {
ERROR_OUT("Failed to accept");
return -1;
}
DEBUG_MSG("Accept fd: %d", client_fd);
AcHandle *handle = new AcConnectHandle;
if(NULL == handle) {
ERROR_OUT("Failed to allocate memory");
close(client_fd);
return -1;
}
assert(dispatcher_);
handle->set_fd(client_fd);
handle->set_address(addr);
handle->set_dispatcher(dispatcher_);
dispatcher_->AddEvent(handle,EVENT_READ);
return 0;
}
/* input function: DCC SEND - someone tried to connect to our socket */
static void dcc_send_connected(SEND_DCC_REC *dcc)
{
GIOChannel *handle;
IPADDR addr;
int port;
/* accept connection */
handle = net_accept(dcc->handle, &addr, &port);
if (handle == NULL)
return;
/* TODO: some kind of paranoia check would be nice. it would check
that the host of the nick who we sent the request matches the
address who connected us. */
net_disconnect(dcc->handle);
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->handle = handle;
memcpy(&dcc->addr, &addr, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_send_read_size, dcc);
dcc->tagwrite = g_input_add(handle, G_INPUT_WRITE,
(GInputFunction) dcc_send_data, dcc);
signal_emit("dcc connected", 1, dcc);
}
/* input function: DCC CHAT - someone tried to connect to our socket */
static void dcc_chat_listen(CHAT_DCC_REC *dcc)
{
IPADDR ip;
GIOChannel *handle;
int port;
g_return_if_fail(IS_DCC_CHAT(dcc));
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == NULL)
return;
/* TODO: add paranoia check - see dcc-files.c */
net_disconnect(dcc->handle);
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->handle = handle;
dcc->sendbuf = net_sendbuffer_create(handle, 0);
memcpy(&dcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dcc);
signal_emit("dcc connected", 1, dcc);
}
int check_for_clients(IRCD *ircd)
{
fd_set rfds;
struct timeval tv;
int retval;
/* Watch stdin (fd 0) to see when it has input. */
FD_ZERO(&rfds);
FD_SET(ircd->socks.ircd.fd, &rfds);
/* Wait up to one second. */
tv.tv_sec = 1;
tv.tv_usec = 0;
retval = select(1, &rfds, NULL, NULL, &tv);
if (retval == -1) {
fprintf(stderr, "[check_for_clients] select()\n");
} else if (retval == 0) {
printf("[check_for_clients] Timeout occured, no new connection.\n");
} else {
printf("[check_for_clients] Client is available now.\n");
}
if ( net_accept(ircd->socks.ircd, ircd->users[ircd->numusers].sock) != -1 ) {
++ircd->numusers;
printf("[check_for_clients] At %d users. [%d]\n", ircd->numusers, ircd->users[ircd->numusers].sock.fd);
}
return 0;
}
static void sig_botnet_listen(BOTNET_REC *botnet)
{
BOT_CONNECT_REC *rec;
IPADDR ip;
int handle;
g_return_if_fail(botnet != NULL);
/* accept connection */
handle = net_accept(botnet->listen_handle, &ip, NULL);
if (handle == -1)
return;
rec = g_new0(BOT_CONNECT_REC, 1);
rec->botnet = g_strdup(botnet->name);
memcpy(&rec->ip, &ip, sizeof(IPADDR));
rec->handle = handle;
if (!net_gethostbyaddr_nonblock(&ip, (NET_HOST_CALLBACK) sig_host_got, rec)) {
/* failed for some reason, try without host */
connect_downlink(botnet, handle, &ip, NULL);
g_free(rec->botnet);
g_free(rec);
}
}
static
void *
proto_server_event_listen(void *arg)
{
int fd = Proto_Server.EventListenFD;
int connfd;
if (net_listen(fd)<0) {
exit(-1);
}
for (;;) {
connfd = net_accept(fd);
if (connfd < 0) {
fprintf(stderr, "Error: EventListen accept failed (%d)\n", errno);
} else {
int i;
fprintf(stderr, "EventListen: connfd=%d -> ", connfd);
if (proto_server_record_event_subscriber(connfd, &i) <0) {
fprintf(stderr, "oops no space for any more event subscribers\n");
close(connfd);
} else {
}
}
}
}
int
main(int argc, char **argv)
{
int listenfd, port=0;
long connfd;
pthread_t tid;
bzero(&globals, sizeof(globals));
if (net_setup_listen_socket(&listenfd,&port)!=1) {
fprintf(stderr, "net_setup_listen_socket FAILED!\n");
exit(-1);
}
printf("listening on port=%d\n", port);
if (net_listen(listenfd) < 0) {
fprintf(stderr, "Error: server listen failed (%d)\n", errno);
exit(-1);
}
for (;;) {
connfd = net_accept(listenfd);
if (connfd < 0) {
fprintf(stderr, "Error: server accept failed (%d)\n", errno);
} else {
//EXPLAIN WHAT IS HAPPENING HERE IN YOUR LOG
pthread_create(&tid, NULL, &doit, (void *)connfd);
}
}
VPRINTF("Exiting\n");
}
void network_init()
{
struct sockaddr_in my_name;
my_name.sin_family = AF_INET;
my_name.sin_port = htons(SERVER_PORT);
my_name.sin_addr.s_addr = htonl(INADDR_ANY);
net_init();
server_socket = net_socket(AF_INET, SOCK_STREAM, 0);
int yes = 1;
net_setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
while(net_bind(server_socket, (struct sockaddr*)&my_name, sizeof(my_name)) < 0)
{
}
net_listen(server_socket, 0);
struct sockaddr_in client_info;
socklen_t ssize = sizeof(client_info);
client_socket = net_accept(server_socket, (struct sockaddr*)&client_info, &ssize);
network_printf("Hello world!\n");
}
static void accept_new(int accept_fd)
{
int from, to, feid, teid;
while (1) {
from = net_accept(cos_spd_id(), accept_fd);
assert(from != accept_fd);
if (-EAGAIN == from) {
return;
} else if (from < 0) {
BUG();
return;
}
feid = evt_get();
assert(feid > 0);
if (0 < net_accept_data(cos_spd_id(), from, feid)) BUG();
teid = evt_get();
assert(teid > 0);
to = tsplit(cos_spd_id(), td_root, "", 0, TOR_RW, teid);
if (to < 0) {
printc("torrent split returned %d", to);
BUG();
}
mapping_add(from, to, feid, teid);
}
}
/* input function: DCC CHAT - someone tried to connect to our socket */
static void dcc_chat_listen(DCC_REC *dcc)
{
IPADDR ip;
int handle, port;
g_return_if_fail(dcc != NULL);
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == -1)
return;
/* TODO: add paranoia check - see dcc-files.c */
g_source_remove(dcc->tagread);
close(dcc->handle);
dcc->starttime = time(NULL);
dcc->handle = handle;
memcpy(&dcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dcc);
signal_emit("dcc connected", 1, dcc);
}
int main(int argc, char *argv[]) {
#ifdef TCP
int s = net_connect_tcp("0","2334",1);
#else
int s = net_connect_udp("2334",1);
#endif
if (s < 0) {
printf("Failed to serve (%d)\n",s);
return 0;
}
printf("%d serving...\n",s);
#ifdef TCP
int c = net_accept(s);
if (c < 0) {
printf("Client not found (%d)\n",c);
return 0;
}
printf("Connected %d\n",c);
char *str = net_receive(c);
if (str == NULL)
printf("Receive error (%d)\n",errno);
else
printf("Received: %s\nSending: %s\n",str,"Goodbye Cruel World");
char *msg = "Goodbye Cruel World";
if (net_send(c,msg,strlen(msg)+1) < 0)
printf("Send error (%d)\n",errno);
closesocket(c);
#else
net_bounce(s);
#endif
closesocket(s);
printf("Session terminated\n");
}
static
void *
proto_server_rpc_listen(void *arg)
{
int fd = Proto_Server.RPCListenFD;
unsigned long connfd;
pthread_t tid;
if (net_listen(fd) < 0)
{
fprintf(stderr, "Error: proto_server_rpc_listen listen failed (%d)\n", errno);
exit(-1);
}
for (;;)
{
connfd = net_accept(fd);
if (connfd < 0)
{
fprintf(stderr, "Error: proto_server_rpc_listen accept failed (%d)\n", errno);
}
else
{
pthread_create(&tid, NULL, &proto_server_req_dispatcher,
(void *)connfd);
}
}
}
/* input function: DCC SERVER - someone tried to connect to our socket */
static void dcc_server_listen(SERVER_DCC_REC *dcc)
{
SERVER_DCC_REC *newdcc;
IPADDR ip;
GIOChannel *handle;
int port;
g_return_if_fail(IS_DCC_SERVER(dcc));
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == NULL)
return;
/* Create a new DCC SERVER to handle this connection */
newdcc = dcc_server_clone(dcc);
newdcc->starttime = time(NULL);
newdcc->handle = handle;
newdcc->sendbuf = net_sendbuffer_create(handle, 0);
memcpy(&newdcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&newdcc->addr, newdcc->addrstr);
newdcc->port = port;
newdcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_server_input, newdcc);
signal_emit("dcc connected", 1, newdcc);
}
/****************************************************************************
* NetworkWait
***************************************************************************/
int NetworkWait() {
if (!checkincomming)
return -3;
struct sockaddr_in sin;
struct sockaddr_in client_address;
socklen_t addrlen = sizeof(client_address);
//Open socket
socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (socket == INVALID_SOCKET) {
return socket;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if (net_bind(socket, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
net_close(socket);
return -1;
}
if (net_listen(socket, 3) < 0) {
net_close(socket);
return -1;
}
connection = net_accept(socket, (struct sockaddr*)&client_address, &addrlen);
sprintf(incommingIP, "%s", inet_ntoa(client_address.sin_addr));
if (connection < 0) {
net_close(connection);
net_close(socket);
return -4;
} else {
unsigned char haxx[9];
//skip haxx
net_read(connection, &haxx, 8);
wiiloadVersion[0] = haxx[4];
wiiloadVersion[1] = haxx[5];
net_read(connection, &infilesize, 4);
if (haxx[4] > 0 || haxx[5] > 4) {
net_read(connection, &uncfilesize, 4); // Compressed protocol, read another 4 bytes
}
waitforanswer = true;
checkincomming = false;
networkHalt = true;
}
return 1;
}
void ReactorAccept(int listenFd, short listenEv, void * arg)
{
NetReactor * nrc = (NetReactor *)arg;
if(nrc->isStop())
{
event lis = nrc->getListenEv();
event_del(&lis);
Log::NOTICE("SVR is STOP, don not accept");
return;
}
struct sockaddr sa;
socklen_t slen = sizeof(sa);
int connfd = net_accept(listenFd, &sa, &slen);
struct bufferevent ** pool;
pool = nrc->getFdPool();
int maxConnected = nrc->getMaxConnected();
in_addr ipaddr = ((struct sockaddr_in *)&sa)->sin_addr;
char *peer_ip = inet_ntoa(ipaddr);
if(connfd > maxConnected)
{
Log::ERROR("Too much user, connfd : %d", connfd);
close(connfd);
return;
}
NetConnManager * cMag = NetConnManager::getInstance();
if(cMag->IsUserConnExist(connfd))
{
Log::ERROR("assign a working fd, connfd : %d, will clean it",
connfd);
}
struct bufferevent * bev;
set_fd_noblock(connfd);
bev = bufferevent_new(connfd,
EvReadCallback,
NULL,
EvErrorCallback,
nrc);
bev->timeout_read = nrc->getReadTo();
bev->timeout_write = nrc->getWriteTo();
bufferevent_enable(bev, EV_READ|EV_WRITE);
std::unique_ptr<Iconn> con(new UserConn(nrc, bev));
cMag->setConn(connfd, std::move(con));
/* use for test */
//cMag->addAppConnFd(connfd);
Log::NOTICE("ACCEPT Connect SUCC, connfd : %d, UserIP : %s", connfd, peer_ip);
}
Socket ServerSocket::Accept()
{
AMJU_CALL_STACK;
#ifdef GEKKO
return net_accept(m_socket, 0, 0);
#else
return accept(m_socket, 0, 0);
#endif
}
td_t
tsplit(spdid_t spdid, td_t tid, char *param, int len,
tor_flags_t tflags, long evtid)
{
td_t ret = -EINVAL;
struct torrent *t;
net_connection_t nc = 0;
int accept = 0;
if (tor_isnull(tid)) return -EINVAL;
NET_LOCK_TAKE();
/* creating a new connection */
if (tid == td_root || len == 0 || strstr(param, "accept")) {
if (tid == td_root) { /* new connection */
nc = net_create_tcp_connection(spdid, cos_get_thd_id(), evtid);
if (nc <= 0) ERR_THROW(-ENOMEM, done);
} else { /* len == 0 || strstr(param, "accept"), accept on connection */
t = tor_lookup(tid);
if (!t) goto done;
nc = net_accept(spdid, (net_connection_t)t->data);
if (nc == -EAGAIN) {
/* printc("net accept return EAGAIN\n"); */
ERR_THROW(-EAGAIN, done);
}
if (nc < 0) ERR_THROW(-EINVAL, done);
if (0 < net_accept_data(spdid, nc, evtid)) BUG();
accept = 1;
}
t = tor_alloc((void*)nc, tflags);
if (!t) ERR_THROW(-ENOMEM, free);
ret = t->td;
} else { /* modifying an existing connection */
t = tor_lookup(tid);
if (!t) goto done;
nc = (net_connection_t)t->data;
}
if (!accept && len != 0) {
int r;
NET_LOCK_RELEASE();
r = modify_connection(spdid, nc, param, len);
if (r < 0) ret = r;
NET_LOCK_TAKE();
}
done:
NET_LOCK_RELEASE();
assert(lock_contested(&net_lock) != cos_get_thd_id());
return ret;
free:
net_close(spdid, nc);
goto done;
}
static void *worker_loop(void *p)
{
struct work_info *wi = p;
struct channel ch;
while (wi->active) {
if (net_accept(wi->li, &ch))
break;
ht_process(&ch);
ch_close(&ch);
}
return NULL;
}
int WaitForConnection(int& server_socket)
{
int addrlen;
struct sockaddr_in my_name, peer_name;
int status;
server_socket = net_socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1)
{
printf("Failed to create server socket\n");
}
int yes = 1;
net_setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
memset(&my_name, 0, sizeof(my_name));
my_name.sin_family = AF_INET;
my_name.sin_port = htons(DFF_CONN_PORT);
my_name.sin_addr.s_addr = htonl(INADDR_ANY);
status = net_bind(server_socket, (struct sockaddr*)&my_name, sizeof(my_name));
if (status == -1)
{
printf("Failed to bind server socket\n");
}
status = net_listen(server_socket, 5); // TODO: Change second parameter..
if (status == -1)
{
printf("Failed to listen on server socket\n");
}
printf("Listening now!\n");
int client_socket = -1;
struct sockaddr_in client_info;
socklen_t ssize = sizeof(client_info);
int new_socket = net_accept(server_socket, (struct sockaddr*)&client_info, &ssize);
if (new_socket < 0)
{
printf("accept failed!\n");
}
else
{
client_socket = new_socket;
printf("accept succeeded and returned %d\n", client_socket);
}
return client_socket;
}
static void *worker_loop(void *p)
{
struct work_info *wi = p;
struct channel ch;
char desc[40];
struct net_socket sock;
while (wi->active) {
if (net_accept(&wi->li->sock, &sock, sizeof(desc), desc))
break;
ch_init(&ch, sock, desc);
ht_process(&ch);
ch_close(&ch);
}
return NULL;
}
void net_on_accept(struct net_connection* con, int event, void *arg)
{
struct hub_info* hub = (struct hub_info*) arg;
struct hub_probe* probe = 0;
struct ip_addr_encap ipaddr;
int server_fd = net_con_get_sd(con);
#ifdef PLUGIN_SUPPORT
plugin_st status;
#endif
for (;;)
{
int fd = net_accept(server_fd, &ipaddr);
if (fd == -1)
{
if (net_error() == EWOULDBLOCK)
{
break;
}
else
{
LOG_ERROR("Accept error: %d %s", net_error(), strerror(net_error()));
break;
}
}
#ifdef PLUGIN_SUPPORT
status = plugin_check_ip_early(hub, &ipaddr);
if (status == st_deny)
{
plugin_log_connection_denied(hub, &ipaddr);
net_close(fd);
continue;
}
plugin_log_connection_accepted(hub, &ipaddr);
#endif
probe = probe_create(hub, fd, &ipaddr);
if (!probe)
{
LOG_ERROR("Unable to create probe after socket accepted. Out of memory?");
net_close(fd);
break;
}
}
}
/* input function: DCC SEND - someone tried to connect to our socket */
static void dcc_send_init(DCC_REC *dcc)
{
int handle, port;
IPADDR addr;
g_return_if_fail(dcc != NULL);
/* accept connection */
handle = net_accept(dcc->handle, &addr, &port);
if (handle == -1)
return;
/* TODO: some kind of paranoia check would be nice. it would check
that the host of the nick who we sent the request matches the
address who connected us. */
g_source_remove(dcc->tagread);
close(dcc->handle);
dcc->starttime = time(NULL);
dcc->fastsend = settings_get_bool("dcc_fast_send");
dcc->handle = handle;
memcpy(&dcc->addr, &addr, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->databufsize = settings_get_int("dcc_block_size");
if (dcc->databufsize <= 0) dcc->databufsize = 2048;
dcc->databuf = g_malloc(dcc->databufsize);
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_send_read_size, dcc);
dcc->tagwrite = !dcc->fastsend ? -1 :
g_input_add(handle, G_INPUT_WRITE, (GInputFunction) dcc_send_data, dcc);
signal_emit("dcc connected", 1, dcc);
if (!dcc->fastsend) {
/* send first block */
dcc->gotalldata = TRUE;
dcc_send_data(dcc);
}
}
/*
* accept a connection and start a thread to manage it
*/
int server_accept (XML *xml, NETCON *conn, SSL_CTX *ctx, TASKQ *q)
{
SERVERPARM *s;
NETCON *c;
debug ("accepting connection\n");
if ((c = net_accept (conn, ctx)) == NULL)
{
debug ("failed to successfully accept socket\n");
return (-1);
}
s = (SERVERPARM *) malloc (sizeof (SERVERPARM));
s->conn = c;
s->xml = xml;
if (!task_available (q))
warn ("No available server threads for request\n");
task_add (q, server_request, s);
return (0);
}
static void sig_listen(LISTEN_REC *listen)
{
CLIENT_REC *rec;
IPADDR ip;
NET_SENDBUF_REC *sendbuf;
GIOChannel *handle;
char host[MAX_IP_LEN];
int port;
g_return_if_fail(listen != NULL);
/* accept connection */
handle = net_accept(listen->handle, &ip, &port);
if (handle == NULL)
return;
net_ip2host(&ip, host);
sendbuf = net_sendbuffer_create(handle, 0);
rec = g_new0(CLIENT_REC, 1);
rec->listen = listen;
rec->handle = sendbuf;
rec->host = g_strdup(host);
rec->port = port;
if (g_strcmp0(listen->ircnet, "*") == 0) {
rec->proxy_address = g_strdup("irc.proxy");
rec->server = servers == NULL ? NULL : IRC_SERVER(servers->data);
} else {
rec->proxy_address = g_strdup_printf("%s.proxy", listen->ircnet);
rec->server = servers == NULL ? NULL :
IRC_SERVER(server_find_chatnet(listen->ircnet));
}
rec->recv_tag = g_input_add(handle, G_INPUT_READ,
(GInputFunction) sig_listen_client, rec);
proxy_clients = g_slist_prepend(proxy_clients, rec);
rec->listen->clients = g_slist_prepend(rec->listen->clients, rec);
signal_emit("proxy client connecting", 1, rec);
printtext(rec->server, NULL, MSGLEVEL_CLIENTNOTICE,
"Proxy: New client %s:%d on port %d (%s)",
rec->host, rec->port, listen->port, listen->ircnet);
}
int net_server_serverClass::acceptNewRequest()
{
if(!isStart) return -1;
if(isShuttingDown) return -1; // don't accept new request when shutting down
net_sockHandle hnd = net_accept(sock);
if(hnd.sock != INVALID_SOCKET) { /** Connection recieved */
net_ext_sock client = net_ext_createSock();
client.sockHandle = hnd;
client.status = NET_EXT_SOCK_ONLINE;
char cc[100]; sprintf(cc,"%s connected",net_getIpFromHandle(hnd).c_str());
if(debugFunc != NULL) (*debugFunc)(string(cc));
clientList.push_back(client);
if(accFunc != NULL) if((*accFunc)(client) == false) {
// reject this acception
disconnect(clientList.size()-1);
return 2; // connection rejected
}
return 1; // new connection recieved
}
return 0; // nothing new
}
static void sig_listen(PLUGIN_DATA *data, gint handle)
{
CLIENT_REC *rec;
IPADDR ip;
gint port;
g_return_if_fail(data != NULL);
if (servers == NULL) return;
/* accept connection */
handle = net_accept(handle, &ip, &port);
if (handle == -1)
return;
rec = g_new0(CLIENT_REC, 1);
rec->handle = handle;
rec->server = servers == NULL ? NULL : servers->data;
rec->tag = g_input_add(handle, G_INPUT_READ, (GInputFunction) sig_listen_client, rec);
data->clients = g_slist_append(data->clients, rec);
}
static
s32 helper_opentcpip( DebugHelper_t *helper)
{
struct sockaddr_in client;
u32 clientlen = sizeof(client);
if ( helper->listensock >=0 && helper->clientsock<0 ) {
memset (&client, 0, sizeof (client));
DEBUG_PRINT(( NULL,0, "helper_opentcpip(%p), try net_accept(), listensock=%d.\n", helper, helper->listensock));
helper->clientsock = net_accept (helper->listensock, (struct sockaddr *) &client, &clientlen);
DEBUG_PRINT(( NULL,0, "helper_opentcpip(%p), clientsock=%d.\n", helper, helper->clientsock));
return helper->clientsock ;
}
return -1;
}
gint accept_connection(gint in_fd, gchar ** location)
{
int fd;
gchar *error_message;
gchar *port;
fd = net_accept(in_fd, &error_message);
if (fd < 0) {
log_message(MSG_ERROR, "%s\n", error_message);
g_free(error_message);
return -1;
}
g_assert(location != NULL);
if (!net_get_peer_name(fd, location, &port, &error_message)) {
log_message(MSG_ERROR, "%s\n", error_message);
g_free(error_message);
}
g_free(port);
return fd;
}
/**
* \brief Accept a connection from a remote client
*
* \param bind_fd Relevant socket
* \param client_fd Will contain the connected client socket
* \param client_ip Will contain the client IP address
*
* \return 0 if successful, POLARSSL_ERR_NET_ACCEPT_FAILED, or
* POLARSSL_ERR_NET_WOULD_BLOCK is bind_fd was set to
* non-blocking and accept() is blocking.
*/
int net_accept_proxy( int bind_fd, int *client_fd, void *client_ip )
{
mute();
int ret = net_accept(bind_fd, client_fd, client_ip);
unmute();
SymN("socket", 0);
Nondet();
assume_intype("bitstring");
size_t len = sizeof(*client_fd);
assume_len(&len, false, sizeof(len));
store_buf(client_fd);
// Let the attacker decide what this function returns.
input("client_ip", MAX_PRINCIPAL_LENGTH);
store_buf(client_ip);
input("net_accept_result", sizeof(ret));
store_buf(&ret);
return ret;
}
int tcp_accept(int fd)
{
/* Accept incoming connection. */
int incoming = net_accept(fd, NULL);
/* Evaluate connection. */
if (incoming >= 0) {
#ifdef SO_RCVTIMEO
struct timeval tv;
rcu_read_lock();
conf_val_t *val = &conf()->cache.srv_tcp_idle_timeout;
tv.tv_sec = conf_int(val);
rcu_read_unlock();
tv.tv_usec = 0;
if (setsockopt(incoming, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
log_warning("TCP, failed to set up watchdog timer"
", fd %d", incoming);
}
#endif
}
return incoming;
}
