xref: /dports/security/spybye/spybye-0.3/spybye.gen.c

/*
 * Automatically generated from spybye.rpc
 * by event_rpcgen.py/0.1.  DO NOT EDIT THIS FILE.
 */

#include <sys/types.h>
#include <sys/time.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <event.h>


#include "spybye.gen.h"

void event_err(int eval, const char *fmt, ...);
void event_warn(const char *fmt, ...);
void event_errx(int eval, const char *fmt, ...);
void event_warnx(const char *fmt, ...);


/*
 * Implementation of dangerousload
 */

struct dangerousload *
dangerousload_new()
{
  struct dangerousload *tmp;
  if ((tmp = malloc(sizeof(struct dangerousload))) == NULL) {
    event_warn("%s: malloc", __func__);
    return (NULL);
  }
  tmp->time_in_seconds_assign = dangerousload_time_in_seconds_assign;
  tmp->time_in_seconds_get = dangerousload_time_in_seconds_get;
  tmp->time_in_seconds_set = 0;

  tmp->parent_url_data = NULL;
  tmp->parent_url_assign = dangerousload_parent_url_assign;
  tmp->parent_url_get = dangerousload_parent_url_get;
  tmp->parent_url_set = 0;

  tmp->dangerous_url_data = NULL;
  tmp->dangerous_url_assign = dangerousload_dangerous_url_assign;
  tmp->dangerous_url_get = dangerousload_dangerous_url_get;
  tmp->dangerous_url_set = 0;

  tmp->virus_result_data = NULL;
  tmp->virus_result_assign = dangerousload_virus_result_assign;
  tmp->virus_result_get = dangerousload_virus_result_get;
  tmp->virus_result_set = 0;

  memset(tmp->digest_data, 0, sizeof(tmp->digest_data));
  tmp->digest_assign = dangerousload_digest_assign;
  tmp->digest_get = dangerousload_digest_get;
  tmp->digest_set = 0;

  return (tmp);
}






int
dangerousload_time_in_seconds_assign(struct dangerousload *msg, const u_int32_t value)
{
  msg->time_in_seconds_set = 1;
  msg->time_in_seconds_data = value;
  return (0);
}

int
dangerousload_parent_url_assign(struct dangerousload *msg, const char * value)
{
  if (msg->parent_url_data != NULL)
    free(msg->parent_url_data);
  if ((msg->parent_url_data = strdup(value)) == NULL)
    return (-1);
  msg->parent_url_set = 1;
  return (0);
}

int
dangerousload_dangerous_url_assign(struct dangerousload *msg, const char * value)
{
  if (msg->dangerous_url_data != NULL)
    free(msg->dangerous_url_data);
  if ((msg->dangerous_url_data = strdup(value)) == NULL)
    return (-1);
  msg->dangerous_url_set = 1;
  return (0);
}

int
dangerousload_virus_result_assign(struct dangerousload *msg, const char * value)
{
  if (msg->virus_result_data != NULL)
    free(msg->virus_result_data);
  if ((msg->virus_result_data = strdup(value)) == NULL)
    return (-1);
  msg->virus_result_set = 1;
  return (0);
}

int
dangerousload_digest_assign(struct dangerousload *msg, const u_int8_t *value)
{
  msg->digest_set = 1;
  memcpy(msg->digest_data, value, 16);
  return (0);
}

int
dangerousload_time_in_seconds_get(struct dangerousload *msg, u_int32_t *value)
{
  if (msg->time_in_seconds_set != 1)
    return (-1);
  *value = msg->time_in_seconds_data;
  return (0);
}

int
dangerousload_parent_url_get(struct dangerousload *msg, char * *value)
{
  if (msg->parent_url_set != 1)
    return (-1);
  *value = msg->parent_url_data;
  return (0);
}

int
dangerousload_dangerous_url_get(struct dangerousload *msg, char * *value)
{
  if (msg->dangerous_url_set != 1)
    return (-1);
  *value = msg->dangerous_url_data;
  return (0);
}

int
dangerousload_virus_result_get(struct dangerousload *msg, char * *value)
{
  if (msg->virus_result_set != 1)
    return (-1);
  *value = msg->virus_result_data;
  return (0);
}

int
dangerousload_digest_get(struct dangerousload *msg, u_int8_t **value)
{
  if (msg->digest_set != 1)
    return (-1);
  *value = msg->digest_data;
  return (0);
}

void
dangerousload_clear(struct dangerousload *tmp)
{
  tmp->time_in_seconds_set = 0;
  if (tmp->parent_url_set == 1) {
    free (tmp->parent_url_data);
    tmp->parent_url_data = NULL;
    tmp->parent_url_set = 0;
  }
  if (tmp->dangerous_url_set == 1) {
    free (tmp->dangerous_url_data);
    tmp->dangerous_url_data = NULL;
    tmp->dangerous_url_set = 0;
  }
  if (tmp->virus_result_set == 1) {
    free (tmp->virus_result_data);
    tmp->virus_result_data = NULL;
    tmp->virus_result_set = 0;
  }
  tmp->digest_set = 0;
  memset(tmp->digest_data, 0, sizeof(tmp->digest_data));
}

void
dangerousload_free(struct dangerousload *tmp)
{
  if (tmp->parent_url_data != NULL)
      free (tmp->parent_url_data);
  if (tmp->dangerous_url_data != NULL)
      free (tmp->dangerous_url_data);
  if (tmp->virus_result_data != NULL)
      free (tmp->virus_result_data);
  free(tmp);
}

void
dangerousload_marshal(struct evbuffer *evbuf, const struct dangerousload *tmp){
  evtag_marshal_int(evbuf, DANGEROUSLOAD_TIME_IN_SECONDS, tmp->time_in_seconds_data);
  evtag_marshal_string(evbuf, DANGEROUSLOAD_PARENT_URL, tmp->parent_url_data);
  evtag_marshal_string(evbuf, DANGEROUSLOAD_DANGEROUS_URL, tmp->dangerous_url_data);
  if (tmp->virus_result_set) {
    evtag_marshal_string(evbuf, DANGEROUSLOAD_VIRUS_RESULT, tmp->virus_result_data);
  }
  if (tmp->digest_set) {
    evtag_marshal(evbuf, DANGEROUSLOAD_DIGEST, tmp->digest_data, sizeof(tmp->digest_data));
  }
}

int
dangerousload_unmarshal(struct dangerousload *tmp,  struct evbuffer *evbuf)
{
  u_int8_t tag;
  while (EVBUFFER_LENGTH(evbuf) > 0) {
    if (evtag_peek(evbuf, &tag) == -1)
      return (-1);
    switch (tag) {

      case DANGEROUSLOAD_TIME_IN_SECONDS:

        if (tmp->time_in_seconds_set)
          return (-1);
        if (evtag_unmarshal_int(evbuf, DANGEROUSLOAD_TIME_IN_SECONDS, &tmp->time_in_seconds_data) == -1) {
          event_warnx("%s: failed to unmarshal time_in_seconds", __func__);
          return (-1);
        }
        tmp->time_in_seconds_set = 1;
        break;

      case DANGEROUSLOAD_PARENT_URL:

        if (tmp->parent_url_set)
          return (-1);
        if (evtag_unmarshal_string(evbuf, DANGEROUSLOAD_PARENT_URL, &tmp->parent_url_data) == -1) {
          event_warnx("%s: failed to unmarshal parent_url", __func__);
          return (-1);
        }
        tmp->parent_url_set = 1;
        break;

      case DANGEROUSLOAD_DANGEROUS_URL:

        if (tmp->dangerous_url_set)
          return (-1);
        if (evtag_unmarshal_string(evbuf, DANGEROUSLOAD_DANGEROUS_URL, &tmp->dangerous_url_data) == -1) {
          event_warnx("%s: failed to unmarshal dangerous_url", __func__);
          return (-1);
        }
        tmp->dangerous_url_set = 1;
        break;

      case DANGEROUSLOAD_VIRUS_RESULT:

        if (tmp->virus_result_set)
          return (-1);
        if (evtag_unmarshal_string(evbuf, DANGEROUSLOAD_VIRUS_RESULT, &tmp->virus_result_data) == -1) {
          event_warnx("%s: failed to unmarshal virus_result", __func__);
          return (-1);
        }
        tmp->virus_result_set = 1;
        break;

      case DANGEROUSLOAD_DIGEST:

        if (tmp->digest_set)
          return (-1);
        if (evtag_unmarshal_fixed(evbuf, DANGEROUSLOAD_DIGEST, tmp->digest_data, sizeof(tmp->digest_data)) == -1) {
          event_warnx("%s: failed to unmarshal digest", __func__);
          return (-1);
        }
        tmp->digest_set = 1;
        break;

      default:
        return -1;
    }
  }

  if (dangerousload_complete(tmp) == -1)
    return (-1);
  return (0);
}

int
dangerousload_complete(struct dangerousload *msg)
{
  if (!msg->time_in_seconds_set)
    return (-1);
  if (!msg->parent_url_set)
    return (-1);
  if (!msg->dangerous_url_set)
    return (-1);
  return (0);
}

int
evtag_unmarshal_dangerousload(struct evbuffer *evbuf, u_int8_t need_tag,  struct dangerousload *msg)
{
  u_int8_t tag;
  int res = -1;

  struct evbuffer *tmp = evbuffer_new();

  if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag)
    goto error;

  if (dangerousload_unmarshal(msg, tmp) == -1)
    goto error;

  res = 0;

 error:
  evbuffer_free(tmp);
  return (res);
}

void
evtag_marshal_dangerousload(struct evbuffer *evbuf, u_int8_t tag, const struct dangerousload *msg)
{
  struct evbuffer *_buf = evbuffer_new();
  assert(_buf != NULL);
  evbuffer_drain(_buf, -1);
  dangerousload_marshal(_buf, msg);
  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), EVBUFFER_LENGTH(_buf));
  evbuffer_free(_buf);
}

/*
 * Implementation of dangerous_report
 */

struct dangerous_report *
dangerous_report_new()
{
  struct dangerous_report *tmp;
  if ((tmp = malloc(sizeof(struct dangerous_report))) == NULL) {
    event_warn("%s: malloc", __func__);
    return (NULL);
  }
  tmp->time_in_seconds_assign = dangerous_report_time_in_seconds_assign;
  tmp->time_in_seconds_get = dangerous_report_time_in_seconds_get;
  tmp->time_in_seconds_set = 0;

  tmp->remote_ip_data = NULL;
  tmp->remote_ip_assign = dangerous_report_remote_ip_assign;
  tmp->remote_ip_get = dangerous_report_remote_ip_get;
  tmp->remote_ip_set = 0;

  tmp->report_data = NULL;
  tmp->report_assign = dangerous_report_report_assign;
  tmp->report_get = dangerous_report_report_get;
  tmp->report_set = 0;

  return (tmp);
}




int
dangerous_report_time_in_seconds_assign(struct dangerous_report *msg, const u_int32_t value)
{
  msg->time_in_seconds_set = 1;
  msg->time_in_seconds_data = value;
  return (0);
}

int
dangerous_report_remote_ip_assign(struct dangerous_report *msg, const char * value)
{
  if (msg->remote_ip_data != NULL)
    free(msg->remote_ip_data);
  if ((msg->remote_ip_data = strdup(value)) == NULL)
    return (-1);
  msg->remote_ip_set = 1;
  return (0);
}

int
dangerous_report_report_assign(struct dangerous_report *msg, const struct dangerousload *value)
{
  struct evbuffer *tmp = NULL;
  if (msg->report_set) {
    dangerousload_clear(msg->report_data);
    msg->report_set = 0;
  } else {
    msg->report_data = dangerousload_new();
    if (msg->report_data == NULL) {
      event_warn("%s: dangerousload_new()", __func__);
      goto error;
    }
  }
  if ((tmp = evbuffer_new()) == NULL) {
    event_warn("%s: evbuffer_new()", __func__);
    goto error;
  }
  dangerousload_marshal(tmp, value);
  if (dangerousload_unmarshal(msg->report_data, tmp) == -1) {
    event_warnx("%s: dangerousload_unmarshal", __func__);
    goto error;
  }
  msg->report_set = 1;
  evbuffer_free(tmp);
  return (0);
 error:
  if (tmp != NULL)
    evbuffer_free(tmp);
  if (msg->report_data != NULL) {
    dangerousload_free(msg->report_data);
    msg->report_data = NULL;
  }
  return (-1);
}

int
dangerous_report_time_in_seconds_get(struct dangerous_report *msg, u_int32_t *value)
{
  if (msg->time_in_seconds_set != 1)
    return (-1);
  *value = msg->time_in_seconds_data;
  return (0);
}

int
dangerous_report_remote_ip_get(struct dangerous_report *msg, char * *value)
{
  if (msg->remote_ip_set != 1)
    return (-1);
  *value = msg->remote_ip_data;
  return (0);
}

int
dangerous_report_report_get(struct dangerous_report *msg, struct dangerousload **value)
{
  if (msg->report_set != 1) {
    msg->report_data = dangerousload_new();
    if (msg->report_data == NULL)
      return (-1);
    msg->report_set = 1;
  }
  *value = msg->report_data;
  return (0);
}

void
dangerous_report_clear(struct dangerous_report *tmp)
{
  tmp->time_in_seconds_set = 0;
  if (tmp->remote_ip_set == 1) {
    free (tmp->remote_ip_data);
    tmp->remote_ip_data = NULL;
    tmp->remote_ip_set = 0;
  }
  if (tmp->report_set == 1) {
    dangerousload_free(tmp->report_data);
    tmp->report_data = NULL;
    tmp->report_set = 0;
  }
}

void
dangerous_report_free(struct dangerous_report *tmp)
{
  if (tmp->remote_ip_data != NULL)
      free (tmp->remote_ip_data);
  if (tmp->report_data != NULL)
      dangerousload_free(tmp->report_data);
  free(tmp);
}

void
dangerous_report_marshal(struct evbuffer *evbuf, const struct dangerous_report *tmp){
  evtag_marshal_int(evbuf, DANGEROUS_REPORT_TIME_IN_SECONDS, tmp->time_in_seconds_data);
  evtag_marshal_string(evbuf, DANGEROUS_REPORT_REMOTE_IP, tmp->remote_ip_data);
  evtag_marshal_dangerousload(evbuf, DANGEROUS_REPORT_REPORT, tmp->report_data);
}

int
dangerous_report_unmarshal(struct dangerous_report *tmp,  struct evbuffer *evbuf)
{
  u_int8_t tag;
  while (EVBUFFER_LENGTH(evbuf) > 0) {
    if (evtag_peek(evbuf, &tag) == -1)
      return (-1);
    switch (tag) {

      case DANGEROUS_REPORT_TIME_IN_SECONDS:

        if (tmp->time_in_seconds_set)
          return (-1);
        if (evtag_unmarshal_int(evbuf, DANGEROUS_REPORT_TIME_IN_SECONDS, &tmp->time_in_seconds_data) == -1) {
          event_warnx("%s: failed to unmarshal time_in_seconds", __func__);
          return (-1);
        }
        tmp->time_in_seconds_set = 1;
        break;

      case DANGEROUS_REPORT_REMOTE_IP:

        if (tmp->remote_ip_set)
          return (-1);
        if (evtag_unmarshal_string(evbuf, DANGEROUS_REPORT_REMOTE_IP, &tmp->remote_ip_data) == -1) {
          event_warnx("%s: failed to unmarshal remote_ip", __func__);
          return (-1);
        }
        tmp->remote_ip_set = 1;
        break;

      case DANGEROUS_REPORT_REPORT:

        if (tmp->report_set)
          return (-1);
        tmp->report_data = dangerousload_new();
        if (tmp->report_data == NULL)
          return (-1);
        if (evtag_unmarshal_dangerousload(evbuf, DANGEROUS_REPORT_REPORT, tmp->report_data) == -1) {
          event_warnx("%s: failed to unmarshal report", __func__);
          return (-1);
        }
        tmp->report_set = 1;
        break;

      default:
        return -1;
    }
  }

  if (dangerous_report_complete(tmp) == -1)
    return (-1);
  return (0);
}

int
dangerous_report_complete(struct dangerous_report *msg)
{
  if (!msg->time_in_seconds_set)
    return (-1);
  if (!msg->remote_ip_set)
    return (-1);
  if (dangerousload_complete(msg->report_data) == -1)
    return (-1);
  return (0);
}

int
evtag_unmarshal_dangerous_report(struct evbuffer *evbuf, u_int8_t need_tag,  struct dangerous_report *msg)
{
  u_int8_t tag;
  int res = -1;

  struct evbuffer *tmp = evbuffer_new();

  if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag)
    goto error;

  if (dangerous_report_unmarshal(msg, tmp) == -1)
    goto error;

  res = 0;

 error:
  evbuffer_free(tmp);
  return (res);
}

void
evtag_marshal_dangerous_report(struct evbuffer *evbuf, u_int8_t tag, const struct dangerous_report *msg)
{
  struct evbuffer *_buf = evbuffer_new();
  assert(_buf != NULL);
  evbuffer_drain(_buf, -1);
  dangerous_report_marshal(_buf, msg);
  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), EVBUFFER_LENGTH(_buf));
  evbuffer_free(_buf);
}

/*
 * Implementation of virusscan
 */

struct virusscan *
virusscan_new()
{
  struct virusscan *tmp;
  if ((tmp = malloc(sizeof(struct virusscan))) == NULL) {
    event_warn("%s: malloc", __func__);
    return (NULL);
  }
  tmp->buffer_data = NULL;
  tmp->buffer_length = 0;
  tmp->buffer_assign = virusscan_buffer_assign;
  tmp->buffer_get = virusscan_buffer_get;
  tmp->buffer_set = 0;

  tmp->context_data = NULL;
  tmp->context_length = 0;
  tmp->context_assign = virusscan_context_assign;
  tmp->context_get = virusscan_context_get;
  tmp->context_set = 0;

  return (tmp);
}



int
virusscan_buffer_assign(struct virusscan *msg, const u_int8_t * value, u_int32_t len)
{
  if (msg->buffer_data != NULL)
    free (msg->buffer_data);
  msg->buffer_data = malloc(len);
  if (msg->buffer_data == NULL)
    return (-1);
  msg->buffer_set = 1;
  msg->buffer_length = len;
  memcpy(msg->buffer_data, value, len);
  return (0);
}

int
virusscan_context_assign(struct virusscan *msg, const u_int8_t * value, u_int32_t len)
{
  if (msg->context_data != NULL)
    free (msg->context_data);
  msg->context_data = malloc(len);
  if (msg->context_data == NULL)
    return (-1);
  msg->context_set = 1;
  msg->context_length = len;
  memcpy(msg->context_data, value, len);
  return (0);
}

int
virusscan_buffer_get(struct virusscan *msg, u_int8_t * *value, u_int32_t *plen)
{
  if (msg->buffer_set != 1)
    return (-1);
  *value = msg->buffer_data;
  *plen = msg->buffer_length;
  return (0);
}

int
virusscan_context_get(struct virusscan *msg, u_int8_t * *value, u_int32_t *plen)
{
  if (msg->context_set != 1)
    return (-1);
  *value = msg->context_data;
  *plen = msg->context_length;
  return (0);
}

void
virusscan_clear(struct virusscan *tmp)
{
  if (tmp->buffer_set == 1) {
    free (tmp->buffer_data);
    tmp->buffer_data = NULL;
    tmp->buffer_length = 0;
    tmp->buffer_set = 0;
  }
  if (tmp->context_set == 1) {
    free (tmp->context_data);
    tmp->context_data = NULL;
    tmp->context_length = 0;
    tmp->context_set = 0;
  }
}

void
virusscan_free(struct virusscan *tmp)
{
  if (tmp->buffer_data != NULL)
      free (tmp->buffer_data);
  if (tmp->context_data != NULL)
      free (tmp->context_data);
  free(tmp);
}

void
virusscan_marshal(struct evbuffer *evbuf, const struct virusscan *tmp){
  evtag_marshal(evbuf, VIRUSSCAN_BUFFER, tmp->buffer_data, tmp->buffer_length);
  evtag_marshal(evbuf, VIRUSSCAN_CONTEXT, tmp->context_data, tmp->context_length);
}

int
virusscan_unmarshal(struct virusscan *tmp,  struct evbuffer *evbuf)
{
  u_int8_t tag;
  while (EVBUFFER_LENGTH(evbuf) > 0) {
    if (evtag_peek(evbuf, &tag) == -1)
      return (-1);
    switch (tag) {

      case VIRUSSCAN_BUFFER:

        if (tmp->buffer_set)
          return (-1);
        if (evtag_payload_length(evbuf, &tmp->buffer_length) == -1)
          return (-1);
        if (tmp->buffer_length > EVBUFFER_LENGTH(evbuf))
          return (-1);
        if ((tmp->buffer_data = malloc(tmp->buffer_length)) == NULL)
          return (-1);
        if (evtag_unmarshal_fixed(evbuf, VIRUSSCAN_BUFFER, tmp->buffer_data, tmp->buffer_length) == -1) {
          event_warnx("%s: failed to unmarshal buffer", __func__);
          return (-1);
        }
        tmp->buffer_set = 1;
        break;

      case VIRUSSCAN_CONTEXT:

        if (tmp->context_set)
          return (-1);
        if (evtag_payload_length(evbuf, &tmp->context_length) == -1)
          return (-1);
        if (tmp->context_length > EVBUFFER_LENGTH(evbuf))
          return (-1);
        if ((tmp->context_data = malloc(tmp->context_length)) == NULL)
          return (-1);
        if (evtag_unmarshal_fixed(evbuf, VIRUSSCAN_CONTEXT, tmp->context_data, tmp->context_length) == -1) {
          event_warnx("%s: failed to unmarshal context", __func__);
          return (-1);
        }
        tmp->context_set = 1;
        break;

      default:
        return -1;
    }
  }

  if (virusscan_complete(tmp) == -1)
    return (-1);
  return (0);
}

int
virusscan_complete(struct virusscan *msg)
{
  if (!msg->buffer_set)
    return (-1);
  if (!msg->context_set)
    return (-1);
  return (0);
}

int
evtag_unmarshal_virusscan(struct evbuffer *evbuf, u_int8_t need_tag,  struct virusscan *msg)
{
  u_int8_t tag;
  int res = -1;

  struct evbuffer *tmp = evbuffer_new();

  if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag)
    goto error;

  if (virusscan_unmarshal(msg, tmp) == -1)
    goto error;

  res = 0;

 error:
  evbuffer_free(tmp);
  return (res);
}

void
evtag_marshal_virusscan(struct evbuffer *evbuf, u_int8_t tag, const struct virusscan *msg)
{
  struct evbuffer *_buf = evbuffer_new();
  assert(_buf != NULL);
  evbuffer_drain(_buf, -1);
  virusscan_marshal(_buf, msg);
  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), EVBUFFER_LENGTH(_buf));
  evbuffer_free(_buf);
}

/*
 * Implementation of virusresult
 */

struct virusresult *
virusresult_new()
{
  struct virusresult *tmp;
  if ((tmp = malloc(sizeof(struct virusresult))) == NULL) {
    event_warn("%s: malloc", __func__);
    return (NULL);
  }
  tmp->result_data = NULL;
  tmp->result_assign = virusresult_result_assign;
  tmp->result_get = virusresult_result_get;
  tmp->result_set = 0;

  tmp->context_data = NULL;
  tmp->context_length = 0;
  tmp->context_assign = virusresult_context_assign;
  tmp->context_get = virusresult_context_get;
  tmp->context_set = 0;

  return (tmp);
}



int
virusresult_result_assign(struct virusresult *msg, const char * value)
{
  if (msg->result_data != NULL)
    free(msg->result_data);
  if ((msg->result_data = strdup(value)) == NULL)
    return (-1);
  msg->result_set = 1;
  return (0);
}

int
virusresult_context_assign(struct virusresult *msg, const u_int8_t * value, u_int32_t len)
{
  if (msg->context_data != NULL)
    free (msg->context_data);
  msg->context_data = malloc(len);
  if (msg->context_data == NULL)
    return (-1);
  msg->context_set = 1;
  msg->context_length = len;
  memcpy(msg->context_data, value, len);
  return (0);
}

int
virusresult_result_get(struct virusresult *msg, char * *value)
{
  if (msg->result_set != 1)
    return (-1);
  *value = msg->result_data;
  return (0);
}

int
virusresult_context_get(struct virusresult *msg, u_int8_t * *value, u_int32_t *plen)
{
  if (msg->context_set != 1)
    return (-1);
  *value = msg->context_data;
  *plen = msg->context_length;
  return (0);
}

void
virusresult_clear(struct virusresult *tmp)
{
  if (tmp->result_set == 1) {
    free (tmp->result_data);
    tmp->result_data = NULL;
    tmp->result_set = 0;
  }
  if (tmp->context_set == 1) {
    free (tmp->context_data);
    tmp->context_data = NULL;
    tmp->context_length = 0;
    tmp->context_set = 0;
  }
}

void
virusresult_free(struct virusresult *tmp)
{
  if (tmp->result_data != NULL)
      free (tmp->result_data);
  if (tmp->context_data != NULL)
      free (tmp->context_data);
  free(tmp);
}

void
virusresult_marshal(struct evbuffer *evbuf, const struct virusresult *tmp){
  evtag_marshal_string(evbuf, VIRUSRESULT_RESULT, tmp->result_data);
  evtag_marshal(evbuf, VIRUSRESULT_CONTEXT, tmp->context_data, tmp->context_length);
}

int
virusresult_unmarshal(struct virusresult *tmp,  struct evbuffer *evbuf)
{
  u_int8_t tag;
  while (EVBUFFER_LENGTH(evbuf) > 0) {
    if (evtag_peek(evbuf, &tag) == -1)
      return (-1);
    switch (tag) {

      case VIRUSRESULT_RESULT:

        if (tmp->result_set)
          return (-1);
        if (evtag_unmarshal_string(evbuf, VIRUSRESULT_RESULT, &tmp->result_data) == -1) {
          event_warnx("%s: failed to unmarshal result", __func__);
          return (-1);
        }
        tmp->result_set = 1;
        break;

      case VIRUSRESULT_CONTEXT:

        if (tmp->context_set)
          return (-1);
        if (evtag_payload_length(evbuf, &tmp->context_length) == -1)
          return (-1);
        if (tmp->context_length > EVBUFFER_LENGTH(evbuf))
          return (-1);
        if ((tmp->context_data = malloc(tmp->context_length)) == NULL)
          return (-1);
        if (evtag_unmarshal_fixed(evbuf, VIRUSRESULT_CONTEXT, tmp->context_data, tmp->context_length) == -1) {
          event_warnx("%s: failed to unmarshal context", __func__);
          return (-1);
        }
        tmp->context_set = 1;
        break;

      default:
        return -1;
    }
  }

  if (virusresult_complete(tmp) == -1)
    return (-1);
  return (0);
}

int
virusresult_complete(struct virusresult *msg)
{
  if (!msg->result_set)
    return (-1);
  if (!msg->context_set)
    return (-1);
  return (0);
}

int
evtag_unmarshal_virusresult(struct evbuffer *evbuf, u_int8_t need_tag,  struct virusresult *msg)
{
  u_int8_t tag;
  int res = -1;

  struct evbuffer *tmp = evbuffer_new();

  if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag)
    goto error;

  if (virusresult_unmarshal(msg, tmp) == -1)
    goto error;

  res = 0;

 error:
  evbuffer_free(tmp);
  return (res);
}

void
evtag_marshal_virusresult(struct evbuffer *evbuf, u_int8_t tag, const struct virusresult *msg)
{
  struct evbuffer *_buf = evbuffer_new();
  assert(_buf != NULL);
  evbuffer_drain(_buf, -1);
  virusresult_marshal(_buf, msg);
  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), EVBUFFER_LENGTH(_buf));
  evbuffer_free(_buf);
}