/* Cleanup serial input */
int in_serial_exit(void *in_context, struct flb_config *config)
{
struct flb_in_serial_config *ctx = in_context;
flb_trace("[in_serial] Restoring original termios...");
tcsetattr(ctx->fd, TCSANOW, &ctx->tio_orig);
return 0;
}
/*
* For a server event, the collection event means a new client have arrived, we
* accept the connection and create a new MQTT instance which will wait for
* events/data (MQTT control packages)
*/
int in_mqtt_collect(struct flb_config *config, void *in_context)
{
int fd;
struct flb_in_mqtt_config *ctx = in_context;
struct mqtt_conn *conn;
/* Accept the new connection */
fd = flb_net_accept(ctx->server_fd);
if (fd == -1) {
flb_error("[in_mqtt] could not accept new connection");
return -1;
}
flb_trace("[in_mqtt] [fd=%i] new TCP connection", fd);
conn = mqtt_conn_add(fd, ctx);
if (!conn) {
return -1;
}
return 0;
}
int in_lib_collect(struct flb_config *config, void *in_context)
{
int n;
int ret;
int bytes;
int out_size;
int capacity;
int size;
char *ptr;
char *pack;
struct flb_in_lib_config *ctx = in_context;
capacity = (ctx->buf_size - ctx->buf_len);
/* Allocate memory as required (FIXME: this will be limited in later) */
if (capacity == 0) {
size = ctx->buf_size + LIB_BUF_CHUNK;
ptr = flb_realloc(ctx->buf_data, size);
if (!ptr) {
perror("realloc");
return -1;
}
ctx->buf_data = ptr;
ctx->buf_size = size;
capacity = LIB_BUF_CHUNK;
}
bytes = read(ctx->fd,
ctx->buf_data + ctx->buf_len,
capacity);
flb_trace("in_lib read() = %i", bytes);
if (bytes == -1) {
perror("read");
if (errno == -EPIPE) {
return -1;
}
return 0;
}
ctx->buf_len += bytes;
/* initially we should support json input */
ret = flb_pack_json_state(ctx->buf_data, ctx->buf_len,
&pack, &out_size, &ctx->state);
if (ret == FLB_ERR_JSON_PART) {
flb_warn("lib data incomplete, waiting for more data...");
return 0;
}
else if (ret == FLB_ERR_JSON_INVAL) {
flb_warn("lib data invalid");
flb_pack_state_reset(&ctx->state);
flb_pack_state_init(&ctx->state);
return -1;
}
ctx->buf_len = 0;
capacity = (ctx->msgp_size - ctx->msgp_len);
if (capacity < out_size) {
n = ((out_size - capacity) / LIB_BUF_CHUNK) + 1;
size = ctx->msgp_size + (LIB_BUF_CHUNK * n);
ptr = flb_realloc(ctx->msgp_data, size);
if (!ptr) {
perror("realloc");
flb_free(pack);
flb_pack_state_reset(&ctx->state);
flb_pack_state_init(&ctx->state);
return -1;
}
ctx->msgp_data = ptr;
ctx->msgp_size = size;
}
memcpy(ctx->msgp_data + ctx->msgp_len, pack, out_size);
ctx->msgp_len += out_size;
flb_free(pack);
flb_pack_state_reset(&ctx->state);
flb_pack_state_init(&ctx->state);
return 0;
}
/* 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;
}
}
}
void cb_forward_flush(void *data, size_t bytes,
char *tag, int tag_len,
struct flb_input_instance *i_ins, void *out_context,
struct flb_config *config)
{
int ret = -1;
int entries = 0;
size_t off = 0;
size_t total;
size_t bytes_sent;
msgpack_packer mp_pck;
msgpack_sbuffer mp_sbuf;
msgpack_unpacked result;
struct flb_out_forward_config *ctx = out_context;
struct flb_upstream_conn *u_conn;
(void) i_ins;
(void) config;
flb_debug("[out_forward] request %lu bytes to flush", bytes);
/* Initialize packager */
msgpack_sbuffer_init(&mp_sbuf);
msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
/* Count number of entries, is there a better way to do this ? */
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, data, bytes, &off)) {
entries++;
}
flb_debug("[out_fw] %i entries tag='%s' tag_len=%i",
entries, tag, tag_len);
msgpack_unpacked_destroy(&result);
/* Output: root array */
msgpack_pack_array(&mp_pck, 2);
msgpack_pack_str(&mp_pck, tag_len);
msgpack_pack_str_body(&mp_pck, tag, tag_len);
msgpack_pack_array(&mp_pck, entries);
/* Get a TCP connection instance */
u_conn = flb_upstream_conn_get(ctx->u);
if (!u_conn) {
flb_error("[out_forward] no upstream connections available");
msgpack_sbuffer_destroy(&mp_sbuf);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
/* Write message header */
ret = flb_io_net_write(u_conn, mp_sbuf.data, mp_sbuf.size, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] could not write chunk header");
msgpack_sbuffer_destroy(&mp_sbuf);
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
msgpack_sbuffer_destroy(&mp_sbuf);
total = ret;
/* Write body */
ret = flb_io_net_write(u_conn, data, bytes, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] error writing content body");
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
total += bytes_sent;
flb_upstream_conn_release(u_conn);
flb_trace("[out_forward] ended write()=%d bytes", total);
FLB_OUTPUT_RETURN(FLB_OK);
}
/* 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;
}