SOCKET open_listeningsocket( uint16_t port)
{
SOCKET listening_socket;
struct sockaddr_in sin;
int sock_optval = 1;
listening_socket = socket(AF_INET, SOCK_STREAM, 0);
if ( listening_socket == -1 ){
perror("socket");
exit(1);
}
if ( setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&sock_optval, sizeof(sock_optval)) == -1 ){
perror("setsockopt");
exit(1);
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if ( bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0 ){
perror("bind");
close_socket(listening_socket);
exit(1);
}
if( listen(listening_socket, SOMAXCONN) == -1){
perror("listen");
close_socket(listening_socket);
exit(1);
}
fprintf( FCGI_stderr, "port %d is listened\n", port);
return listening_socket;
}
///----------------------------------------------------------------------------
void socket::connect(yield_t yield)
{
if (sending_)
{
reconn_ = true;
}
close_socket();
boost::asio::ip::tcp::resolver::query query(host_, port_);
boost::asio::ip::tcp::resolver::iterator itr = reso_.async_resolve(query, yield);
if (yield.ec_ && *yield.ec_)
{
return;
}
boost::asio::async_connect(sock_, itr, yield);
}
/*
Description: send a broadcast trigger to all WARP nodes in the setup
*/
void sendTrigger(){
assert(initialized ==1);
int trig_sock = init_socket();
get_send_buffer_size(trig_sock);
get_receive_buffer_size(trig_sock);
char trig_buffer[18] = {0, 0, 255, 255, 0, 202, 0, 0, 0, 4, 0, 13, 0, 0, 0, 0, 0, 1};
// port 10000 is used for broadcast
sendData(trig_sock, trig_buffer, sizeof(trig_buffer), "10.0.0.255", 10000);
close_socket(trig_sock);
}
void do_delete( CHAR_DATA * ch, char * argument ) {
DESCRIPTOR_DATA * d;
if ( !ch->desc ) {
return;
}
if ( str_cmp( ch->desc->incomm, "delete yes" ) ) {
send_to_char( C_DEFAULT, "If you want to DELETE yourself, type 'delete yes'\n\r", ch );
return;
}
if ( ch->desc->original || IS_NPC( ch ) ) {
send_to_char( C_DEFAULT, "You may not delete a switched character.\n\r", ch );
return;
}
stop_fighting( ch, TRUE );
send_to_char( C_DEFAULT, "You are no more.\n\r", ch );
act( AT_BLOOD, "$n is no more.", ch, NULL, NULL, TO_ROOM );
info( "%s is no more.", (int)( ch->name ), 0 );
sprintf( log_buf, "$N has DELETED in room vnum %d.", ch->in_room->vnum );
wiznet( log_buf, ch, NULL, WIZ_LOGINS, 0, 0 );
// delete player file
sprintf( log_buf, "%s%c/%s", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
remove( log_buf );
// delete finger file
sprintf( log_buf, "%s%c/%s.fng", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
remove( log_buf );
// delete corpses
sprintf( log_buf, "%s%c/%s.cps", PLAYER_DIR, LOWER( ch->name[ 0 ] ), capitalize( ch->name ) );
remove( log_buf );
delete_playerlist( ch->name );
d = ch->desc;
extract_char( ch, TRUE );
if ( d ) {
close_socket( d );
}
return;
}
/**
* Closes a ssl connection (ssl socket + net socket)
* @param ssl ssl connection
* @return TRUE, or FALSE if an error has occured.
*/
int close_ssl_socket(ssl_connection *ssl) {
int rv;
if (!ssl)
return FALSE;
if (! (rv = SSL_shutdown(ssl->handler))) {
shutdown(ssl->socket, 1);
rv = SSL_shutdown(ssl->handler);
}
close_socket(ssl->socket);
cleanup_ssl_socket(ssl);
return (rv > 0) ? TRUE : FALSE;
}
void tcp_listener_cleaner(void *arg)
{
int socket;
socket = *((int *) arg);
#ifdef PLMC_LIB_DEBUG
fprintf(plmc_lib_debug, "tcp_listener_cleaner was called\n");
fflush(plmc_lib_debug);
#endif
/* Close socket so no more connection can happen */
close_socket(socket);
if (pthread_cancel(plmc_connection_mgr_id) != 0) {
syslog(LOG_ERR, "plmc_lib: tcp_listener_cleaner "
"encountered an error canceling a thread");
}
}
MODULE accept_client_connection (THREAD *thread)
{
sock_t
slave_socket; /* Connected socket */
tcb = thread-> tcb; /* Point to thread's context */
slave_socket = accept_socket (tcb-> handle);
if (slave_socket != INVALID_SOCKET)
{
close_socket (tcb-> handle);
tcb-> handle = slave_socket;
}
else
if (sockerrno != EAGAIN)
raise_exception (exception_event);
}
void replay_event_loop(void)
{
while (!quit_services) {
if (!replay_connected) {
/* this time fudging is to get some of the logging right */
self->link_time = self->boot = now;
cManager.uplink->state = AUTHENTICATING;
irc_introduce(cManager.uplink->password);
replay_connected = 1;
} else if (!replay_read()) {
log_module(MAIN_LOG, LOG_ERROR, "Connection to server lost.");
close_socket();
}
timeq_run();
}
}
int socket_server::ctrl_cmd(struct socket_message * result)
{
int fd = recvctrl_fd;
uint8_t buffer[256];
uint8_t header[2];
block_readpipe(fd, (void *)header, sizeof(header));
int type = header[0];
int len = header[1];
block_readpipe(fd, buffer, len);
switch (type) {
case 'S':
return start_socket((struct request_start *)buffer, result);
case 'B':
return bind_socket((struct request_bind *)buffer, result);
case 'L':
return listen_socket((struct request_listen *)buffer, result);
case 'K':
return close_socket((struct request_close *)buffer, result);
case 'O':
return open_socket((struct request_open *)buffer, result);;
case 'X':
result->opaque = 0;
result->ud = 0;
result->id = 0;
result->data = nullptr;
return SOCKET_EXIT;
case 'D':
printf("*****************send data*******************\n");
return send_socket((struct request_send *)buffer, result, PRIORITY_HIGH);
case 'P':
break;
case 'A':
break;
case 'C':
break;
case 'T':
setopt_socket((struct request_setopt *)buffer);
return -1;
case 'U':
break;
default:
fprintf(stderr, "socket-server: unknown ctrl %c.\n", type);
break;
}
return -1;
}
DWORD WINAPI http_do_request(void *lPtr)
{
socket_conn* conn = (socket_conn*)lPtr;
if(conn == 0)
return 0;
printf("[%08x]new connection\n", GetCurrentThreadId());
while(1)
{
int keepalive = 0;
dynamic_object * req = dynamic_create();
if(http_read_request(conn, req) == 0)
{
dynamic_delete(req);
break;
}
char* path = dynamic_get_string(dynamic_map_find(req, "PATH"));
char* method = dynamic_get_string(dynamic_map_find(req, "METHOD"));
char* connection = dynamic_get_string(dynamic_map_find(req, HTTP_HEADER_CONNECTION));
if(connection && strcmp(connection, "keep-alive")==0)
keepalive = 1;
printf("[%08x]%s %s\n", GetCurrentThreadId(), method, path);
if(strcmp(path, "/hello") == 0)
{
char* html = "<html><body>Hello World!</body></html>";
int htmllen = strlen(html);
dynamic_object * res = dynamic_create();
dynamic_string_printf(dynamic_map_insert(res, HTTP_HEADER_CONTENT_LENGTH), "%d", htmllen);
dynamic_set_string(dynamic_map_insert(res, HTTP_HEADER_CONTENT_TYPE), "text/html");
http_send_response(conn, 200, res);
write_socket(conn, html, htmllen, -1);
dynamic_delete(res);
}else
{
http_send_file(conn, req);
}
dynamic_delete(req);
if(keepalive == 0)
break;
}
close_socket(conn);
printf("[%08x]close connection\n", GetCurrentThreadId());
return 0;
}
void new_connection_socket(int soc_ec, s_socket *tc, int ssl)
{
int nc, soc_tmp;
struct sockaddr_in adrC_tmp;
TRACE(L_DEBUG, "server: connection server in progress (socket) ...");
soc_tmp = bor_accept_in (soc_ec, &adrC_tmp);
if (soc_tmp < 0) {
return;
}
/* Search free space in tc[].soc */
for (nc = 0; nc < MAXCLI; nc++)
if (tc[nc].soc == -1) break;
if (nc < MAXCLI) {
init_socket(&tc[nc]);
tc[nc].soc = soc_tmp;
memcpy (&tc[nc].adrC, &adrC_tmp, sizeof(struct sockaddr_in));
TRACE(L_VERBOSE, "server [%d]: established server connection with %s",
nc, bor_adrtoa_in(&adrC_tmp));
#ifdef HAVE_LIBSSL
/* Init SSL here
*/
if ( ssl == 1 ) {
TRACE(L_DEBUG, "server [%d]: socks5 enable ssl ...", nc);
tc[nc].ssl = ssl_neogiciate_server(tc[nc].soc);
if ( tc[nc].ssl == NULL ) {
ERROR(L_VERBOSE, "server [%d]: ssl error", nc);
close_socket(&tc[nc]);
return;
}
TRACE(L_DEBUG, "server [%d]: ssl ok.", nc);
set_non_blocking(tc[nc].soc);
}
#endif /* HAVE_LIBSSL */
//append_log_client(&tc[nc], "%s", bor_adrtoa_in(&adrC_tmp));
//set_non_blocking(tc[nc].soc);
} else {
CLOSE_SOCKET(soc_tmp);
ERROR (L_NOTICE, "server: %s connection refused : too many clients!",
bor_adrtoa_in(&adrC_tmp));
}
}
/**
* Closes an accepted SSL server connection and deletes it form the
* connection list.
* @param ssl_server data for ssl server connection
* @param ssl data the connection to be deleted
*/
void close_accepted_ssl_socket(ssl_server_connection *ssl_server, ssl_connection *ssl) {
if (!ssl || !ssl_server)
return;
close_socket(ssl->socket);
LOCK(ssl_mutex);
if (ssl->prev == NULL)
ssl_server->ssl_conn_list = ssl->next;
else
ssl->prev->next = ssl->next;
END_LOCK;
delete_ssl_socket(ssl);
}
int main(int argc, char* argv[]) {
char* resstr;
struct LiStreamStatus* li;
E_COUNTRY c;
resstr = NULL;
open_socket("127.0.0.1", 9051);
tctrl_authenticate("torika");
c = tctrl_ip_to_country("98.236.50.49");
if ( c == US ) {
printf("%s\n", "HURRA DE");
}
list_stream_status_init(&li);
printf("%s\n", li->next->s->target_ip);
list_stream_status_free(&li);
close_socket();
return 0;
}
static void* CTCT_ListenThread( void* argp )
{
int connfd;
socklen_t servlen;
char str[80];
CTCG_PARMBLK parm;
// set up the parameters passed via create_thread
parm = *((CTCG_PARMBLK*) argp);
free( argp );
for( ; ; )
{
servlen = sizeof(parm.addr);
// await a connection
connfd = accept( parm.listenfd,
(struct sockaddr *)&parm.addr,
&servlen );
MSGBUF( str, "%s:%d",
inet_ntoa( parm.addr.sin_addr ),
ntohs( parm.addr.sin_port ) );
if( strcmp( str, parm.dev->filename ) != 0 )
{
WRMSG(HHC00974, "E", SSID_TO_LCSS(parm.dev->ssid), parm.dev->devnum,
parm.dev->filename, str);
close_socket( connfd );
}
else
{
parm.dev->fd = connfd;
}
// Ok, so having done that we're going to loop back to the
// accept(). This was meant to handle the connection failing
// at the other end; this end will be ready to accept another
// connection. Although this will happen, I'm sure you can
// see the possibility for bad things to occur (eg if another
// Hercules tries to connect). This will also be fixed RSN.
}
// UNREACHABLE
}
void
xexit(int exit_value)
/* exit after having freed memory and removed lock file */
{
cf_t *f = NULL;
now = time(NULL);
/* we save all files now and after having waiting for all
* job being executed because we might get a SIGKILL
* if we don't exit quickly */
save_file(NULL);
#ifdef FCRONDYN
close_socket();
#endif
f = file_base;
while (f != NULL) {
if (f->cf_running > 0) {
/* */
debug("waiting jobs for %s ...", f->cf_user);
/* */
wait_all(&f->cf_running);
save_file(f);
}
delete_file(f->cf_user);
/* delete_file remove the f file from the list :
* next file to remove is now pointed by file_base. */
f = file_base;
}
remove(pidfile);
exe_list_destroy(exe_list);
lavg_list_destroy(lavg_list);
free_conf();
Free_safe(orig_tz_envvar);
explain("Exiting with code %d", exit_value);
exit(exit_value);
}
MODULE terminate_the_thread (THREAD *thread)
{
NS_REQUEST
*next,
*request;
USER_DATA
*next_data,
*user_data;
tcb = thread-> tcb; /* Point to thread's context */
mem_strfree (&tcb-> ip_value);
mem_strfree (&tcb-> host_name);
if (tcb-> handle)
close_socket (tcb-> handle);
if (tcb-> query)
mem_free (tcb-> query);
/* Free stack of requests */
request = tcb-> stack.next;
while ((void *)request != (void *)&tcb-> stack)
{
next = request-> next;
rdns_request_free (request);
request = next;
}
/* Free reply list */
user_data = tcb-> reply.next;
while ((void *)user_data != (void *)&tcb-> reply)
{
next_data = user_data-> next;
mem_free (user_data);
user_data = next_data;
}
if (tcb-> invalid_ns_tab)
sym_delete_table (tcb-> invalid_ns_tab);
if (tcb-> rr_result)
mem_free (tcb-> rr_result);
the_next_event = terminate_event;
}
void TransportTCP::close()
{
Callback disconnect_cb;
if (!closed_)
{
{
boost::recursive_mutex::scoped_lock lock(close_mutex_);
if (!closed_)
{
closed_ = true;
ROS_ASSERT(sock_ != ROS_INVALID_SOCKET);
if (poll_set_)
{
poll_set_->delSocket(sock_);
}
::shutdown(sock_, ROS_SOCKETS_SHUT_RDWR);
if ( close_socket(sock_) != 0 )
{
ROS_ERROR("Error closing socket [%d]: [%s]", sock_, last_socket_error_string());
} else
{
ROSCPP_LOG_DEBUG("TCP socket [%d] closed", sock_);
}
sock_ = ROS_INVALID_SOCKET;
disconnect_cb = disconnect_cb_;
disconnect_cb_ = Callback();
read_cb_ = Callback();
write_cb_ = Callback();
accept_cb_ = AcceptCallback();
}
}
}
if (disconnect_cb)
{
disconnect_cb(shared_from_this());
}
}
void cql_ccm_bridge_t::start_connection(const cql_ccm_bridge_configuration_t& settings) {
_socket = ::socket(AF_INET, SOCK_STREAM, 0);
if (_socket == -1)
throw cql_ccm_bridge_exception_t("cannot create socket");
sockaddr_in socket_address;
socket_address.sin_family = AF_INET;
socket_address.sin_port = htons(settings.ssh_port());
socket_address.sin_addr.s_addr = inet_addr(settings.ssh_host().c_str());
int result = connect(_socket, reinterpret_cast<sockaddr *>(&socket_address),
sizeof(socket_address));
if (result == -1) {
close_socket();
throw cql_ccm_bridge_exception_t("cannot connect to remote host");
}
}
static int on_new_connection(void *userdata, unsigned int revents){
belle_sip_socket_t child;
struct sockaddr_storage addr;
socklen_t slen=sizeof(addr);
belle_sip_tls_listening_point_t *lp=(belle_sip_tls_listening_point_t*)userdata;
belle_sip_stream_listening_point_t *super=(belle_sip_stream_listening_point_t*)lp;
child=accept(super->server_sock,(struct sockaddr*)&addr,&slen);
if (child==(belle_sip_socket_t)-1){
belle_sip_error("Listening point [%p] accept() failed on TLS server socket: %s",lp,belle_sip_get_socket_error_string());
belle_sip_stream_listening_point_destroy_server_socket(super);
belle_sip_stream_listening_point_setup_server_socket(super,on_new_connection);
return BELLE_SIP_STOP;
}
belle_sip_message("New connection arriving on TLS, not handled !");
close_socket(child);
return BELLE_SIP_CONTINUE;
}
void
done_socket(struct socket *socket)
{
struct socket_weak_ref *ref;
close_socket(socket);
if (socket->connect_info)
done_connection_info(socket);
mem_free_set(&socket->read_buffer, NULL);
mem_free_set(&socket->write_buffer, NULL);
foreach(ref, socket_weak_refs) {
if (ref->socket == socket)
ref->socket = NULL;
}
}
static void
uplink_readable(struct io_fd *fd) {
static char buffer[MAXLEN];
char *eol;
int pos;
pos = ioset_line_read(fd, buffer, sizeof(buffer));
if (pos <= 0) {
close_socket();
return;
}
if ((eol = strpbrk(buffer, "\r\n")))
*eol = 0;
log_replay(MAIN_LOG, false, buffer);
if (cManager.uplink->state != DISCONNECTED)
parse_line(buffer, 0);
lines_processed++;
}
static size_t tcpsocket_write(KFile *fd, const void *buf, size_t len)
{
TcpSocket *socket = TCPSOCKET_CAST(fd);
/* Try reconnecting if our socket isn't valid */
if ((socket->sock == NULL) && !tcpsocket_reconnect(socket))
return 0;
socket->error = netconn_write(socket->sock, buf, len, NETCONN_COPY);
if (socket->error != ERR_OK)
{
LOG_ERR("While writing %d\n", socket->error);
close_socket(socket);
return 0;
}
return len;
}
static gboolean
tcp_connect_event(G_GNUC_UNUSED GIOChannel *source,
G_GNUC_UNUSED GIOCondition condition,
gpointer data)
{
struct tcp_connect *c = data;
assert(c->source != NULL);
assert(c->timeout_source != NULL);
/* clear the socket source */
g_source_unref(c->source);
c->source = NULL;
/* delete the timeout source */
g_source_destroy(c->timeout_source);
g_source_unref(c->timeout_source);
c->timeout_source = NULL;
/* obtain the connect result */
int s_err = 0;
socklen_t s_err_size = sizeof(s_err);
if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR,
(char*)&s_err, &s_err_size) < 0)
s_err = errno;
if (s_err == 0) {
/* connection established successfully */
c->handler->success(c->fd, c->handler_ctx);
} else {
/* there was an I/O error; close the socket and pass
the error to the handler */
close_socket(c->fd);
GError *error =
g_error_new_literal(g_file_error_quark(), s_err,
g_strerror(s_err));
c->handler->error(error, c->handler_ctx);
}
return false;
}
static void* run_master(void * arg) {
ni = init_ec((char*)arg);
init_slave_db();
if(ni != 0) {
printf("Attach netif \n\n");
EtherCAT_DataLinkLayer::instance()->attach(ni);
printf("Master initializing \n\n");
EtherCAT_Master * EM = EtherCAT_Master::instance();
printf("Getting slave handler\n");
EtherCAT_SlaveHandler * sh_ek1100 = EM->get_slave_handler(0x03e9);
//sleep(1);
printf("Setting EK1100 to OP STATE\n");
if(sh_ek1100->to_state(EC_OP_STATE))
printf("EK1100 succesfully set in OP STATE\n");
else
printf("\nfailed to set EK1100 in OP STATE\n");
printf("Getting slave handler\n");
EtherCAT_SlaveHandler * sh_el4102 = EM->get_slave_handler(0x03ea);
printf("Setting EL4102 to OP STATE\n");
if(sh_el4102->to_state(EC_OP_STATE))
printf("EL4102 succesfully set in OP STATE\n");
else
printf("\nfailed to set EL4102 in OP STATE!!\n");
printf("AL initializing \n\n");
EtherCAT_AL * AL = EtherCAT_AL::instance();
///Set Channel 1 to 5V
unsigned char msg[2] = {0xff, 0x3f};
if(AL->isReady()) {
printf("Test: Set Channel 1 to 5V: \n\n");
int count = 0;
while(count<100000) {
EM->txandrx_PD(sizeof(msg),msg);
count++;
}
printf("Test done.\n");
}
close_socket(ni);
}
}
/*-------------------------------------------------------------------*/
static void
write_buffer (DEVBLK *dev, char *buf, int len, BYTE *unitstat)
{
int rc; /* Return code */
/* Write data to the printer file */
if (dev->bs)
{
/* (socket printer) */
rc = write_socket (dev->fd, buf, len);
/* Check for socket error */
if (rc < len)
{
/* Close the connection */
if (dev->fd != -1)
{
int fd = dev->fd;
dev->fd = -1;
close_socket( fd );
WRMSG (HHC01100, "I", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->bs->clientname, dev->bs->clientip, dev->bs->spec);
}
/* Set unit check with intervention required */
dev->sense[0] = SENSE_IR;
*unitstat = CSW_CE | CSW_DE | CSW_UC;
}
}
else
{
/* Write data to the printer file */
rc = write (dev->fd, buf, len);
/* Equipment check if error writing to printer file */
if (rc < len)
{
WRMSG (HHC01105, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, "write()",
rc < 0 ? strerror(errno) : "incomplete record written");
dev->sense[0] = SENSE_EC;
*unitstat = CSW_CE | CSW_DE | CSW_UC;
}
}
} /* end function write_buffer */
/*PAGE
*
* close_stream
*
* Close control stream of session.
*
* Input parameters:
* info - corresponding SessionInfo structure
*
* Output parameters:
* NONE
*
*/
static void
close_stream(FTPD_SessionInfo_t* info)
{
if (NULL != info->ctrl_fp)
{
if (0 != fclose(info->ctrl_fp))
{
syslog(LOG_ERR, "ftpd: Could not close control stream: %s", serr());
}
else
info->ctrl_socket = -1;
}
if (!close_socket(info->ctrl_socket))
syslog(LOG_ERR, "ftpd: Could not close control socket: %s", serr());
info->ctrl_fp = NULL;
info->ctrl_socket = -1;
}
// return type
static int
ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
int fd = ss->recvctrl_fd;
// the length of message is one byte, so 256+8 buffer size is enough.
uint8_t buffer[256];
uint8_t header[2];
block_readpipe(fd, header, sizeof(header));
int type = header[0];
int len = header[1];
block_readpipe(fd, buffer, len);
// ctrl command only exist in local fd, so don't worry about endian.
switch (type) {
case 'S':
return start_socket(ss,(struct request_start *)buffer, result);
case 'B':
return bind_socket(ss,(struct request_bind *)buffer, result);
case 'L':
return listen_socket(ss,(struct request_listen *)buffer, result);
case 'K':
return close_socket(ss,(struct request_close *)buffer, result);
case 'O':
return open_socket(ss, (struct request_open *)buffer, result);
case 'X':
result->opaque = 0;
result->id = 0;
result->ud = 0;
result->data = NULL;
return SOCKET_EXIT;
case 'D':
return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_HIGH);
case 'P':
return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_LOW);
case 'T':
setopt_socket(ss, (struct request_setopt *)buffer);
return -1;
default:
fprintf(stderr, "socket-server: Unknown ctrl %c.\n",type);
return -1;
};
return -1;
}
long redrobd_rc_net_server_thread::cleanup(void)
{
try {
redrobd_log_writeln(get_name() + " : cleanup started");
///////////////////////////////////////////////
// If no controlled shutdown was requested,
// proceed with cleanup
///////////////////////////////////////////////
if (!m_shutdown_requested) {
// Shutdown server socket
if (shutdown_socket(m_server_sd,
true,
true) != SOCKET_SUPPORT_SUCCESS) {
THROW_EXP(REDROBD_INTERNAL_ERROR, REDROBD_SOCKET_OPERATION_FAILED,
"Shutdown server socket failed in thread %s",
get_name().c_str());
}
// Close server socket
if (close_socket(m_server_sd) != SOCKET_SUPPORT_SUCCESS) {
THROW_EXP(REDROBD_INTERNAL_ERROR, REDROBD_SOCKET_OPERATION_FAILED,
"Close server socket failed in thread %s",
get_name().c_str());
}
m_server_closed = true;
}
redrobd_log_writeln(get_name() + " : cleanup done");
return THREAD_SUCCESS;
}
catch (excep &exp) {
syslog_error(redrobd_error_syslog_string(exp).c_str());
return THREAD_INTERNAL_ERROR;
}
catch (...) {
syslog_error("redrobd_rc_net_server_thread::cleanup->Unexpected exception");
return THREAD_INTERNAL_ERROR;
}
}
static bool tcpsocket_reconnect(TcpSocket *socket)
{
LOG_ERR("Reconnecting..\n");
/* Close socket if was open */
close_socket(socket);
/* If we are in server mode we do nothing */
if (socket->handler)
return false;
/* Start with new connection */
socket->sock = netconn_new(NETCONN_TCP);
if(!socket->sock)
{
LOG_ERR("Unabe to alloc new connection\n");
socket->error = -1;
goto error;
}
socket->error = netconn_bind(socket->sock, socket->local_addr, socket->port);
if(socket->error != ERR_OK)
{
LOG_ERR("Connection error\n");
goto error;
}
socket->error = netconn_connect(socket->sock, socket->remote_addr, socket->port);
if(socket->error != ERR_OK)
{
LOG_ERR("Cannot create socket\n");
goto error;
}
LOG_INFO("connected ip=%d.%d.%d.%d\n", IP_ADDR_TO_INT_TUPLE(socket->remote_addr->addr));
return true;
error:
netconn_delete(socket->sock);
socket->sock = NULL;
return false;
}
static belle_sip_socket_t create_udp_socket(const char *addr, int port, int *family){
/* struct addrinfo hints={0}; */
struct addrinfo *res=NULL;
int err;
belle_sip_socket_t sock;
char portnum[10];
/* int optval=1; */
snprintf(portnum,sizeof(portnum),"%i",port);
/* hints.ai_family=AF_UNSPEC;
hints.ai_socktype=SOCK_DGRAM;
hints.ai_protocol=IPPROTO_UDP;
hints.ai_flags=AI_NUMERICSERV; */
err=Xgetaddrinfo(addr,NULL,NULL,&res);
if (err!=0){
printf("getaddrinfo() failed for %s port %i: %s",addr,port,gai_strerror(err));
return -1;
}
*family=res->ai_family;
/* sock=Xsocket(res->ai_family,res->ai_socktype,res->ai_protocol); */
sock=Xsocket(AF_XIA, SOCK_DGRAM, 0);
if (sock==-1){
printf("Cannot create UDP socket: %s",belle_sip_get_socket_error_string());
Xfreeaddrinfo(res);
return -1;
}
/* err = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char*)&optval, sizeof (optval));
if (err == -1){
belle_sip_warning ("Fail to set SIP/UDP address reusable: %s.", belle_sip_get_socket_error_string());
} */
err=Xbind(sock,res->ai_addr,res->ai_addrlen);
if (err==-1){
printf("udp bind() failed for %s port %i: %s",addr,port,belle_sip_get_socket_error_string());
close_socket(sock);
Xfreeaddrinfo(res);
return -1;
}
Xfreeaddrinfo(res);
return sock;
}
