int main(int argv,char **args)
{
int ret,epfd,nfds,server_socket_fd,i,index;
struct epoll_event events[256];
int count;
server_socket_fd = server_start();
if(server_socket_fd<0)
{
return 0;
}
set_non_blocking(server_socket_fd);
epfd = epoll_create(1024);
set_non_blocking(epfd);
epoll_add(epfd,server_socket_fd);
struct http_request_r *r=NULL,*p=NULL;
while(1)
{
nfds=epoll_wait(epfd,events,20,500);
for(i=0;i<nfds;i++)
{
if(events[i].data.fd==server_socket_fd)
{
onAccept(epfd,events[i],&r);
}
else if(events[i].events&EPOLLIN)
{
onData(epfd,events[i],&r);
}
}
}
}
// connect to remote server timeout call.
bool connect_timeout(int sockfd, const struct sockaddr *addr, socklen_t addrlen, struct timeval* tv_to)
{
bool result = false;
set_non_blocking(sockfd, true);
int res = connect(sockfd, addr, addrlen);
if ( res < 0 )
{
if ( errno == EINPROGRESS )
{
fd_set set;
FD_ZERO(&set);
FD_SET(sockfd, &set);
if ( select(sockfd + 1, NULL, &set, NULL, tv_to) > 0 )
{
int valopt;
int lon = sizeof(int);
getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if ( valopt )
{
logPrint("connect_timeout error in connect(%d): %s", sockfd, strerror(errno));
}
}
else
{
logPrint("connect_timeout select(%d) timeout or error: %s", sockfd, strerror(errno));
}
}
else
{
logPrint("connect_timeout connect(%d) error: %s", sockfd, strerror(errno));
}
}
set_non_blocking(sockfd, false);
return true;
}
int ssl_client_handshake(struct Client *cptr) {
char *str;
int err;
cptr->ssl = (struct SSL*)SSL_new (ctx); CHK_NULL(cptr->ssl);
SSL_set_fd ((SSL*)cptr->ssl, cptr->fd);
set_blocking(cptr->fd);
err = SSL_connect ((SSL*)cptr->ssl);
set_non_blocking(cptr->fd);
if ((err)==-1) {
irclog(L_NOTICE,"Could connect to %s:Error in SSL_connect()",
get_client_name(cptr, TRUE));
return 0;
}
/* Following two steps are optional and not required for
data exchange to be successful. */
/* Get the cipher - opt */
set_blocking(cptr->fd);
irclog (L_NOTICE,"SSL connection using %s", SSL_get_cipher ((SSL*)cptr->ssl));
SetSecure(cptr);
/* Get server's certificate (note: beware of dynamic allocation) - opt */
cptr->client_cert = (struct X509*)SSL_get_peer_certificate ((SSL *)cptr->ssl);
set_non_blocking(cptr->fd);
if (cptr->client_cert != NULL)
{
irclog (L_NOTICE,"Server certificate:");
str = X509_NAME_oneline (X509_get_subject_name ((X509*)cptr->client_cert),0,0);
CHK_NULL(str);
irclog (L_NOTICE, "\t subject: %s", str);
// Free (str);
free (str);
str = X509_NAME_oneline (X509_get_issuer_name ((X509*)cptr->client_cert),0,0);
CHK_NULL(str);
irclog (L_NOTICE, "\t issuer: %s", str);
// Free (str);
free (str);
/* We could do all sorts of certificate verification stuff here before
deallocating the certificate. */
X509_free ((X509*)cptr->client_cert);
}
else
irclog (L_NOTICE, "Server does not have certificate.");
return 1;
}
int
main(int argc, const char* const* argv)
{
printf("GIMME YOUR INPUTS!\n");
// set stdin/out to nonblocking
set_non_blocking(STDIN_FILENO);
set_non_blocking(STDOUT_FILENO);
loop = uv_default_loop();
uv_poll_init(loop, &stdin_watcher, STDIN_FILENO);
uv_poll_init(loop, &stdout_watcher, STDOUT_FILENO);
uv_poll_start(&stdin_watcher, UV_READABLE, stdin_cb);
uv_run(loop, 0);
return 0;
}
int main(void)
{
int sock_fd = -1;
char buffer[1024];
int bytes_recv = -1;
log_set_level(LOG_LEVEL_DEBUG);
sock_fd = udp_unix_socket_create(UNIX_DOMAIN_PATH);
if (sock_fd < 0) {
log_error("udp_unix_socket_create failed.");
return 0;
}
set_non_blocking(sock_fd);
while(1) {
bzero(buffer, sizeof(buffer));
bytes_recv = udp_unix_socket_recv(sock_fd, buffer, sizeof(buffer) - 1);
if (bytes_recv > 0) {
log_debug("%d %s", bytes_recv, buffer);
}
else {
log_info("no data received.");
}
}
udp_unix_socket_close(sock_fd);
return 1;
}
int
_do_controller_direct_open_with_line(char* linebuf, size_t size, sc_controller* contr)
{
sc_follow_context* cxt = NULL;
char *atbl[51], **ap = atbl, *p, *val;
for (p = linebuf; p != NULL; ) {
while ((val = strsep(&p, " \t")) != NULL && *val == '\0');
*ap++ = val;
}
*ap = 0;
ap = atbl;
while ((*ap)[0] == '-') {
}
contr->displayName = strdup(ap[0]);
contr->f_direct = 1;
fprintf(stderr, "OPEN: displayName=(%s)\n", p);
cxt = sc_follow_context_new(ap[1], ap[0], 1, BUFSIZE, g_connection);
g_context_list = az_list_add(g_context_list, cxt);
set_non_blocking(contr->socket_fd);
return 0;
}
VALUE io_spec_rb_io_wait_readable(VALUE self, VALUE io, VALUE read_p) {
int fd = io_spec_get_fd(io);
set_non_blocking(fd);
char buf[RB_IO_WAIT_READABLE_BUF];
wait_bool ret;
if(RTEST(read_p)) {
rb_ivar_set(self, rb_intern("@write_data"), Qtrue);
if(read(fd, buf, RB_IO_WAIT_READABLE_BUF) != -1) {
return Qnil;
}
}
ret = rb_io_wait_readable(fd);
if(RTEST(read_p)) {
if(read(fd, buf, RB_IO_WAIT_READABLE_BUF) != 13) {
return Qnil;
}
rb_ivar_set(self, rb_intern("@read_data"),
rb_str_new(buf, RB_IO_WAIT_READABLE_BUF));
}
return wait_bool_to_ruby_bool(ret);
}
int new_connection_handler(event_loop* el, int fd, kivi_client* client) {
log_info("new connection %d", fd);
int client_fd = accept(fd, NULL, NULL);
if (client_fd > 0) {
if (set_non_blocking(client_fd)) {
log_warn("couldn't make client socket nonblocking %d", client_fd);
return FAILED;
}
file_event file_ev;
file_ev.mask = READ_EVENT | WRITE_EVENT;
file_ev.read_handler = socket_reader;
file_ev.write_handler = socket_writer;
if (add_to_el(el, client_fd, file_ev) == FAILED) {
return FAILED;
} else {
client = create_new_client(client_fd);
server.clients[client_fd] = client;
}
} else {
return FAILED;
}
return OK;
}
bool TransportUDP::initializeSocket()
{
ROS_ASSERT(sock_ != ROS_INVALID_SOCKET);
if (!(flags_ & SYNCHRONOUS))
{
int result = set_non_blocking(sock_);
if ( result != 0 ) {
ROS_ERROR("setting socket [%d] as non_blocking failed with error [%d]", sock_, result);
close();
return false;
}
}
socklen_t len = sizeof(local_address_);
getsockname(sock_, (sockaddr *)&local_address_, &len);
local_port_ = ntohs(local_address_.sin_port);
ROS_ASSERT(poll_set_ || (flags_ & SYNCHRONOUS));
if (poll_set_)
{
poll_set_->addSocket(sock_, boost::bind(&TransportUDP::socketUpdate, this, _1), shared_from_this());
}
return true;
}
/*
* It is possible for a race condition to exist; such that select()
* indicates that a listen()ing socket is able to recieve a new connection
* and that a later accept() call will still block because the connection
* has been closed in the interim. This wrapper for accept() attempts to
* defeat this by making the accept() call nonblocking.
*/
int my_accept (int s, struct sockaddr *addr, int *addrlen)
{
int retval;
set_non_blocking(s);
retval = accept(s, addr, addrlen);
set_blocking(s);
return retval;
}
static int run_script_select(FILE **sout, FILE **serr, struct cntr *cntr, int logfunc)
{
int mfd=-1;
fd_set fsr;
struct timeval tval;
int soutfd=fileno(*sout);
int serrfd=fileno(*serr);
setlinebuf(*sout);
setlinebuf(*serr);
set_non_blocking(soutfd);
set_non_blocking(serrfd);
while(1)
{
mfd=-1;
FD_ZERO(&fsr);
if(*sout) add_fd_to_sets(soutfd, &fsr, NULL, NULL, &mfd);
if(*serr) add_fd_to_sets(serrfd, &fsr, NULL, NULL, &mfd);
tval.tv_sec=1;
tval.tv_usec=0;
if(select(mfd+1, &fsr, NULL, NULL, &tval)<0)
{
if(errno!=EAGAIN && errno!=EINTR)
{
logp("run_script_select error: %s\n",
strerror(errno));
return -1;
}
}
if(FD_ISSET(soutfd, &fsr))
log_script_output(sout, NULL, logfunc);
if(FD_ISSET(serrfd, &fsr))
log_script_output(serr, cntr, logfunc);
if(!*sout && !*serr && got_sigchld)
{
//fclose(*sout); *sout=NULL;
//fclose(*serr); *serr=NULL;
got_sigchld=0;
return 0;
}
}
// Never get here.
return -1;
}
static enum cliret initial_comms(struct async *as,
enum action *action, char **incexc, struct conf **confs)
{
struct asfd *asfd;
char *server_version=NULL;
enum cliret ret=CLIENT_OK;
asfd=as->asfd;
if(authorise_client(asfd, &server_version,
get_string(confs[OPT_CNAME]),
get_string(confs[OPT_PASSWORD]),
get_cntr(confs)))
goto error;
if(server_version)
{
logp("Server version: %s\n", server_version);
// Servers before 1.3.2 did not tell us their versions.
// 1.3.2 and above can do the automatic CA stuff that
// follows.
switch(ca_client_setup(asfd, confs))
{
case 0:
break; // All OK.
case 1:
// Certificate signed successfully.
// Everything is OK, but we will reconnect now,
// in order to use the new keys/certificates.
goto reconnect;
default:
logp("Error with cert signing request\n");
goto error;
}
}
set_non_blocking(asfd->fd);
if(ssl_check_cert(asfd->ssl, NULL, confs))
{
logp("check cert failed\n");
goto error;
}
if(extra_comms(as, confs, action, incexc))
{
logp("extra comms failed\n");
goto error;
}
ret=CLIENT_OK; goto end;
error:
ret=CLIENT_ERROR; goto end;
reconnect:
ret=CLIENT_RECONNECT; goto end;
end:
free_w(&server_version);
return ret;
}
static int
init(char *server_addr, char *server_port, char *event_sub_server_port, int *listen_fd, int *event_sub_fd) {
int ret;
*listen_fd = create_listening_fd(server_addr, server_port);
if(*listen_fd == -1) {
fprintf(stderr, "I cannot create the listening socket\n");
return -1;
}
if(set_non_blocking(*listen_fd) == 0)
return -1;
*event_sub_fd = create_listening_fd(server_addr, event_sub_server_port);
if(*event_sub_fd == -1) {
fprintf(stderr, "I cannot create the event subscribe listening socket\n");
return -1;
}
if(set_non_blocking(*event_sub_fd) == 0)
return -1;
/* I get my architecture */
if( (my_arch = aconv_get_host_arch()) == ACONV_ARCH_ERROR ) {
fprintf(stderr, "I cannot get my architecture\n");
return -1;
}
/* I init the librsc module */
ret = rscs_init(my_arch);
if(ret == -1) {
fprintf(stderr, "I cannot initialize the RSC module\n");
return -1;
}
GDEBUG(1, "My architecture is %s\n", aconv_arch2str(my_arch));
/* I set the list of ioctl request I support AFTER the initialization
* of the rsc_module (otherwise segfault)*/
init_ioctl_register_request();
/* I Init the pollfd structure */
if((pfdinfo = pollfd_init()) == NULL) {
fprintf(stderr, "I cannot init the pollfd structure\n");
return -1;
}
return 0;
}
static enum cliret initial_comms(struct async *as,
enum action *action, char **incexc, long *name_max,
struct conf *conf)
{
struct asfd *asfd;
char *server_version=NULL;
enum cliret ret=CLIENT_OK;
asfd=as->asfd;
if(authorise_client(asfd, conf, &server_version))
goto error;
if(server_version)
{
int ca_ret=0;
logp("Server version: %s\n", server_version);
// Servers before 1.3.2 did not tell us their versions.
// 1.3.2 and above can do the automatic CA stuff that
// follows.
if((ca_ret=ca_client_setup(asfd, conf))<0)
{
// Error
logp("Error with certificate signing request\n");
goto error;
}
else if(ca_ret>0)
{
// Certificate signed successfully.
// Everything is OK, but we will reconnect now, in
// order to use the new keys/certificates.
goto reconnect;
}
}
set_non_blocking(asfd->fd);
if(ssl_check_cert(asfd->ssl, conf))
{
logp("check cert failed\n");
goto error;
}
if(extra_comms(as, conf, action, incexc, name_max))
{
logp("extra comms failed\n");
goto error;
}
ret=CLIENT_OK; goto end;
error:
ret=CLIENT_ERROR; goto end;
reconnect:
ret=CLIENT_RECONNECT; goto end;
end:
if(server_version) free(server_version);
return ret;
}
int listening_socket( const char *port ) {
if ( not port )
return -1;
// stolen from https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/
addrinfo hints;
memset( &hints, 0, sizeof( addrinfo ) );
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE; /* All interfaces */
addrinfo *result;
if ( int s = getaddrinfo( NULL, port, &hints, &result ) ) {
fprintf( stderr, "getaddrinfo: %s\n", gai_strerror( s ) );
return -1;
}
for ( addrinfo *rp = result; rp; rp = rp->ai_next ) {
// socket ok ?
int listen_fd = socket( rp->ai_family, rp->ai_socktype, rp->ai_protocol );
if ( listen_fd < 0 )
continue;
// no "Address already in use" error message
int yes = 1;
if ( setsockopt( listen_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof( yes ) ) == -1 )
perror( "setsockopt" );
// TCP_CORK
//if ( setsockopt( listen_fd, SOL_TCP, TCP_CORK, &yes, sizeof( yes ) ) == -1 )
// perror( "setsockopt" );
// bind ok ?
if ( bind( listen_fd, rp->ai_addr, rp->ai_addrlen ) == 0 ) {
freeaddrinfo( result );
if ( set_non_blocking( listen_fd ) == -1 ) {
close( listen_fd );
return -1;
}
if ( listen( listen_fd, SOMAXCONN ) == -1 ) {
perror( "listen" );
close( listen_fd );
return -1;
}
return listen_fd;
}
close( listen_fd );
}
fprintf( stderr, "Could not bind\n" );
freeaddrinfo( result );
return -1;
}
void addfd(int epollfd, int fd)
{
struct epoll_event _event;
_event.data.fd = fd;
_event.events = EPOLLIN | EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &_event);
set_non_blocking(fd);
log_info("%d add to epoll fd %d\n", fd, epollfd);
}
/*
* It is possible for a race condition to exist; such that select()
* indicates that a listen()ing socket is able to recieve a new connection
* and that a later accept() call will still block because the connection
* has been closed in the interim. This wrapper for accept() attempts to
* defeat this by making the accept() call nonblocking.
*/
int Accept (int s, SA *addr, int *addrlen)
{
int retval;
set_non_blocking(s);
retval = accept(s, addr, addrlen);
set_blocking(s);
return retval;
}
void TCPServer::connect(const SocketAddress& socket_address)
{
if (!socket_address.is_server_valid())
throw NetworkException(NetworkExceptionT::InvalidSocketAddress);
struct addrinfo hints;
std::memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // Both IPV6 and IPV4
hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_PASSIVE; // We want to bind on
struct addrinfo* addrs = nullptr;
//Create a lambda deleter
auto deleter = [](struct addrinfo* ptr)
{ if (ptr != nullptr) freeaddrinfo(ptr); };
//Will store addresses to allow RAII.
std::unique_ptr<struct addrinfo, void(*)(struct addrinfo*)>
resources_keeper(nullptr, deleter);
retrieve_addresses(socket_address.m_name, socket_address.m_port,
hints, addrs,
resources_keeper, deleter);
//Socket FileDescriptor
FileDescriptor fd;
struct addrinfo *addr = nullptr;
for (addr = addrs; addr != nullptr; addr = addr->ai_next)
{
fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if (fd == -1)
continue;
int errcode = bind(fd, addr->ai_addr, addr->ai_addrlen);
//We binded on this socket
if (errcode == 0)
break;
//Failed, let's try again
close (fd);
}
if (addr == nullptr)
throw NetworkException(NetworkExceptionT::BindFailed);
if (!set_non_blocking(fd))
throw NetworkException(NetworkExceptionT::CantSetNonblocking);
if (listen(fd, MAX_CONNECTIONS) < 0)
throw NetworkException(NetworkExceptionT::ListenFailed);
m_connected = true;
m_fd = fd;
}
static int accept_cb(tcp_server_stream_t *listen_stream)
{
struct sockaddr_in remote_addr;
struct epoll_event event;
socklen_t addr_len;
int sock_fd;
tcp_server_t *server;
tcp_server_stream_t *stream;
bzero(&remote_addr, sizeof(remote_addr));
addr_len = sizeof(struct sockaddr_in);
sock_fd = accept(listen_stream->sock_fd, (struct sockaddr *)&remote_addr, &addr_len);
if (sock_fd < 0) {
if (EAGAIN != errno) {
log_error("accept error, %s.", strerror(errno));
return 0;
}
else {
log_info("no connection for accept.");
return 1;
}
}
log_debug("new connection comes, fd: %d.", sock_fd);
if (!set_non_blocking(sock_fd)) {
log_error("set sock_fd: %d failed.", sock_fd);
close(sock_fd);
return 0;
}
stream = get_idle_tcp_stream(server);
if (NULL == stream) {
log_error("no idle stream.");
return 0;
}
tcp_stream_init(server, stream, sock_fd, &remote_addr);
add_stream_into_busy_list(server, stream);
/* 将当前sock fd添加到epoll中 */
bzero(&event, sizeof(event));
event.data.fd = sock_fd;
event.data.ptr = stream;
event.events = EPOLLIN | EPOLLET;
if (epoll_ctl(server->epoll_fd, EPOLL_CTL_ADD, sock_fd, &event) < 0) {
log_error("accept_cb, EPOLL_CTL_ADD error, %s.", strerror(errno));
tcp_stream_close(stream);
return 0;
}
server->active_stream_num++;
return 1;
}
int pkr_conn_accepted_cb(int sockfd, void* void_pkm)
{
struct incoming_conn_state* ics;
struct pk_manager* pkm = (struct pk_manager*) void_pkm;
struct pk_backend_conn* pkb;
socklen_t slen;
char rbuf[128];
char lbuf[128];
PK_TRACE_FUNCTION;
ics = malloc(sizeof(struct incoming_conn_state));
ics->pkm = pkm;
ics->pkb = NULL;
ics->tunnel = NULL;
ics->hostname = NULL;
ics->parsed_as = PROTO_UNKNOWN;
ics->parse_state = PARSE_UNDECIDED;
ics->created = pk_time();
ics->unparsed_data = NULL;
slen = sizeof(ics->local_addr);
getsockname(sockfd, (struct sockaddr*) &(ics->local_addr), &slen);
slen = sizeof(ics->remote_addr);
getpeername(sockfd, (struct sockaddr*) &(ics->remote_addr), &slen);
pk_log(PK_LOG_TUNNEL_DATA,
"Accepted; remote=%s; local=%s; fd=%d",
in_addr_to_str((struct sockaddr*) &(ics->remote_addr), rbuf, 128),
in_addr_to_str((struct sockaddr*) &(ics->local_addr), lbuf, 128),
sockfd);
/* Allocate a connection for this request or die... */
sprintf(lbuf, "!NEW:%d", ics->remote_addr.sin_port);
if (NULL == (pkb = pkm_alloc_be_conn(pkm, NULL, lbuf))) {
_pkr_close(ics, PK_LOG_ERROR, "BE alloc failed");
PKS_close(sockfd);
return -1;
}
pkb->kite = NULL;
pkb->conn.sockfd = sockfd;
ics->pkb = pkb;
set_non_blocking(sockfd);
ev_io_init(&(pkb->conn.watch_r),
pkr_new_conn_readable_cb,
PKS_EV_FD(sockfd),
EV_READ);
pkb->conn.watch_r.data = (void *) ics;
ev_io_start(pkm->loop, &(pkb->conn.watch_r));
return 0;
}
static void listen_socket_create(struct pollfd *pfds)
{
struct addrinfo hints, *res, *res0;
char servname[64];
int i, sock, opt;
memset(servname, 0, sizeof(servname));
snprintf(servname, sizeof(servname), "%d", ISCSI_LISTEN_PORT);
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if (getaddrinfo(NULL, servname, &hints, &res0)) {
log_error("unable to get address info (%s)!", strerror(errno));
exit(1);
}
for (i = 0, res = res0; res && i < LISTEN_MAX; i++, res = res->ai_next) {
sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (sock < 0) {
log_error("unable to create server socket (%s) %d %d %d!",
strerror(errno), res->ai_family,
res->ai_socktype, res->ai_protocol);
continue;
}
opt = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)))
log_warning("unable to set SO_REUSEADDR on server socket (%s)!",
strerror(errno));
opt = 1;
if (res->ai_family == AF_INET6 &&
setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt)))
continue;
if (bind(sock, res->ai_addr, res->ai_addrlen)) {
log_error("unable to bind server socket (%s)!", strerror(errno));
continue;
}
if (listen(sock, INCOMING_MAX)) {
log_error("unable to listen to server socket (%s)!", strerror(errno));
continue;
}
set_non_blocking(sock);
pfds[i].fd = sock;
pfds[i].events = POLLIN;
}
freeaddrinfo(res0);
}
VALUE io_spec_rb_io_wait_readable(VALUE self, VALUE io) {
int fd = io_spec_get_fd(io);
set_non_blocking(fd);
char buf[256];
int ret;
ret = read(fd, buf, 256);
if (ret < 1)
return rb_io_wait_readable(fd) ? Qtrue : Qfalse;
else
return Qnil;
}
/* create and add the notify object to the list */
static void
upnp_event_create_notify(struct subscriber * sub)
{
struct upnp_event_notify * obj;
/*struct timeval sock_timeout;*/
obj = calloc(1, sizeof(struct upnp_event_notify));
if(!obj) {
syslog(LOG_ERR, "%s: calloc(): %m", "upnp_event_create_notify");
return;
}
obj->sub = sub;
obj->state = ECreated;
#ifdef ENABLE_IPV6
obj->s = socket((obj->sub->callback[7] == '[') ? PF_INET6 : PF_INET,
SOCK_STREAM, 0);
#else
obj->s = socket(PF_INET, SOCK_STREAM, 0);
#endif
if(obj->s<0) {
syslog(LOG_ERR, "%s: socket(): %m", "upnp_event_create_notify");
goto error;
}
#if 0 /* does not work for non blocking connect() */
/* set timeout to 3 seconds */
sock_timeout.tv_sec = 3;
sock_timeout.tv_usec = 0;
if(setsockopt(obj->s, SOL_SOCKET, SO_RCVTIMEO, &sock_timeout, sizeof(struct timeval)) < 0) {
syslog(LOG_WARNING, "%s: setsockopt(SO_RCVTIMEO): %m",
"upnp_event_create_notify");
}
sock_timeout.tv_sec = 3;
sock_timeout.tv_usec = 0;
if(setsockopt(obj->s, SOL_SOCKET, SO_SNDTIMEO, &sock_timeout, sizeof(struct timeval)) < 0) {
syslog(LOG_WARNING, "%s: setsockopt(SO_SNDTIMEO): %m",
"upnp_event_create_notify");
}
#endif
/* set socket non blocking */
if(!set_non_blocking(obj->s)) {
syslog(LOG_ERR, "%s: set_non_blocking(): %m",
"upnp_event_create_notify");
goto error;
}
if(sub)
sub->notify = obj;
LIST_INSERT_HEAD(¬ifylist, obj, entries);
return;
error:
if(obj->s >= 0)
close(obj->s);
free(obj);
}
static void mgmt_event_handler(int accept_fd, int events, void *data)
{
int fd, err;
struct mgmt_task *mtask;
fd = ipc_accept(accept_fd);
if (fd < 0) {
eprintf("failed to accept a socket\n");
return;
}
err = ipc_perm(fd);
if (err < 0) {
eprintf("permission error\n");
goto out;
}
err = set_non_blocking(fd);
if (err) {
eprintf("failed to set a socket non-blocking\n");
goto out;
}
mtask = zalloc(sizeof(*mtask));
if (!mtask) {
eprintf("can't allocate mtask\n");
goto out;
}
mtask->buf = zalloc(BUFSIZE);
if (!mtask->buf) {
eprintf("can't allocate mtask buffer\n");
free(mtask);
goto out;
}
mtask->bsize = BUFSIZE;
mtask->mtask_state = MTASK_STATE_HDR_RECV;
err = tgt_event_add(fd, EPOLLIN, mtask_handler, mtask);
if (err) {
eprintf("failed to add a socket to epoll %d\n", fd);
free(mtask->buf);
free(mtask);
goto out;
}
return;
out:
if (fd > 0)
close(fd);
return;
}
/*
* It is possible for a race condition to exist; such that select()
* indicates that a listen()ing socket is able to recieve a new connection
* and that a later accept() call will still block because the connection
* has been closed in the interim. This wrapper for accept() attempts to
* defeat this by making the accept() call nonblocking.
*/
int my_accept (int s, SA *addr, socklen_t *addrlen)
{
int retval;
set_non_blocking(s);
if ((retval = accept(s, addr, addrlen)) < 0)
syserr(-1, "my_accept: accept(%d) failed: %s",
s, strerror(errno));
set_blocking(s);
set_blocking(retval); /* Just in case */
return retval;
}
ssize_t timed_read(int sockfd, void* buf, size_t count, int timeout_ms)
{
ssize_t rv;
set_non_blocking(sockfd);
do {
if (0 <= (rv = wait_fd(sockfd, timeout_ms)))
rv = read(sockfd, buf, count);
} while (errno == EINTR);
set_blocking(sockfd);
return rv;
}
bool net::socket::create(int domain, int type)
{
if ((_M_fd = ::socket(domain, type, 0)) < 0) {
return false;
}
if (!set_non_blocking()) {
close();
return false;
}
return true;
}
bool TransportTCP::setNonBlocking()
{
if (!(flags_ & SYNCHRONOUS))
{
int result = set_non_blocking(sock_);
if ( result != 0 ) {
ROS_ERROR("setting socket [%d] as non_blocking failed with error [%d]", sock_, result);
close();
return false;
}
}
return true;
}
bool basic_io_device::dont_block(event_handler const &h)
{
if(nonblocking_was_set_)
return true;
system::error_code e;
set_non_blocking(true,e);
if(e) {
get_io_service().post(h,e);
return false;
}
nonblocking_was_set_ = true;
return true;
}
static int Connect (int fd, SA *addr)
{
int retval;
set_non_blocking(fd);
if ((retval = connect(fd, addr, socklen(addr))))
{
if (errno != EINPROGRESS)
syserr(-1, "Connect: connect(%d) failed: %s", fd, strerror(errno));
else
retval = 0;
}
set_blocking(fd);
return retval;
}
