void* console_thread_func(void*)
{
/*Start logs*/
while(bConsoleActive)
{
while(!qConsoleMessages.empty())
{
console_msg front_msg = qConsoleMessages.front();
gdk_threads_enter();
GtkTextIter console_end_iter;
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter); /*Get end of console*/
if(front_msg.type != important_online && front_msg.type != important_offline && front_msg.type != motd){
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.from_who.c_str(), strlen(front_msg.from_who.c_str()), console_format_normal, NULL);
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter); /*Get end again*/
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, ": ", strlen(": "), console_format_normal, NULL);/*Formating*/
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter);
}
switch(front_msg.type){ //from_who uses console_format_normal
case notification:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_notification, NULL);
break;
case error:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_error, NULL);
break;
case warning:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_warning, NULL);
break;
case important_online:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_important_online, NULL);
break;
case important_offline:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_important_offline, NULL);
break;
case motd:
gtk_text_buffer_insert_with_tags(console_buffer, &console_end_iter, front_msg.strMessage.c_str(), strlen(front_msg.strMessage.c_str()), console_format_motd, NULL);
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter);
gtk_text_buffer_insert(console_buffer, &console_end_iter, "\n", strlen("\n"));
break;
}
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter);
gtk_text_buffer_insert(console_buffer, &console_end_iter, "\n", strlen("\n"));
gtk_text_buffer_get_end_iter(console_buffer, &console_end_iter);
gtk_text_view_scroll_to_iter((GtkTextView*)console_text, &console_end_iter, 0, 0, 0, 0);
gdk_threads_leave();
qConsoleMessages.pop(); //pop 'em
poll(0,0, CONSOLE_DELAY); /*Don't want it to spout all out and shit*/
}
}
/*Clean up and save logs here*/
return NULL;
}
static void *
manager_output_loop( DirectThread *thread, void *arg )
{
int len;
struct pollfd pf;
VoodooManager *manager = arg;
while (!manager->quit) {
D_MAGIC_ASSERT( manager, VoodooManager );
pf.fd = manager->fd;
pf.events = POLLOUT;
switch (poll( &pf, 1, 100 )) {
case -1:
if (errno != EINTR) {
D_PERROR( "Voodoo/Output: Could not poll() the socket!\n" );
usleep( 200000 );
}
/* fall through */
case 0:
continue;
}
pthread_mutex_lock( &manager->output.lock );
while (manager->output.start == manager->output.end) {
struct timeval now;
struct timespec timeout;
D_ASSUME( manager->output.start == 0 );
D_ASSUME( manager->output.end == 0 );
gettimeofday( &now, NULL );
timeout.tv_sec = now.tv_sec;
timeout.tv_nsec = (now.tv_usec + 50000) * 1000;
timeout.tv_sec += timeout.tv_nsec / 1000000000;
timeout.tv_nsec %= 1000000000;
pthread_cond_timedwait( &manager->output.wait, &manager->output.lock, &timeout );
if (manager->quit)
break;
}
if (!manager->quit) {
len = send( manager->fd, manager->output.buffer + manager->output.start,
manager->output.end - manager->output.start, MSG_DONTWAIT );
if (len < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
break;
default:
D_PERROR( "Voodoo/Output: Could not send() data!\n" );
usleep( 200000 );
}
}
else {
D_DEBUG( "Voodoo/Output: Sent %d/%d bytes...\n", len, manager->output.end - manager->output.start );
manager->output.start += len;
if (manager->output.start == manager->output.end) {
manager->output.start = manager->output.end = 0;
pthread_cond_broadcast( &manager->output.wait );
}
}
}
pthread_mutex_unlock( &manager->output.lock );
}
return NULL;
}
int multipipe(int size, int fd[][2])
{
int i, r, w, p;
char ** buffers;
if ((buffers = malloc(size * sizeof(char*))) == NULL) {
perror("malloc");
return -1;
}
for (i = 0 ; i < size ; i++) {
if ((buffers[i] = malloc(BUFSIZE * sizeof(char))) == NULL) {
perror("malloc");
return -1;
}
}
int * c;
if ((c = malloc(size * sizeof(int))) == NULL) {
perror("malloc");
return -1;
}
for (i = 0 ; i < size ; i++) {
c[i] = 0;
}
int * t;
if ((t = malloc(size * sizeof(int))) == NULL) {
perror("malloc");
return -1;
}
struct pollfd * pfd = NULL;
if ((pfd = malloc(2 * size * sizeof(struct pollfd))) == NULL) {
perror("malloc");
exit(1);
}
while (1) {
p = 0;
for (i = 0 ; i < size ; i++) {
if (c[i] < BUFSIZE) {
pfd[p].fd = fd[i][0];
pfd[p].events = POLLIN;
pfd[p].revents = 0;
t[p] = i;
p++;
}
if (c[i] > 0) {
pfd[p].fd = fd[i][1];
pfd[p].events = POLLOUT;
pfd[p].revents = 0;
t[p] = i;
p++;
}
}
if ((r = poll(pfd, p, -1)) <= 0) {
if (r == 0 || errno == EINTR)
continue;
perror("poll");
return -1;
}
for (i = 0 ; i < p ; i++) {
if (pfd[i].revents & POLLIN) {
if ((r = read(fd[t[i]][0], buffers[t[i]], BUFSIZE-c[t[i]])) < 0) {
if ((r == 0) || (errno != EAGAIN && errno != EWOULDBLOCK)) {
perror("read");
return -1;
}
}
c[t[i]] += r;
}
if (pfd[i].revents & POLLOUT) {
if ((w = write(fd[t[i]][1], buffers[t[i]], c[t[i]])) < 0) {
perror("write");
return -1;
}
if (w != 0) {
c[t[i]] -= w;
memmove(buffers[t[i]], &(buffers[t[i]]), c[t[i]]);
}
}
}
}
}
int read_gps_mtk(int *fd, char *gps_rx_buffer, int buffer_size) // returns 1 if the thread should terminate
{
// printf("in read_gps_mtk\n");
uint8_t ret = 0;
uint8_t c;
int rx_count = 0;
int gpsRxOverflow = 0;
struct pollfd fds;
fds.fd = *fd;
fds.events = POLLIN;
// This blocks the task until there is something on the buffer
while (1) {
//check if the thread should terminate
if (terminate_gps_thread == true) {
// printf("terminate_gps_thread=%u ", terminate_gps_thread);
// printf("exiting mtk thread\n");
// fflush(stdout);
ret = 1;
break;
}
if (poll(&fds, 1, 1000) > 0) {
if (read(*fd, &c, 1) > 0) {
// printf("Read %x\n",c);
if (rx_count >= buffer_size) {
// The buffer is already full and we haven't found a valid NMEA sentence.
// Flush the buffer and note the overflow event.
gpsRxOverflow++;
rx_count = 0;
mtk_decode_init();
if (gps_verbose) printf("[gps] Buffer full\r\n");
} else {
//gps_rx_buffer[rx_count] = c;
rx_count++;
}
int msg_read = mtk_parse(c, gps_rx_buffer);
if (msg_read > 0) {
// printf("Found sequence\n");
break;
}
} else {
break;
}
} else {
break;
}
}
return ret;
}
int zmq_poll (zmq_pollitem_t *items_, int nitems_, long timeout_)
{
if (!items_) {
errno = EFAULT;
return -1;
}
#if defined ZMQ_POLL_BASED_ON_POLL
if (unlikely (nitems_ < 0)) {
errno = EINVAL;
return -1;
}
if (unlikely (nitems_ == 0)) {
if (timeout_ == 0)
return 0;
#if defined ZMQ_HAVE_WINDOWS
Sleep (timeout_ > 0 ? timeout_ : INFINITE);
return 0;
#elif defined ZMQ_HAVE_ANDROID
usleep (timeout_ * 1000);
return 0;
#else
return usleep (timeout_ * 1000);
#endif
}
zmq::clock_t clock;
uint64_t now = 0;
uint64_t end = 0;
pollfd *pollfds = (pollfd*) malloc (nitems_ * sizeof (pollfd));
alloc_assert (pollfds);
// Build pollset for poll () system call.
for (int i = 0; i != nitems_; i++) {
// If the poll item is a 0MQ socket, we poll on the file descriptor
// retrieved by the ZMQ_FD socket option.
if (items_ [i].socket) {
size_t zmq_fd_size = sizeof (zmq::fd_t);
if (zmq_getsockopt (items_ [i].socket, ZMQ_FD, &pollfds [i].fd,
&zmq_fd_size) == -1) {
free (pollfds);
return -1;
}
pollfds [i].events = items_ [i].events ? POLLIN : 0;
}
// Else, the poll item is a raw file descriptor. Just convert the
// events to normal POLLIN/POLLOUT for poll ().
else {
pollfds [i].fd = items_ [i].fd;
pollfds [i].events =
(items_ [i].events & ZMQ_POLLIN ? POLLIN : 0) |
(items_ [i].events & ZMQ_POLLOUT ? POLLOUT : 0);
}
}
bool first_pass = true;
int nevents = 0;
while (true) {
// Compute the timeout for the subsequent poll.
int timeout;
if (first_pass)
timeout = 0;
else if (timeout_ < 0)
timeout = -1;
else
timeout = end - now;
// Wait for events.
while (true) {
int rc = poll (pollfds, nitems_, timeout);
if (rc == -1 && errno == EINTR) {
free (pollfds);
return -1;
}
errno_assert (rc >= 0);
break;
}
// Check for the events.
for (int i = 0; i != nitems_; i++) {
items_ [i].revents = 0;
// The poll item is a 0MQ socket. Retrieve pending events
// using the ZMQ_EVENTS socket option.
if (items_ [i].socket) {
size_t zmq_events_size = sizeof (uint32_t);
uint32_t zmq_events;
if (zmq_getsockopt (items_ [i].socket, ZMQ_EVENTS, &zmq_events,
&zmq_events_size) == -1) {
free (pollfds);
return -1;
}
if ((items_ [i].events & ZMQ_POLLOUT) &&
(zmq_events & ZMQ_POLLOUT))
items_ [i].revents |= ZMQ_POLLOUT;
if ((items_ [i].events & ZMQ_POLLIN) &&
(zmq_events & ZMQ_POLLIN))
items_ [i].revents |= ZMQ_POLLIN;
}
// Else, the poll item is a raw file descriptor, simply convert
// the events to zmq_pollitem_t-style format.
else {
if (pollfds [i].revents & POLLIN)
items_ [i].revents |= ZMQ_POLLIN;
if (pollfds [i].revents & POLLOUT)
items_ [i].revents |= ZMQ_POLLOUT;
if (pollfds [i].revents & ~(POLLIN | POLLOUT))
items_ [i].revents |= ZMQ_POLLERR;
}
if (items_ [i].revents)
nevents++;
}
// If timout is zero, exit immediately whether there are events or not.
if (timeout_ == 0)
break;
// If there are events to return, we can exit immediately.
if (nevents)
break;
// At this point we are meant to wait for events but there are none.
// If timeout is infinite we can just loop until we get some events.
if (timeout_ < 0) {
if (first_pass)
first_pass = false;
continue;
}
// The timeout is finite and there are no events. In the first pass
// we get a timestamp of when the polling have begun. (We assume that
// first pass have taken negligible time). We also compute the time
// when the polling should time out.
if (first_pass) {
now = clock.now_ms ();
end = now + timeout_;
if (now == end)
break;
first_pass = false;
continue;
}
// Find out whether timeout have expired.
now = clock.now_ms ();
if (now >= end)
break;
}
free (pollfds);
return nevents;
#elif defined ZMQ_POLL_BASED_ON_SELECT
if (unlikely (nitems_ < 0)) {
errno = EINVAL;
return -1;
}
if (unlikely (nitems_ == 0)) {
if (timeout_ == 0)
return 0;
#if defined ZMQ_HAVE_WINDOWS
Sleep (timeout_ > 0 ? timeout_ : INFINITE);
return 0;
#else
return usleep (timeout_ * 1000);
#endif
}
zmq::clock_t clock;
uint64_t now = 0;
uint64_t end = 0;
// Ensure we do not attempt to select () on more than FD_SETSIZE
// file descriptors.
zmq_assert (nitems_ <= FD_SETSIZE);
fd_set pollset_in;
FD_ZERO (&pollset_in);
fd_set pollset_out;
FD_ZERO (&pollset_out);
fd_set pollset_err;
FD_ZERO (&pollset_err);
zmq::fd_t maxfd = 0;
// Build the fd_sets for passing to select ().
for (int i = 0; i != nitems_; i++) {
// If the poll item is a 0MQ socket we are interested in input on the
// notification file descriptor retrieved by the ZMQ_FD socket option.
if (items_ [i].socket) {
size_t zmq_fd_size = sizeof (zmq::fd_t);
zmq::fd_t notify_fd;
if (zmq_getsockopt (items_ [i].socket, ZMQ_FD, ¬ify_fd,
&zmq_fd_size) == -1)
return -1;
if (items_ [i].events) {
FD_SET (notify_fd, &pollset_in);
if (maxfd < notify_fd)
maxfd = notify_fd;
}
}
// Else, the poll item is a raw file descriptor. Convert the poll item
// events to the appropriate fd_sets.
else {
if (items_ [i].events & ZMQ_POLLIN)
FD_SET (items_ [i].fd, &pollset_in);
if (items_ [i].events & ZMQ_POLLOUT)
FD_SET (items_ [i].fd, &pollset_out);
if (items_ [i].events & ZMQ_POLLERR)
FD_SET (items_ [i].fd, &pollset_err);
if (maxfd < items_ [i].fd)
maxfd = items_ [i].fd;
}
}
bool first_pass = true;
int nevents = 0;
fd_set inset, outset, errset;
while (true) {
// Compute the timeout for the subsequent poll.
timeval timeout;
timeval *ptimeout;
if (first_pass) {
timeout.tv_sec = 0;
timeout.tv_usec = 0;
ptimeout = &timeout;
}
else if (timeout_ < 0)
ptimeout = NULL;
else {
timeout.tv_sec = (long) ((end - now) / 1000);
timeout.tv_usec = (long) ((end - now) % 1000 * 1000);
ptimeout = &timeout;
}
// Wait for events. Ignore interrupts if there's infinite timeout.
while (true) {
memcpy (&inset, &pollset_in, sizeof (fd_set));
memcpy (&outset, &pollset_out, sizeof (fd_set));
memcpy (&errset, &pollset_err, sizeof (fd_set));
#if defined ZMQ_HAVE_WINDOWS
int rc = select (0, &inset, &outset, &errset, ptimeout);
if (unlikely (rc == SOCKET_ERROR)) {
errno = zmq::wsa_error_to_errno (WSAGetLastError ());
wsa_assert (errno == ENOTSOCK);
return -1;
}
#else
int rc = select (maxfd + 1, &inset, &outset, &errset, ptimeout);
if (unlikely (rc == -1)) {
errno_assert (errno == EINTR || errno == EBADF);
return -1;
}
#endif
break;
}
// Check for the events.
for (int i = 0; i != nitems_; i++) {
items_ [i].revents = 0;
// The poll item is a 0MQ socket. Retrieve pending events
// using the ZMQ_EVENTS socket option.
if (items_ [i].socket) {
size_t zmq_events_size = sizeof (uint32_t);
uint32_t zmq_events;
if (zmq_getsockopt (items_ [i].socket, ZMQ_EVENTS, &zmq_events,
&zmq_events_size) == -1)
return -1;
if ((items_ [i].events & ZMQ_POLLOUT) &&
(zmq_events & ZMQ_POLLOUT))
items_ [i].revents |= ZMQ_POLLOUT;
if ((items_ [i].events & ZMQ_POLLIN) &&
(zmq_events & ZMQ_POLLIN))
items_ [i].revents |= ZMQ_POLLIN;
}
// Else, the poll item is a raw file descriptor, simply convert
// the events to zmq_pollitem_t-style format.
else {
if (FD_ISSET (items_ [i].fd, &inset))
items_ [i].revents |= ZMQ_POLLIN;
if (FD_ISSET (items_ [i].fd, &outset))
items_ [i].revents |= ZMQ_POLLOUT;
if (FD_ISSET (items_ [i].fd, &errset))
items_ [i].revents |= ZMQ_POLLERR;
}
if (items_ [i].revents)
nevents++;
}
// If timout is zero, exit immediately whether there are events or not.
if (timeout_ == 0)
break;
// If there are events to return, we can exit immediately.
if (nevents)
break;
// At this point we are meant to wait for events but there are none.
// If timeout is infinite we can just loop until we get some events.
if (timeout_ < 0) {
if (first_pass)
first_pass = false;
continue;
}
// The timeout is finite and there are no events. In the first pass
// we get a timestamp of when the polling have begun. (We assume that
// first pass have taken negligible time). We also compute the time
// when the polling should time out.
if (first_pass) {
now = clock.now_ms ();
end = now + timeout_;
if (now == end)
break;
first_pass = false;
continue;
}
// Find out whether timeout have expired.
now = clock.now_ms ();
if (now >= end)
break;
}
return nevents;
#else
// Exotic platforms that support neither poll() nor select().
errno = ENOTSUP;
return -1;
#endif
}
int tls_do_handshake(rdpTls* tls, BOOL clientMode)
{
CryptoCert cert;
int verify_status, status;
do
{
#ifdef HAVE_POLL_H
struct pollfd pollfds;
#else
struct timeval tv;
fd_set rset;
#endif
int fd;
status = BIO_do_handshake(tls->bio);
if (status == 1)
break;
if (!BIO_should_retry(tls->bio))
return -1;
/* we select() only for read even if we should test both read and write
* depending of what have blocked */
fd = BIO_get_fd(tls->bio, NULL);
if (fd < 0)
{
WLog_ERR(TAG, "unable to retrieve BIO fd");
return -1;
}
#ifdef HAVE_POLL_H
pollfds.fd = fd;
pollfds.events = POLLIN;
pollfds.revents = 0;
do
{
status = poll(&pollfds, 1, 10 * 1000);
}
while ((status < 0) && (errno == EINTR));
#else
FD_ZERO(&rset);
FD_SET(fd, &rset);
tv.tv_sec = 0;
tv.tv_usec = 10 * 1000; /* 10ms */
status = _select(fd + 1, &rset, NULL, NULL, &tv);
#endif
if (status < 0)
{
WLog_ERR(TAG, "error during select()");
return -1;
}
}
while (TRUE);
cert = tls_get_certificate(tls, clientMode);
if (!cert)
{
WLog_ERR(TAG, "tls_get_certificate failed to return the server certificate.");
return -1;
}
tls->Bindings = tls_get_channel_bindings(cert->px509);
if (!tls->Bindings)
{
WLog_ERR(TAG, "unable to retrieve bindings");
verify_status = -1;
goto out;
}
if (!crypto_cert_get_public_key(cert, &tls->PublicKey, &tls->PublicKeyLength))
{
WLog_ERR(TAG, "crypto_cert_get_public_key failed to return the server public key.");
verify_status = -1;
goto out;
}
/* Note: server-side NLA needs public keys (keys from us, the server) but no
* certificate verify
*/
verify_status = 1;
if (clientMode)
{
verify_status = tls_verify_certificate(tls, cert, tls->hostname, tls->port);
if (verify_status < 1)
{
WLog_ERR(TAG, "certificate not trusted, aborting.");
tls_disconnect(tls);
verify_status = 0;
}
}
out:
tls_free_certificate(cert);
return verify_status;
}
void
lgssd_run()
{
int ret;
struct sigaction dn_act;
int fd;
time_t child_check = 0;
pid_t child_pid;
/* Taken from linux/Documentation/dnotify.txt: */
dn_act.sa_sigaction = dir_notify_handler;
sigemptyset(&dn_act.sa_mask);
dn_act.sa_flags = SA_SIGINFO;
sigaction(DNOTIFY_SIGNAL, &dn_act, NULL);
if ((fd = open(pipefs_dir, O_RDONLY)) == -1) {
printerr(0, "ERROR: failed to open %s: %s\n",
pipefs_dir, strerror(errno));
return;
}
fcntl(fd, F_SETSIG, DNOTIFY_SIGNAL);
fcntl(fd, F_NOTIFY, DN_CREATE|DN_DELETE|DN_MODIFY|DN_MULTISHOT);
init_client_list();
while (1) {
while (dir_changed) {
dir_changed = 0;
printerr(2, "pipefs root dir changed\n");
if (update_client_list()) {
printerr(0, "ERROR: couldn't update "
"client list\n");
goto out;
}
}
/* every 5s cleanup possible zombies of child processes */
if (time(NULL) - child_check >= 5) {
printerr(3, "check zombie children...\n");
while (1) {
child_pid = waitpid(-1, NULL, WNOHANG);
if (child_pid <= 0)
break;
printerr(2, "terminate zombie child: %d\n",
child_pid);
}
child_check = time(NULL);
}
/* race condition here: dir_changed could be set before we
* enter the poll, and we'd never notice if it weren't for the
* timeout. */
ret = poll(pollarray, pollsize, POLL_MILLISECS);
if (ret < 0) {
if (errno != EINTR)
printerr(0,
"WARNING: error return from poll\n");
} else if (ret == 0) {
/* timeout */
} else { /* ret > 0 */
scan_poll_results(ret);
}
}
out:
close(fd);
return;
}
int ev_get(int timeout_ms)
{
int r, i;
r = poll(ev_fds, ev_count, timeout_ms);
if (r <= 0)
return -1;
for (i=0;i<ev_count;i++) {
if ((ev_fds[i].revents & POLLIN) == 0)
continue;
if (ev_type[i] == EV_TYPE_KEYBOARD) {
struct input_event ev;
r = read(ev_fds[i].fd, &ev, sizeof(ev));
fprintf(stderr, "keyboard event: (%x,%x,%x)\n", ev.type, ev.code, ev.value);
if(r == sizeof(ev)) {
/* POWER key */
if ((ev.type == EV_KEY) && (ev.code == EV_POWER_KEY_CODE) && (ev.value == EV_KEY_VALUE_DOWN))
return EVENT_POWER_KEY_DOWN;
if ((ev.type == EV_KEY) && (ev.code == EV_POWER_KEY_CODE) && (ev.value == EV_KEY_VALUE_UP))
return EVENT_POWER_KEY_UP;
/* VOLUMEDOWN key */
if ((ev.type == EV_KEY) && (ev.code == EV_VOLUMEDOWN_KEY_CODE) && (ev.value == EV_KEY_VALUE_DOWN))
return EVENT_VOLUMEDOWN_KEY_DOWN;
if ((ev.type == EV_KEY) && (ev.code == EV_VOLUMEDOWN_KEY_CODE) && (ev.value == EV_KEY_VALUE_UP))
return EVENT_VOLUMEDOWN_KEY_UP;
/* VOLUMEUP key */
if ((ev.type == EV_KEY) && (ev.code == EV_VOLUMEUP_KEY_CODE) && (ev.value == EV_KEY_VALUE_DOWN))
return EVENT_VOLUMEUP_KEY_DOWN;
if ((ev.type == EV_KEY) && (ev.code == EV_VOLUMEUP_KEY_CODE) && (ev.value == EV_KEY_VALUE_UP))
return EVENT_VOLUMEUP_KEY_UP;
/* CAMERA key */
if ((ev.type == EV_KEY) && (ev.code == EV_CAMERA_KEY_CODE) && (ev.value == EV_KEY_VALUE_DOWN))
return EVENT_CAMERA_KEY_DOWN;
if ((ev.type == EV_KEY) && (ev.code == EV_CAMERA_KEY_CODE) && (ev.value == EV_KEY_VALUE_UP))
return EVENT_CAMERA_KEY_UP;
return -1;
}
} else if (ev_type[i] == EV_TYPE_UEVENT) {
char msg[1024];
while ((r = recv(ev_fds[i].fd, msg, sizeof(msg), 0)) > 0)
;
if(strstr(msg, CHARGER_DRIVER))
{
ALOGD("pm8921_battery UEVENT msg : %s\n", msg);
return EVENT_BATTERY;
}
}
}
return -1;
}
/*
* This is an internal function used for waiting for read or write
* events on a pair of file descriptors. It uses poll() when a fine
* poll() is available, in order to avoid limits with FD_SETSIZE,
* otherwise select() is used. An error is returned if select() is
* being used and a file descriptor is too large for FD_SETSIZE.
* A negative timeout value makes this function wait indefinitely,
* unles no valid file descriptor is given, when this happens the
* negative timeout is ignored and the function times out immediately.
* When compiled with CURL_ACKNOWLEDGE_EINTR defined, EINTR condition
* is honored and function might exit early without awaiting timeout,
* otherwise EINTR will be ignored.
*
* Return values:
* -1 = system call error or fd >= FD_SETSIZE
* 0 = timeout
* CURL_CSELECT_IN | CURL_CSELECT_OUT | CURL_CSELECT_ERR
*/
int Curl_socket_ready(curl_socket_t readfd, curl_socket_t writefd,
int timeout_ms)
{
#ifdef HAVE_POLL_FINE
struct pollfd pfd[2];
int num;
#else
struct timeval pending_tv;
struct timeval *ptimeout;
fd_set fds_read;
fd_set fds_write;
fd_set fds_err;
curl_socket_t maxfd;
#endif
struct timeval initial_tv = {0,0};
int pending_ms = 0;
int error;
int r;
int ret;
if((readfd == CURL_SOCKET_BAD) && (writefd == CURL_SOCKET_BAD)) {
r = wait_ms(timeout_ms);
return r;
}
/* Avoid initial timestamp, avoid gettimeofday() call, when elapsed
time in this function does not need to be measured. This happens
when function is called with a zero timeout or a negative timeout
value indicating a blocking call should be performed. */
if(timeout_ms > 0) {
pending_ms = timeout_ms;
initial_tv = curlx_tvnow();
}
#ifdef HAVE_POLL_FINE
num = 0;
if(readfd != CURL_SOCKET_BAD) {
pfd[num].fd = readfd;
pfd[num].events = POLLRDNORM|POLLIN|POLLRDBAND|POLLPRI;
pfd[num].revents = 0;
num++;
}
if(writefd != CURL_SOCKET_BAD) {
pfd[num].fd = writefd;
pfd[num].events = POLLWRNORM|POLLOUT;
pfd[num].revents = 0;
num++;
}
do {
if(timeout_ms < 0)
pending_ms = -1;
else if(!timeout_ms)
pending_ms = 0;
r = poll(pfd, num, pending_ms);
if(r != -1)
break;
error = SOCKERRNO;
if(error && error_not_EINTR)
break;
if(timeout_ms > 0) {
pending_ms = timeout_ms - elapsed_ms;
if(pending_ms <= 0)
break;
}
} while(r == -1);
if(r < 0)
return -1;
if(r == 0)
return 0;
ret = 0;
num = 0;
if(readfd != CURL_SOCKET_BAD) {
if(pfd[num].revents & (POLLRDNORM|POLLIN|POLLERR|POLLHUP))
ret |= CURL_CSELECT_IN;
if(pfd[num].revents & (POLLRDBAND|POLLPRI|POLLNVAL))
ret |= CURL_CSELECT_ERR;
num++;
}
if(writefd != CURL_SOCKET_BAD) {
if(pfd[num].revents & (POLLWRNORM|POLLOUT))
ret |= CURL_CSELECT_OUT;
if(pfd[num].revents & (POLLERR|POLLHUP|POLLNVAL))
ret |= CURL_CSELECT_ERR;
}
return ret;
#else /* HAVE_POLL_FINE */
FD_ZERO(&fds_err);
maxfd = (curl_socket_t)-1;
FD_ZERO(&fds_read);
if(readfd != CURL_SOCKET_BAD) {
VERIFY_SOCK(readfd);
FD_SET(readfd, &fds_read);
FD_SET(readfd, &fds_err);
maxfd = readfd;
}
FD_ZERO(&fds_write);
if(writefd != CURL_SOCKET_BAD) {
VERIFY_SOCK(writefd);
FD_SET(writefd, &fds_write);
FD_SET(writefd, &fds_err);
if(writefd > maxfd)
maxfd = writefd;
}
ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;
do {
if(timeout_ms > 0) {
pending_tv.tv_sec = pending_ms / 1000;
pending_tv.tv_usec = (pending_ms % 1000) * 1000;
}
else if(!timeout_ms) {
pending_tv.tv_sec = 0;
pending_tv.tv_usec = 0;
}
r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
if(r != -1)
break;
error = SOCKERRNO;
if(error && error_not_EINTR)
break;
if(timeout_ms > 0) {
pending_ms = timeout_ms - elapsed_ms;
if(pending_ms <= 0)
break;
}
} while(r == -1);
if(r < 0)
return -1;
if(r == 0)
return 0;
ret = 0;
if(readfd != CURL_SOCKET_BAD) {
if(FD_ISSET(readfd, &fds_read))
ret |= CURL_CSELECT_IN;
if(FD_ISSET(readfd, &fds_err))
ret |= CURL_CSELECT_ERR;
}
if(writefd != CURL_SOCKET_BAD) {
if(FD_ISSET(writefd, &fds_write))
ret |= CURL_CSELECT_OUT;
if(FD_ISSET(writefd, &fds_err))
ret |= CURL_CSELECT_ERR;
}
return ret;
#endif /* HAVE_POLL_FINE */
}
SE(WindowHandle _handle)
: m_ev(poll(_handle) )
{
}
struct SE { const Event* m_ev; SE() : m_ev(poll() ) {} ~SE() { if (NULL != m_ev) { release(m_ev); } } } scopeEvent;
int kdbus_test_chat(struct kdbus_test_env *env)
{
int ret, cookie;
struct kdbus_conn *conn_a, *conn_b;
struct pollfd fds[2];
uint64_t flags;
int count;
conn_a = kdbus_hello(env->buspath, 0, NULL, 0);
conn_b = kdbus_hello(env->buspath, 0, NULL, 0);
ASSERT_RETURN(conn_a && conn_b);
flags = KDBUS_NAME_ALLOW_REPLACEMENT;
ret = kdbus_name_acquire(conn_a, "foo.bar.test", &flags);
ASSERT_RETURN(ret == 0);
ret = kdbus_name_acquire(conn_a, "foo.bar.baz", NULL);
ASSERT_RETURN(ret == 0);
flags = KDBUS_NAME_QUEUE;
ret = kdbus_name_acquire(conn_b, "foo.bar.baz", &flags);
ASSERT_RETURN(ret == 0);
ret = kdbus_name_acquire(conn_a, "foo.bar.double", NULL);
ASSERT_RETURN(ret == 0);
ret = kdbus_name_acquire(conn_a, "foo.bar.double", NULL);
ASSERT_RETURN(ret == -EALREADY);
ret = kdbus_name_release(conn_a, "foo.bar.double");
ASSERT_RETURN(ret == 0);
ret = kdbus_name_release(conn_a, "foo.bar.double");
ASSERT_RETURN(ret == -ESRCH);
ret = kdbus_list(conn_b, KDBUS_LIST_UNIQUE |
KDBUS_LIST_NAMES |
KDBUS_LIST_QUEUED |
KDBUS_LIST_ACTIVATORS);
ASSERT_RETURN(ret == 0);
ret = kdbus_add_match_empty(conn_a);
ASSERT_RETURN(ret == 0);
ret = kdbus_add_match_empty(conn_b);
ASSERT_RETURN(ret == 0);
cookie = 0;
ret = kdbus_msg_send(conn_b, NULL, 0xc0000000 | cookie, 0, 0, 0,
KDBUS_DST_ID_BROADCAST);
ASSERT_RETURN(ret == 0);
fds[0].fd = conn_a->fd;
fds[1].fd = conn_b->fd;
kdbus_printf("-- entering poll loop ...\n");
for (count = 0;; count++) {
int i, nfds = sizeof(fds) / sizeof(fds[0]);
for (i = 0; i < nfds; i++) {
fds[i].events = POLLIN | POLLPRI | POLLHUP;
fds[i].revents = 0;
}
ret = poll(fds, nfds, 3000);
ASSERT_RETURN(ret >= 0);
if (fds[0].revents & POLLIN) {
if (count > 2)
kdbus_name_release(conn_a, "foo.bar.baz");
ret = kdbus_msg_recv(conn_a, NULL, NULL);
ASSERT_RETURN(ret == 0);
ret = kdbus_msg_send(conn_a, NULL,
0xc0000000 | cookie++,
0, 0, 0, conn_b->id);
ASSERT_RETURN(ret == 0);
}
if (fds[1].revents & POLLIN) {
ret = kdbus_msg_recv(conn_b, NULL, NULL);
ASSERT_RETURN(ret == 0);
ret = kdbus_msg_send(conn_b, NULL,
0xc0000000 | cookie++,
0, 0, 0, conn_a->id);
ASSERT_RETURN(ret == 0);
}
ret = kdbus_list(conn_b, KDBUS_LIST_UNIQUE |
KDBUS_LIST_NAMES |
KDBUS_LIST_QUEUED |
KDBUS_LIST_ACTIVATORS);
ASSERT_RETURN(ret == 0);
if (count > 10)
break;
}
kdbus_printf("-- closing bus connections\n");
kdbus_conn_free(conn_a);
kdbus_conn_free(conn_b);
return TEST_OK;
}
/**
* Perform some basic functional tests on the driver;
* make sure we can collect data from the sensor in polled
* and automatic modes.
*/
void
test()
{
struct range_finder_report report;
ssize_t sz;
int ret;
int fd = open(MB12XX_DEVICE_PATH, O_RDONLY);
if (fd < 0) {
err(1, "%s open failed (try 'mb12xx start' if the driver is not running", MB12XX_DEVICE_PATH);
}
/* do a simple demand read */
sz = read(fd, &report, sizeof(report));
if (sz != sizeof(report)) {
err(1, "immediate read failed");
}
warnx("single read");
warnx("measurement: %0.2f m", (double)report.distance);
warnx("time: %lld", report.timestamp);
/* start the sensor polling at 2Hz */
if (OK != ioctl(fd, SENSORIOCSPOLLRATE, 2)) {
errx(1, "failed to set 2Hz poll rate");
}
/* read the sensor 5x and report each value */
for (unsigned i = 0; i < 5; i++) {
struct pollfd fds;
/* wait for data to be ready */
fds.fd = fd;
fds.events = POLLIN;
ret = poll(&fds, 1, 2000);
if (ret != 1) {
errx(1, "timed out waiting for sensor data");
}
/* now go get it */
sz = read(fd, &report, sizeof(report));
if (sz != sizeof(report)) {
err(1, "periodic read failed");
}
warnx("periodic read %u", i);
warnx("measurement: %0.3f", (double)report.distance);
warnx("time: %lld", report.timestamp);
}
/* reset the sensor polling to default rate */
if (OK != ioctl(fd, SENSORIOCSPOLLRATE, SENSOR_POLLRATE_DEFAULT)) {
errx(1, "failed to set default poll rate");
}
errx(0, "PASS");
}
static int
wait_for_mysql(MYSQL *mysql, int status)
{
#ifdef __WIN__
fd_set rs, ws, es;
int res;
struct timeval tv, *timeout;
my_socket s= mysql_get_socket(mysql);
FD_ZERO(&rs);
FD_ZERO(&ws);
FD_ZERO(&es);
if (status & MYSQL_WAIT_READ)
FD_SET(s, &rs);
if (status & MYSQL_WAIT_WRITE)
FD_SET(s, &ws);
if (status & MYSQL_WAIT_EXCEPT)
FD_SET(s, &es);
if (status & MYSQL_WAIT_TIMEOUT)
{
tv.tv_sec= mysql_get_timeout_value(mysql);
tv.tv_usec= 0;
timeout= &tv;
}
else
timeout= NULL;
res= select(1, &rs, &ws, &es, timeout);
if (res == 0)
return MYSQL_WAIT_TIMEOUT;
else if (res == SOCKET_ERROR)
{
/*
In a real event framework, we should handle errors and re-try the select.
*/
return MYSQL_WAIT_TIMEOUT;
}
else
{
int status= 0;
if (FD_ISSET(s, &rs))
status|= MYSQL_WAIT_READ;
if (FD_ISSET(s, &ws))
status|= MYSQL_WAIT_WRITE;
if (FD_ISSET(s, &es))
status|= MYSQL_WAIT_EXCEPT;
return status;
}
#else
struct pollfd pfd;
int timeout;
int res;
pfd.fd= mysql_get_socket(mysql);
pfd.events=
(status & MYSQL_WAIT_READ ? POLLIN : 0) |
(status & MYSQL_WAIT_WRITE ? POLLOUT : 0) |
(status & MYSQL_WAIT_EXCEPT ? POLLPRI : 0);
if (status & MYSQL_WAIT_TIMEOUT)
timeout= 1000*mysql_get_timeout_value(mysql);
else
timeout= -1;
res= poll(&pfd, 1, timeout);
if (res == 0)
return MYSQL_WAIT_TIMEOUT;
else if (res < 0)
{
/*
In a real event framework, we should handle EINTR and re-try the poll.
*/
return MYSQL_WAIT_TIMEOUT;
}
else
{
int status= 0;
if (pfd.revents & POLLIN)
status|= MYSQL_WAIT_READ;
if (pfd.revents & POLLOUT)
status|= MYSQL_WAIT_WRITE;
if (pfd.revents & POLLPRI)
status|= MYSQL_WAIT_EXCEPT;
return status;
}
#endif
}
/*
* This is a wrapper around poll(). If poll() does not exist, then
* select() is used instead. An error is returned if select() is
* being used and a file descriptor is too large for FD_SETSIZE.
* A negative timeout value makes this function wait indefinitely,
* unles no valid file descriptor is given, when this happens the
* negative timeout is ignored and the function times out immediately.
* When compiled with CURL_ACKNOWLEDGE_EINTR defined, EINTR condition
* is honored and function might exit early without awaiting timeout,
* otherwise EINTR will be ignored.
*
* Return values:
* -1 = system call error or fd >= FD_SETSIZE
* 0 = timeout
* N = number of structures with non zero revent fields
*/
int Curl_poll(struct pollfd ufds[], unsigned int nfds, int timeout_ms)
{
#ifndef HAVE_POLL_FINE
struct timeval pending_tv;
struct timeval *ptimeout;
fd_set fds_read;
fd_set fds_write;
fd_set fds_err;
curl_socket_t maxfd;
#endif
struct timeval initial_tv = {0,0};
bool fds_none = TRUE;
unsigned int i;
int pending_ms = 0;
int error;
int r;
if(ufds) {
for (i = 0; i < nfds; i++) {
if(ufds[i].fd != CURL_SOCKET_BAD) {
fds_none = FALSE;
break;
}
}
}
if(fds_none) {
r = wait_ms(timeout_ms);
return r;
}
/* Avoid initial timestamp, avoid gettimeofday() call, when elapsed
time in this function does not need to be measured. This happens
when function is called with a zero timeout or a negative timeout
value indicating a blocking call should be performed. */
if(timeout_ms > 0) {
pending_ms = timeout_ms;
initial_tv = curlx_tvnow();
}
#ifdef HAVE_POLL_FINE
do {
if(timeout_ms < 0)
pending_ms = -1;
else if(!timeout_ms)
pending_ms = 0;
r = poll(ufds, nfds, pending_ms);
if(r != -1)
break;
error = SOCKERRNO;
if(error && error_not_EINTR)
break;
if(timeout_ms > 0) {
pending_ms = timeout_ms - elapsed_ms;
if(pending_ms <= 0)
break;
}
} while(r == -1);
#else /* HAVE_POLL_FINE */
FD_ZERO(&fds_read);
FD_ZERO(&fds_write);
FD_ZERO(&fds_err);
maxfd = (curl_socket_t)-1;
for (i = 0; i < nfds; i++) {
ufds[i].revents = 0;
if(ufds[i].fd == CURL_SOCKET_BAD)
continue;
VERIFY_SOCK(ufds[i].fd);
if(ufds[i].events & (POLLIN|POLLOUT|POLLPRI|
POLLRDNORM|POLLWRNORM|POLLRDBAND)) {
if(ufds[i].fd > maxfd)
maxfd = ufds[i].fd;
if(ufds[i].events & (POLLRDNORM|POLLIN))
FD_SET(ufds[i].fd, &fds_read);
if(ufds[i].events & (POLLWRNORM|POLLOUT))
FD_SET(ufds[i].fd, &fds_write);
if(ufds[i].events & (POLLRDBAND|POLLPRI))
FD_SET(ufds[i].fd, &fds_err);
}
}
ptimeout = (timeout_ms < 0) ? NULL : &pending_tv;
do {
if(timeout_ms > 0) {
pending_tv.tv_sec = pending_ms / 1000;
pending_tv.tv_usec = (pending_ms % 1000) * 1000;
}
else if(!timeout_ms) {
pending_tv.tv_sec = 0;
pending_tv.tv_usec = 0;
}
r = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, ptimeout);
if(r != -1)
break;
error = SOCKERRNO;
if(error && error_not_EINTR)
break;
if(timeout_ms > 0) {
pending_ms = timeout_ms - elapsed_ms;
if(pending_ms <= 0)
break;
}
} while(r == -1);
if(r < 0)
return -1;
if(r == 0)
return 0;
r = 0;
for (i = 0; i < nfds; i++) {
ufds[i].revents = 0;
if(ufds[i].fd == CURL_SOCKET_BAD)
continue;
if(FD_ISSET(ufds[i].fd, &fds_read))
ufds[i].revents |= POLLIN;
if(FD_ISSET(ufds[i].fd, &fds_write))
ufds[i].revents |= POLLOUT;
if(FD_ISSET(ufds[i].fd, &fds_err))
ufds[i].revents |= POLLPRI;
if(ufds[i].revents != 0)
r++;
}
#endif /* HAVE_POLL_FINE */
return r;
}
static enum req_fsm_nxt
http1_wait(struct sess *sp, struct worker *wrk, struct req *req)
{
int j, tmo;
struct pollfd pfd[1];
double now, when;
enum sess_close why = SC_NULL;
enum http1_status_e hs;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
assert(req->sp == sp);
AZ(req->vcl);
AZ(req->esi_level);
AZ(isnan(sp->t_idle));
assert(isnan(req->t_first));
assert(isnan(req->t_prev));
assert(isnan(req->t_req));
tmo = (int)(1e3 * cache_param->timeout_linger);
while (1) {
pfd[0].fd = sp->fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
j = poll(pfd, 1, tmo);
assert(j >= 0);
now = VTIM_real();
if (j != 0)
hs = HTTP1_Rx(req->htc);
else
hs = HTTP1_Complete(req->htc);
if (hs == HTTP1_COMPLETE) {
/* Got it, run with it */
if (isnan(req->t_first))
req->t_first = now;
if (isnan(req->t_req))
req->t_req = now;
req->acct.req_hdrbytes += Tlen(req->htc->rxbuf);
return (REQ_FSM_MORE);
} else if (hs == HTTP1_ERROR_EOF) {
why = SC_REM_CLOSE;
break;
} else if (hs == HTTP1_OVERFLOW) {
why = SC_RX_OVERFLOW;
break;
} else if (hs == HTTP1_ALL_WHITESPACE) {
/* Nothing but whitespace */
when = sp->t_idle + cache_param->timeout_idle;
if (when < now) {
why = SC_RX_TIMEOUT;
break;
}
when = sp->t_idle + cache_param->timeout_linger;
tmo = (int)(1e3 * (when - now));
if (when < now || tmo == 0) {
wrk->stats->sess_herd++;
SES_ReleaseReq(req);
WAIT_Enter(sp);
return (REQ_FSM_DONE);
}
} else {
/* Working on it */
if (isnan(req->t_first))
/* Record first byte received time stamp */
req->t_first = now;
when = sp->t_idle + cache_param->timeout_req;
tmo = (int)(1e3 * (when - now));
if (when < now || tmo == 0) {
why = SC_RX_TIMEOUT;
break;
}
}
}
req->acct.req_hdrbytes += Tlen(req->htc->rxbuf);
CNT_AcctLogCharge(wrk->stats, req);
SES_ReleaseReq(req);
assert(why != SC_NULL);
SES_Delete(sp, why, now);
return (REQ_FSM_DONE);
}
/**
Poll the socket for more work
@retval EFI_SUCCESS The application is running normally
@retval EFI_NOT_STARTED Listen socket error
@retval Other The user stopped the application
**/
EFI_STATUS
SocketPoll (
)
{
BOOLEAN bRemoveSocket;
BOOLEAN bListenError;
size_t BytesReceived;
int CloseStatus;
nfds_t Entry;
INTN EntryPrevious;
int FdCount;
nfds_t Index;
socklen_t LengthInBytes;
struct sockaddr_in * pPortIpAddress4;
struct sockaddr_in6 * pPortIpAddress6;
struct sockaddr_in * pRemoteAddress4;
struct sockaddr_in6 * pRemoteAddress6;
struct sockaddr_in6 RemoteAddress;
int Socket;
EFI_STATUS Status;
EFI_TPL TplPrevious;
//
// Check for control-C
//
pRemoteAddress4 = (struct sockaddr_in *)&RemoteAddress;
pRemoteAddress6 = (struct sockaddr_in6 *)&RemoteAddress;
bListenError = FALSE;
Status = ControlCCheck ( );
if ( !EFI_ERROR ( Status )) {
//
// Poll the sockets
//
FdCount = poll ( &PollFd[0],
MaxPort,
0 );
if ( -1 == FdCount ) {
//
// Poll error
//
DEBUG (( DEBUG_ERROR,
"ERROR - Poll error, errno: %d\r\n",
errno ));
Status = EFI_DEVICE_ERROR;
}
else {
//
// Process the poll output
//
Index = 0;
while ( FdCount ) {
bRemoveSocket = FALSE;
//
// Account for this descriptor
//
pPortIpAddress4 = (struct sockaddr_in *)&Port[ Index ].IpAddress;
pPortIpAddress6 = (struct sockaddr_in6 *)&Port[ Index ].IpAddress;
if ( 0 != PollFd[ Index ].revents ) {
FdCount -= 1;
}
//
// Check for a broken connection
//
if ( 0 != ( PollFd[ Index ].revents & POLLHUP )) {
bRemoveSocket = TRUE;
if ( ListenSocket == PollFd[ Index ].fd ) {
bListenError = TRUE;
DEBUG (( DEBUG_ERROR,
"ERROR - Network closed on listen socket, errno: %d\r\n",
errno ));
}
else {
if ( AF_INET == pPortIpAddress4->sin_family ) {
DEBUG (( DEBUG_ERROR,
"ERROR - Network closed on socket %d.%d.%d.%d:%d, errno: %d\r\n",
pPortIpAddress4->sin_addr.s_addr & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,
ntohs ( pPortIpAddress4->sin_port ),
errno ));
}
else {
DEBUG (( DEBUG_ERROR,
"ERROR - Network closed on socket [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d, errno: %d\r\n",
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 0 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 1 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 2 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 3 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 4 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 5 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 6 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 7 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 8 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 9 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 10 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 11 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 12 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],
pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],
ntohs ( pPortIpAddress6->sin6_port ),
errno ));
}
//
// Close the socket
//
CloseStatus = close ( PollFd[ Index ].fd );
if ( 0 == CloseStatus ) {
bRemoveSocket = TRUE;
if ( AF_INET == pPortIpAddress4->sin_family ) {
DEBUG (( DEBUG_INFO,
"0x%08x: Socket closed for %d.%d.%d.%d:%d\r\n",
PollFd[ Index ].fd,
pPortIpAddress4->sin_addr.s_addr & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,
( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,
ntohs ( pPortIpAddress4->sin_port )));
}
else {
static void loop (int master_fd, int ignore_eof)
{
ssize_t n;
char buf [BUFSIZ];
struct pollfd fds [2];
char control_buf [BUFSIZ];
char data_buf [BUFSIZ];
int flags;
struct strbuf control;
struct strbuf data;
struct iocblk *ioc;
struct termios *term;
unsigned char msg_type;
int i;
fds [0].fd = STDIN_FILENO;
fds [0].events = POLLIN;
fds [0].revents = 0;
fds [1].fd = master_fd;
fds [1].events = POLLIN;
fds [1].revents = 0;
control.buf = control_buf;
control.maxlen = BUFSIZ;
data.buf = data_buf;
data.maxlen = BUFSIZ;
for (;;) {
if (poll ((struct pollfd *) &fds, 2, INFTIM) == -1)
err_msg ("poll failed");
if (fds [0].revents & POLLIN) {
if ((n = read (STDIN_FILENO, buf, BUFSIZ)) == -1)
err_msg ("read from stdin failed");
if (n == 0) {
if (ignore_eof) {
fds [0].events = 0;
continue;
}
else
break;
}
if (writen (master_fd, buf, n) == -1)
err_msg ("writen to pty master failed");
}
if (fds [1].revents & POLLIN) {
flags = 0;
if ((n = getmsg (master_fd, &control, &data, &flags)) == -1)
err_msg ("getmsg from pty master failed");
msg_type = control.buf [0];
switch (msg_type) {
case M_DATA:
if (writen (STDOUT_FILENO, data.buf, data.len) == -1)
err_msg ("writen to stdout failed");
break;
case M_FLUSH:
fprintf (stderr, "pckt: pty slave flushed its queues\n");
break;
case M_STOPI:
fprintf (stderr, "pckt: pty slave suspended output\n");
break;
case M_STARTI:
fprintf (stderr, "pckt: pty slave resumed output\n");
break;
case M_STOP:
fprintf (stderr, "pckt: pty slave disabled XON/XOFF "
"flow control\n");
break;
case M_START:
fprintf (stderr, "pckt: pty slave enabled XON/XOFF "
"flow control\n");
break;
case M_IOCTL:
ioc = (struct iocblk *) &data.buf [0];
switch (ioc -> ioc_cmd) {
case TCSBRK:
fprintf (stderr, "pckt: pty slave sent BREAK\n");
goto out;
case TCSETS:
case TCSETSW:
case TCSETSF:
fprintf (stderr, "pckt: pty slave changed "
"terminal attributes\n");
term = (struct termios *)
&data.buf [sizeof (struct iocblk)];
fprintf (stderr, " term.c_iflag = %04x\n",
term -> c_iflag);
fprintf (stderr, " term.c_oflag = %04x\n",
term -> c_oflag);
fprintf (stderr, " term.c_cflag = %04x\n",
term -> c_cflag);
fprintf (stderr, " term.c_lflag = %04x\n",
term -> c_lflag);
fprintf (stderr, " term.c_cc = ");
for (i = 0; i < NCCS; i++)
fprintf (stderr, "%02x ", term -> c_cc [i]);
fprintf (stderr, "\n");
break;
default:
fprintf (stderr, "pckt: Unrecognised ioc_cmd: "
"%04x\n", ioc -> ioc_cmd);
fprintf (stderr, " ioc -> ioc_cmd = %04x\n",
ioc -> ioc_cmd);
fprintf (stderr, " ioc -> ioc_id = %04x\n",
ioc -> ioc_id);
fprintf (stderr, " ioc -> ioc_flag = %04x\n",
ioc -> ioc_flag);
fprintf (stderr, " ioc -> ioc_count = %04x\n",
ioc -> ioc_count);
fprintf (stderr, " ioc -> ioc_rval = %04x\n",
ioc -> ioc_rval);
fprintf (stderr, " ioc -> ioc_error = %04x\n",
ioc -> ioc_error);
break;
}
break;
default:
fprintf (stderr, "pckt: Unrecognised message type: "
"%02x\n", msg_type);
break;
}
}
}
out:
;
}
static void
rtpp_cmd_acceptor_run(void *arg)
{
struct rtpp_cmd_async_cf *cmd_cf;
struct pollfd *tp;
struct rtpp_cmd_pollset *psp;
struct rtpp_cmd_accptset *asp;
struct rtpp_cmd_connection *rcc;
int nready, controlfd, i, tstate;
cmd_cf = (struct rtpp_cmd_async_cf *)arg;
psp = &cmd_cf->pset;
asp = &cmd_cf->aset;
for (;;) {
#ifndef LINUX_XXX
nready = poll(asp->pfds, asp->pfds_used, INFTIM);
#else
nready = poll(asp->pfds, asp->pfds_used, 100);
#endif
pthread_mutex_lock(&cmd_cf->cmd_mutex);
tstate = cmd_cf->tstate_acceptor;
pthread_mutex_unlock(&cmd_cf->cmd_mutex);
if (tstate == TSTATE_CEASE) {
break;
}
if (nready <= 0)
continue;
for (i = 0; i < asp->pfds_used; i++) {
if ((asp->pfds[i].revents & POLLIN) == 0) {
continue;
}
pthread_mutex_lock(&psp->pfds_mutex);
if (psp->pfds_used >= RTPC_MAX_CONNECTIONS) {
pthread_mutex_unlock(&psp->pfds_mutex);
continue;
}
controlfd = accept_connection(cmd_cf->cf_save, asp->pfds[i].fd);
if (controlfd < 0) {
pthread_mutex_unlock(&psp->pfds_mutex);
continue;
}
tp = realloc(psp->pfds, sizeof(struct pollfd) * (psp->pfds_used + 1));
if (tp == NULL) {
pthread_mutex_unlock(&psp->pfds_mutex);
close(controlfd); /* Yeah, sorry, please try later */
continue;
}
rcc = rtpp_cmd_connection_ctor(controlfd, controlfd, asp->csocks[i]);
if (rcc == NULL) {
pthread_mutex_unlock(&psp->pfds_mutex);
close(controlfd); /* Yeah, sorry, please try later */
continue;
}
psp->pfds = tp;
psp->pfds[psp->pfds_used].fd = controlfd;
psp->pfds[psp->pfds_used].events = POLLIN | POLLERR | POLLHUP;
psp->pfds[psp->pfds_used].revents = 0;
psp->rccs[psp->pfds_used] = rcc;
psp->pfds_used++;
pthread_mutex_unlock(&psp->pfds_mutex);
rtpp_command_async_wakeup(&cmd_cf->pub);
}
}
}
static void ping(char *svr)
{
struct sigaction sa;
struct sockaddr_l2 addr;
socklen_t optlen;
unsigned char *send_buf;
unsigned char *recv_buf;
char str[18];
int i, sk, lost;
uint8_t id;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = stat;
sigaction(SIGINT, &sa, NULL);
send_buf = malloc(L2CAP_CMD_HDR_SIZE + size);
recv_buf = malloc(L2CAP_CMD_HDR_SIZE + size);
if (!send_buf || !recv_buf) {
perror("Can't allocate buffer");
exit(1);
}
/* Create socket */
sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
if (sk < 0) {
perror("Can't create socket");
goto error;
}
/* Bind to local address */
memset(&addr, 0, sizeof(addr));
addr.l2_family = AF_BLUETOOTH;
bacpy(&addr.l2_bdaddr, &bdaddr);
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Can't bind socket");
goto error;
}
/* Connect to remote device */
memset(&addr, 0, sizeof(addr));
addr.l2_family = AF_BLUETOOTH;
str2ba(svr, &addr.l2_bdaddr);
if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Can't connect");
goto error;
}
/* Get local address */
memset(&addr, 0, sizeof(addr));
optlen = sizeof(addr);
if (getsockname(sk, (struct sockaddr *) &addr, &optlen) < 0) {
perror("Can't get local address");
goto error;
}
ba2str(&addr.l2_bdaddr, str);
printf("Ping: %s from %s (data size %d) ...\n", svr, str, size);
/* Initialize send buffer */
for (i = 0; i < size; i++)
send_buf[L2CAP_CMD_HDR_SIZE + i] = (i % 40) + 'A';
id = ident;
while (count == -1 || count-- > 0) {
struct timeval tv_send, tv_recv, tv_diff;
l2cap_cmd_hdr *send_cmd = (l2cap_cmd_hdr *) send_buf;
l2cap_cmd_hdr *recv_cmd = (l2cap_cmd_hdr *) recv_buf;
/* Build command header */
send_cmd->ident = id;
send_cmd->len = htobs(size);
if (reverse)
send_cmd->code = L2CAP_ECHO_RSP;
else
send_cmd->code = L2CAP_ECHO_REQ;
gettimeofday(&tv_send, NULL);
/* Send Echo Command */
if (send(sk, send_buf, L2CAP_CMD_HDR_SIZE + size, 0) <= 0) {
perror("Send failed");
goto error;
}
/* Wait for Echo Response */
lost = 0;
while (1) {
struct pollfd pf[1];
int err;
pf[0].fd = sk;
pf[0].events = POLLIN;
if ((err = poll(pf, 1, timeout * 1000)) < 0) {
perror("Poll failed");
goto error;
}
if (!err) {
lost = 1;
break;
}
if ((err = recv(sk, recv_buf, L2CAP_CMD_HDR_SIZE + size, 0)) < 0) {
perror("Recv failed");
goto error;
}
if (!err){
printf("Disconnected\n");
goto error;
}
recv_cmd->len = btohs(recv_cmd->len);
/* Check for our id */
if (recv_cmd->ident != id)
continue;
/* Check type */
if (!reverse && recv_cmd->code == L2CAP_ECHO_RSP)
break;
if (recv_cmd->code == L2CAP_COMMAND_REJ) {
printf("Peer doesn't support Echo packets\n");
goto error;
}
}
sent_pkt++;
if (!lost) {
recv_pkt++;
gettimeofday(&tv_recv, NULL);
timersub(&tv_recv, &tv_send, &tv_diff);
if (verify) {
/* Check payload length */
if (recv_cmd->len != size) {
fprintf(stderr, "Received %d bytes, expected %d\n",
recv_cmd->len, size);
goto error;
}
/* Check payload */
if (memcmp(&send_buf[L2CAP_CMD_HDR_SIZE],
&recv_buf[L2CAP_CMD_HDR_SIZE], size)) {
fprintf(stderr, "Response payload different.\n");
goto error;
}
}
printf("%d bytes from %s id %d time %.2fms\n", recv_cmd->len, svr,
id - ident, tv2fl(tv_diff));
if (delay)
sleep(delay);
} else {
printf("no response from %s: id %d\n", svr, id - ident);
}
if (++id > 254)
id = ident;
}
stat(0);
free(send_buf);
free(recv_buf);
return;
error:
close(sk);
free(send_buf);
free(recv_buf);
exit(1);
}
static void
rtpp_cmd_queue_run(void *arg)
{
struct rtpp_cmd_async_cf *cmd_cf;
struct rtpp_cmd_pollset *psp;
int i, nready, rval, umode;
double sptime;
#if 0
double eptime, tused;
#endif
struct rtpp_command_stats *csp;
struct rtpp_stats_obj *rtpp_stats_cf;
cmd_cf = (struct rtpp_cmd_async_cf *)arg;
rtpp_stats_cf = cmd_cf->cf_save->stable->rtpp_stats;
csp = &cmd_cf->cstats;
psp = &cmd_cf->pset;
for (;;) {
sptime = getdtime();
pthread_mutex_lock(&psp->pfds_mutex);
if (psp->pfds_used == 0) {
pthread_mutex_unlock(&psp->pfds_mutex);
if (wait_next_clock(cmd_cf) == TSTATE_CEASE) {
break;
}
continue;
}
nready = poll(psp->pfds, psp->pfds_used, 2);
if (nready == 0) {
pthread_mutex_unlock(&psp->pfds_mutex);
if (wait_next_clock(cmd_cf) == TSTATE_CEASE) {
break;
}
continue;
}
if (nready < 0 && errno == EINTR) {
pthread_mutex_unlock(&psp->pfds_mutex);
continue;
}
if (nready > 0) {
for (i = 0; i < psp->pfds_used; i++) {
if ((psp->pfds[i].revents & (POLLERR | POLLHUP)) != 0) {
if (RTPP_CTRL_ISUNIX(psp->rccs[i]->csock)) {
goto closefd;
}
if (psp->rccs[i]->csock->type == RTPC_STDIO && (psp->pfds[i].revents & POLLIN) == 0) {
goto closefd;
}
}
if ((psp->pfds[i].revents & POLLIN) == 0) {
continue;
}
if (RTPP_CTRL_ISSTREAM(psp->rccs[i]->csock)) {
rval = process_commands_stream(cmd_cf->cf_save, psp->rccs[i], sptime, csp, rtpp_stats_cf);
} else {
umode = RTPP_CTRL_ISDG(psp->rccs[i]->csock);
rval = process_commands(cmd_cf->cf_save, psp->pfds[i].fd,
sptime, csp, umode, rtpp_stats_cf, cmd_cf->rcache);
}
/*
* Shut down non-datagram sockets that got I/O error
* and also all non-continuous UNIX sockets are recycled
* after each use.
*/
if (!RTPP_CTRL_ISDG(psp->rccs[i]->csock) && (rval == -1 || !RTPP_CTRL_ISSTREAM(psp->rccs[i]->csock))) {
closefd:
if (psp->rccs[i]->csock->type == RTPC_STDIO && psp->rccs[i]->csock->exit_on_close != 0) {
cmd_cf->cf_save->stable->slowshutdown = 1;
}
rtpp_cmd_connection_dtor(psp->rccs[i]);
psp->pfds_used--;
if (psp->pfds_used > 0 && i < psp->pfds_used) {
memcpy(&psp->pfds[i], &psp->pfds[i + 1],
(psp->pfds_used - i) * sizeof(struct pollfd));
memcpy(&psp->rccs[i], &psp->rccs[i + 1],
(psp->pfds_used - i) * sizeof(struct rtpp_ctrl_connection *));
}
}
}
}
pthread_mutex_unlock(&psp->pfds_mutex);
if (nready > 0) {
rtpp_anetio_pump(cmd_cf->cf_save->stable->rtpp_netio_cf);
}
#if 0
eptime = getdtime();
pthread_mutex_lock(&cmd_cf->cmd_mutex);
recfilter_apply(&cmd_cf->average_load, (eptime - sptime + tused) * cmd_cf->cf_save->stable->target_pfreq);
pthread_mutex_unlock(&cmd_cf->cmd_mutex);
#endif
flush_cstats(rtpp_stats_cf, csp);
#if 0
#if RTPP_DEBUG
if (last_ctick % (unsigned int)cmd_cf->cf_save->stable->target_pfreq == 0 || last_ctick < 1000) {
rtpp_log_write(RTPP_LOG_DBUG, cmd_cf->cf_save->stable->glog, "rtpp_cmd_queue_run %lld sptime %f eptime %f, CSV: %f,%f,%f,%f,%f", \
last_ctick, sptime, eptime, (double)last_ctick / cmd_cf->cf_save->stable->target_pfreq, \
eptime - sptime + tused, eptime, sptime, tused);
rtpp_log_write(RTPP_LOG_DBUG, cmd_cf->cf_save->stable->glog, "run %lld average load %f, CSV: %f,%f", last_ctick, \
cmd_cf->average_load.lastval * 100.0, (double)last_ctick / cmd_cf->cf_save->stable->target_pfreq, cmd_cf->average_load.lastval);
}
#endif
#endif
}
}
int tls_write_all(rdpTls* tls, const BYTE* data, int length)
{
int status, nchunks, commitedBytes;
rdpTcp *tcp;
#ifdef HAVE_POLL_H
struct pollfd pollfds;
#else
fd_set rset, wset;
fd_set *rsetPtr, *wsetPtr;
struct timeval tv;
#endif
BIO* bio = tls->bio;
DataChunk chunks[2];
BIO* bufferedBio = findBufferedBio(bio);
if (!bufferedBio)
{
WLog_ERR(TAG, "error unable to retrieve the bufferedBio in the BIO chain");
return -1;
}
tcp = (rdpTcp*) bufferedBio->ptr;
do
{
status = BIO_write(bio, data, length);
if (status > 0)
break;
if (!BIO_should_retry(bio))
return -1;
#ifdef HAVE_POLL_H
pollfds.fd = tcp->sockfd;
pollfds.revents = 0;
pollfds.events = 0;
if (tcp->writeBlocked)
{
pollfds.events |= POLLOUT;
}
else if (tcp->readBlocked)
{
pollfds.events |= POLLIN;
}
else
{
WLog_ERR(TAG, "weird we're blocked but the underlying is not read or write blocked !");
USleep(10);
continue;
}
do
{
status = poll(&pollfds, 1, 100);
}
while ((status < 0) && (errno == EINTR));
#else
/* we try to handle SSL want_read and want_write nicely */
rsetPtr = wsetPtr = NULL;
if (tcp->writeBlocked)
{
wsetPtr = &wset;
FD_ZERO(&wset);
FD_SET(tcp->sockfd, &wset);
}
else if (tcp->readBlocked)
{
rsetPtr = &rset;
FD_ZERO(&rset);
FD_SET(tcp->sockfd, &rset);
}
else
{
WLog_ERR(TAG, "weird we're blocked but the underlying is not read or write blocked !");
USleep(10);
continue;
}
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000;
status = _select(tcp->sockfd + 1, rsetPtr, wsetPtr, NULL, &tv);
#endif
if (status < 0)
return -1;
}
while (TRUE);
/* make sure the output buffer is empty */
commitedBytes = 0;
while ((nchunks = ringbuffer_peek(&tcp->xmitBuffer, chunks, ringbuffer_used(&tcp->xmitBuffer))))
{
int i;
for (i = 0; i < nchunks; i++)
{
while (chunks[i].size)
{
status = BIO_write(tcp->socketBio, chunks[i].data, chunks[i].size);
if (status > 0)
{
chunks[i].size -= status;
chunks[i].data += status;
commitedBytes += status;
continue;
}
if (!BIO_should_retry(tcp->socketBio))
goto out_fail;
#ifdef HAVE_POLL_H
pollfds.fd = tcp->sockfd;
pollfds.events = POLLIN;
pollfds.revents = 0;
do
{
status = poll(&pollfds, 1, 100);
}
while ((status < 0) && (errno == EINTR));
#else
FD_ZERO(&rset);
FD_SET(tcp->sockfd, &rset);
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000;
status = _select(tcp->sockfd + 1, &rset, NULL, NULL, &tv);
#endif
if (status < 0)
goto out_fail;
}
}
}
ringbuffer_commit_read_bytes(&tcp->xmitBuffer, commitedBytes);
return length;
out_fail:
ringbuffer_commit_read_bytes(&tcp->xmitBuffer, commitedBytes);
return -1;
}
void run_work(struct work_param* param) {
if (pipe(param->pipes) != 0) {
printf("Failed to create pipe! %s\n", strerror(errno));
return;
}
unsigned char wb;
unsigned char* mbuf = xmalloc(1024);
while (1) {
pthread_rwlock_rdlock(¶m->conns->data_mutex);
size_t cc = param->conns->count;
struct pollfd fds[cc + 1];
struct conn* conns[cc];
int fdi = 0;
for (int i = 0; i < param->conns->size; i++) {
if (param->conns->data[i] != NULL) {
conns[fdi] = (param->conns->data[i]);
struct conn* conn = conns[fdi];
fds[fdi].fd = conns[fdi]->fd;
fds[fdi].events = POLLIN | (conn->writeBuffer_size > 0 ? POLLOUT : 0);
fds[fdi++].revents = 0;
if (fdi == cc) break;
} else conns[fdi] = NULL;
}
pthread_rwlock_unlock(¶m->conns->data_mutex);
fds[cc].fd = param->pipes[0];
fds[cc].events = POLLIN;
fds[cc].revents = 0;
int cp = poll(fds, cc + 1, -1);
if (param->mysql->mysql && param->mysql->complete && param->zone != param->mysql->czone) {
if (param->zone != NULL) {
freeZone(param->zone);
}
param->zone = param->mysql->czone;
}
if (cp < 0) {
printf("Poll error in worker thread! %s\n", strerror(errno));
} else if (cp == 0) continue;
else if ((fds[cc].revents & POLLIN) == POLLIN) {
if (read(param->pipes[0], &wb, 1) < 1) printf("Error reading from pipe, infinite loop COULD happen here.\n");
if (cp-- == 1) continue;
}
for (int i = 0; i < cc; i++) {
int re = fds[i].revents;
struct conn* conn = conns[i];
if (conn == NULL) continue;
if ((re & POLLERR) == POLLERR) {
//printf("POLLERR in worker poll! This is bad!\n");
goto cont;
}
if ((re & POLLHUP) == POLLHUP) {
closeConn(param, conn);
conn = NULL;
goto cont;
}
if ((re & POLLNVAL) == POLLNVAL) {
printf("Invalid FD in worker poll! This is bad!\n");
closeConn(param, conn);
conn = NULL;
goto cont;
}
if ((re & POLLIN) == POLLIN) {
size_t tr = 0;
ioctl(fds[i].fd, FIONREAD, &tr);
unsigned char* loc;
if (conn->readBuffer == NULL) {
conn->readBuffer = xmalloc(tr); // TODO: max upload?
conn->readBuffer_size = tr;
loc = conn->readBuffer;
} else {
conn->readBuffer_size += tr;
conn->readBuffer = xrealloc(conn->readBuffer, conn->readBuffer_size);
loc = conn->readBuffer + conn->readBuffer_size - tr;
}
ssize_t r = 0;
if (r == 0 && tr == 0) { // nothing to read, but wont block.
ssize_t x = 0;
x = read(fds[i].fd, loc + r, tr - r);
if (x <= 0) {
closeConn(param, conn);
conn = NULL;
goto cont;
}
r += x;
}
while (r < tr) {
ssize_t x = 0;
x = read(fds[i].fd, loc + r, tr - r);
if (x <= 0) {
closeConn(param, conn);
conn = NULL;
goto cont;
}
r += x;
}
int p = 0;
p = handleRead(conn, param, fds[i].fd);
if (p == 1) {
goto cont;
}
}
if ((re & POLLOUT) == POLLOUT && conn != NULL) {
ssize_t mtr = write(fds[i].fd, conn->writeBuffer, conn->writeBuffer_size);
if (mtr < 0 && errno != EAGAIN) {
closeConn(param, conn);
conn = NULL;
goto cont;
} else if (mtr < 0) {
goto cont;
} else if (mtr < conn->writeBuffer_size) {
memmove(conn->writeBuffer, conn->writeBuffer + mtr, conn->writeBuffer_size - mtr);
conn->writeBuffer_size -= mtr;
conn->writeBuffer = xrealloc(conn->writeBuffer, conn->writeBuffer_size);
} else {
conn->writeBuffer_size = 0;
xfree(conn->writeBuffer);
conn->writeBuffer = NULL;
}
if (conn->writeBuffer_size == 0 && conn->state == 1) {
closeConn(param, conn);
conn = NULL;
goto cont;
}
}
cont: ;
if (--cp == 0) break;
}
}
xfree(mbuf);
}
/*
* Filter out unresponsive servers, and save the domain info
* returned by the "LDAP ping" in the returned object.
* If ctx != NULL, this is a query for a DC, in which case we
* also save the Domain GUID, Site name, and Forest name as
* "auto" (discovered) values in the ctx.
*
* Only return the "winner". (We only want one DC/GC)
*/
ad_disc_ds_t *
ldap_ping(ad_disc_t ctx, ad_disc_cds_t *dclist, char *dname, int reqflags)
{
struct sockaddr_in6 addr6;
socklen_t addrlen;
struct pollfd pingchk;
ad_disc_cds_t *send_ds;
ad_disc_cds_t *recv_ds = NULL;
ad_disc_ds_t *ret_ds = NULL;
BerElement *req = NULL;
BerElement *res = NULL;
struct _berelement *be, *rbe;
size_t be_len, rbe_len;
int fd = -1;
int tries = 3;
int waitsec;
int r;
uint16_t msgid;
/* One plus a null entry. */
ret_ds = calloc(2, sizeof (ad_disc_ds_t));
if (ret_ds == NULL)
goto fail;
if ((fd = socket(PF_INET6, SOCK_DGRAM, 0)) < 0)
goto fail;
(void) memset(&addr6, 0, sizeof (addr6));
addr6.sin6_family = AF_INET6;
addr6.sin6_addr = in6addr_any;
if (bind(fd, (struct sockaddr *)&addr6, sizeof (addr6)) < 0)
goto fail;
/*
* semi-unique msgid...
*/
msgid = gethrtime() & 0xffff;
/*
* Is ntver right? It certainly works on w2k8... If others are needed,
* that might require changes to cldap_parse
*/
req = cldap_build_request(dname, NULL,
NETLOGON_NT_VERSION_5EX, msgid);
if (req == NULL)
goto fail;
be = (struct _berelement *)req;
be_len = be->ber_end - be->ber_buf;
if ((res = ber_alloc()) == NULL)
goto fail;
rbe = (struct _berelement *)res;
rbe_len = rbe->ber_end - rbe->ber_buf;
pingchk.fd = fd;
pingchk.events = POLLIN;
pingchk.revents = 0;
try_again:
send_ds = dclist;
waitsec = 5;
while (recv_ds == NULL && waitsec > 0) {
/*
* If there is another candidate, send to it.
*/
if (send_ds->cds_ds.host[0] != '\0') {
send_to_cds(send_ds, be->ber_buf, be_len, fd);
send_ds++;
/*
* Wait 1/10 sec. before the next send.
*/
r = poll(&pingchk, 1, 100);
#if 0 /* DEBUG */
/* Drop all responses 1st pass. */
if (waitsec == 5)
r = 0;
#endif
} else {
/*
* No more candidates to "ping", so
* just wait a sec for responses.
*/
r = poll(&pingchk, 1, 1000);
if (r == 0)
--waitsec;
}
if (r > 0) {
/*
* Got a response.
*/
(void) memset(&addr6, 0, addrlen = sizeof (addr6));
r = recvfrom(fd, rbe->ber_buf, rbe_len, 0,
(struct sockaddr *)&addr6, &addrlen);
recv_ds = find_cds_by_addr(dclist, &addr6);
if (recv_ds == NULL)
continue;
(void) cldap_parse(ctx, recv_ds, res);
if ((recv_ds->cds_ds.flags & reqflags) != reqflags) {
logger(LOG_ERR, "Skip %s"
"due to flags 0x%X",
recv_ds->cds_ds.host,
recv_ds->cds_ds.flags);
recv_ds = NULL;
}
}
}
if (recv_ds == NULL) {
if (--tries <= 0)
goto fail;
goto try_again;
}
(void) memcpy(ret_ds, recv_ds, sizeof (*ret_ds));
ber_free(res, 1);
ber_free(req, 1);
(void) close(fd);
return (ret_ds);
fail:
ber_free(res, 1);
ber_free(req, 1);
(void) close(fd);
free(ret_ds);
return (NULL);
}
/*ARGSUSED*/
static void *
env_polling_thread(void *args)
{
int poll_rc;
struct pollfd poll_fds[1];
void *datap;
int smcfd;
struct strioctl strio;
sc_cmdspec_t set;
smcfd = env_open_smc();
if (smcfd == -1) {
syslog(LOG_ERR, gettext("SUNW_envmond:Error in polling, "
"Open of SMC drv failed"));
create_polling_thr = B_TRUE;
return (NULL);
}
set.args[0] = SMC_SENSOR_EVENT_ENABLE_SET;
set.attribute = SC_ATTR_SHARED;
strio.ic_cmd = SCIOC_MSG_SPEC;
strio.ic_timout = 0;
strio.ic_len = ENV_SENSOR_EV_ENABLE_PKT_LEN;
strio.ic_dp = (char *)&set;
if (ioctl(smcfd, I_STR, &strio) < 0) {
syslog(LOG_ERR, gettext("SUNW_envmond:Request for "
"Sensor events failed"));
(void) close(smcfd);
create_polling_thr = B_TRUE;
return (NULL);
}
/* request for async messages */
poll_fds[0].fd = smcfd;
poll_fds[0].events = POLLIN|POLLPRI;
poll_fds[0].revents = 0;
set.attribute = SC_ATTR_SHARED;
set.args[0] = SMC_IPMI_RESPONSE_NOTIF;
set.args[1] = SMC_SMC_LOCAL_EVENT_NOTIF;
strio.ic_cmd = SCIOC_MSG_SPEC;
strio.ic_timout = 0;
strio.ic_len = ENV_IPMI_SMC_ENABLE_PKT_LEN;
strio.ic_dp = (char *)&set;
if (ioctl(smcfd, I_STR, &strio) == -1) {
syslog(LOG_ERR, gettext("SUNW_envmond:Request for"
"Async messages failed"));
(void) close(smcfd);
create_polling_thr = B_TRUE;
return (NULL);
}
/* Now wait for SMC events to come */
for (;;) {
poll_rc = poll(poll_fds, 1, -1); /* poll forever */
if (poll_rc < 0) {
syslog(LOG_ERR, gettext("SUNW_envmond:Event "
"processing halted"));
break;
}
if (env_process_smc_event(smcfd, &datap) == NO_EVENT) {
syslog(LOG_ERR, gettext("SUNW_envmond:"
"wrong event data posted from SMC"));
}
}
(void) close(smcfd);
create_polling_thr = B_TRUE;
return (NULL);
}
bool stop_serv()
{
if(bServerOnline) //Make sure it actually is online
{
gtk_widget_set_sensitive(start_and_stop_button, false);
bServerOnline = false; //Make sure the server is actually off
add_console_msg("[Main]",notification,"Waiting for all threads to complete");
while(!check_if_all_threads_completed());
/*Wait for safety!*/
add_console_msg("[Main]",notification,"All threads have exited safely");
for(unsigned int i=0; i<rgClients.size(); i++)
{
if(i==0) close(rgClients[0].uiSocketUDP);
close(rgClients[i].uiSocketTCP);
}
/*Wait for safety!*/
add_console_msg("[Main]",notification,"All sockets (including server's) have been closed");
/*Back up all players here*/
add_console_msg("[Main]",notification,"Pushing all accounts to save queue");
for(unsigned int i=0; i<rgAccounts.size(); i++)
{
if(rgAccounts[i].status == active)
{
qSaveAccounts.push(rgAccounts[i]);
}
}
add_console_msg("[Main]",notification,"Waiting for saving queue to finish");
while(!qSaveAccounts.empty()); //Block until qSaveAccounts has been all worked upon
/*Wait for safety!*/
/*Cleaning up for next time init*/
add_console_msg("[Main]",notification,"Cleaning up existing list of sockets, clients, and accounts");
rgAccounts.clear();
/*Wait for safety!*/
rgClients.clear();
/*Wait for safety!*/
rgSockets.clear(); //Clear these parallel mother fuckers!
/*Close databases*/
add_console_msg("[Database]", notification,"Closing database/accounts.db");
sqlite3_close(accounts_db);
accounts_db = NULL;
add_console_msg("[Database]", notification,"Accounts database has successfully closed");
/*Wait for safety!*/
add_console_msg("[Database]", notification,"Closing database/area.db");
sqlite3_close(area_db);
accounts_db = NULL;
add_console_msg("[Database]", notification,"Area database has successfully closed");
gtk_button_set_label((GtkButton*)start_and_stop_button, "Start");
g_signal_handler_disconnect(start_and_stop_button, start_stop_button_ls_id);
start_stop_button_ls_id = g_signal_connect_after(start_and_stop_button, "released", G_CALLBACK(init_serv), NULL);
add_console_msg("[Main]",notification,"Server has stopped successfully");
change_status_msg("<span foreground='red'><b>Offline</b></span> The server has stopped successfully");
add_console_msg("[Server]", important_offline, "[Server is now offline]");
poll(0,0,25);
gtk_widget_set_sensitive(start_and_stop_button, true);
bConsoleActive = false; //Turn off console
return true;
}
return false;
}
static void *
manager_input_loop( DirectThread *thread, void *arg )
{
int len;
struct pollfd pf;
VoodooManager *manager = arg;
manager->millis = direct_clock_get_millis();
while (!manager->quit) {
D_MAGIC_ASSERT( manager, VoodooManager );
pf.fd = manager->fd;
pf.events = POLLIN;
switch (poll( &pf, 1, 100 )) {
case -1:
if (errno != EINTR) {
D_PERROR( "Voodoo/Input: Could not poll() the socket!\n" );
usleep( 200000 );
}
/* fall through */
case 0:
continue;
}
pthread_mutex_lock( &manager->input.lock );
while (manager->input.end == manager->input.max) {
pthread_cond_wait( &manager->input.wait, &manager->input.lock );
if (manager->quit)
break;
}
if (!manager->quit) {
len = recv( manager->fd, manager->input.buffer + manager->input.end,
manager->input.max - manager->input.end, MSG_DONTWAIT );
if (len < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
break;
default:
D_PERROR( "Voodoo/Input: Could not recv() data!\n" );
usleep( 200000 );
}
}
else if (len > 0) {
D_DEBUG( "Voodoo/Input: Received %d bytes...\n", len );
manager->input.end += len;
pthread_cond_broadcast( &manager->input.wait );
}
else
handle_disconnect( manager );
}
pthread_mutex_unlock( &manager->input.lock );
}
return NULL;
}
void *listen_thread_func(void* args) //TCP's thread
{
bThreadActive[0] = true;
thread_args* my_args = (thread_args*) args;
add_console_msg("[Listen]",notification, "Thread has started");
add_console_msg("[Listen]",notification, "Doing safe cleanup of Sockets and Clients");
if(rgSockets.size() > 0)
{
rgSockets.clear();
}
if(rgClients.size() > 0 )
{
rgClients.clear();
}
if(rgAccounts.size() > 0)
{
rgAccounts.clear();
}
pollfd MasterSocket;
MasterSocket.fd = uiMasterSocketTCP;
MasterSocket.events = POLLIN;
rgSockets.push_back(MasterSocket);
soft_client MasterClient(server_fill, uiMasterSocketTCP, uiMasterSocketUDP);
rgClients.push_back(MasterClient);
soft_account MasterAccount;
MasterClient.set_account(MasterAccount);
rgAccounts.push_back(MasterAccount);
int PollActivity;
pollfd* ptrPollSockets;
add_console_msg("[Listen]",notification, "Poll is ready to read incoming connections");
while(bServerOnline)
{
ptrPollSockets = &rgSockets[0];
while(bServerOnline)
{
PollActivity = poll(ptrPollSockets, rgSockets.size(), POLL_DELAY);
if(PollActivity !=0) break;
}
if(PollActivity < 0)
{
perror("tcp-poll");
add_console_msg("[Listen]",warning, "Could not poll sockets");
}
if(rgSockets[0].revents & POLLIN) //Server received a connection
{
unsigned int uiNewSocket;
struct sockaddr_storage SNewClientAddr;
socklen_t iNewClientAddr_Size = sizeof SNewClientAddr;
if((uiNewSocket = accept(uiMasterSocketTCP, (struct sockaddr*)&SNewClientAddr, &iNewClientAddr_Size)) < 0)
{
perror("tcp-accept");
add_console_msg("[Listen]", warning, "Failed to accept client");
}
else
{
add_console_msg("[Listen]", notification, "A client has successfully connected"); //Remove this later
/*Create a pollfd for new socket*/
pollfd NewSocket;
NewSocket.fd = uiNewSocket;
NewSocket.events = POLLIN;
rgSockets.push_back(NewSocket);
/*Create a new client for socket*/
soft_client NewClient(uiNewSocket, SNewClientAddr); //takes TCP socket and udp address and port
soft_account InactiveAccount; //Creates a blank account with inactivityand databaseID equals to 0
NewClient.set_account(InactiveAccount); //This does not increment accounts logged in. You must LOG in to do so.
rgClients.push_back(NewClient);
rgAccounts.push_back(InactiveAccount);
change_status_msg("<span foreground='green'><b>Online</b></span> <b>"+convert_to_str(rgSockets.size()-1)+"</b> user(s) connected");
/*Add to Address Watchlist*/
rgAddressWatch.push_back(SNewClientAddr);
}
}
for(unsigned int i=1; i<rgSockets.size(); i++)
{
if(i != rgClients[i].uiPosition) rgClients[i].uiPosition = i; //Take uiPosition
if(rgSockets[i].revents & POLLIN)
{
int read_val;
char chBuffer[50];
if((read_val = (recv(rgSockets[i].fd, chBuffer, 50, 0))) !=0)
{
/*Players get linked to an account here*/
}
else
{
/*Client has disconnected*/
add_console_msg("[Listen]", notification, "A client has disconnected");
rgClients[i].status = offline; //He will be taken care of in the next step. To keep order
}
}
}
/*Sweep disconnected players*/
for(unsigned int i=1; i<rgClients.size(); i++)
{
if(rgClients[i].status == offline)
{
if(rgClients[i].AccountInfo.status == active)
{
/*Save the account so far*/
add_console_msg("[Listen]",notification, "Client's account was pushed to the save queue");
qSaveAccounts.push(rgAccounts[i]); //Put in save queue
}
close(rgClients[i].uiSocketTCP); //Closes their TCP socket
rgSockets.erase(rgSockets.begin()+i);
rgClients.erase(rgClients.begin()+i); // then remove
rgAccounts.erase(rgAccounts.begin()+i); //remove accounts whether inactive or not
add_console_msg("[Listen]",notification, "Client and socket have been removed from polling");
change_status_msg("<span foreground='green'><b>Online</b></span> <b>"+convert_to_str(rgSockets.size()-1)+"</b> user(s) connected");
}
}
poll(0,0,CPU_DELAY); //Reduce CPU usage
}
ptrPollSockets = NULL;
my_args = NULL;
add_console_msg("[Listen]",notification, "Thread has exited successfully");
bThreadActive[0] = false;
return NULL;
}
smcp_status_t
smcp_plat_process(
smcp_t self
) {
SMCP_EMBEDDED_SELF_HOOK;
smcp_status_t ret = 0;
int tmp;
struct pollfd polls[4];
int poll_count;
poll_count = smcp_plat_update_pollfds(self, polls, sizeof(polls)/sizeof(polls[0]));
if (poll_count > (int)(sizeof(polls)/sizeof(*polls))) {
poll_count = sizeof(polls)/sizeof(*polls);
}
errno = 0;
tmp = poll(polls, poll_count, 0);
// Ensure that poll did not fail with an error.
require_action_string(
errno == 0,
bail,
ret = SMCP_STATUS_ERRNO,
strerror(errno)
);
if(tmp > 0) {
for (tmp = 0; tmp < poll_count; tmp++) {
if (!polls[tmp].revents) {
continue;
} else {
char packet[SMCP_MAX_PACKET_LENGTH+1];
smcp_sockaddr_t remote_saddr = {};
smcp_sockaddr_t local_saddr = {};
ssize_t packet_len = 0;
char cmbuf[0x100];
struct iovec iov = { packet, SMCP_MAX_PACKET_LENGTH };
struct msghdr msg = {
.msg_name = &remote_saddr,
.msg_namelen = sizeof(remote_saddr),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmbuf,
.msg_controllen = sizeof(cmbuf),
};
struct cmsghdr *cmsg;
packet_len = recvmsg(polls[tmp].fd, &msg, 0);
require_action(packet_len > 0, bail, ret = SMCP_STATUS_ERRNO);
packet[packet_len] = 0;
for (
cmsg = CMSG_FIRSTHDR(&msg);
cmsg != NULL;
cmsg = CMSG_NXTHDR(&msg, cmsg)
) {
if (cmsg->cmsg_level != SMCP_IPPROTO
|| cmsg->cmsg_type != SMCP_PKTINFO
) {
continue;
}
// Preinitialize some of the fields.
local_saddr = remote_saddr;
#if SMCP_BSD_SOCKETS_NET_FAMILY==AF_INET6
struct in6_pktinfo *pi = (struct in6_pktinfo *)CMSG_DATA(cmsg);
local_saddr.smcp_addr = pi->ipi6_addr;
local_saddr.sin6_scope_id = pi->ipi6_ifindex;
#elif SMCP_BSD_SOCKETS_NET_FAMILY==AF_INET
struct in_pktinfo *pi = (struct in_pktinfo *)CMSG_DATA(cmsg);
local_saddr.smcp_addr = pi->ipi_addr;
#endif
local_saddr.smcp_port = htons(get_port_for_fd(polls[tmp].fd));
self->plat.pktinfo = *pi;
}
smcp_set_current_instance(self);
smcp_plat_set_remote_sockaddr(&remote_saddr);
smcp_plat_set_local_sockaddr(&local_saddr);
if (self->plat.fd_udp == polls[tmp].fd) {
smcp_plat_set_session_type(SMCP_SESSION_TYPE_UDP);
ret = smcp_inbound_packet_process(self, packet, (coap_size_t)packet_len, 0);
require_noerr(ret, bail);
#if SMCP_DTLS
} else if (self->plat.fd_dtls == polls[tmp].fd) {
smcp_plat_set_session_type(SMCP_SESSION_TYPE_DTLS);
smcp_plat_ssl_inbound_packet_process(
self,
packet,
(coap_size_t)packet_len
);
#endif
}
}
}
}
smcp_handle_timers(self);
bail:
smcp_set_current_instance(NULL);
self->is_responding = false;
return ret;
}
smcp_status_t
smcp_plat_lookup_hostname(const char* hostname, smcp_sockaddr_t* saddr, int flags)
{
smcp_status_t ret;
struct addrinfo hint = {
.ai_flags = AI_ADDRCONFIG,
.ai_family = AF_UNSPEC,
};
struct addrinfo *results = NULL;
struct addrinfo *iter = NULL;
#if SMCP_BSD_SOCKETS_NET_FAMILY != AF_INET6
hint.ai_family = SMCP_BSD_SOCKETS_NET_FAMILY;
#endif
if ((flags & (SMCP_LOOKUP_HOSTNAME_FLAG_IPV4_ONLY|SMCP_LOOKUP_HOSTNAME_FLAG_IPV6_ONLY)) == (SMCP_LOOKUP_HOSTNAME_FLAG_IPV4_ONLY|SMCP_LOOKUP_HOSTNAME_FLAG_IPV6_ONLY)) {
ret = SMCP_STATUS_INVALID_ARGUMENT;
goto bail;
} else if ((flags & SMCP_LOOKUP_HOSTNAME_FLAG_IPV4_ONLY) == SMCP_LOOKUP_HOSTNAME_FLAG_IPV4_ONLY) {
hint.ai_family = AF_INET;
} else if ((flags & SMCP_LOOKUP_HOSTNAME_FLAG_IPV6_ONLY) == SMCP_LOOKUP_HOSTNAME_FLAG_IPV6_ONLY) {
hint.ai_family = AF_INET6;
}
memset(saddr, 0, sizeof(*saddr));
saddr->___smcp_family = SMCP_BSD_SOCKETS_NET_FAMILY;
#if SOCKADDR_HAS_LENGTH_FIELD
saddr->___smcp_len = sizeof(*saddr);
#endif
int error = getaddrinfo(hostname, NULL, &hint, &results);
#if SMCP_BSD_SOCKETS_NET_FAMILY==AF_INET6
if(error && (inet_addr(hostname) != INADDR_NONE)) {
char addr_v4mapped_str[8 + strlen(hostname)];
hint.ai_family = AF_INET6;
hint.ai_flags = AI_ALL | AI_V4MAPPED,
strcpy(addr_v4mapped_str,"::ffff:");
strcat(addr_v4mapped_str,hostname);
error = getaddrinfo(addr_v4mapped_str,
NULL,
&hint,
&results
);
}
#endif
if (EAI_AGAIN == error) {
ret = SMCP_STATUS_WAIT_FOR_DNS;
goto bail;
}
#ifdef TM_EWOULDBLOCK
if (TM_EWOULDBLOCK == error) {
ret = SMCP_STATUS_WAIT_FOR_DNS;
goto bail;
}
#endif
require_action_string(
!error,
bail,
ret = SMCP_STATUS_HOST_LOOKUP_FAILURE,
gai_strerror(error)
);
// Move to the first recognized result
for(iter = results;iter && (iter->ai_family!=AF_INET6 && iter->ai_family!=AF_INET);iter=iter->ai_next);
require_action(
iter,
bail,
ret = SMCP_STATUS_HOST_LOOKUP_FAILURE
);
#if SMCP_BSD_SOCKETS_NET_FAMILY==AF_INET6
if(iter->ai_family == AF_INET) {
struct sockaddr_in *v4addr = (void*)iter->ai_addr;
saddr->sin6_addr.s6_addr[10] = 0xFF;
saddr->sin6_addr.s6_addr[11] = 0xFF;
memcpy(&saddr->sin6_addr.s6_addr[12], &v4addr->sin_addr.s_addr, 4);
} else
#endif
if(iter->ai_family == SMCP_BSD_SOCKETS_NET_FAMILY) {
memcpy(saddr, iter->ai_addr, iter->ai_addrlen);
}
if(SMCP_IS_ADDR_MULTICAST(&saddr->smcp_addr)) {
smcp_t const self = smcp_get_current_instance();
check(self->outbound.packet->tt != COAP_TRANS_TYPE_CONFIRMABLE);
if(self->outbound.packet->tt == COAP_TRANS_TYPE_CONFIRMABLE) {
self->outbound.packet->tt = COAP_TRANS_TYPE_NONCONFIRMABLE;
}
}
ret = SMCP_STATUS_OK;
bail:
if(results)
freeaddrinfo(results);
return ret;
}
bool init_serv()
{
if(!bServerOnline) //Make sure it is offline.
{
activate_console();
gtk_widget_set_sensitive(start_and_stop_button, false); /*Gray it out*/
init_args xml_args = load_external_files();
if(!xml_args.bSuccess)
{
gtk_widget_set_sensitive(start_and_stop_button, true);
add_console_msg("[Server]",error,"has ended init_serv() process");
return false; //End server start up right away
}
bool bErrorFree = true;
for(unsigned int i=0; i<sizeof(bThreadActive)/sizeof(bool); i++) //Start all threads false
{
bThreadActive[i] = false;
}
uiMasterSocketTCP = socket(AF_INET, SOCK_STREAM, 0);
if(uiMasterSocketTCP < 0)
{
perror("tcp-socket");
add_console_msg("[Init]",error,"Could not initialize TCP socket");
return false;
}
uiMasterSocketUDP = socket(AF_INET, SOCK_DGRAM, 0);
if(uiMasterSocketUDP < 0)
{
perror("udp-socket");
add_console_msg("[Init]",error,"Could not initialize UDP socket");
return false;
}
memset(&SBindTCPAddress, 0, sizeof(SBindTCPAddress)); //Memset to make sure
memset(&SBindUDPAddress, 0, sizeof(SBindUDPAddress)); //Memset to make sure
SBindTCPAddress.sin_family = AF_INET;
SBindUDPAddress.sin_family = AF_INET;
SBindTCPAddress.sin_port = htons(xml_args.uiPortTCP);
SBindUDPAddress.sin_port = htons(xml_args.uiPortUDP);
SBindTCPAddress.sin_addr.s_addr = INADDR_ANY;
SBindUDPAddress.sin_addr.s_addr = INADDR_ANY;
if(bind(uiMasterSocketTCP, (struct sockaddr*) &SBindTCPAddress, sizeof SBindTCPAddress) < 0)
{
perror("tcp-bind"); //Perrors are only for us to debug
add_console_msg("[Init]",error, "Could not bind TCP"); //These are for the end-user
bErrorFree = false;
return false;
}
if(bind(uiMasterSocketUDP, (struct sockaddr*) &SBindUDPAddress, sizeof SBindUDPAddress) < 0)
{
perror("udp-bind");
add_console_msg("[Init]",error, "Could not bind UDP");
bErrorFree = false;
return false;
}
if(listen(uiMasterSocketTCP, xml_args.uiMaxQueue) < 0)
{
perror("tcp-listen");
add_console_msg("[Init]",error, "Could not listen on TCP socket");
bErrorFree = false;
return false;
}
bServerOnline = bErrorFree;
if(bErrorFree)
{
/*listen thread*/
thread_args listen_thread_args;
pthread_create(&listen_thread, NULL, listen_thread_func, &listen_thread_args);
/*flow thread*/
thread_args flow_thread_args;
pthread_create(&flow_thread, NULL, flow_thread_func, &flow_thread_args);
thread_args save_thread_args;
pthread_create(&save_thread, NULL, save_thread_func, &save_thread_args);
while(true)
{
poll(0,0, CPU_DELAY);
if(check_if_all_threads_running())
{
gtk_widget_set_sensitive(start_and_stop_button, true); /*ungray*/
gtk_button_set_label((GtkButton*)start_and_stop_button, "Stop");
g_signal_handler_disconnect(start_and_stop_button, start_stop_button_ls_id);
start_stop_button_ls_id = g_signal_connect_after(start_and_stop_button, "released", G_CALLBACK(stop_serv), NULL);
change_status_msg("<span foreground='green'><b>Online</b></span> <b>0</b> user(s) connected");
add_console_msg("[Server]", important_online, "[Server is now online]");
break;
}
}
return true;
}
}
return false;
}
