proto: Get rid of the mixed usage of LogProtoServerOptionsStorage

Signed-off-by: Hofi <hofione@gmail.com>

Author: HofiOne

lib/cfg-grammar-internal.c

@@ -30,7 +30,7 @@ LogSchedulerOptions *last_scheduler_options;
 LogParser *last_parser;
 FilterExprNode *last_filter_expr;
 LogSourceOptions *last_source_options;
-LogProtoServerOptions *last_proto_server_options;
+LogProtoServerOptionsStorage *last_proto_server_options;
 LogProtoClientOptions *last_proto_client_options;
 LogReaderOptions *last_reader_options;
 LogWriterOptions *last_writer_options;

lib/cfg-grammar-internal.h

@@ -71,7 +71,7 @@
 
 extern LogSourceOptions *last_source_options;
 extern LogReaderOptions *last_reader_options;
-extern LogProtoServerOptions *last_proto_server_options;
+extern LogProtoServerOptionsStorage *last_proto_server_options;
 extern LogProtoClientOptions *last_proto_client_options;
 extern LogWriterOptions *last_writer_options;
 extern FilePermOptions *last_file_perm_options;

lib/cfg-grammar.y

@@ -1440,7 +1440,7 @@ source_reader_option
 	| KW_LOG_FETCH_LIMIT '(' positive_integer ')'	{ last_reader_options->fetch_limit = $3; }
         | KW_FORMAT '(' string ')'              { last_reader_options->parse_options.format = g_strdup($3); free($3); }
         | { last_source_options = &last_reader_options->super; } source_option
-        | { last_proto_server_options = &last_reader_options->proto_options.super; } source_proto_option
+        | { last_proto_server_options = &last_reader_options->proto_options; } source_proto_option
         | { last_msg_format_options = &last_reader_options->parse_options; } msg_format_option
 	;
 
@@ -1459,8 +1459,8 @@ source_proto_option
                         "unknown encoding \"%s\"", $3);
             free($3);
           }
-        | KW_LOG_MSG_SIZE '(' positive_integer ')'      { last_proto_server_options->max_msg_size = $3; }
-        | KW_TRIM_LARGE_MESSAGES '(' yesno ')'          { last_proto_server_options->trim_large_messages = $3; }
+        | KW_LOG_MSG_SIZE '(' positive_integer ')'      { last_proto_server_options->super.max_msg_size = $3; }
+        | KW_TRIM_LARGE_MESSAGES '(' yesno ')'          { last_proto_server_options->super.trim_large_messages = $3; }
         ;
 
 host_resolve_option

lib/logproto/Makefile.am

@@ -27,7 +27,7 @@ logproto_sources = \
 	lib/logproto/logproto-text-client.c  \
 	lib/logproto/logproto-text-server.c	\
 	lib/logproto/logproto-http-server.c \
-	lib/logproto/logproto-http-scraper-responder.h \
+	lib/logproto/logproto-http-scraper-responder.c \
 	lib/logproto/logproto-record-server.c \
 	lib/logproto/logproto-builtins.c
 

lib/logproto/logproto-buffered-server.c

@@ -99,7 +99,7 @@ log_proto_buffered_server_convert_from_raw(LogProtoBufferedServer *self, const g
                       if (avail_in > sizeof(state->raw_buffer_leftover))
                         {
                           msg_error("Invalid byte sequence, the remaining raw buffer is larger than the supported leftover size",
-                                    evt_tag_str("encoding", self->super.options->encoding),
+                                    evt_tag_str("encoding", self->super.options->super.encoding),
                                     evt_tag_int("avail_in", avail_in),
                                     evt_tag_int("leftover_size", sizeof(state->raw_buffer_leftover)));
                           goto error;
@@ -108,15 +108,15 @@ log_proto_buffered_server_convert_from_raw(LogProtoBufferedServer *self, const g
                       state->raw_buffer_leftover_size = avail_in;
                       state->raw_buffer_size -= avail_in;
                       msg_trace("Leftover characters remained after conversion, delaying message until another chunk arrives",
-                                evt_tag_str("encoding", self->super.options->encoding),
+                                evt_tag_str("encoding", self->super.options->super.encoding),
                                 evt_tag_int("avail_in", avail_in));
                       goto success;
                     }
                 }
               else
                 {
                   msg_error("Byte sequence too short, cannot convert an individual frame in its entirety",
-                            evt_tag_str("encoding", self->super.options->encoding),
+                            evt_tag_str("encoding", self->super.options->super.encoding),
                             evt_tag_int("avail_in", avail_in));
                   goto error;
                 }
@@ -125,25 +125,25 @@ log_proto_buffered_server_convert_from_raw(LogProtoBufferedServer *self, const g
               state->pending_buffer_end = state->buffer_size - avail_out;
               /* extend the buffer */
 
-              if (state->buffer_size < self->super.options->max_buffer_size)
+              if (state->buffer_size < self->super.options->super.max_buffer_size)
                 {
                   state->buffer_size *= 2;
-                  if (state->buffer_size > self->super.options->max_buffer_size)
-                    state->buffer_size = self->super.options->max_buffer_size;
+                  if (state->buffer_size > self->super.options->super.max_buffer_size)
+                    state->buffer_size = self->super.options->super.max_buffer_size;
 
                   self->buffer = g_realloc(self->buffer, state->buffer_size);
                 }
               else
                 {
                   msg_error("Incoming byte stream requires a too large conversion buffer, probably invalid character sequence",
-                            evt_tag_str("encoding", self->super.options->encoding),
+                            evt_tag_str("encoding", self->super.options->super.encoding),
                             evt_tag_mem("buffer", self->buffer, state->pending_buffer_end));
                   goto error;
                 }
               break;
             case EILSEQ:
               msg_notice("Invalid byte sequence, skipping character",
-                         evt_tag_str("encoding", self->super.options->encoding),
+                         evt_tag_str("encoding", self->super.options->super.encoding),
                          evt_tag_printf("char", "0x%02x", *(guchar *) raw_buffer));
               raw_buffer++;
               avail_in--;
@@ -153,7 +153,7 @@ log_proto_buffered_server_convert_from_raw(LogProtoBufferedServer *self, const g
             default:
               msg_error("Unknown error while converting input",
                         evt_tag_error("errno"),
-                        evt_tag_str("encoding", self->super.options->encoding),
+                        evt_tag_str("encoding", self->super.options->super.encoding),
                         evt_tag_printf("char", "0x%02x", *(guchar *) raw_buffer));
               goto error;
             }
@@ -191,7 +191,7 @@ log_proto_buffered_server_apply_state(LogProtoBufferedServer *self, PersistEntry
 
   if (!self->buffer)
     {
-      gssize buffer_size = MAX(state->buffer_size, self->super.options->init_buffer_size);
+      gssize buffer_size = MAX(state->buffer_size, self->super.options->super.init_buffer_size);
       self->buffer = g_malloc(buffer_size);
       state->buffer_size = buffer_size;
     }
@@ -226,7 +226,7 @@ log_proto_buffered_server_apply_state(LogProtoBufferedServer *self, PersistEntry
       gssize rc;
       guchar *raw_buffer;
 
-      if (!self->super.options->encoding)
+      if (!self->super.options->super.encoding)
         {
           /* no conversion, we read directly into our buffer */
           if (state->raw_buffer_size > state->buffer_size)
@@ -235,20 +235,20 @@ log_proto_buffered_server_apply_state(LogProtoBufferedServer *self, PersistEntry
                          evt_tag_str("state", persist_name),
                          evt_tag_int("raw_buffer_size", state->raw_buffer_size),
                          evt_tag_int("buffer_size", state->buffer_size),
-                         evt_tag_int("init_buffer_size", self->super.options->init_buffer_size));
+                         evt_tag_int("init_buffer_size", self->super.options->super.init_buffer_size));
               goto error;
             }
           raw_buffer = self->buffer;
         }
       else
         {
-          if (state->raw_buffer_size > self->super.options->max_buffer_size)
+          if (state->raw_buffer_size > self->super.options->super.max_buffer_size)
             {
               msg_notice("Invalid LogProtoBufferedServerState.raw_buffer_size, larger than max_buffer_size, restarting from the beginning",
                          evt_tag_str("state", persist_name),
                          evt_tag_int("raw_buffer_size", state->raw_buffer_size),
-                         evt_tag_int("init_buffer_size", self->super.options->init_buffer_size),
-                         evt_tag_int("max_buffer_size", self->super.options->max_buffer_size));
+                         evt_tag_int("init_buffer_size", self->super.options->super.init_buffer_size),
+                         evt_tag_int("max_buffer_size", self->super.options->super.max_buffer_size));
               goto error;
             }
           raw_buffer = g_alloca(state->raw_buffer_size);
@@ -263,7 +263,7 @@ log_proto_buffered_server_apply_state(LogProtoBufferedServer *self, PersistEntry
         }
 
       state->pending_buffer_end = 0;
-      if (self->super.options->encoding)
+      if (self->super.options->super.encoding)
         {
           if (!log_proto_buffered_server_convert_from_raw(self, raw_buffer, rc))
             {
@@ -412,7 +412,7 @@ log_proto_buffered_server_convert_state(LogProtoBufferedServer *self, guint8 per
 
       if (!self->buffer || state->buffer_size < buffer_len)
         {
-          gsize buffer_size = MAX(self->super.options->init_buffer_size, buffer_len);
+          gsize buffer_size = MAX(self->super.options->super.init_buffer_size, buffer_len);
           self->buffer = g_realloc(self->buffer, buffer_size);
         }
       serialize_archive_free(archive);
@@ -639,11 +639,11 @@ log_proto_buffered_server_get_raw_size_of_buffer(LogProtoBufferedServer *self, c
        * which in turn will speed up the reversal of the UTF8 buffer
        * size to raw buffer sizes.
        */
-      self->convert_scale = log_proto_get_char_size_for_fixed_encoding(self->super.options->encoding);
+      self->convert_scale = log_proto_get_char_size_for_fixed_encoding(self->super.options->super.encoding);
       if (self->convert_scale == 0)
         {
           /* this encoding is not known, do the conversion for real :( */
-          self->reverse_convert = g_iconv_open(self->super.options->encoding, "utf-8");
+          self->reverse_convert = g_iconv_open(self->super.options->super.encoding, "utf-8");
         }
     }
 
@@ -696,7 +696,7 @@ log_proto_buffered_server_split_buffer(LogProtoBufferedServer *self, LogProtoBuf
          duplicate some data */
 
       gsize raw_split_size;
-      if (self->super.options->encoding)
+      if (self->super.options->super.encoding)
         raw_split_size = log_proto_buffered_server_get_raw_size_of_buffer(self, *buffer_start, buffer_bytes);
       else
         raw_split_size = buffer_bytes;
@@ -759,7 +759,7 @@ log_proto_buffered_server_fetch_from_buffer(LogProtoBufferedServer *self, const
 static inline void
 log_proto_buffered_server_allocate_buffer(LogProtoBufferedServer *self, LogProtoBufferedServerState *state)
 {
-  state->buffer_size = self->super.options->init_buffer_size;
+  state->buffer_size = self->super.options->super.init_buffer_size;
   self->buffer = g_malloc(state->buffer_size);
 }
 
@@ -796,9 +796,9 @@ log_proto_buffered_server_fetch_into_buffer(LogProtoBufferedServer *self)
       /* if conversion is needed, we first read into an on-stack
        * buffer, and then convert it into our internal buffer */
 
-      raw_buffer = g_alloca(self->super.options->init_buffer_size + state->raw_buffer_leftover_size);
+      raw_buffer = g_alloca(self->super.options->super.init_buffer_size + state->raw_buffer_leftover_size);
       memcpy(raw_buffer, state->raw_buffer_leftover, state->raw_buffer_leftover_size);
-      avail = self->super.options->init_buffer_size;
+      avail = self->super.options->super.init_buffer_size;
     }
 
   if (avail == 0)
@@ -1041,10 +1041,10 @@ log_proto_buffered_server_validate_options_method(LogProtoServer *s)
 {
   LogProtoBufferedServer *self = (LogProtoBufferedServer *) s;
 
-  if (self->super.options->encoding && self->convert == (GIConv) -1)
+  if (self->super.options->super.encoding && self->convert == (GIConv) -1)
     {
       msg_error("Unknown character set name specified",
-                evt_tag_str("encoding", self->super.options->encoding));
+                evt_tag_str("encoding", self->super.options->super.encoding));
       return FALSE;
     }
   return log_proto_server_validate_options_method(s);
@@ -1074,7 +1074,7 @@ log_proto_buffered_server_free_method(LogProtoServer *s)
 
 void
 log_proto_buffered_server_init(LogProtoBufferedServer *self, LogTransport *transport,
-                               const LogProtoServerOptions *options)
+                               const LogProtoServerOptionsStorage *options)
 {
   log_proto_server_init(&self->super, transport, options);
   self->super.prepare = log_proto_buffered_server_prepare;
@@ -1087,8 +1087,8 @@ log_proto_buffered_server_init(LogProtoBufferedServer *self, LogTransport *trans
   self->reverse_convert = (GIConv) -1;
   self->read_data = log_proto_buffered_server_read_data_method;
   self->io_status = G_IO_STATUS_NORMAL;
-  if (options->encoding)
-    self->convert = g_iconv_open("utf-8", options->encoding);
+  if (options->super.encoding)
+    self->convert = g_iconv_open("utf-8", options->super.encoding);
   else
     self->convert = (GIConv) -1;
   self->stream_based = TRUE;

lib/logproto/logproto-buffered-server.h

@@ -122,7 +122,7 @@ void log_proto_buffered_server_put_state(LogProtoBufferedServer *self);
 /* LogProtoBufferedServer */
 gboolean log_proto_buffered_server_validate_options_method(LogProtoServer *s);
 void log_proto_buffered_server_init(LogProtoBufferedServer *self, LogTransport *transport,
-                                    const LogProtoServerOptions *options);
+                                    const LogProtoServerOptionsStorage *options);
 void log_proto_buffered_server_free_method(LogProtoServer *s);
 
 LogProtoStatus log_proto_buffered_server_fetch(LogProtoServer *s, const guchar **msg, gsize *msg_len,

lib/logproto/logproto-dgram-server.c

@@ -49,7 +49,7 @@ log_proto_dgram_server_fetch_from_buffer(LogProtoBufferedServer *s, const guchar
 }
 
 LogProtoServer *
-log_proto_dgram_server_new(LogTransport *transport, const LogProtoServerOptions *options)
+log_proto_dgram_server_new(LogTransport *transport, const LogProtoServerOptionsStorage *options)
 {
   LogProtoDGramServer *self = g_new0(LogProtoDGramServer, 1);
 

lib/logproto/logproto-dgram-server.h

@@ -32,6 +32,6 @@
  * This class reads input as datagrams, each datagram is a separate
  * message, regardless of embedded EOL/NUL characters.
  */
-LogProtoServer *log_proto_dgram_server_new(LogTransport *transport, const LogProtoServerOptions *options);
+LogProtoServer *log_proto_dgram_server_new(LogTransport *transport, const LogProtoServerOptionsStorage *options);
 
 #endif

lib/logproto/logproto-framed-server.c

@@ -222,7 +222,7 @@ _ensure_buffer(LogProtoFramedServer *self)
   if (G_LIKELY(self->buffer))
     return;
 
-  self->buffer_size = self->super.options->init_buffer_size;
+  self->buffer_size = self->super.options->super.init_buffer_size;
   self->buffer = g_malloc(self->buffer_size);
 }
 
@@ -257,19 +257,19 @@ _on_frame_extract(LogProtoFramedServer *self, LogProtoStatus *status)
 
   self->state = LPFSS_MESSAGE_EXTRACT;
 
-  if (self->frame_len > self->super.options->max_msg_size)
+  if (self->frame_len > self->super.options->super.max_msg_size)
     {
-      if (self->super.options->trim_large_messages)
+      if (self->super.options->super.trim_large_messages)
         {
           msg_debug("Incoming frame larger than log_msg_size(), need to trim.",
-                    evt_tag_int("log_msg_size", self->super.options->max_msg_size),
+                    evt_tag_int("log_msg_size", self->super.options->super.max_msg_size),
                     evt_tag_int("frame_length", self->frame_len));
           self->state = LPFSS_TRIM_MESSAGE_READ;
         }
       else
         {
           msg_error("Incoming frame larger than log_msg_size()",
-                    evt_tag_int("log_msg_size", self->super.options->max_msg_size),
+                    evt_tag_int("log_msg_size", self->super.options->super.max_msg_size),
                     evt_tag_int("frame_length", self->frame_len));
           *status = LPS_ERROR;
           return LPFSSCTRL_RETURN_WITH_STATUS;
@@ -423,7 +423,7 @@ log_proto_framed_server_free(LogProtoServer *s)
 }
 
 LogProtoServer *
-log_proto_framed_server_new(LogTransport *transport, const LogProtoServerOptions *options)
+log_proto_framed_server_new(LogTransport *transport, const LogProtoServerOptionsStorage *options)
 {
   LogProtoFramedServer *self = g_new0(LogProtoFramedServer, 1);
 

lib/logproto/logproto-framed-server.h

@@ -26,6 +26,6 @@
 
 #include "logproto-server.h"
 
-LogProtoServer *log_proto_framed_server_new(LogTransport *transport, const LogProtoServerOptions *options);
+LogProtoServer *log_proto_framed_server_new(LogTransport *transport, const LogProtoServerOptionsStorage *options);
 
 #endif

lib/logproto/logproto-http-scraper-responder.c

@@ -84,17 +84,18 @@ _check_request_headers(LogProtoHTTPServer *s, gchar *buffer_start, gsize buffer_
 
 void
 log_proto_http_scraper_responder_server_init(LogProtoHTTPScraperResponder *self, LogTransport *transport,
-                                             const LogProtoServerOptions *options)
+                                             const LogProtoServerOptionsStorage *options)
 {
-  log_proto_http_server_init((LogProtoHTTPServer *)self, transport, options); //&options->super);
-  self->options = options;
+  log_proto_http_server_init((LogProtoHTTPServer *)self, transport,
+                             (LogProtoHTTPServerOptions *)options); //&options->super);
+  self->options = (const LogProtoHTTPScraperResponderOptions *)options;
   self->super.request_header_checker = _check_request_headers;
   self->super.response_body_composer = _compose_response_body;
 }
 
 LogProtoServer *
 log_proto_http_scraper_responder_server_new(LogTransport *transport,
-                                            const LogProtoServerOptions *options)
+                                            const LogProtoServerOptionsStorage *options)
 {
   LogProtoHTTPScraperResponder *self = g_new0(LogProtoHTTPScraperResponder, 1);
 
@@ -108,23 +109,22 @@ void
 log_proto_http_scraper_responder_options_defaults(LogProtoHTTPScraperResponderOptions *options)
 {
   memset(options, 0, sizeof(*options));
-  options->stat_type = STT_STAT;
+  options->super.stat_type = STT_STAT;
 }
 
 void
 log_proto_http_scraper_responder_options_init(LogProtoHTTPScraperResponderOptions *options,
                                               GlobalConfig *cfg)
 {
-  if (options->initialized)
+  if (options->super.initialized)
     return;
-  log_proto_server_options_init(&options->super, cfg);
-  options->initialized = TRUE;
+  log_proto_server_options_init(&options->super.super->super, cfg);
+  options->super.initialized = TRUE;
 }
 
 void
 log_proto_http_scraper_responder_destroy(LogProtoHTTPScraperResponderOptions *options)
 {
-  // if (options->destroy)
-  //   options->destroy(options);
-  options->initialized = FALSE;
+  log_proto_server_options_destroy(&options->super.super->super);
+  options->super.initialized = FALSE;
 }