static void
write_out_stream (const char *filename, char *data) {
vmbuf_reset(&write_buffer);
vmbuf_sprintf(&write_buffer, "{ \"message\": \"%s|%s|", hostname, filename);
json_escape_str_vmb(&write_buffer, data);
vmbuf_strcpy(&write_buffer, "\" }");
vmbuf_chrcpy(&write_buffer, '\0');
if (write_to_file) {
if (0 > file_writer_write(&fw, vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer))) {
LOGGER_ERROR("%s", "failed write attempt on outfile| aborting to diagnose!");
abort();
}
return;
}
int threshold = INTERFACE_ONERROR_RETRY_THRESHOLD;
while (0 > post_to_interface(vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer)) && (0 < threshold--)) {
if (0 == post_to_interface(vmbuf_data(&write_buffer), vmbuf_wlocpos(&write_buffer))) {
LOGGER_ERROR("post failed to %s, issuing reattempt#%d", eserv.hostname, threshold);
--failure;
break;
}
}
}
int http_server_sendfile2(const char *filename, const char *additional_headers, const char *ext) {
if (0 == *filename)
filename = ".";
struct http_server_context *ctx = http_server_get_context();
int ffd = open(filename, O_RDONLY);
if (ffd < 0)
return HTTP_SERVER_NOT_FOUND;
struct stat st;
if (0 > fstat(ffd, &st)) {
LOGGER_PERROR(filename);
close(ffd);
return HTTP_SERVER_NOT_FOUND;
}
if (S_ISDIR(st.st_mode)) {
close(ffd);
return 1;
}
vmbuf_reset(&ctx->header);
if (NULL != ext)
http_server_header_start(HTTP_STATUS_200, mime_types_by_ext(ext));
else
http_server_header_start(HTTP_STATUS_200, mime_types_by_filename(filename));
vmbuf_sprintf(&ctx->header, "%s%lu", CONTENT_LENGTH, st.st_size);
if (additional_headers)
vmbuf_strcpy(&ctx->header, additional_headers);
http_server_header_close();
int res = http_server_sendfile_payload(ffd, st.st_size);
close(ffd);
if (0 > res)
LOGGER_PERROR(filename);
return res;
}
static void
trigger_writer (
const char *filename,
struct logz_file_def *filedef) {
vmbuf_reset(&write_buffer);
ssize_t res;
char *fn = basename(ribs_strdup(filename));
while(1) {
vmbuf_reset(&write_buffer);
res = read(filedef->fd, vmbuf_wloc(&write_buffer), (BUFSIZ + 1024) &~ 1024);
filedef->size += res;
lseek (filedef->fd, filedef->size, SEEK_SET);
if (0 > vmbuf_wseek(&write_buffer, res)) {
LOGGER_ERROR("%s", "wseek error");
break;
} else if (0 > res) {
LOGGER_ERROR("%s", "read error"); // EAGAIN is handled by poller
break;
} else if (0 < res) {
// initial sanitizer
vmbuf_chrcpy(&write_buffer, '\0'); // kill garbage
char *data = ribs_strdup(vmbuf_data(&write_buffer));
//data = strchr(data, '\n') + 1; // skip broken data from initial buffer start. we read from where the file was first observed
ssize_t write_depth = res = strlen(data);
// line doesn't end here
if (data[res - 1] != '\n') {
char *datafringe = ribs_strdup((char *)memrchr(data, '\n', res));
if (SSTRISEMPTY(datafringe))
break;
write_depth = strlen(data) - strlen(datafringe);
*(data + write_depth) = 0;
if (filedef->size != 0) {
char *rebalanced_data = write_file_fringe(fn, data, filedef->fd);
if (NULL != rebalanced_data) {
data = rebalanced_data;
write_depth = strlen(data);
}
}
thashtable_rec_t *rec = thashtable_lookup(delta_push, &filedef->fd, sizeof(filedef->fd));
struct vmbuf kdelta = *(struct vmbuf *)thashtable_get_val(rec);
vmbuf_strcpy(&kdelta, datafringe);
vmbuf_chrcpy(&kdelta, '\0');
}
vmbuf_reset(&write_buffer);
vmbuf_memcpy(&write_buffer, data, write_depth);
vmbuf_chrcpy(&write_buffer, '\0');
write_out_stream(fn, ribs_strdup(vmbuf_data(&write_buffer)));
} else if (0 == res) {
break;
}
}
}
struct http_client_context *http_client_pool_post_request_init(struct http_client_pool *http_client_pool,
struct in_addr addr, uint16_t port, const char *hostname, const char *format, ...) {
struct http_client_context *cctx = http_client_pool_create_client(http_client_pool, addr, port, NULL);
if (NULL == cctx)
return NULL;
vmbuf_strcpy(&cctx->request, "POST ");
va_list ap;
va_start(ap, format);
vmbuf_vsprintf(&cctx->request, format, ap);
va_end(ap);
vmbuf_sprintf(&cctx->request, " HTTP/1.1\r\nHost: %s", hostname);
return cctx;
}
int http_client_pool_get_request(struct http_client_pool *http_client_pool, struct in_addr addr, uint16_t port, const char *hostname, const char *format, ...) {
struct http_client_context *cctx = http_client_pool_create_client(http_client_pool, addr, port, NULL);
if (NULL == cctx)
return -1;
vmbuf_strcpy(&cctx->request, "GET ");
va_list ap;
va_start(ap, format);
vmbuf_vsprintf(&cctx->request, format, ap);
va_end(ap);
vmbuf_sprintf(&cctx->request, " HTTP/1.1\r\nHost: %s\r\n\r\n", hostname);
if (0 > http_client_send_request(cctx)) {
http_client_free(http_client_pool, cctx);
return -1;
}
return 0;
}
int http_server_generate_dir_list(const char *URI) {
struct http_server_context *ctx = http_server_get_context();
struct vmbuf *payload = &ctx->payload;
const char *dir = URI;
if (*dir == '/') ++dir;
if (0 == *dir)
dir = ".";
vmbuf_sprintf(payload, "<html><head><title>Index of %s</title></head>", dir);
vmbuf_strcpy(payload, "<body>");
vmbuf_sprintf(payload, "<h1>Index of %s</h1><hr>", dir);
vmbuf_sprintf(payload, "<a href=\"..\">../</a><br><br>");
vmbuf_sprintf(payload, "<table width=\"100%%\" border=\"0\">");
DIR *d = opendir(dir);
int error = 0;
if (d) {
struct dirent de, *dep;
while (0 == readdir_r(d, &de, &dep) && dep) {
if (de.d_name[0] == '.')
continue;
struct stat st;
if (0 > fstatat(dirfd(d), de.d_name, &st, 0)) {
vmbuf_sprintf(payload, "<tr><td>ERROR: %s</td><td>N/A</td></tr>", de.d_name);
continue;
}
const char *slash = (S_ISDIR(st.st_mode) ? "/" : "");
struct tm t_res, *t;
t = localtime_r(&st.st_mtime, &t_res);
vmbuf_strcpy(payload, "<tr>");
vmbuf_sprintf(payload, "<td><a href=\"%s%s\">%s%s</a></td>", de.d_name, slash, de.d_name, slash);
vmbuf_strcpy(payload, "<td>");
if (t)
vmbuf_strftime(payload, "%F %T", t);
vmbuf_strcpy(payload, "</td>");
vmbuf_sprintf(payload, "<td>%lu</td>", st.st_size);
vmbuf_strcpy(payload, "</tr>");
}
closedir(d);
}
vmbuf_strcpy(payload, "<tr><td colspan=3><hr></td></tr></table>");
vmbuf_sprintf(payload, "<address>RIBS 2.0 Port %hu</address></body>", ctx->server->port);
vmbuf_strcpy(payload, "</html>");
return error;
}
static int
http_client_pool_post_request2(
struct http_client_pool *http_client_pool,
struct in_addr addr, uint16_t port, const char *hostname,
const char *data, size_t size_of_data, const char *format, ...) {
struct http_client_context *cctx = http_client_pool_create_client2(http_client_pool, addr, port, hostname, NULL);
if (NULL == cctx)
return -1;
vmbuf_reset(&cctx->request);
vmbuf_strcpy(&cctx->request, "POST ");
va_list ap;
va_start(ap, format);
vmbuf_vsprintf(&cctx->request, format, ap);
va_end(ap);
vmbuf_sprintf(&cctx->request, " HTTP/1.1\r\nHost: %s\r\nContent-Type: application/json\r\nContent-Length: %zu\r\n\r\n", hostname, size_of_data);
vmbuf_memcpy(&cctx->request, data, size_of_data);
vmbuf_chrcpy(&cctx->request, '\0');
if (0 > http_client_send_request(cctx))
return http_client_free(cctx), -1;
return 0;
}
void http_server_header_close(void) {
struct http_server_context *ctx = http_server_get_context();
vmbuf_strcpy(&ctx->header, CRLFCRLF);
}
int sendemail2(struct sendemail_mta *mta, struct email *email) {
if (NULL == mta) {
mta = global_mta;
}
int cfd = socket(PF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
if (0 > cfd)
return LOGGER_PERROR("sendemail: socket"), -1;
const int option = 1;
if (0 > setsockopt(cfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)))
return LOGGER_PERROR("sendemail: setsockopt SO_REUSEADDR"), close(cfd), -1;
if (0 > setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &option, sizeof(option)))
return LOGGER_PERROR("sendemail: setsockopt TCP_NODELAY"), close(cfd), -1;
if (0 > connect(cfd, (struct sockaddr *)&mta->saddr, sizeof(mta->saddr)) && EINPROGRESS != errno)
return LOGGER_PERROR("sendemail: connect"), close(cfd), -1;
if (0 > ribs_epoll_add(cfd, EPOLLIN | EPOLLOUT | EPOLLET, current_ctx))
return close(cfd), -1;
struct vmbuf response = VMBUF_INITIALIZER;
struct vmbuf request = VMBUF_INITIALIZER;
vmbuf_init(&response, 4096);
vmbuf_init(&request, 4096);
int code = -1;
size_t ofs = 0;
READ_AND_CHECK(220);
vmbuf_sprintf(&request, "EHLO %s\r\n", mta->myhost);
SEND_DATA;
READ_AND_CHECK(250);
vmbuf_sprintf(&request, "MAIL FROM:<%s>\r\n", email->from);
SEND_DATA;
READ_AND_CHECK(250);
struct rcptlist *rcpt = &email->rcpt;
while (rcpt) {
vmbuf_sprintf(&request, "RCPT TO:<%s>\r\n", rcpt->to);
SEND_DATA;
READ_AND_CHECK(250);
rcpt = rcpt->next;
}
vmbuf_strcpy(&request, "DATA\r\n");
SEND_DATA;
READ_AND_CHECK(354);
struct iovec iov[2]= {
[0] = {
.iov_base = email->data,
.iov_len = strlen(email->data)
},
