static void tcp_accept_handler(event_loop el, int fd, int mask, void *data) {
char cip[128];
int cport, cfd;
client c;
NOT_USED(el);
NOT_USED(mask);
NOT_USED(data);
if ((cfd = net_tcp_accept(fd, cip, &cport, neterr, sizeof neterr)) == -1) {
xcb_log(XCB_LOG_WARNING, "Accepting client connection: %s", neterr);
return;
}
if ((c = client_new(cfd, fd)) == NULL) {
xcb_log(XCB_LOG_WARNING, "Error registering fd '%d' event for the new client: %s",
cfd, strerror(errno));
close(cfd);
} else {
/* heartbeat */
dstr res = dstr_new("HEARTBEAT|");
dstr ip = getipv4();
xcb_log(XCB_LOG_NOTICE, "Accepted %s:%d, client '%p'", cip, cport, c);
res = dstr_cat(res, ip);
res = dstr_cat(res, "\r\n");
pthread_spin_lock(&c->lock);
if (net_try_write(c->fd, res, dstr_length(res), 100, NET_NONBLOCK) == -1)
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", c, strerror(errno));
pthread_spin_unlock(&c->lock);
dstr_free(ip);
dstr_free(res);
}
}
/* FIXME */
int xcb_query(xcb_context_t c, const char *sid, const char *index, const char *pattern,
struct tm *start, struct tm *end) {
dstr s;
char buf[128];
if (sid == NULL || index == NULL || start == NULL || end == NULL) {
xcb_set_error(c, XCB_ERR_OTHER, "Session ID, index, start or end can't be empty");
return XCB_ERR;
}
s = dstr_new("Q");
s = dstr_cat(s, index);
s = dstr_cat(s, ",");
s = dstr_cat(s, sid);
s = dstr_cat(s, ",");
if (pattern)
s = dstr_cat(s, pattern);
s = dstr_cat(s, ",");
strftime(buf, sizeof buf, "%F %T", start);
s = dstr_cat(s, buf);
s = dstr_cat(s, ",");
strftime(buf, sizeof buf, "%F %T", end);
s = dstr_cat(s, buf);
s = dstr_cat(s, "\r\n");
if (net_try_write(c->fd, s, dstr_length(s), 10, NET_NONBLOCK) == -1) {
xcb_set_error(c, XCB_ERR_IO, NULL);
dstr_free(s);
return XCB_ERR;
}
dstr_free(s);
return XCB_OK;
}
/* FIXME */
int xcb_unsubscribe_all(xcb_context_t c) {
if (net_try_write(c->fd, "UALL\r\n", 6, 10, NET_NONBLOCK) == -1) {
xcb_set_error(c, XCB_ERR_IO, NULL);
return XCB_ERR;
}
return XCB_OK;
}
/* FIXME */
int xcb_index(xcb_context_t c, const char *index) {
dstr s;
if (index == NULL) {
xcb_set_error(c, XCB_ERR_OTHER, "Index can't be empty");
return XCB_ERR;
}
s = dstr_new("INDEX,");
s = dstr_cat(s, index);
s = dstr_cat(s, "\r\n");
if (net_try_write(c->fd, s, dstr_length(s), 10, NET_NONBLOCK) == -1) {
xcb_set_error(c, XCB_ERR_IO, NULL);
dstr_free(s);
return XCB_ERR;
}
dstr_free(s);
return XCB_OK;
}
/* FIXME */
int xcb_indices(xcb_context_t c, const char *sid) {
dstr s;
if (sid == NULL) {
xcb_set_error(c, XCB_ERR_OTHER, "Session ID can't be empty");
return XCB_ERR;
}
s = dstr_new("INDICES,");
s = dstr_cat(s, sid);
s = dstr_cat(s, "\r\n");
if (net_try_write(c->fd, s, dstr_length(s), 10, NET_NONBLOCK) == -1) {
xcb_set_error(c, XCB_ERR_IO, NULL);
dstr_free(s);
return XCB_ERR;
}
dstr_free(s);
return XCB_OK;
}
static void read_quote(event_loop el, int fd, int mask, void *data) {
char *buf;
struct sockaddr_in si;
socklen_t slen = sizeof si;
int nread;
NOT_USED(el);
NOT_USED(mask);
NOT_USED(data);
if ((buf = CALLOC(1, sizeof (Quote))) == NULL)
return;
/* FIXME */
if ((nread = recvfrom(fd, buf, sizeof (Quote), 0, (struct sockaddr *)&si, &slen)) > 0) {
Quote *quote;
struct msg *msg;
quote = (Quote *)buf;
if (quote->thyquote.m_nLen == sizeof (THYQuote)) {
int tlen;
quote->thyquote.m_cJYS[sizeof quote->thyquote.m_cJYS - 1] = '\0';
quote->thyquote.m_cHYDM[sizeof quote->thyquote.m_cHYDM - 1] = '\0';
quote->m_nMSec = 0;
/* for testing */
dlist_rwlock_rdlock(monitors);
if (dlist_length(monitors) > 0) {
char res[512];
dlist_iter_t iter = dlist_iter_new(monitors, DLIST_START_HEAD);
dlist_node_t node;
snprintf(res, sizeof res, "RX '%d,%s,%s,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,"
"%.2f,%.2f,%d,%.2f,%d,%d,%.2f,%d,%.2f,%d'\r\n",
quote->thyquote.m_nTime,
quote->thyquote.m_cHYDM,
quote->thyquote.m_cJYS,
quote->thyquote.m_dZXJ,
quote->thyquote.m_dJKP,
quote->thyquote.m_dZGJ,
quote->thyquote.m_dZDJ,
quote->thyquote.m_dZSP,
quote->thyquote.m_dJSP,
quote->thyquote.m_dZJSJ,
quote->thyquote.m_dJJSJ,
quote->thyquote.m_nCJSL,
quote->thyquote.m_dCJJE,
quote->thyquote.m_nZCCL,
quote->thyquote.m_nCCL,
quote->thyquote.m_dMRJG1,
quote->thyquote.m_nMRSL1,
quote->thyquote.m_dMCJG1,
quote->thyquote.m_nMCSL1);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
pthread_spin_lock(&c->lock);
if (c->flags & CLIENT_CLOSE_ASAP) {
pthread_spin_unlock(&c->lock);
continue;
}
if (net_try_write(c->fd, res, strlen(res), 10, NET_NONBLOCK) == -1) {
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
if (++c->eagcount >= 10)
client_free_async(c);
} else if (c->eagcount)
c->eagcount = 0;
pthread_spin_unlock(&c->lock);
}
dlist_iter_free(&iter);
}
dlist_rwlock_unlock(monitors);
/* FIXME */
if (quote->thyquote.m_nTime == 999999999) {
FREE(buf);
return;
} else if ((tlen = intlen(quote->thyquote.m_nTime)) < 10) {
struct timeval tv;
struct tm lt;
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, <);
if (quote->thyquote.m_cHYDM[0] == 'S' && quote->thyquote.m_cHYDM[1] == 'P')
quote->thyquote.m_nTime *= 1000;
else if (tlen == 6 || tlen == 7)
quote->thyquote.m_nTime *= 100;
lt.tm_hour = quote->thyquote.m_nTime / 10000000;
lt.tm_min = quote->thyquote.m_nTime % 10000000 / 100000;
lt.tm_sec = quote->thyquote.m_nTime % 100000 / 1000;
quote->m_nMSec = quote->thyquote.m_nTime % 1000;
quote->thyquote.m_nTime = mktime(<);
}
/* FIXME */
if (addms) {
struct timeval tv;
dstr contract = dstr_new(quote->thyquote.m_cHYDM);
struct sms *sms;
gettimeofday(&tv, NULL);
if ((sms = table_get_value(times, contract)) == NULL) {
if (NEW(sms)) {
sms->qsec = quote->thyquote.m_nTime;
sms->sec = tv.tv_sec;
sms->msec = tv.tv_usec / 1000;
table_insert(times, contract, sms);
}
} else if (sms->qsec != quote->thyquote.m_nTime) {
sms->qsec = quote->thyquote.m_nTime;
sms->sec = tv.tv_sec;
sms->msec = tv.tv_usec / 1000;
dstr_free(contract);
} else {
int32_t offset;
if ((offset = (tv.tv_sec - sms->sec) * 1000 +
tv.tv_usec / 1000 - sms->msec) > 999)
offset = 999;
quote->m_nMSec = offset;
dstr_free(contract);
}
}
}
if (NEW0(msg) == NULL) {
FREE(buf);
return;
}
msg->data = buf;
msg->refcount = 1;
thrpool_queue(tp, send_quote, msg, NULL, msgfree, NULL);
} else
FREE(buf);
}
static int send_quote(void *data, void *data2) {
struct msg *msg = (struct msg *)data;
Quote *quote;
int status;
NOT_USED(data2);
quote = (Quote *)msg->data;
if (quote->thyquote.m_nLen == sizeof (THYQuote)) {
if (get_logger_level() == __LOG_DEBUG) {
time_t t = (time_t)quote->thyquote.m_nTime;
char datestr[64];
strftime(datestr, sizeof datestr, "%F %T", localtime(&t));
xcb_log(XCB_LOG_DEBUG, "%s.%03d,%s,%s,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,"
"%d,%.2f,%d,%d,%.2f,%d,%.2f,%d",
datestr,
quote->m_nMSec,
quote->thyquote.m_cHYDM,
quote->thyquote.m_cJYS,
quote->thyquote.m_dZXJ,
quote->thyquote.m_dJKP,
quote->thyquote.m_dZGJ,
quote->thyquote.m_dZDJ,
quote->thyquote.m_dZSP,
quote->thyquote.m_dJSP,
quote->thyquote.m_dZJSJ,
quote->thyquote.m_dJJSJ,
quote->thyquote.m_nCJSL,
quote->thyquote.m_dCJJE,
quote->thyquote.m_nZCCL,
quote->thyquote.m_nCCL,
quote->thyquote.m_dMRJG1,
quote->thyquote.m_nMRSL1,
quote->thyquote.m_dMCJG1,
quote->thyquote.m_nMCSL1);
}
/* for testing */
dlist_rwlock_rdlock(monitors);
if (dlist_length(monitors) > 0) {
char res[512];
dlist_iter_t iter = dlist_iter_new(monitors, DLIST_START_HEAD);
dlist_node_t node;
snprintf(res, sizeof res, "TX '%d,%s,%s,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,"
"%d,%.2f,%d,%d,%.2f,%d,%.2f,%d'\r\n",
quote->thyquote.m_nTime,
quote->thyquote.m_cHYDM,
quote->thyquote.m_cJYS,
quote->thyquote.m_dZXJ,
quote->thyquote.m_dJKP,
quote->thyquote.m_dZGJ,
quote->thyquote.m_dZDJ,
quote->thyquote.m_dZSP,
quote->thyquote.m_dJSP,
quote->thyquote.m_dZJSJ,
quote->thyquote.m_dJJSJ,
quote->thyquote.m_nCJSL,
quote->thyquote.m_dCJJE,
quote->thyquote.m_nZCCL,
quote->thyquote.m_nCCL,
quote->thyquote.m_dMRJG1,
quote->thyquote.m_nMRSL1,
quote->thyquote.m_dMCJG1,
quote->thyquote.m_nMCSL1);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
pthread_spin_lock(&c->lock);
if (c->flags & CLIENT_CLOSE_ASAP) {
pthread_spin_unlock(&c->lock);
continue;
}
if (net_try_write(c->fd, res, strlen(res), 10, NET_NONBLOCK) == -1) {
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
if (++c->eagcount >= 10)
client_free_async(c);
} else if (c->eagcount)
c->eagcount = 0;
pthread_spin_unlock(&c->lock);
}
dlist_iter_free(&iter);
}
dlist_rwlock_unlock(monitors);
}
/* FIXME */
if ((status = pgm_send(pgm_sender, msg->data, sizeof (Quote), NULL)) != PGM_IO_STATUS_NORMAL)
xcb_log(XCB_LOG_WARNING, "Sending data failed");
msg_decr(msg);
return 0;
}
static int server_cron(event_loop el, unsigned long id, void *data) {
dlist_iter_t iter;
dlist_node_t node;
NOT_USED(el);
NOT_USED(id);
NOT_USED(data);
if (log_reload) {
close_logger();
if (init_logger("/var/log/xcb/xcb-dp2.log", __LOG_DEBUG) == 0) {
const char *tmp;
pthread_mutex_lock(&cfg_lock);
if ((tmp = variable_retrieve(cfg, "general", "log_level"))) {
if (!strcasecmp(tmp, "debug"))
set_logger_level(__LOG_DEBUG);
else if (!strcasecmp(tmp, "info"))
set_logger_level(__LOG_INFO);
else if (!strcasecmp(tmp, "notice"))
set_logger_level(__LOG_NOTICE);
else if (!strcasecmp(tmp, "warning"))
set_logger_level(__LOG_WARNING);
}
pthread_mutex_unlock(&cfg_lock);
log_reload = 0;
}
/* FIXME */
if (addms)
table_clear(times);
}
if (shut_down) {
if (prepare_for_shutdown() == 0)
exit(0);
xcb_log(XCB_LOG_WARNING, "SIGTERM received, but errors trying to shutdown the server");
}
/* FIXME */
iter = dlist_iter_new(clients_to_close, DLIST_START_HEAD);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
if (c->refcount == 0)
client_free(c);
}
dlist_iter_free(&iter);
/* FIXME */
if (cronloops % 200 == 0) {
char meme[] = "SU OT GNOLEB ERA ESAB RUOY LLA";
int status;
/* heartbeat */
dlist_lock(clients);
if (dlist_length(clients) > 0) {
dstr res = dstr_new("HEARTBEAT|");
dstr ip = getipv4();
res = dstr_cat(res, ip);
res = dstr_cat(res, "\r\n");
iter = dlist_iter_new(clients, DLIST_START_HEAD);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
pthread_spin_lock(&c->lock);
if (net_try_write(c->fd, res, dstr_length(res), 100, NET_NONBLOCK) == -1)
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
pthread_spin_unlock(&c->lock);
}
dlist_iter_free(&iter);
dstr_free(ip);
dstr_free(res);
}
dlist_unlock(clients);
/* FIXME: trying to lower the high CPU load while idle */
if ((status = pgm_send(pgm_sender, meme, sizeof meme, NULL)) != PGM_IO_STATUS_NORMAL)
xcb_log(XCB_LOG_WARNING, "Communication test failed");
}
++cronloops;
return 100;
}
void process_quote(void *data) {
Quote *quote;
struct msg *msg;
quote = (Quote *)data;
if (quote->thyquote.m_nLen == sizeof (tHYQuote)) {
dlist_iter_t iter;
dlist_node_t node;
int tlen;
quote->thyquote.m_cJYS[sizeof quote->thyquote.m_cJYS - 1] = '\0';
quote->thyquote.m_cHYDM[sizeof quote->thyquote.m_cHYDM - 1] = '\0';
quote->m_nMSec = 0;
/* in case of multiple monitors */
dlist_rwlock_rdlock(monitors);
if (dlist_length(monitors) > 0) {
char res[512];
snprintf(res, sizeof res, "RX '%d,%s,%s,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,"
"%.2f,%.2f,%d,%.2f,%d,%d,%.2f,%d,%.2f,%d'\r\n",
quote->thyquote.m_nTime,
quote->thyquote.m_cHYDM,
quote->thyquote.m_cJYS,
quote->thyquote.m_dZXJ,
quote->thyquote.m_dJKP,
quote->thyquote.m_dZGJ,
quote->thyquote.m_dZDJ,
quote->thyquote.m_dZSP,
quote->thyquote.m_dJSP,
quote->thyquote.m_dZJSJ,
quote->thyquote.m_dJJSJ,
quote->thyquote.m_nCJSL,
quote->thyquote.m_dCJJE,
quote->thyquote.m_nZCCL,
quote->thyquote.m_nCCL,
quote->thyquote.m_dMRJG1,
quote->thyquote.m_nMRSL1,
quote->thyquote.m_dMCJG1,
quote->thyquote.m_nMCSL1);
iter = dlist_iter_new(monitors, DLIST_START_HEAD);
while ((node = dlist_next(iter))) {
client c = (client)dlist_node_value(node);
pthread_spin_lock(&c->lock);
if (!(c->flags & CLIENT_CLOSE_ASAP)) {
if (net_try_write(c->fd, res, strlen(res),
10, NET_NONBLOCK) == -1) {
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
if (++c->eagcount >= 3)
client_free_async(c);
} else if (c->eagcount)
c->eagcount = 0;
}
pthread_spin_unlock(&c->lock);
}
dlist_iter_free(&iter);
}
dlist_rwlock_unlock(monitors);
/* FIXME */
if (quote->thyquote.m_nTime == 999999999) {
FREE(data);
return;
/* idiosyncrasy of different timestamps */
} else if ((tlen = intlen(quote->thyquote.m_nTime)) < 10) {
int hour;
struct tm lt;
hour = quote->thyquote.m_nTime / 10000000;
if (tv.tv_sec == 0 || hour == 9 || hour == 21)
gettimeofday(&tv, NULL);
if (prev_hour == 23 && hour == 0)
tv.tv_sec += 24 * 60 * 60;
prev_hour = hour;
localtime_r(&tv.tv_sec, <);
if (quote->thyquote.m_cHYDM[0] == 'S' && quote->thyquote.m_cHYDM[1] == 'P')
quote->thyquote.m_nTime *= 1000;
else if (tlen == 6 || tlen == 7)
quote->thyquote.m_nTime *= 100;
lt.tm_sec = quote->thyquote.m_nTime % 100000 / 1000;
lt.tm_min = quote->thyquote.m_nTime % 10000000 / 100000;
lt.tm_hour = hour;
quote->m_nMSec = quote->thyquote.m_nTime % 1000;
quote->thyquote.m_nTime = mktime(<);
}
/* FIXME: no millisecond field in some exchanges' quotes */
if (addms) {
struct timeval tv;
dstr contract = dstr_new(quote->thyquote.m_cHYDM);
struct sms *sms;
gettimeofday(&tv, NULL);
if ((sms = table_get_value(times, contract)) == NULL) {
if (NEW(sms)) {
sms->qsec = quote->thyquote.m_nTime;
sms->sec = tv.tv_sec;
sms->msec = tv.tv_usec / 1000;
table_insert(times, contract, sms);
}
} else if (sms->qsec != quote->thyquote.m_nTime) {
sms->qsec = quote->thyquote.m_nTime;
sms->sec = tv.tv_sec;
sms->msec = tv.tv_usec / 1000;
dstr_free(contract);
} else {
int32_t offset;
if ((offset = (tv.tv_sec - sms->sec) * 1000 +
tv.tv_usec / 1000 - sms->msec) > 999)
offset = 999;
quote->m_nMSec = offset;
dstr_free(contract);
}
}
if (get_logger_level() == __LOG_DEBUG) {
time_t t = (time_t)quote->thyquote.m_nTime;
char datestr[64];
strftime(datestr, sizeof datestr, "%F %T", localtime(&t));
xcb_log(XCB_LOG_DEBUG, "%s.%03d,%s,%s,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,"
"%d,%.2f,%d,%d,%.2f,%d,%.2f,%d",
datestr,
quote->m_nMSec,
quote->thyquote.m_cHYDM,
quote->thyquote.m_cJYS,
quote->thyquote.m_dZXJ,
quote->thyquote.m_dJKP,
quote->thyquote.m_dZGJ,
quote->thyquote.m_dZDJ,
quote->thyquote.m_dZSP,
quote->thyquote.m_dJSP,
quote->thyquote.m_dZJSJ,
quote->thyquote.m_dJJSJ,
quote->thyquote.m_nCJSL,
quote->thyquote.m_dCJJE,
quote->thyquote.m_nZCCL,
quote->thyquote.m_nCCL,
quote->thyquote.m_dMRJG1,
quote->thyquote.m_nMRSL1,
quote->thyquote.m_dMCJG1,
quote->thyquote.m_nMCSL1);
}
} else
xcb_log(XCB_LOG_DEBUG, "Data '%s' received", data);
if (NEW0(msg) == NULL) {
FREE(data);
return;
}
msg->data = data;
msg->refcount = 1;
thrpool_queue(tp, send_quote, msg, NULL, msgfree, NULL);
}
int main(int argc, char **argv) {
int opt, count = 1;
pthread_t thread;
/* FIXME */
ip = dstr_new("127.0.0.1");
port = 33330;
while ((opt = getopt(argc, argv, "h:p:xt?")) != -1)
switch (opt) {
case 'h':
dstr_free(ip);
ip = dstr_new(optarg);
count += 2;
break;
case 'p':
port = atoi(optarg);
count += 2;
break;
case 'x':
execute = 1;
count += 1;
break;
case 't':
timestamp = 1;
count += 1;
break;
case '?':
default:
usage();
}
if ((tcpsock = net_tcp_nonblock_connect(ip, port, neterr, sizeof neterr)) == -1) {
fprintf(stderr, "Connecting %s:%d: %s\n", ip, port, neterr);
exit(1);
}
if (errno == EINPROGRESS) {
struct pollfd wfd[1];
int res, err = 0;
socklen_t errlen = sizeof err;
wfd[0].fd = tcpsock;
wfd[0].events = POLLOUT;
/* wait for 5 seconds */
if ((res = poll(wfd, 1, 5000)) == -1) {
fprintf(stderr, "Connecting %s:%d: %s\n", ip, port, strerror(errno));
exit(1);
} else if (res == 0) {
errno = ETIMEDOUT;
fprintf(stderr, "Connecting %s:%d: %s\n", ip, port, strerror(errno));
exit(1);
}
if (getsockopt(tcpsock, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
fprintf(stderr, "Connecting %s:%d: %s\n", ip, port, strerror(errno));
exit(1);
}
if (err) {
errno = err;
fprintf(stderr, "Connecting %s:%d: %s\n", ip, port, strerror(errno));
exit(1);
}
}
if (execute && pipe(proceed_pipe) != 0) {
fprintf(stderr, "Error creating pipe: %s\n", strerror(errno));
exit(1);
}
if (execute) {
argc -= count;
argv += count;
if (argc > 0) {
dstr cmd;
int i;
struct pollfd rfd[1];
if (pthread_create(&thread, NULL, recv_thread, NULL) != 0) {
fprintf(stderr, "Error initializing receiver thread\n");
exit(1);
}
cmd = dstr_new(argv[0]);
for (i = 1; i < argc; ++i) {
cmd = dstr_cat(cmd, " ");
cmd = dstr_cat(cmd, argv[i]);
}
cmd = dstr_cat(cmd, "\r\n");
net_try_write(tcpsock, cmd, dstr_length(cmd), 100, NET_NONBLOCK);
/* dstr_free(cmd); */
rfd[0].fd = proceed_pipe[0];
rfd[0].events = POLLIN;
if (poll(rfd, 1, -1) == -1) {
fprintf(stderr, "Error polling: %s\n", strerror(errno));
exit(1);
}
}
} else {
fprintf(stdout, "XCUBE CLI, Copyright (c) 2013-2015, "
"Dalian Futures Information Technology Co., Ltd.\n");
fprintf(stdout, "Type 'help' or '?' for help.\n");
init_readline();
stifle_history(100);
if (pthread_create(&thread, NULL, recv_thread, NULL) != 0) {
fprintf(stderr, "Error initializing receiver thread\n");
exit(1);
}
while (loop) {
char *line;
line = readline(prompt);
if (rl_inited == 0)
rl_inited = 1;
if (line == NULL)
continue;
LTRIM(line);
RTRIM(line);
if (*line) {
add_history(line);
if (tcpsock == -1)
execute_line(line);
else {
net_try_write(tcpsock, line, strlen(line), 100, NET_NONBLOCK);
net_try_write(tcpsock, "\r\n", 2, 100, NET_NONBLOCK);
if (!strncasecmp(line, "quit", 4))
com_quit(NULL);
}
}
FREE(line);
}
}
return 0;
}
/* FIXME */
static void *q_thread(void *data) {
struct crss *crss = (struct crss *)data;
char buf[64];
dstr rid, res = NULL;
db_iterator_t *it;
const char *key, *value;
size_t klen, vlen;
snprintf(buf, sizeof buf, "%p,", crss->c);
rid = dstr_new(buf);
rid = dstr_cat(rid, crss->rid);
it = db_iterator_create(db, db_ro);
db_iterator_seek(it, crss->start, dstr_length(crss->start));
/* seek failed */
if (!db_iterator_valid(it)) {
res = dstr_new(crss->rid);
res = dstr_cat(res, ",1\r\n\r\n");
pthread_spin_lock(&crss->c->lock);
if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1)
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", crss->c, strerror(errno));
pthread_spin_unlock(&crss->c->lock);
goto end;
}
key = db_iterator_key(it, &klen);
while (memcmp(key, crss->stop, dstr_length(crss->stop)) <= 0) {
if (crss->cancel)
break;
if (!strcmp(crss->match, "") || strstr(key, crss->match)) {
value = db_iterator_value(it, &vlen);
res = dstr_new(crss->rid);
res = dstr_cat(res, ",0,");
res = dstr_cat_len(res, key, klen);
res = dstr_cat(res, ",");
res = dstr_cat_len(res, value, vlen);
res = dstr_cat(res, "\r\n");
pthread_spin_lock(&crss->c->lock);
if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1) {
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
crss->c, strerror(errno));
pthread_spin_unlock(&crss->c->lock);
goto end;
}
pthread_spin_unlock(&crss->c->lock);
dstr_free(res);
}
db_iterator_next(it);
if (!db_iterator_valid(it) || crss->cancel)
break;
key = db_iterator_key(it, &klen);
}
res = dstr_new(crss->rid);
res = dstr_cat(res, ",1\r\n\r\n");
pthread_spin_lock(&crss->c->lock);
if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1)
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", crss->c, strerror(errno));
pthread_spin_unlock(&crss->c->lock);
end:
db_iterator_destroy(&it);
dstr_free(res);
table_lock(rids);
table_remove(rids, rid);
table_unlock(rids);
dstr_free(rid);
client_decr(crss->c);
dstr_free(crss->rid);
dstr_free(crss->match);
dstr_free(crss->start);
dstr_free(crss->stop);
FREE(crss);
return NULL;
}
/* FIXME */
void s_command(client c) {
dstr pkey, skey;
int i;
dlist_t dlist;
struct kvd *kvd;
if (dstr_length(c->argv[0]) == 1) {
add_reply_error(c, "index can't be empty\r\n");
return;
}
pkey = dstr_new(c->argv[0] + 1);
skey = dstr_new(pkey);
if (c->argc > 1)
for (i = 1; i < c->argc; ++i) {
skey = dstr_cat(skey, ",");
skey = dstr_cat(skey, c->argv[i]);
}
table_lock(cache);
if ((dlist = table_get_value(cache, pkey))) {
dlist_iter_t iter = dlist_iter_new(dlist, DLIST_START_HEAD);
dlist_node_t node;
/* FIXME: still has room to improve */
while ((node = dlist_next(iter))) {
kvd = (struct kvd *)dlist_node_value(node);
if (dstr_length(kvd->key) >= dstr_length(skey) &&
!memcmp(kvd->key, skey, dstr_length(skey))) {
dstr *fields = NULL;
int nfield = 0;
dstr res, contracts = NULL;
fields = dstr_split_len(kvd->key, dstr_length(kvd->key), ",", 1, &nfield);
res = dstr_new(fields[0]);
if (nfield > 1) {
contracts = dstr_new(fields[1]);
for (i = 2; i < nfield; ++i) {
contracts = dstr_cat(contracts, ",");
contracts = dstr_cat(contracts, fields[i]);
}
}
dstr_free_tokens(fields, nfield);
fields = NULL, nfield = 0;
fields = dstr_split_len(kvd->u.value, dstr_length(kvd->u.value),
",", 1, &nfield);
res = dstr_cat(res, ",");
res = dstr_cat(res, fields[0]);
if (contracts) {
res = dstr_cat(res, ",");
res = dstr_cat(res, contracts);
}
for (i = 1; i < nfield; ++i) {
res = dstr_cat(res, ",");
res = dstr_cat(res, fields[i]);
}
res = dstr_cat(res, "\r\n");
pthread_spin_lock(&c->lock);
if (!(c->flags & CLIENT_CLOSE_ASAP)) {
if (net_try_write(c->fd, res, dstr_length(res),
10, NET_NONBLOCK) == -1) {
xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s",
c, strerror(errno));
if (++c->eagcount >= 3) {
client_free_async(c);
pthread_spin_unlock(&c->lock);
dstr_free(contracts);
dstr_free(res);
dstr_free_tokens(fields, nfield);
table_unlock(cache);
dstr_free(skey);
dstr_free(pkey);
return;
}
} else if (c->eagcount)
c->eagcount = 0;
}
pthread_spin_unlock(&c->lock);
dstr_free(contracts);
dstr_free(res);
dstr_free_tokens(fields, nfield);
}
}
dlist_iter_free(&iter);
}
table_unlock(cache);
table_rwlock_wrlock(subscribers);
if ((dlist = table_get_value(subscribers, pkey)) == NULL) {
if (NEW(kvd)) {
kvd->key = skey;
kvd->u.dlist = dlist_new(NULL, NULL);
dlist_insert_tail(kvd->u.dlist, c);
dlist = dlist_new(cmpkvd, kdfree);
dlist_insert_sort(dlist, kvd);
table_insert(subscribers, pkey, dlist);
} else {
add_reply_error(c, "error allocating memory for kvd\r\n");
dstr_free(skey);
dstr_free(pkey);
}
} else {
if (NEW(kvd)) {
dlist_node_t node;
kvd->key = skey;
kvd->u.dlist = dlist_new(NULL, NULL);
if ((node = dlist_find(dlist, kvd)) == NULL) {
dlist_insert_tail(kvd->u.dlist, c);
dlist_insert_sort(dlist, kvd);
} else {
kdfree(kvd);
kvd = (struct kvd *)dlist_node_value(node);
if (dlist_find(kvd->u.dlist, c) == NULL)
dlist_insert_tail(kvd->u.dlist, c);
}
} else {
add_reply_error(c, "error allocating memory for kvd\r\n");
dstr_free(skey);
}
dstr_free(pkey);
}
table_rwlock_unlock(subscribers);
}
