yaid.c: Beef up `reply' with an extra token argument.

[yaid] / yaid.h

/* -*-c-*-
 *
 * Common definitions for YAID
 *
 * (c) 2012 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Yet Another Ident Daemon (YAID).
 *
 * YAID is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * YAID is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with YAID; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef YAID_H
#define YAID_H

#ifdef __cplusplus
  extern "C" {
#endif

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <string.h>

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

#include <pwd.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <syslog.h>

#include <mLib/bits.h>
#include <mLib/conn.h>
#include <mLib/darray.h>
#include <mLib/dstr.h>
#include <mLib/fdflags.h>
#include <mLib/fwatch.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sel.h>
#include <mLib/selbuf.h>

/*----- System specifics --------------------------------------------------*/

#define SYS_UNDEF 0
#define SYS_LINUX 1

#if SYS == SYS_LINUX
#  include <linux/netlink.h>
#  include <linux/rtnetlink.h>
#else
#  error "Unsupported operating system: sorry.  Patches welcome!"
#endif

/*----- Data structures ---------------------------------------------------*/

#define ADDRLEN 64

union addr {
  struct in_addr ipv4;
  struct in6_addr ipv6;
};

struct socket {
  union addr addr;
  unsigned port;
};

struct addrpat {
  unsigned len;
  union addr addr;
};

struct portpat {
  unsigned lo, hi;
};

struct sockpat {
  struct addrpat addr;
  struct portpat port;
};

#define ADDRTYPES(_)							\
  _(ipv4, IPV4)								\
  _(ipv6, IPV6)

struct addrops {
  int af;
  const char *name;
  unsigned len;
  const union addr *any;
  const struct addrops_sys *sys;
  int (*addreq)(const union addr *, const union addr *);
  int (*match_addrpat)(const struct addrpat *, const union addr *);
  void (*socket_to_sockaddr)(const struct socket *s, void *, size_t *);
  void (*sockaddr_to_addr)(const void *, union addr *);
  int (*init_listen_socket)(int);
};

enum {
#define DEFADDR(ty, TY) ADDR_##TY,
  ADDRTYPES(DEFADDR)
#undef DEFADDR
  ADDR_LIMIT
};

extern const struct addrops addroptab[];
#define OPS_SYS(ty, TY)					\
  extern const struct addrops_sys addrops_sys_##ty;
ADDRTYPES(OPS_SYS)
#undef OPS_SYS

enum { L, R, NDIR };

#define RESPONSE(_)							\
  _(ERROR, U(error, unsigned))						\
  _(UID, U(uid, uid_t))							\
  _(NAT, U(nat, struct socket))

#define ERROR(_)							\
  _(INVPORT, "INVALID-PORT")						\
  _(NOUSER, "NO-USER")							\
  _(HIDDEN, "HIDDEN-USER")						\
  _(UNKNOWN, "UNKNOWN-ERROR")
extern const char *const errtok[];

enum {
#define DEFENUM(err, tok) E_##err,
  ERROR(DEFENUM)
#undef DEFENUM
  E_LIMIT
};

enum {
#define DEFENUM(what, branch) R_##what,
  RESPONSE(DEFENUM)
#undef DEFENUM
  R_LIMIT
};

struct query {
  const struct addrops *ao;
  struct socket s[NDIR];
  unsigned resp;
  union {
#define DEFBRANCH(WHAT, branch) branch
#define U(memb, ty) ty memb;
#define N
    RESPONSE(DEFBRANCH)
#undef U
#undef N
#undef DEFBRANCH
  } u;
} query;

enum {
  T_OK,
  T_EOL,
  T_EOF,
  T_ERROR
};

#define ACTIONS(_)							\
  _(USER, "user")							\
  _(TOKEN, "token")							\
  _(NAME, "name")							\
  _(DENY, "deny")							\
  _(HIDE, "hide")							\
  _(LIE, "lie")

enum {
#define DEFENUM(tag, word) A_##tag,
  ACTIONS(DEFENUM)
#undef DEFENUM
  A_LIMIT
};

struct action {
  unsigned act;
  union {
    unsigned user;
    char *lie;
  } u;
};

struct policy {
  const struct addrops *ao;
  struct sockpat sp[NDIR];
  struct action act;
};
#define POLICY_INIT(a) { 0, { { { 0 } } }, { a } }

struct policy_file {
  FILE *fp;
  const struct query *q;
  const char *name;
  const char *what;
  int err;
  int lno;
  struct policy p;
};

DA_DECL(policy_v, struct policy);

/*----- Functions provided ------------------------------------------------*/

int sockeq(const struct addrops *ao,
	   const struct socket *sa, const struct socket *sb);
void dputsock(dstr *d, const struct addrops *ao, const struct socket *s);

void logmsg(const struct query *q, int prio, const char *msg, ...);

void identify(struct query *q);
void init_sys(void);

void init_policy(struct policy *p);
void free_policy(struct policy *p);
void print_policy(const struct policy *p);
int match_policy(const struct policy *p, const struct query *q);
int parse_policy(FILE *fp, struct policy *p);
int open_policy_file(struct policy_file *pf, const char *name,
		     const char *what, const struct query *q);
int read_policy_file(struct policy_file *pf);
void close_policy_file(struct policy_file *pf);
int load_policy_file(const char *file, policy_v *pv);

/*----- That's all, folks -------------------------------------------------*/

#ifdef __cplusplus
  }
#endif

#endif