serval-dna.c File Reference

re-implementation of the serval-dna daemon as a commotiond plugin More...

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <poll.h>
#include <serval.h>
#include <serval/conf.h>
#include "debug.h"
#include "plugin.h"
#include "socket.h"
#include "loop.h"
#include "util.h"
#include "list.h"
#include "tree.h"
#include "profile.h"
#include "cmd.h"
#include "serval-dna.h"
#include "crypto.h"

Classes
struct	co_alarm_t

Macros
#define	_alarm   42
#define	IS_ALARM(J)   (IS_EXT(J) && ((co_alarm_t *)J)->_exttype == _alarm)
#define	SCHEDULE(X, Y, D)

Functions
int	serval_socket_cb (co_obj_t *self, co_obj_t *context)
int	serval_timer_cb (co_obj_t *self, co_obj_t **output, co_obj_t *context)
int	_schedule (struct __sourceloc __whence, struct sched_ent *alarm)
int	_unschedule (struct __sourceloc __whence, struct sched_ent *alarm)
int	_watch (struct __sourceloc __whence, struct sched_ent *alarm)
int	_unwatch (struct __sourceloc __whence, struct sched_ent *alarm)
int	co_plugin_name (co_obj_t *self, co_obj_t **output, co_obj_t *params)
	SCHEMA (serval)
	SCHEMA (mdp)
int	co_plugin_register (co_obj_t *self, co_obj_t **output, co_obj_t *params)
int	co_plugin_init (co_obj_t *self, co_obj_t **output, co_obj_t *params)
int	co_plugin_shutdown (co_obj_t *self, co_obj_t **output, co_obj_t *params)
int	serval_daemon_handler (co_obj_t *self, co_obj_t **output, co_obj_t *params)

Variables
keyring_file *	keyring
char *	serval_path
co_socket_t	co_socket_proto = {}
svl_crypto_ctx *	global_ctx = NULL
bool	serval_registered = false
bool	daemon_started = false
co_obj_t *	err_msg

Detailed Description

re-implementation of the serval-dna daemon as a commotiond plugin

Author

Dan Staples (dismantl), danst.nosp@m.aple.nosp@m.s@ope.nosp@m.ntec.nosp@m.hinst.nosp@m.itut.nosp@m.e.org

Macro Definition Documentation

#define SCHEDULE	(		X,
			Y,
			D
	)

Value:

{ \
static struct profile_total _stats_##X={.name="" #X "",}; \
static struct sched_ent _sched_##X={\
.stats = &_stats_##X, \
.function=X,\
}; \
_sched_##X.alarm=(gettime_ms()+Y);\
_sched_##X.deadline=(gettime_ms()+Y+D);\
schedule(&_sched_##X); }

Function Documentation

int _schedule	(	struct __sourceloc	__whence,
		struct sched_ent *	alarm
	)

Overridden Serval function to schedule timed events

this messes up Serval's overlay interface setup

References co_list_append(), co_list_parse(), co_loop_add_timer(), and co_timer_create().

                                                                    {
//   DEBUG("###### SCHEDULE ######");
  co_obj_t *timer = NULL, *node = NULL;
  
  CHECK(alarm->function,"No callback function associated with timer");
  CHECK(!(node = co_list_parse(timer_alarms, _alarm_ptr_match_i, alarm)),"Trying to schedule duplicate alarm %p",alarm);
  
  time_ms_t now = gettime_ms();
  
  if (alarm->deadline < alarm->alarm)
    alarm->deadline = alarm->alarm;
  
  CHECK(now - alarm->alarm <= 1000,"Alarm tried to schedule a deadline %lldms ago, from %s() %s:%d",
   (now - alarm->deadline),
   __whence.function,__whence.file,__whence.line);
  
  /** this messes up Serval's overlay interface setup */
  // if the alarm has already expired, execute callback function
//   if (alarm->deadline <= now) {
//     DEBUG("ALREADY EXPIRED, DEADLINE %lld %lld",alarm->alarm, gettime_ms());
//     alarm->function(alarm);
//     return 0;
//   }
  
//   DEBUG("NEW TIMER: ALARM %lld - %lld = %lld %p",alarm->alarm,now,alarm->alarm - now,alarm);
  CHECK(alarm->alarm - now < 86400000,"Timer deadline is more than 24 hrs from now, ignoring");

  time_ms_t deadline_time;
  struct timeval deadline;
//   if (alarm->alarm - now > 1)
    deadline_time = alarm->alarm;
//   else
//     deadline_time = alarm->deadline;

  deadline.tv_sec = deadline_time / 1000;
  deadline.tv_usec = (deadline_time % 1000) * 1000;
  if (deadline.tv_usec > 1000000) {
    deadline.tv_sec++;
    deadline.tv_usec %= 1000000;
  }

  CHECK_MEM((timer = co_timer_create(deadline, serval_timer_cb, alarm)));
  CHECK(co_loop_add_timer(timer,NULL),"Failed to add timer %ld.%06ld %p",deadline.tv_sec,deadline.tv_usec,alarm);
  CHECK(co_list_append(timer_alarms,co_alarm_create(alarm)),"Failed to add to timer_alarms");
  
  return 0;
  
error:
  if (timer) free(timer);
  return -1;
}

int _unschedule	(	struct __sourceloc	__whence,
		struct sched_ent *	alarm
	)

Overridden Serval function to unschedule timed events

References co_list_delete(), co_list_parse(), co_loop_get_timer(), and co_loop_remove_timer().

                                                                      {
//   DEBUG("###### UNSCHEDULE ######");
  co_obj_t *alarm_node = NULL, *timer = NULL;
  
//   CHECK((alarm_node = co_list_parse(timer_alarms, _alarm_ptr_match_i, alarm)),"Attempting to unschedule timer that is not scheduled");
  if (!(alarm_node = co_list_parse(timer_alarms, _alarm_ptr_match_i, alarm))) goto error;
  co_list_delete(timer_alarms,alarm_node);
  co_obj_free(alarm_node);
  
  // Get the timer associated with the alarm
  CHECK((timer = co_loop_get_timer(alarm,NULL)),"Could not find timer to remove");
  CHECK(co_loop_remove_timer(timer,NULL),"Failed to remove timer from event loop");
  co_obj_free(timer);
  
  return 0;
  
error:
  return -1;
}

int _watch	(	struct __sourceloc	__whence,
		struct sched_ent *	alarm
	)

Overridden Serval function to register sockets with event loop

need to set: sock->fd sock->rfd sock->listen sock->uri sock->poll_cb sock->fd_registered sock->rfd_registered

References co_fd_create(), co_list_append(), co_list_parse(), co_loop_add_socket(), and serval_socket_cb().

                                                                 {
//   DEBUG("OVERRIDDEN WATCH FUNCTION!");
  co_socket_t *sock = NULL;
  
  /** need to set:
   *  sock->fd
   *  sock->rfd
   *  sock->listen
   *  sock->uri
   *  sock->poll_cb
   *  sock->fd_registered
   *  sock->rfd_registered
   */
  
  if ((alarm->_poll_index == 1) || co_list_parse(sock_alarms, _alarm_ptr_match_i, alarm)) {
    WARN("Socket %d already registered: %d",alarm->poll.fd,alarm->_poll_index);
  } else {
    sock = (co_socket_t*)NEW(co_socket, co_socket);
    
    sock->fd = (co_fd_t*)co_fd_create((co_obj_t*)sock,alarm->poll.fd);
    sock->rfd_lst = co_list16_create();
    sock->listen = true;
    // NOTE: Aren't able to get the Serval socket uris, so instead use string representation of fd
    sock->uri = h_calloc(1,6);
    hattach(sock->uri,sock);
    sprintf(sock->uri,"%d",sock->fd->fd);
    sock->fd_registered = false;
    sock->local = NULL;
    sock->remote = NULL;
  
    sock->poll_cb = serval_socket_cb;
  
    // register sock
    CHECK(co_loop_add_socket((co_obj_t*)sock, (co_obj_t*)sock->fd) == 1,"Failed to add socket %d",sock->fd->fd);
    DEBUG("Successfully added socket %d",sock->fd->fd);
  
    sock->fd_registered = true;
    // NOTE: it would be better to get the actual poll index from the event loop instead of this:
    alarm->_poll_index = 1;
    alarm->poll.revents = 0;
    
    CHECK(co_list_append(sock_alarms, co_alarm_create(alarm)),"Failed to add to sock_alarms");
    DEBUG("Successfully added to sock_alarms %p",alarm);
  }
  
  return 0;
error:
  if (sock) free((co_obj_t*)sock);
  return -1;
}

int serval_socket_cb	(	co_obj_t *	self,
		co_obj_t *	context
	)

Callback function for when Serval socket has data to read

References co_list_parse().

Referenced by _watch().

                                                        {
//   DEBUG("SERVAL_SOCKET_CB");
  co_socket_t *sock = (co_socket_t*)self;
  co_obj_t *node = NULL;
  struct sched_ent *alarm = NULL;
  
  // find alarm associated w/ sock, call alarm->function(alarm)
  if ((node = co_list_parse(sock_alarms, _alarm_fd_match_i, &sock->fd->fd))) {
    alarm = ((co_alarm_t*)node)->alarm;
    alarm->poll.revents = sock->events;
    
    alarm->function(alarm); // Serval callback function associated with alarm/socket
    alarm->poll.revents = 0;
    
    return 1;
  }
  
  return 0;
}