SequenceLogic/Sleds
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b56ef122dd
Sleds/K2Client/platform_binding.cpp

978 lines
25 KiB
C++
Raw Blame History

/*
Copyright (c) 2013, 2014 IOnU Security Inc. All rights reserved. Copyright (c) 2015, 2016 Sequence Logic, Inc.
Created August 2013 by Kendrick Webster
K2Client/platform_binding.c - implementation of platform_binding.h
(see platform_binding.h for module description)
*/
#include <sys/types.h>
#ifndef WIN32
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <sys/time.h>
#else
#include <Winsock2.h>
#include <ws2tcpip.h>
#pragma comment (lib, "Ws2_32.lib")
#define strdup _strdup
#endif
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>
#ifdef __MACH__
#include <mach/mach_time.h>
#else
#include <time.h>
#endif
#include "constants.h"
#include "util.h"
#include "K2IPC.h"
#include "K2Client.h"
#include "proxy.h"
#include "servers.h"
#include "platform_binding.h"
/* internal plumbing constants and macros */
#define TIMER_MICROSECONDS (1000000 / K2CLI_TIMER_TICKS_PER_SECOND)
#define TIMER_MILLISECONDS (TIMER_MICROSECONDS / 1000)
#define TICK_MINIMUM_MS (TIMER_MILLISECONDS * 2 / 3)
#define LOCALHOST_ADDRESS "127.0.0.1"
/* data accessed only by this module's internal thread */
static SOCKET sockfd = INVALID_SOCKET; /* UDP socket file descriptor */
static struct sockaddr_in servaddr; /* address of K2Daemon server */
static struct sockaddr_in recvaddr; /* address of received packet */
static struct sockaddr_in selfaddr; /* address that <sockfd> is bound to */
static uint8_t buf[K2IPC_MAX_PACKET_SIZE]; /* UDP packet buffer for Rx and Tx */
static char* status_select_offices_copy; /* thread-safe copy of status_select_offices */
static int ticksSkipped; /* count of timer ticks skipped due to insufficient clock time elapsed (glitch detector) */
/* ID of this module's internal thread */
static pthread_t thread_id;
/* inter-thread flags */
static volatile int running; /* TRUE if internal thread was started and not yet stopped */
static volatile int end_thread; /* TRUE if internal thread should exit */
static volatile int login; /* TRUE if a K2Daemon login should be initiated */
static volatile int poll_db; /* TRUE if K2Daemon should be signalled to poll the database */
static volatile int get_stats; /* TRUE if K2Daemon should be signalled to return CPU and memory statistics */
static volatile int have_stats; /* TRUE if stats were received in response to an earlier get_stats */
static volatile int stats_pending; /* TRUE if waiting for stats from daemon */
static volatile int duplicate_urn; /* TRUE if URN is already in use by another client */
/* inter-thread flags for testing */
static volatile int newsock; /* triggers socket close/re-open */
static volatile int no_logout; /* stop internal thread without sending a logout packet */
/*
mutex for serializing access to the module interface functions so that they can
safely be called by multi-threaded library clients
this also ensures that this module's thread state and flags are consistent with
calls to K2_Start(...) et. al.
*/
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_MUTEX pthread_mutex_lock(&mutex);
#define UNLOCK_MUTEX pthread_mutex_unlock(&mutex);
/*
params and callbacks from higher-layer code, registered via K2_Start(...),
modified only when thread is not running
*/
static char urn[128];
static char servers[896];
static k2_message_callback_t upcallMessage;
/*
data and signals from higher-layer code that may be modified while the
thread is running (mutex protected)
*/
static pthread_mutex_t signal_mutex = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_SIGNAL_MUTEX pthread_mutex_lock(&signal_mutex);
#define UNLOCK_SIGNAL_MUTEX pthread_mutex_unlock(&signal_mutex);
static char* volatile status_select_offices; /* from K2_StatusSelect(offices) */
static volatile int status_select_offices_changed;
/*
data to higher-layer code
*/
static pthread_mutex_t stats_mutex = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_STATS_MUTEX pthread_mutex_lock(&stats_mutex);
#define UNLOCK_STATS_MUTEX pthread_mutex_unlock(&stats_mutex);
static char* volatile daemon_stats;
/* this module's callbacks, registered with (called by) lower-layer code */
static void onMessage(const char* info);
static void onEvent(unsigned int event);
static void onDeviceStatus(const char* status);
static void onStats(const char* stats);
static void sendUDP(unsigned int len);
static int stopwatch(int reset);
/* ====================== Implementation functions ====================== */
/*
Functions are grouped into purpose-specific sections with comments
above each section.
Lower-level functions are generally towards the top.
*/
/* ------------------------------ Timing ----------------------------- */
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#define log_skipped_ticks(...)
#else
static void log_skipped_ticks(void)
{
if (ticksSkipped)
{
log_warn("skipped %d timer ticks", ticksSkipped);
ticksSkipped = 0;
}
}
#endif
static int get_uptime_ms()
{
#ifdef __MACH__
const int64_t k = 1000 * 1000;
static mach_timebase_info_data_t s;
if (0 == s.denom)
{
mach_timebase_info(&s);
}
return (int)((mach_absolute_time() * s.numer) / (k * s.denom));
#else
#ifdef WIN32
static double k;
static BOOL i = FALSE;
if (!i)
{
i = TRUE;
LARGE_INTEGER f;
QueryPerformanceFrequency(&f);
k = (double)f.QuadPart / 1000.0;
}
LARGE_INTEGER t;
QueryPerformanceCounter(&t);
return (int)((double)t.QuadPart / k);
#else
const int64_t k = 1000;
const int64_t M = k * k;
struct timespec t;
clock_gettime(CLOCK_MONOTONIC, &t);
return (int)((t.tv_sec * k) + (t.tv_nsec / M));
#endif
#endif
}
/* ----------------------- Message upcalls to lib client callback ----------------------- */
static void upcall_message_1(const char* message)
{
if (NULL != upcallMessage)
{
upcallMessage(message);
}
log_verbose("message: %s", message);
}
/* all message upcalls funnel through this function and its helper (above) */
static void upcall_message(const char* type, const char* info)
{
int n = (int)(strlen(type) + strlen(info) + 1);
char* buf = (char *)malloc(n);
snprintf(buf, n, "%s%s", type, info);
upcall_message_1(buf);
free(buf);
}
/* for generic K2Client messsages */
void upcall_k2cli_message(const char* message)
{
upcall_message(K2_MESSAGE_PREFIX_INTERNAL, message);
}
/* ----------------------- Error message upcalls ----------------------- */
void upcall_error_string(const char* where, const char* error_string)
{
int n = (int)(strlen(K2_MESSAGE_2ND_PREFIX_FOR_ERRORS) + strlen(error_string) + strlen(where) + 3);
char* buf = (char *)malloc(n);
snprintf(buf, n, "%s%s: %s", K2_MESSAGE_2ND_PREFIX_FOR_ERRORS, where, error_string);
upcall_k2cli_message(buf);
free(buf);
}
#ifdef WIN32
/**
* Format a Windows error number. Caller MUST call 'LocalFree' on the returned pointer.
*/
static LPTSTR formatWinError(DWORD nErr)
{
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
nErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpMsgBuf,
0, NULL);
return (LPTSTR)lpMsgBuf;
}
#endif
#ifdef WIN32
void upcall_error(const char* where, int errnum)
{
LPTSTR pErrMsg = formatWinError(errnum);
const char ERR_MSG[] = "Socket error:\n";
size_t nMsgLen = strlen(ERR_MSG) + strlen(pErrMsg) + 1;
char* buf = (char *)malloc(nMsgLen);
snprintf(buf, nMsgLen, "%s%s", ERR_MSG, pErrMsg);
upcall_error_string(where, buf);
free(buf);
LocalFree((LPVOID)pErrMsg);
}
#else
void upcall_error(const char* where, int errnum)
{
upcall_error_string(where, strerror(errnum));
}
#endif
#ifdef WIN32
void upcall_errno(const char* where)
{
upcall_error(where, WSAGetLastError());
}
#else
void upcall_errno(const char* where)
{
upcall_error(where, errno);
}
#endif
/* ----------------------- Network, socket, address boilerplate ----------------------- */
static void init_server_address(void)
{
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(LOCALHOST_ADDRESS);
servaddr.sin_port = htons(K2IPC_DEFAULT_UDP_PORT);
}
static void address_to_string(const struct sockaddr_in* a, char* buf, unsigned int buflen)
{
if (htonl(INADDR_ANY) == a->sin_addr.s_addr)
{
snprintf(buf, buflen, "INADDR_ANY");
}
else
{
#if 0 /*
If or when we decide to support IPV6, we need to use inet_ntop(), however,
it is not availavble under Windows XP, so for now we use inet_ntoa().
The code in this #if 0 block works on all platforms except Windows XP.
*/
#ifdef WIN32
if (!inet_ntop(a->sin_family, (PVOID)&(a->sin_addr), buf, buflen))
#else
if (!inet_ntop(a->sin_family, (const void *)&(a->sin_addr), buf, buflen))
#endif
{
snprintf(buf, buflen, "inet_ntop ERROR");
}
#endif /* 0 */
snprintf(buf, buflen, "%s", inet_ntoa(a->sin_addr));
}
}
static void show_socket_address(void)
{
char a[ADDRESS_STRING_LENGTH], b[ADDRESS_STRING_LENGTH + 64];
address_to_string(&selfaddr, a, sizeof(a));
snprintf(b, sizeof(b), "socket %d bound to %s port %d", sockfd, a, ntohs(selfaddr.sin_port));
upcall_k2cli_message(b);
}
static int get_socket_address(void)
{
socklen_t addr_len = sizeof(selfaddr);
memset(&selfaddr, 0, sizeof(selfaddr));
selfaddr.sin_family = AF_INET;
selfaddr.sin_addr.s_addr = htonl(INADDR_ANY);
selfaddr.sin_port = htons(0);
if (0 != getsockname(sockfd, (struct sockaddr *)&selfaddr, &addr_len))
{
upcall_errno("getsockname");
return 1;
}
show_socket_address();
return 0;
}
static int set_socket_timeout(void)
{
#ifdef WIN32
//DWORD tv = TIMER_MICROSECONDS / 1000; /* milliseconds */
// Windows, being lame again. It seems that you cannot set recieve/send timeouts to be
// less then 500ms. We want 100ms (or the like).
// Set the socket to non-blocking...
u_long mode = 1;
if (0 != ioctlsocket(sockfd, FIONBIO, &mode))
{
upcall_errno("ioctlsocket(FIONBIO)");
return 1;
}
#else
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = TIMER_MICROSECONDS;
//#endif
if (0 != setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv)))
{
upcall_errno("setsockopt(SO_RCVTIMEO)");
return 1;
}
#endif
return 0;
}
static int bind_socket(void)
{
memset(&selfaddr, 0, sizeof(selfaddr));
selfaddr.sin_family = AF_INET;
selfaddr.sin_addr.s_addr = htonl(INADDR_ANY);
selfaddr.sin_port = htons(0);
if (0 != bind(sockfd, (struct sockaddr *)&selfaddr, sizeof(selfaddr)))
{
upcall_errno("bind");
return 1;
}
return get_socket_address();
}
static int init_socket(void)
{
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (INVALID_SOCKET == sockfd)
{
upcall_errno("socket");
return 1;
}
#ifdef __APPLE__
int set = 1;
// Prevent SIGPIPE if socket closed in K2Daemon (iOSX)
if (0 != setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int)))
{
upcall_errno("setsockopt(SO_NOSIGPIPE)");
return 1;
}
#endif
if (set_socket_timeout())
{
return 1;
}
if (bind_socket())
{
return 1;
}
return 0;
}
static int receive_packet(void)
{
socklen_t recvaddr_len;
recvaddr_len = sizeof(recvaddr);
int retVal = 0;
#ifdef WIN32
// Again, lame... See comments in 'set_socket_timeout'
WaitForSingleObject((HANDLE)sockfd, TIMER_MICROSECONDS / 1000);
retVal = (int)recvfrom(sockfd, (char *)buf, sizeof(buf), 0, (struct sockaddr *)&recvaddr, &recvaddr_len);
#else
retVal = (int)recvfrom(sockfd, (char *)buf, sizeof(buf), 0, (struct sockaddr *)&recvaddr, &recvaddr_len);
#endif
return retVal;
}
/* callback from <proxy_start>, sends UDP packet to self */
static void sendToSelf(uint8_t* buf, size_t len)
{
selfaddr.sin_addr.s_addr = inet_addr(LOCALHOST_ADDRESS);
sendto(
sockfd,
#ifdef WIN32
(const char *)buf, (int) len,
#else
buf, len,
#endif
0, (struct sockaddr *)&selfaddr, sizeof(selfaddr));
}
/* callback from <select_server>, called with address of the server that was selected */
static void onServerSelected(const void* address, const char* host)
{
const struct sockaddr_in* addr = (const struct sockaddr_in*)address;
servaddr.sin_addr.s_addr = addr->sin_addr.s_addr;
servaddr.sin_port = addr->sin_port;
if (is_using_proxy)
{
proxy_start(&servaddr, host, urn, sendToSelf);
}
else
{
proxy_stop();
}
}
/* sets <servaddr> to the address of the next server to try to use */
static void next_server_address(void)
{
/*
As a default (in case host lookup fails, etc.) set the server address to loopback.
This will cause this module to receive a K2CLI_ERROR_NOT_CONNECTED after a delay of
a few seconds. Receiving that event will cause this module to pick a new server.
The delay is good. It prevents us from hammering the message upcall with error
messages when the network is down or the server list is bad.
*/
init_server_address();
/* randomly selects a server, tries direct UDP before proxy */
select_server(onServerSelected);
}
/* ----------------------- Main thread procedure loop ----------------------- */
static void timer_tick(void)
{
#define FINISH_LOGIN_TIMEOUT_TICKS 50
static int finish_login = 0;
static int n = 0;
char* p;
seed_random();
if (newsock)
{
newsock = FALSE;
#ifdef WIN32
closesocket(sockfd);
#else
close(sockfd);
#endif
init_socket();
}
if (login)
{
login = FALSE;
next_server_address();
seed_random();
finish_login = FINISH_LOGIN_TIMEOUT_TICKS;
}
if (finish_login)
{
if (!is_using_proxy || is_proxy_session_active)
{
finish_login = 0;
K2Cli_Login();
if (status_select_offices_copy && (0 < strlen(status_select_offices_copy)))
{
K2Cli_StatusSelect(status_select_offices_copy);
}
}
else if (0 == --finish_login)
{
log_warn("timed out waiting for proxy connect or init");
K2Cli_Login(); // lets state machine continue, it will trigger a re-connect to a different server
}
}
if (poll_db)
{
poll_db = FALSE;
K2Cli_Poll_DB();
}
if (status_select_offices_changed)
{
LOCK_SIGNAL_MUTEX
{
p = status_select_offices;
status_select_offices = NULL;
status_select_offices_changed = FALSE;
}
UNLOCK_SIGNAL_MUTEX
free(status_select_offices_copy);
status_select_offices_copy = p;
K2Cli_StatusSelect(status_select_offices_copy);
}
if (get_stats)
{
get_stats = FALSE;
K2Cli_QueryStats();
}
if (++n >= K2CLI_TIMER_TICKS_PER_SECOND) // once per second
{
n = 0;
log_skipped_ticks();
}
K2Cli_Timer();
}
static void* threadproc(void* arg)
{
int n, t0 = 0, t, fatal_error = FALSE;
#ifdef WIN32
/* Initialize the socket library */
WSADATA wsaData;
int nRes = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
if (nRes != 0)
{
upcall_error("WSAStartup(2.2)", nRes);
return NULL;
}
#endif
init_server_address();
if (0 != init_socket())
{
#ifdef WIN32
/* Clean up the socket library */
::WSACleanup();
#endif
return NULL;
}
seed_random_with_bytes(urn, strlen(urn));
seed_random();
set_servers(servers);
/* Start client IPC loop */
K2Cli_Initialize(buf, urn, onMessage, onEvent, onDeviceStatus, onStats, sendUDP, stopwatch);
login = TRUE;
timer_tick();
while (!(end_thread || fatal_error))
{
n = receive_packet();
if (n <= 0)
{
#ifdef WIN32
int nError = WSAGetLastError();
if (WSAEWOULDBLOCK == nError)
#else
if (EAGAIN == errno)
#endif
{
t = get_uptime_ms();
if ((t < t0) || (t >= (t0 + TICK_MINIMUM_MS)))
{
t0 = t;
timer_tick();
}
else
{
++ticksSkipped;
}
}
else
{
#ifdef WIN32
if (WSAECONNRESET == nError) {
closesocket(sockfd);
#else
if (ECONNRESET == errno) {
close(sockfd);
#endif
upcall_k2cli_message("connection reset");
init_socket();
} else {
#ifdef WIN32
upcall_error("recvfrom", nError);
#else
upcall_errno("recvfrom");
#endif
login = TRUE; // lets state machine continue, it will trigger a re-connect to a different server
//fatal_error = TRUE;
}
}
}
else if (!end_thread)
{
K2Cli_HandlePacket(n);
}
}
if (!no_logout)
{
K2Cli_Logout();
K2Cli_Timer();
}
proxy_stop();
clear_servers();
#ifdef WIN32
if (0 != closesocket(sockfd))
#else
if (0 != close(sockfd))
#endif
{
upcall_errno("close(sockfd)");
}
sockfd = INVALID_SOCKET;
#ifdef WIN32
/* Clean up the socket library */
::WSACleanup();
#endif
/*
Normally the <running> flag is updated by the module interface functions that
start or stop the thread. Fatal errors can also cause the thread to stop.
*/
if (fatal_error && !end_thread)
{
running = FALSE;
}
return NULL;
}
/* ------------------ Module interface function helpers ------------------ */
/* These functions run in the library client's thread with this module's mutex locked */
static void start_thread(void)
{
int error = pthread_create(&thread_id, NULL, threadproc, NULL);
if (error)
{
upcall_error("pthread_create", error);
}
else
{
running = TRUE;
}
}
static void stop_thread(void)
{
int error;
char buf[1] = {0};
end_thread = TRUE;
/* send UDP packet to self to awaken thread sooner than timer expiry */
selfaddr.sin_addr.s_addr = inet_addr(LOCALHOST_ADDRESS);
sendto(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&selfaddr, sizeof(selfaddr));
error = pthread_join(thread_id, NULL);
if (error)
{
upcall_error("pthread_join", error);
}
running = end_thread = FALSE;
}
/* runs only when this module's thread is not running, modifies <urn> and <servers> */
static void start(const char* urn_, const char* servers_, k2_message_callback_t onMessage)
{
duplicate_urn = FALSE;
upcallMessage = onMessage;
if (safe_strcpy(urn, sizeof(urn), urn_))
{
upcall_error_string("K2_Start", "URN too long");
}
if (safe_strcpy(servers, sizeof(servers), servers_))
{
upcall_error_string("K2_Start", "Servers string too long");
}
start_thread();
}
/* ----------------------- Callbacks from K2Client.c ----------------------- */
static void onMessage(const char* info)
{
upcall_message(K2_MESSAGE_PREFIX_FROM_CLOUD, info);
}
static void onEvent(unsigned int event)
{
char a[ADDRESS_STRING_LENGTH];
char b[ADDRESS_STRING_LENGTH + 128];
const char* event_text = "(unknown event)";
switch (event)
{
#define X(name, text) case name: event_text = text; break;
K2CLI_EVENTS
#undef X
}
/* translate event to text for message upcall */
switch (event)
{
case K2CLI_ERROR_BAD_OPCODE:
case K2CLI_ERROR_BAD_MSG_SEQUENCE:
case K2CLI_ERROR_BAD_ACK_SEQUENCE:
case K2CLI_ERROR_WRONG_URN:
case K2CLI_ERROR_MISSING_NUL:
case K2CLI_INFO_SPURIOUS_PACKET:
address_to_string(&recvaddr, a, sizeof(a));
snprintf(b, sizeof(b), "%s (from %s port %d)", event_text, a, ntohs(recvaddr.sin_port));
upcall_k2cli_message(b);
break;
default:
upcall_k2cli_message(event_text);
break;
}
/* take special actions based on certain events */
switch (event)
{
case K2CLI_ERROR_NOT_CONNECTED:
if (!duplicate_urn)
{
login = TRUE; /* causes server to be randomly selected from list of servers */
}
break;
case K2CLI_ERROR_DUPLICATE_URN:
duplicate_urn = TRUE; /* avoids endless loop attempting server connect */
break;
}
if (stats_pending && (K2CLI_ERROR_NOT_CONNECTED <= event))
{
onStats(NULL);
}
}
static void onDeviceStatus(const char* status)
{
upcall_message(K2_MESSAGE_PREFIX_DEVICE_STATUS, status);
}
static void onStats(const char* stats)
{
char *p, *q;
if (stats)
{
q = strdup(stats);
}
else
{
q = NULL;
}
LOCK_STATS_MUTEX
{
p = daemon_stats;
daemon_stats = q;
}
UNLOCK_STATS_MUTEX
stats_pending = FALSE;
have_stats = TRUE;
free(p);
}
static void sendUDP(unsigned int len)
{
if (is_using_proxy)
{
proxy_send(buf, len);
}
else
{
sendto(
sockfd,
// Prevent SIGPIPE if socket closed in K2Daemon (Android and Linux)
#ifdef WIN32
(const char *)buf, len, 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
#elif defined (__APPLE__)
buf, len, 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
#else
buf, len, MSG_NOSIGNAL, (struct sockaddr *)&servaddr, sizeof(servaddr));
#endif
}
}
static int stopwatch(int reset)
{
static time_t t0;
time_t t = time(NULL);
if (reset || (0 == t0))
{
t0 = t;
}
return (int)(t - t0);
}
/* ----------------------- Module interface functions for testing (unpublicized) ----------------------- */
/* close old socket and open a new one (to get a new dynamic local port number) */
void K2_Newsock(void)
{
newsock = TRUE;
}
/* stop the client thread without loggging out (produces a heartbeat timeout) */
void K2_Stop_NoLogout(void)
{
no_logout = TRUE;
K2_Stop();
}
/* ----------------------- Module interface functions ----------------------- */
void K2_Start(const char* urn_, const char* servers_, k2_message_callback_t onMessage)
{
initialize_logging();
log_info("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
log_info("K2_Start");
LOCK_MUTEX
{
if (running)
{
stop_thread();
}
start(urn_, servers_, onMessage);
}
UNLOCK_MUTEX
}
void K2_Stop(void)
{
log_info("K2_Stop");
LOCK_MUTEX
{
if (running)
{
stop_thread();
}
}
UNLOCK_MUTEX
log_info("################################################################################");
finalize_logging();
}
void K2_Restart(void)
{
initialize_logging();
log_info("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
log_info("K2_Restart");
LOCK_MUTEX
{
if (!running)
{
start_thread();
}
}
UNLOCK_MUTEX
}
void K2_StatusSelect(const char* offices)
{
char *p, *q;
if (offices && (0 < strlen(offices)))
{
q = strdup(offices);
}
else
{
q = NULL;
}
LOCK_MUTEX
{
LOCK_SIGNAL_MUTEX
{
p = status_select_offices;
status_select_offices = q;
status_select_offices_changed = TRUE;
}
UNLOCK_SIGNAL_MUTEX
}
UNLOCK_MUTEX
free(p);
}
void K2_Poll_DB(void)
{
poll_db = TRUE;
}
int K2_GetStats(char* buf, unsigned int bufsize)
{
int timeout = 700; /* message retry timeout is 6.3 seconds, if > 7 seconds, something is really wrong */
char* stats = NULL;
LOCK_MUTEX
{
have_stats = FALSE;
stats_pending = TRUE;
get_stats = TRUE;
while (running && !have_stats && timeout--)
{
#ifdef WIN32
Sleep(10);
#else
usleep(10000);
#endif
}
LOCK_STATS_MUTEX
{
stats = daemon_stats;
daemon_stats = NULL;
}
UNLOCK_STATS_MUTEX
}
UNLOCK_MUTEX
snprintf(buf, bufsize, "%s", stats ? stats : "");
free(stats);
return stats ? TRUE : FALSE;
}
void K2_SetLogVerbosityLevel(log_verbosity_level_t level)
{
switch (level)
{
case LOG_LEVEL_FATAL: set_log_level(LOG_FATAL); break;
case LOG_LEVEL_ERROR: set_log_level(LOG_ERROR); break;
case LOG_LEVEL_WARNING: set_log_level(LOG_WARNING); break;
case LOG_LEVEL_INFORMATIONAL: set_log_level(LOG_INFORMATIONAL); break;
case LOG_LEVEL_DEBUG: set_log_level(LOG_DEBUG); break;
case LOG_LEVEL_VERBOSE: set_log_level(LOG_VERBOSE); break;
default:
log_error("Log verbosity level %d is unknown, ignoring call to K2_SetLogVerbosityLevel", level);
break;
}
}
Reference in New Issue View Git Blame Copy Permalink