daemon.c File Reference

commotiond - an embedded C daemon for managing mesh networks. More...

#include <stdlib.h>
#include <stdio.h>
#include <getopt.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <arpa/inet.h>
#include <limits.h>
#include "config.h"
#include "debug.h"
#include "cmd.h"
#include "util.h"
#include "loop.h"
#include "plugin.h"
#include "process.h"
#include "profile.h"
#include "socket.h"
#include "msg.h"
#include "iface.h"
#include "id.h"
#include "obj.h"
#include "list.h"
#include "tree.h"

Macros
#define	REQUEST_MAX   1024
#define	RESPONSE_MAX   1024

Functions
	SCHEMA (default)
	SCHEMA (global)
	CMD (help)
	CMD (profiles)
	CMD (up)
	CMD (down)
	CMD (status)
	CMD (state)
	CMD (nodeid)
	CMD (genip)
	CMD (genbssid)
	CMD (set)
	CMD (get)
	CMD (save)
	CMD (new)
	CMD (delete)
int	dispatcher_cb (co_obj_t *self, co_obj_t *fd)
	sends/receives socket messages More...
int	main (int argc, char *argv[])
	Creates sockets for event loop, daemon and dispatcher. Starts/stops event loop.

Variables
co_socket_t	unix_socket_proto

Detailed Description

commotiond - an embedded C daemon for managing mesh networks.

Author

Josh King (jheretic), jking.nosp@m.@cha.nosp@m.mbana.nosp@m..net

Function Documentation

int dispatcher_cb	(	co_obj_t *	self,
		co_obj_t *	fd
	)

sends/receives socket messages

Parameters

self	pointer to dispatcher socket struct
fd	file descriptor object of connected socket

References co_cmd_exec(), co_list_element(), co_list_import(), co_response_alloc(), and co_tree_insert().

Referenced by main().

                                                {
  CHECK(IS_SOCK(self),"Not a socket.");
  co_socket_t *sock = (co_socket_t*)self;
  char reqbuf[REQUEST_MAX];
  memset(reqbuf, '\0', sizeof(reqbuf));
  ssize_t reqlen = 0;
  char respbuf[RESPONSE_MAX];
  memset(respbuf, '\0', sizeof(respbuf));
  size_t resplen = 0;
  co_obj_t *request = NULL;
  uint8_t *type = NULL;
  uint32_t *id = NULL;
  co_obj_t *nil = co_nil_create(0);

  /* Incoming message on socket */
  reqlen = sock->receive((co_obj_t*)sock, fd, reqbuf, sizeof(reqbuf));
  DEBUG("Received %d bytes.", (int)reqlen);
  if(reqlen == 0) {
    INFO("Received connection.");
    return 1;
  }
  if (reqlen < 0) {
    INFO("Connection recvd() -1");
    sock->hangup((co_obj_t*)sock, fd);
    return 1;
  }
  /* If it's a commotion message type, parse the header, target and payload */
  CHECK(co_list_import(&request, reqbuf, reqlen) > 0, "Failed to import request.");
  co_obj_data((char **)&type, co_list_element(request, 0)); 
  CHECK(*type == 0, "Not a valid request.");
  CHECK(co_obj_data((char **)&id, co_list_element(request, 1)) == sizeof(uint32_t), "Not a valid request ID.");
  co_obj_t *ret = NULL;
  if(co_cmd_exec(co_list_element(request, 2), &ret, co_list_element(request, 3)))
  {
    resplen = co_response_alloc(respbuf, sizeof(respbuf), *id, nil, ret);
    sock->send(fd, respbuf, resplen);
  }
  else
  {
    if(ret == NULL)
    {
      ret = co_tree16_create();
      co_tree_insert(ret, "error", sizeof("error"), co_str8_create("Incorrect command.", sizeof("Incorrect command."), 0));
    }
    resplen = co_response_alloc(respbuf, sizeof(respbuf), *id, ret, nil);
    sock->send(fd, respbuf, resplen);
  }

  co_obj_free(nil);
  co_obj_free(request);
  co_obj_free(ret);
  return 1;
error:
  co_obj_free(nil);
  co_obj_free(request);
  co_obj_free(ret);
  return 1;
}