int main(int cgc_argc, char *cgc_argv[])
{
uint8_t *data = NULL;
cgc_init_vault();
cgc_store_in_vault(0, (void *)cgc_handlers, sizeof(cgc_handlers));
while (1)
{
uint8_t msg[6], *newdata;
uint16_t id;
uint32_t len;
if (cgc_read_bytes(&msg[0], 4) == 0)
break;
id = betoh16(*(uint16_t *)&msg[0]);
len = betoh16(*(uint16_t *)&msg[2]);
if (len & 0x8000)
{
if (cgc_read_bytes(&msg[4], 2) == 0)
break;
len = betoh32(*(uint32_t *)&msg[2]) & 0x7fffffff;
}
if (!is_supported(id))
{
ignore:
if (consume_bytes(len) == 0)
break;
continue;
}
newdata = cgc_realloc(data, len);
if (newdata == NULL)
goto ignore;
data = newdata;
if (cgc_read_bytes(data, len) == 0)
break;
handle_msg(id, data, len);
}
cgc_free(data);
return 0;
}
int write_bytes(server *srv, int fd, chunkqueue *cq, size_t num_bytes)
{
return consume_bytes(srv, OP_WRITE, fd, NULL, cq, num_bytes);
}
int copy_bytes(server *srv, void *dst, chunkqueue *cq, size_t num_bytes)
{
return consume_bytes(srv, OP_COPY, -1, dst, cq, num_bytes);
}
int discard_bytes(server *srv, chunkqueue *cq, size_t num_bytes)
{
return consume_bytes(srv, OP_DISCARD, -1, NULL, cq, num_bytes);
}
/* Callback invoked every time an event is triggered for a connection */
int tcp_conn_event(void *data)
{
int ret;
int bytes;
int available;
int size;
char *tmp;
struct mk_event *event;
struct tcp_conn *conn = data;
struct flb_in_tcp_config *ctx = conn->ctx;
jsmntok_t *t;
event = &conn->event;
if (event->mask & MK_EVENT_READ) {
available = (conn->buf_size - conn->buf_len);
if (available < 1) {
if (conn->buf_size + ctx->chunk_size > ctx->buffer_size) {
flb_trace("[in_tcp] fd=%i incoming data exceed limit (%i KB)",
event->fd, (ctx->buffer_size / 1024));
tcp_conn_del(conn);
return -1;
}
size = conn->buf_size + ctx->chunk_size;
tmp = flb_realloc(conn->buf_data, size);
if (!tmp) {
perror("realloc");
return -1;
}
flb_trace("[in_tcp] fd=%i buffer realloc %i -> %i",
event->fd, conn->buf_size, size);
conn->buf_data = tmp;
conn->buf_size = size;
available = (conn->buf_size - conn->buf_len);
}
/* Read data */
bytes = read(conn->fd,
conn->buf_data + conn->buf_len, available);
if (bytes <= 0) {
flb_trace("[in_tcp] fd=%i closed connection", event->fd);
tcp_conn_del(conn);
return -1;
}
flb_trace("[in_tcp] read()=%i pre_len=%i now_len=%i",
bytes, conn->buf_len, conn->buf_len + bytes);
conn->buf_len += bytes;
conn->buf_data[conn->buf_len] = '\0';
/* Strip CR or LF if found at first byte */
if (conn->buf_data[0] == '\r' || conn->buf_data[0] == '\n') {
/* Skip message with one byte with CR or LF */
flb_trace("[in_tcp] skip one byte message with ASCII code=%i",
conn->buf_data[0]);
consume_bytes(conn->buf_data, 1, conn->buf_len);
conn->buf_len--;
}
/* JSON Format handler */
char *pack;
int out_size;
ret = flb_pack_json_state(conn->buf_data, conn->buf_len,
&pack, &out_size, &conn->pack_state);
if (ret == FLB_ERR_JSON_PART) {
flb_debug("[in_serial] JSON incomplete, waiting for more data...");
return 0;
}
else if (ret == FLB_ERR_JSON_INVAL) {
flb_debug("[in_serial] invalid JSON message, skipping");
flb_pack_state_reset(&conn->pack_state);
flb_pack_state_init(&conn->pack_state);
conn->pack_state.multiple = FLB_TRUE;
return -1;
}
/*
* Given the Tokens used for the packaged message, append
* the records and then adjust buffer.
*/
process_pack(conn, pack, out_size);
t = &conn->pack_state.tokens[0];
consume_bytes(conn->buf_data, t->end, conn->buf_len);
conn->buf_len -= t->end;
conn->buf_data[conn->buf_len] = '\0';
flb_pack_state_reset(&conn->pack_state);
flb_pack_state_init(&conn->pack_state);
conn->pack_state.multiple = FLB_TRUE;
flb_free(pack);
return bytes;
}
if (event->mask & MK_EVENT_CLOSE) {
flb_trace("[in_tcp] fd=%i hangup", event->fd);
tcp_conn_del(conn);
return -1;
}
return 0;
}
/* Callback triggered when some serial msgs are available */
int in_serial_collect(struct flb_config *config, void *in_context)
{
int ret;
int bytes;
int available;
int len;
int hits;
char *sep;
char *buf;
struct flb_in_serial_config *ctx = in_context;
while (1) {
available = (sizeof(ctx->buf_data) -1) - ctx->buf_len;
if (available > 1) {
bytes = read(ctx->fd, ctx->buf_data + ctx->buf_len, available);
if (bytes == -1) {
if (errno == EPIPE || errno == EINTR) {
return -1;
}
return 0;
}
else if (bytes == 0) {
return 0;
}
}
ctx->buf_len += bytes;
/* Always set a delimiter to avoid buffer trash */
ctx->buf_data[ctx->buf_len] = '\0';
/* Check if our buffer is full */
if (ctx->buffer_id + 1 == SERIAL_BUFFER_SIZE) {
ret = flb_engine_flush(config, &in_serial_plugin);
if (ret == -1) {
ctx->buffer_id = 0;
}
}
sep = NULL;
buf = ctx->buf_data;
len = ctx->buf_len;
hits = 0;
/* Handle FTDI handshake */
if (ctx->buf_data[0] == '\0') {
consume_bytes(ctx->buf_data, 1, ctx->buf_len);
ctx->buf_len--;
}
/* Strip CR or LF if found at first byte */
if (ctx->buf_data[0] == '\r' || ctx->buf_data[0] == '\n') {
/* Skip message with one byte with CR or LF */
flb_trace("[in_serial] skip one byte message with ASCII code=%i",
ctx->buf_data[0]);
consume_bytes(ctx->buf_data, 1, ctx->buf_len);
ctx->buf_len--;
}
if (ctx->separator) {
while ((sep = strstr(ctx->buf_data, ctx->separator))) {
len = (sep - ctx->buf_data);
if (len > 0) {
/* process the line based in the separator position */
process_line(buf, len, ctx);
consume_bytes(ctx->buf_data, len + ctx->sep_len, ctx->buf_len);
ctx->buf_len -= (len + ctx->sep_len);
hits++;
}
else {
consume_bytes(ctx->buf_data, ctx->sep_len, ctx->buf_len);
ctx->buf_len -= ctx->sep_len;
}
ctx->buf_data[ctx->buf_len] = '\0';
}
if (hits == 0 && available <= 1) {
flb_debug("[in_serial] no separator found, no more space");
ctx->buf_len = 0;
return 0;
}
}
else {
/* Process and enqueue the received line */
process_line(ctx->buf_data, ctx->buf_len, ctx);
ctx->buf_len = 0;
}
}
}
/* Callback triggered when some serial msgs are available */
int in_serial_collect(struct flb_config *config, void *in_context)
{
int ret;
int bytes = 0;
int available;
int len;
int hits;
char *sep;
char *buf;
jsmntok_t *t;
struct flb_in_serial_config *ctx = in_context;
while (1) {
available = (sizeof(ctx->buf_data) -1) - ctx->buf_len;
if (available > 1) {
bytes = read(ctx->fd, ctx->buf_data + ctx->buf_len, available);
if (bytes == -1) {
if (errno == EPIPE || errno == EINTR) {
return -1;
}
return 0;
}
else if (bytes == 0) {
return 0;
}
}
ctx->buf_len += bytes;
/* Always set a delimiter to avoid buffer trash */
ctx->buf_data[ctx->buf_len] = '\0';
/* Check if our buffer is full */
if (ctx->buffer_id + 1 == SERIAL_BUFFER_SIZE) {
ret = flb_engine_flush(config, &in_serial_plugin);
if (ret == -1) {
ctx->buffer_id = 0;
}
}
sep = NULL;
buf = ctx->buf_data;
len = ctx->buf_len;
hits = 0;
/* Handle FTDI handshake */
if (ctx->buf_data[0] == '\0') {
consume_bytes(ctx->buf_data, 1, ctx->buf_len);
ctx->buf_len--;
}
/* Strip CR or LF if found at first byte */
if (ctx->buf_data[0] == '\r' || ctx->buf_data[0] == '\n') {
/* Skip message with one byte with CR or LF */
flb_trace("[in_serial] skip one byte message with ASCII code=%i",
ctx->buf_data[0]);
consume_bytes(ctx->buf_data, 1, ctx->buf_len);
ctx->buf_len--;
}
/* Handle the case when a Separator is set */
if (ctx->separator) {
while ((sep = strstr(ctx->buf_data, ctx->separator))) {
len = (sep - ctx->buf_data);
if (len > 0) {
/* process the line based in the separator position */
process_line(buf, len, ctx);
consume_bytes(ctx->buf_data, len + ctx->sep_len, ctx->buf_len);
ctx->buf_len -= (len + ctx->sep_len);
hits++;
}
else {
consume_bytes(ctx->buf_data, ctx->sep_len, ctx->buf_len);
ctx->buf_len -= ctx->sep_len;
}
ctx->buf_data[ctx->buf_len] = '\0';
}
if (hits == 0 && available <= 1) {
flb_debug("[in_serial] no separator found, no more space");
ctx->buf_len = 0;
return 0;
}
}
else if (ctx->format == FLB_SERIAL_FORMAT_JSON) {
/* JSON Format handler */
char *pack;
int out_size;
ret = flb_pack_json_state(ctx->buf_data, ctx->buf_len,
&pack, &out_size, &ctx->pack_state);
if (ret == FLB_ERR_JSON_PART) {
flb_debug("[in_serial] JSON incomplete, waiting for more data...");
return 0;
}
else if (ret == FLB_ERR_JSON_INVAL) {
flb_debug("[in_serial] invalid JSON message, skipping");
flb_pack_state_reset(&ctx->pack_state);
flb_pack_state_init(&ctx->pack_state);
ctx->pack_state.multiple = FLB_TRUE;
return -1;
}
/*
* Given the Tokens used for the packaged message, append
* the records and then adjust buffer.
*/
process_pack(ctx, pack, out_size);
flb_free(pack);
t = &ctx->pack_state.tokens[0];
consume_bytes(ctx->buf_data, t->end, ctx->buf_len);
ctx->buf_len -= t->end;
ctx->buf_data[ctx->buf_len] = '\0';
flb_pack_state_reset(&ctx->pack_state);
flb_pack_state_init(&ctx->pack_state);
ctx->pack_state.multiple = FLB_TRUE;
}
else {
/* Process and enqueue the received line */
process_line(ctx->buf_data, ctx->buf_len, ctx);
ctx->buf_len = 0;
}
}
return 0;
}
