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 ------------------------------------------------------*/
48 #include <sys/types.h>
55 #include <sys/socket.h>
56 #include <netinet/in.h>
57 #include <arpa/inet.h>
61 #include <mLib/bits.h>
62 #include <mLib/conn.h>
63 #include <mLib/darray.h>
64 #include <mLib/dstr.h>
65 #include <mLib/fdflags.h>
66 #include <mLib/fwatch.h>
67 #include <mLib/quis.h>
68 #include <mLib/report.h>
70 #include <mLib/selbuf.h>
72 /*----- Address family handling -------------------------------------------*/
74 /* The maximum length of an address formatted as a text string, including the
75 * terminating null byte.
79 /* A list of address types. */
80 #define ADDRTYPES(_) \
84 /* Address types for the various families, in the form acceptable to
85 * inet_ntop(3) and inet_pton(3). */
86 #define TYPE_IPV4 struct in_addr
87 #define TYPE_IPV6 struct in6_addr
89 /* A union of address types. */
91 #define UMEMB(ty, TY) TYPE_##TY ty;
96 /* A socket holds an address and a port number. */
98 union addr addr
; /* The address */
99 unsigned port
; /* The port, in /host/ byte order */
102 /* An address pattern consists of an address and a prefix length: the
103 * pattern matches an address if they agree in the first LEN bits.
106 union addr addr
; /* The base address */
107 unsigned len
; /* The prefix length */
110 /* A port pattern matches a port if the port is within the stated (inclusive)
117 /* A socket pattern consists simply of an address pattern and a port pattern:
118 * it matches a socket componentwise.
125 /* The table of address-type operations. Each address family has one of
126 * these, so that most of the program doesn't need to worry about these
130 int af
; /* The AF_* constant */
131 const char *name
; /* Name of the protocol, for logs */
132 unsigned len
; /* Length of an address, in bits */
133 const union addr
*any
; /* A wildcard address */
134 const struct addrops_sys
*sys
; /* Pointer to system-specific ops */
136 int (*addreq
)(const union addr
*, const union addr
*);
137 /* Return nonzero if the two addresses are equal. */
139 int (*match_addrpat
)(const struct addrpat
*, const union addr
*);
140 /* Return nonzero if the pattern matches the address. */
142 void (*socket_to_sockaddr
)(const struct socket
*s
, void *, size_t *);
143 /* Convert a socket structure to a `struct sockaddr', and return the
144 * size of the latter.
147 void (*sockaddr_to_addr
)(const void *, union addr
*);
148 /* Extract the address from a `struct sockaddr'. */
150 int (*init_listen_socket
)(int);
151 /* Perform any necessary extra operations on a socket which is going
152 * to be used to listen for incoming connections.
156 /* A handy constant for each address family. These are more useful than the
157 * AF_* constants in that they form a dense sequence.
160 #define DEFADDR(ty, TY) ADDR_##TY,
166 /* The table of address operations, indexed by the ADDR_* constants defined
169 extern const struct addrops addroptab
[];
171 /* System-specific operations, provided by the system-specific code for its
174 #define OPS_SYS(ty, TY) \
175 extern const struct addrops_sys addrops_sys_##ty;
179 /* Answer whether the sockets SA and SB are equal. */
180 extern int sockeq(const struct addrops */
*ao*/
,
181 const struct socket */
*sa*/
, const struct socket */
*sb*/
);
183 /* Write a textual description of S to the string D. */
184 extern void dputsock(dstr */
*d*/
, const struct addrops */
*ao*/
,
185 const struct socket */
*s*/
);
187 /*----- Queries and responses ---------------------------------------------*/
189 /* Constants for describing the `L'ocal and `R'emote ends of a connection. */
192 /* Response types, and the data needed to represent any associated data. A
193 * U(MEMB, TYPE) constructs a union member; an N means no associated data.
195 #define RESPONSE(_) \
196 _(ERROR, U(error, unsigned)) \
197 _(UID, U(uid, uid_t)) \
198 _(NAT, U(nat, struct socket))
201 #define DEFENUM(what, branch) R_##what,
207 /* Protocol error tokens. */
209 _(INVPORT, "INVALID-PORT") \
210 _(NOUSER, "NO-USER") \
211 _(HIDDEN, "HIDDEN-USER") \
212 _(UNKNOWN, "UNKNOWN-ERROR")
215 #define DEFENUM(err, tok) E_##err,
221 extern const char *const errtok
[];
223 /* The query structure keeps together the parameters to the client's query
224 * and our response to it.
227 const struct addrops
*ao
; /* Address family operations */
228 struct socket s
[NDIR
]; /* The local and remote ends */
229 unsigned resp
; /* Our response type */
230 union { /* A union of response data */
231 #define DEFBRANCH(WHAT, branch) branch
232 #define U(memb, ty) ty memb;
241 /*----- Common utility functions ------------------------------------------*/
243 /* Format and log MSG somewhere sensible, at the syslog(3) priority PRIO.
244 * Prefix it with a description of the query Q, if non-null.
246 extern void logmsg(const struct query */
*q*/
,
247 int /*prio*/, const char */
*msg*/
, ...);
249 /*----- System-specific connection identification code --------------------*/
251 /* Find out who is responsible for the connection described in the query Q.
252 * Write the answer to Q. Errors are logged and reported via the query
255 extern void identify(struct query */
*q*/
);
257 /* Initialize the system-specific code. */
258 extern void init_sys(void);
260 /*----- Policy management -------------------------------------------------*/
262 /* The possible policy actions and their names. */
272 #define DEFENUM(tag, word) A_##tag,
278 /* A policy action. */
282 unsigned user
; /* Bitmask of permitted actions */
283 char *lie
; /* The user name to impersonate */
287 /* A user pattern matches a user if the uid is within the given bounds. */
292 /* A policy rule: if the query matches the pattern, then perform the
296 const struct addrops
*ao
;
297 struct sockpat sp
[NDIR
];
301 #define POLICY_INIT(a) { .act.act = a }
302 DA_DECL(policy_v
, struct policy
);
304 /* Initialize a policy structure. In this state, it doesn't actually have
305 * any resources allocated (so can be simply discarded) but it's safe to free
306 * (using `free_policy').
308 extern void init_policy(struct policy */
*p*/
);
310 /* Free a policy structure, resetting it to its freshly-initialized state.
311 * This function is idempotent.
313 extern void free_policy(struct policy */
*p*/
);
315 /* Print a policy rule to standard output. */
316 extern void print_policy(const struct policy */
*p*/
);
318 /* Return true if the query matches the patterns in the policy rule. */
319 extern int match_policy(const struct policy */
*p*/
,
320 const struct query */
*q*/
);
322 /*----- Parsing policy files ----------------------------------------------*/
324 /* Possible results from a parse. */
326 T_OK
, /* Successful: results returned */
327 T_EOL
, /* End-of-line found immediately */
328 T_EOF
, /* End-of-file found immediately */
329 T_ERROR
/* Some kind of error occurred */
332 /* A context for parsing a policy file. */
334 FILE *fp
; /* The file to read from */
335 const struct query
*q
; /* A query to use for logging */
336 const char *name
; /* The name of the file */
337 const char *what
; /* A description of the file */
338 int err
; /* Have there been any errors? */
339 int lno
; /* The current line number */
340 struct policy p
; /* Parsed policy rule goes here */
343 /* Open a policy file by NAME. The description WHAT and query Q are used for
344 * formatting error messages for the log.
346 extern int open_policy_file(struct policy_file */
*pf*/
, const char */
*name*/
,
347 const char */
*what*/
, const struct query */
*q*/
);
349 /* Read a policy rule from the file, storing it in PF->p. Return one of the
352 extern int read_policy_file(struct policy_file */
*pf*/
);
354 /* Close a policy file. It doesn't matter whether the file was completely
357 extern void close_policy_file(struct policy_file */
*pf*/
);
359 /* Load a policy file, writing a vector of records into PV. If the policy
360 * file has errors, then leave PV unchanged and return nonzero.
362 extern int load_policy_file(const char */
*file*/
, policy_v */
*pv*/
);
364 /*----- That's all, folks -------------------------------------------------*/