/* 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; }