bool sp_write(struct ring_buf_data* p_pd)
{
log_trace2("sp_write");
if(S_OK != mb_validate(p_pd))
{
// message is not valid
log_trace("ignoring invalid message send request, size: %d", rb_size(p_pd));
return(false);
}
log_trace2("send: -->");
for(uint8_t i=0, imax=rb_size(p_pd); i<imax; ++i)
{
const uint8_t val = rb_at(p_pd, i);
const ssize_t bytesWritten = write(s_fd, &val, 1);
if(1 != bytesWritten)
{
// error
log_err("serial write error");
return(false);
}
log_trace2("%c", val);
}
log_trace2("<--");
// TODO: bug in atmega32 code requires an extra byte to be sent for now
write(s_fd, "\n", 1);
return(true);
}
const char* trigger_release_event(const char** remote_name, const char** button_name)
{
int len = 0;
if (release_remote != NULL) {
release_remote->release_detected = 1;
*remote_name = release_remote->name;
*button_name = release_ncode->name;
len = write_message(message,
PACKET_SIZE + 1,
release_remote->name,
release_ncode->name,
release_suffix,
release_code,
0);
timerclear(&release_time);
release_remote = NULL;
release_ncode = NULL;
release_code = 0;
if (len >= PACKET_SIZE + 1) {
log_error("message buffer overflow");
return NULL;
}
log_trace2("trigger");
return message;
}
return NULL;
}
const char* check_release_event(const char** remote_name, const char** button_name)
{
int len = 0;
if (release_remote2 != NULL) {
*remote_name = release_remote2->name;
*button_name = release_ncode2->name;
len = write_message(message,
PACKET_SIZE + 1,
release_remote2->name,
release_ncode2->name,
release_suffix,
release_code2,
0);
release_remote2 = NULL;
release_ncode2 = NULL;
release_code2 = 0;
if (len >= PACKET_SIZE + 1) {
log_error("message buffer overflow");
return NULL;
}
log_trace2("check");
return message;
}
return NULL;
}
void add_client(int sock)
{
int fd;
socklen_t clilen;
struct sockaddr client_addr;
int flags;
clilen = sizeof(client_addr);
fd = accept(sock, (struct sockaddr*)&client_addr, &clilen);
if (fd == -1) {
log_perror_err("accept() failed for new client");
return;
}
;
if (clin >= MAX_CLIENTS) {
log_error("connection rejected");
shutdown(fd, 2);
close(fd);
return;
}
nolinger(fd);
flags = fcntl(fd, F_GETFL, 0);
if (flags != -1)
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
log_trace2( "accepted new client");
clis[clin].fd = fd;
clis[clin].ident_string = NULL;
clis[clin].first_event = NULL;
clis[clin].pending_code = NULL;
clin++;
}
static int code_func(int fd, char* message, char* arguments)
{
int index;
struct event_info* ei;
struct config_info* ci;
int ret;
if (arguments == NULL)
return send_error(fd, message, "protocol error\n");
index = get_client_index(fd);
if (index == -1)
return send_error(fd, message, "identify yourself first!\n");
if (clis[index].pending_code != NULL)
return send_error(fd, message, "protocol error\n");
log_trace2("%s asking for code -%s-", clis[index].ident_string, arguments);
ei = clis[index].first_event;
if (ei != NULL) {
log_trace2("compare: -%s- -%s-", ei->code, arguments);
if (strcmp(ei->code, arguments) == 0) {
ci = ei->first;
if (ci != NULL) {
log_trace2("result: -%s-", ci->config_string);
ret = send_result(fd, message, ci->config_string);
ei->first = ci->next;
free(ci->config_string);
free(ci);
return ret;
}
clis[index].first_event = ei->next;
free(ei->code);
free(ei);
return send_success(fd, message);
} else {
return send_success(fd, message);
}
}
clis[index].pending_code = strdup(arguments);
if (clis[index].pending_code == NULL)
return send_error(fd, message, "out of memory\n");
return 1;
}
static int queue_get(lirc_t* pdata)
{
if (rec_wptr != rec_rptr) {
*pdata = rec_buf[rec_rptr];
rec_rptr = (rec_rptr + 1) % rec_size;
log_trace2("queue_get: %d", *pdata);
return 0;
}
log_error("uirt2_raw: queue empty");
return -1;
}
/*
* queue
*/
static int queue_put(lirc_t data)
{
int next = (rec_wptr + 1) % rec_size;
log_trace2("queue_put: %d", data);
if (next != rec_rptr) {
rec_buf[rec_wptr] = data;
rec_wptr = next;
return 0;
}
log_error("uirt2_raw: queue full");
return -1;
}
static int handle_input(void)
{
char* code;
char* config_string;
char* prog;
int ret;
struct event_info* e;
struct event_info* n;
int i;
log_trace("input from lircd");
if (lirc_nextcode(&code) != 0)
return 0;
for (i = 0; i < clin; i++) {
n = (struct event_info*) malloc(sizeof(*n));
if (n == NULL)
return 0;
n->code = strdup(code);
if (n->code == NULL) {
free(n);
return 0;
}
/* remove trailing \n */
n->code[strlen(n->code) - 1] = 0;
n->first = NULL;
n->next = NULL;
e = clis[i].first_event;
while (e && e->next)
e = e->next;
if (e == NULL)
clis[i].first_event = n;
else
e->next = n;
}
log_trace2("input from lircd: \"%s\"", code);
while ((ret = lirc_code2charprog(config, code, &config_string, &prog)) == 0 && config_string != NULL) {
int i;
log_trace2("%s: -%s-", prog, config_string);
for (i = 0; i < clin; i++) {
if (strcmp(prog, clis[i].ident_string) == 0)
if (!schedule(i, config_string))
return 0;
}
}
for (i = 0; i < clin; i++) {
if (clis[i].pending_code != NULL) {
char message[strlen(clis[i].pending_code) + 1];
char* backup;
log_trace2("pending_code(%s): -%s-", clis[i].ident_string, clis[i].pending_code);
backup = clis[i].pending_code;
clis[i].pending_code = NULL;
sprintf(message, "CODE %s\n", backup);
(void)code_func(clis[i].fd, message, backup);
free(backup);
}
}
free(code);
return 1;
}
static void loop(int sockfd, int lircdfd)
{
static const int POLLFDS_SIZE =
sizeof(struct pfd_byname) / sizeof(struct pollfd);
union {
struct pfd_byname byname;
struct pollfd byindex[POLLFDS_SIZE];
} poll_fds;
int i;
int ret;
while (1) {
do {
/* handle signals */
if (term) {
log_notice("caught signal");
return;
}
memset(&poll_fds, 0, sizeof(poll_fds));
for (i = 0; i < POLLFDS_SIZE; i += 1)
poll_fds.byindex[i].fd = -1;
poll_fds.byname.sockfd.fd = sockfd;
poll_fds.byname.sockfd.events = POLLIN;
poll_fds.byname.lircdfd.fd = lircdfd;
poll_fds.byname.lircdfd.events = POLLIN;
for (i = 0; i < clin; i++) {
poll_fds.byname.clis[i].fd = clis[i].fd;
poll_fds.byname.clis[i].events = POLLIN;
}
log_trace2("poll");
ret = poll((struct pollfd*) &poll_fds.byindex,
POLLFDS_SIZE,
0);
if (ret == -1 && errno != EINTR) {
log_perror_err("loop: poll() failed");
raise(SIGTERM);
continue;
}
} while (ret == -1 && errno == EINTR);
for (i = 0; i < clin; i++) {
if (poll_fds.byname.clis[i].revents & POLLIN) {
poll_fds.byname.clis[i].revents = 0;
if (get_command(clis[i].fd) == 0) {
remove_client(i);
i--;
if (clin == 0) {
log_info("last client disconnected, shutting down");
return;
}
}
}
}
if (poll_fds.byname.sockfd.revents & POLLIN) {
log_trace("registering local client");
add_client(sockfd);
}
if (poll_fds.byname.lircdfd.revents & POLLIN) {
if (!handle_input()) {
while (clin > 0)
remove_client(0);
log_error("connection lost");
return;
}
}
}
}
