3 * Common definitions for YAID
5 * (c) 2012 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of Yet Another Ident Daemon (YAID).
12 * YAID is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * YAID is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with YAID; if not, write to the Free Software Foundation,
24 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
34 /*----- Header files ------------------------------------------------------*/
47 #include <sys/types.h>
53 #include <sys/socket.h>
54 #include <netinet/in.h>
55 #include <arpa/inet.h>
59 #include <mLib/bits.h>
60 #include <mLib/conn.h>
61 #include <mLib/darray.h>
62 #include <mLib/dstr.h>
63 #include <mLib/fdflags.h>
64 #include <mLib/fwatch.h>
65 #include <mLib/quis.h>
66 #include <mLib/report.h>
68 #include <mLib/selbuf.h>
70 /*----- Address family handling -------------------------------------------*/
72 /* The maximum length of an address formatted as a text string, including the
73 * terminating null byte.
77 /* A list of address types. */
78 #define ADDRTYPES(_) \
82 /* Address types for the various families, in the form acceptable to
83 * inet_ntop(3) and inet_pton(3). */
84 #define TYPE_IPV4 struct in_addr
85 #define TYPE_IPV6 struct in6_addr
87 /* A union of address types. */
89 #define UMEMB(ty, TY) TYPE_##TY ty;
94 /* A socket holds an address and a port number. */
96 union addr addr
; /* The address */
97 unsigned port
; /* The port, in /host/ byte order */
100 /* An address pattern consists of an address and a prefix length: the
101 * pattern matches an address if they agree in the first LEN bits.
104 union addr addr
; /* The base address */
105 unsigned len
; /* The prefix length */
108 /* A port pattern matches a port if the port is within the stated (inclusive)
115 /* A socket pattern consists simply of an address pattern and a port pattern:
116 * it matches a socket componentwise.
123 /* The table of address-type operations. Each address family has one of
124 * these, so that most of the program doesn't need to worry about these
128 int af
; /* The AF_* constant */
129 const char *name
; /* Name of the protocol, for logs */
130 unsigned len
; /* Length of an address, in bits */
131 const union addr
*any
; /* A wildcard address */
132 const struct addrops_sys
*sys
; /* Pointer to system-specific ops */
134 int (*addreq
)(const union addr
*, const union addr
*);
135 /* Return nonzero if the two addresses are equal. */
137 int (*match_addrpat
)(const struct addrpat
*, const union addr
*);
138 /* Return nonzero if the pattern matches the address. */
140 void (*socket_to_sockaddr
)(const struct socket
*s
, void *, size_t *);
141 /* Convert a socket structure to a `struct sockaddr', and return the
142 * size of the latter.
145 void (*sockaddr_to_addr
)(const void *, union addr
*);
146 /* Extract the address from a `struct sockaddr'. */
148 int (*init_listen_socket
)(int);
149 /* Perform any necessary extra operations on a socket which is going
150 * to be used to listen for incoming connections.
154 /* A handy constant for each address family. These are more useful than the
155 * AF_* constants in that they form a dense sequence.
158 #define DEFADDR(ty, TY) ADDR_##TY,
164 /* The table of address operations, indexed by the ADDR_* constants defined
167 extern const struct addrops addroptab
[];
169 /* System-specific operations, provided by the system-specific code for its
172 #define OPS_SYS(ty, TY) \
173 extern const struct addrops_sys addrops_sys_##ty;
177 /* Answer whether the sockets SA and SB are equal. */
178 extern int sockeq(const struct addrops */
*ao*/
,
179 const struct socket */
*sa*/
, const struct socket */
*sb*/
);
181 /* Write a textual description of S to the string D. */
182 extern void dputsock(dstr */
*d*/
, const struct addrops */
*ao*/
,
183 const struct socket */
*s*/
);
185 /*----- Queries and responses ---------------------------------------------*/
187 /* Constants for describing the `L'ocal and `R'emote ends of a connection. */
190 /* Response types, and the data needed to represent any associated data. A
191 * U(MEMB, TYPE) constructs a union member; an N means no associated data.
193 #define RESPONSE(_) \
194 _(ERROR, U(error, unsigned)) \
195 _(UID, U(uid, uid_t)) \
196 _(NAT, U(nat, struct socket))
199 #define DEFENUM(what, branch) R_##what,
205 /* Protocol error tokens. */
207 _(INVPORT, "INVALID-PORT") \
208 _(NOUSER, "NO-USER") \
209 _(HIDDEN, "HIDDEN-USER") \
210 _(UNKNOWN, "UNKNOWN-ERROR")
213 #define DEFENUM(err, tok) E_##err,
219 extern const char *const errtok
[];
221 /* The query structure keeps together the parameters to the client's query
222 * and our response to it.
225 const struct addrops
*ao
; /* Address family operations */
226 struct socket s
[NDIR
]; /* The local and remote ends */
227 unsigned resp
; /* Our response type */
228 union { /* A union of response data */
229 #define DEFBRANCH(WHAT, branch) branch
230 #define U(memb, ty) ty memb;
239 /*----- Common utility functions ------------------------------------------*/
241 /* Format and log MSG somewhere sensible, at the syslog(3) priority PRIO.
242 * Prefix it with a description of the query Q, if non-null.
244 extern void logmsg(const struct query */
*q*/
,
245 int /*prio*/, const char */
*msg*/
, ...);
247 /*----- System-specific connection identification code --------------------*/
249 /* Find out who is responsible for the connection described in the query Q.
250 * Write the answer to Q. Errors are logged and reported via the query
253 extern void identify(struct query */
*q*/
);
255 /* Initialize the system-specific code. */
256 extern void init_sys(void);
258 /*----- Policy management -------------------------------------------------*/
260 /* The possible policy actions and their names. */
270 #define DEFENUM(tag, word) A_##tag,
276 /* A policy action. */
280 unsigned user
; /* Bitmask of permitted actions */
281 char *lie
; /* The user name to impersonate */
285 /* A policy rule: if the query matches the pattern, then perform the
289 const struct addrops
*ao
;
290 struct sockpat sp
[NDIR
];
293 #define POLICY_INIT(a) { .act.act = a }
294 DA_DECL(policy_v
, struct policy
);
296 /* Initialize a policy structure. In this state, it doesn't actually have
297 * any resources allocated (so can be simply discarded) but it's safe to free
298 * (using `free_policy').
300 extern void init_policy(struct policy */
*p*/
);
302 /* Free a policy structure, resetting it to its freshly-initialized state.
303 * This function is idempotent.
305 extern void free_policy(struct policy */
*p*/
);
307 /* Print a policy rule to standard output. */
308 extern void print_policy(const struct policy */
*p*/
);
310 /* Return true if the query matches the patterns in the policy rule. */
311 extern int match_policy(const struct policy */
*p*/
,
312 const struct query */
*q*/
);
314 /*----- Parsing policy files ----------------------------------------------*/
316 /* Possible results from a parse. */
318 T_OK
, /* Successful: results returned */
319 T_EOL
, /* End-of-line found immediately */
320 T_EOF
, /* End-of-file found immediately */
321 T_ERROR
/* Some kind of error occurred */
324 /* A context for parsing a policy file. */
326 FILE *fp
; /* The file to read from */
327 const struct query
*q
; /* A query to use for logging */
328 const char *name
; /* The name of the file */
329 const char *what
; /* A description of the file */
330 int err
; /* Have there been any errors? */
331 int lno
; /* The current line number */
332 struct policy p
; /* Parsed policy rule goes here */
335 /* Open a policy file by NAME. The description WHAT and query Q are used for
336 * formatting error messages for the log.
338 extern int open_policy_file(struct policy_file */
*pf*/
, const char */
*name*/
,
339 const char */
*what*/
, const struct query */
*q*/
);
341 /* Read a policy rule from the file, storing it in PF->p. Return one of the
344 extern int read_policy_file(struct policy_file */
*pf*/
);
346 /* Close a policy file. It doesn't matter whether the file was completely
349 extern void close_policy_file(struct policy_file */
*pf*/
);
351 /* Load a policy file, writing a vector of records into PV. If the policy
352 * file has errors, then leave PV unchanged and return nonzero.
354 extern int load_policy_file(const char */
*file*/
, policy_v */
*pv*/
);
356 /*----- That's all, folks -------------------------------------------------*/