3 * $Id: check.c,v 1.7 1998/04/23 13:22:08 mdw Exp $
5 * Check validity of requests
10 /*----- Licensing notice --------------------------------------------------*
12 * This file is part of `become'
14 * `Become' is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * `Become' is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with `become'; if not, write to the Free Software Foundation,
26 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29 /*----- Revision history --------------------------------------------------*
32 * Revision 1.7 1998/04/23 13:22:08 mdw
33 * Support no-network configuration option, and new interface to
34 * configuration file parser.
36 * Revision 1.6 1998/01/12 16:45:47 mdw
39 * Revision 1.5 1997/09/26 09:14:58 mdw
40 * Merged blowfish branch into trunk.
42 * Revision 1.4.2.1 1997/09/26 09:08:01 mdw
43 * Use the Blowfish encryption algorithm instead of IDEA. This is partly
44 * because I prefer Blowfish (without any particularly strong evidence) but
45 * mainly because IDEA is patented and Blowfish isn't.
47 * Revision 1.4 1997/08/07 09:52:05 mdw
48 * (Log entry for previous version is bogus.) Added support for multiple
51 * Revision 1.2 1997/08/04 10:24:20 mdw
52 * Sources placed under CVS control.
54 * Revision 1.1 1997/07/21 13:47:53 mdw
59 /*----- Header files ------------------------------------------------------*/
61 /* --- ANSI headers --- */
70 /* --- Unix headers --- */
73 #include <sys/types.h>
74 #include <sys/socket.h>
76 #include <netinet/in.h>
78 #include <arpa/inet.h>
83 /* --- Local headers --- */
98 /*----- Client-end network support ----------------------------------------*/
102 /* --- @check__send@ --- *
104 * Arguments: @unsigned char *crq@ = pointer to encrypted request
105 * @int fd@ = socket to send from
106 * @struct sockaddr_in *serv@ = pointer to table of servers
107 * @size_t n_serv@ = number of servers
111 * Use: Sends the request packet to the list of servers. If the
112 * message couldn't be sent to any of them, an error is
116 static void check__send(unsigned char *crq, int fd,
117 struct sockaddr_in *serv, size_t n_serv)
123 for (i = 0; i < n_serv; i++) {
124 if (sendto(fd, (char *)crq, crq_size, 0,
125 (struct sockaddr *)(serv + i), sizeof(serv[i])) < 0) {
126 T( trace(TRACE_CLIENT, "client: send to %s failed: %s",
127 inet_ntoa(serv[i].sin_addr), strerror(errno)); )
134 die("couldn't send request to server: %s", strerror(err));
137 /* --- @check__ask@ --- *
139 * Arguments: @request *rq@ = pointer to request buffer
140 * @struct sockaddr_in *serv@ = pointer to table of servers
141 * @size_t n_serv@ = number of servers
143 * Returns: Nonzero if OK, zero if forbidden
145 * Use: Contacts a number of servers to decide whether the request
149 static int check__ask(request *rq, struct sockaddr_in *serv, size_t n_serv)
152 unsigned char crq[crq_size];
153 unsigned char sk[BLOWFISH_KEYSIZE];
157 /* --- First, build the encrypted request packet --- */
160 unsigned char k[BLOWFISH_KEYSIZE];
163 /* --- Read in the encryption key --- */
165 if ((fp = fopen(file_KEY, "r")) == 0) {
166 die("couldn't open key file `%s': %s", file_KEY,
169 tx_getBits(k, 128, fp);
171 /* --- Now build a request packet --- */
175 crypt_packRequest(rq, crq, t, pid, k, sk);
177 T( trace(TRACE_CLIENT, "client: encrypted request packet"); )
180 /* --- Create my socket --- */
183 struct sockaddr_in sin;
185 if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
186 die("couldn't create socket: %s", strerror(errno));
188 /* --- Bind myself to some address --- */
190 sin.sin_family = AF_INET;
192 sin.sin_addr.s_addr = htonl(INADDR_ANY);
194 if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
195 die("couldn't bind socket to address: %s", strerror(errno));
198 /* --- Now wait for a reply --- */
202 struct timeval start, now, tv;
206 /* --- State table for waiting for replies --- *
208 * For each number, send off the request to our servers, and wait for
209 * that many seconds to have elapsed since we started. If the number is
210 * %$-1$% then it's time to give up.
213 static int tbl[] = { 0, 5, 10, 20, -1 };
215 /* --- Find out when we are --- */
217 gettimeofday(&start, 0);
220 /* --- Now loop until everything's done --- */
223 gettimeofday(&now, 0);
225 /* --- If the current timer has expired, find one that hasn't --- *
227 * Also resend the request after I've found a timer which is still
228 * extant. If there aren't any, report an error.
231 if (now.tv_sec >= start.tv_sec + tbl[ind] &&
232 now.tv_usec >= start.tv_usec) {
236 die("no reply from servers");
237 } while (now.tv_sec >= start.tv_sec + tbl[ind] &&
238 now.tv_usec >= start.tv_usec);
239 check__send(crq, fd, serv, n_serv);
240 T( trace(TRACE_CLIENT, "client: send request to servers"); )
243 /* --- Now wait for a packet to arrive --- */
245 if (now.tv_usec > start.tv_usec) {
246 now.tv_usec -= 1000000;
249 tv.tv_sec = start.tv_sec + tbl[ind] - now.tv_sec;
250 tv.tv_usec = start.tv_usec - now.tv_usec;
252 /* --- Sort out file descriptors to watch --- */
257 /* --- Wait for them --- */
259 i = select(FD_SETSIZE, &fds, 0, 0, &tv);
260 if (i == 0 || (i < 0 && errno == EINTR))
263 die("error waiting for reply: %s", strerror(errno));
265 /* --- A reply should be waiting now --- */
268 struct sockaddr_in sin;
269 int slen = sizeof(sin);
270 unsigned char buff[256];
273 /* --- Read the reply data --- */
275 if (recvfrom(fd, (char *)buff, sizeof(buff), 0,
276 (struct sockaddr *)&sin, &slen) < 0)
277 die("error reading server's reply: %s", strerror(errno));
279 IF_TRACING(TRACE_CLIENT, {
280 struct hostent *h = gethostbyaddr((char *)&sin.sin_addr,
281 sizeof(sin.sin_addr), AF_INET);
282 trace(TRACE_CLIENT, "client: reply received from %s port %i",
283 h ? h->h_name : inet_ntoa(sin.sin_addr),
284 ntohs(sin.sin_port));
287 /* --- Verify the sender --- *
289 * This is more to avoid confusion than for security: an active
290 * attacker is quite capable of forging the source address. We rely
291 * on the checksum in the reply packet for authentication.
294 for (i = 0; i < n_serv; i++) {
295 if (sin.sin_addr.s_addr == serv[i].sin_addr.s_addr &&
296 sin.sin_port == serv[i].sin_port)
300 T( trace(TRACE_CLIENT, "client: reply from unknown host"); )
304 /* --- Unpack and verify the response --- */
306 answer = crypt_unpackReply(buff, sk, t, pid);
308 T( trace(TRACE_CLIENT,
309 "client: invalid or corrupt reply packet"); )
317 die("internal error: can't get here in check__ask");
321 /* --- @check__client@ --- *
323 * Arguments: @request *rq@ = pointer to a request block
324 * @FILE *fp@ = file containing server configuration
326 * Returns: Nonzero if OK, zero if forbidden
328 * Use: Asks one or several servers whether a request is acceptable.
331 int check__client(request *rq, FILE *fp)
333 /* --- Format of the file --- *
335 * The `servers' file contains entries of the form
337 * %%\syntax{<host> [`:' <port>]}%%
339 * separates by whitespace. I build them all into an array of socket
340 * addresses and pass the whole lot to another function.
343 struct sockaddr_in *serv; /* Array of servers */
344 size_t n_serv, max_serv; /* Number and maximum number */
346 /* --- Initialise the server array --- */
348 T( trace(TRACE_CLIENT, "client: reading server definitions"); )
349 n_serv = 0; max_serv = 4; /* Four seems reasonable */
350 serv = xmalloc(sizeof(*serv) * max_serv);
352 /* --- Start reading the file --- */
355 char buff[256], *p, *l; /* A buffer and pointers for it */
356 int port; /* Default port for servers */
357 int state; /* Current parser state */
358 struct in_addr t_host; /* Temp place for an address*/
359 int t_port; /* Temp place for a port */
360 int ch; /* The current character */
362 /* --- Parser states --- */
365 st_start, /* Waiting to begin */
366 st_host, /* Reading a new hostname */
367 st_colon, /* Expecting a colon, maybe */
368 st_preport, /* Waiting before reading port */
369 st_port, /* Reading a port number */
370 st_commit, /* Commit a newly read server */
371 st_done /* Finished reading the file */
374 /* --- Find a default port --- */
377 struct servent *s = getservbyname(quis(), "udp");
378 port = (s ? s->s_port : -1);
381 /* --- Initialise for scanning the file --- */
385 l = buff + sizeof(buff);
389 /* --- Go for it --- */
391 while (state != st_done) {
394 /* --- Initial whitespace before hostname --- */
399 else if (isspace((unsigned char)ch))
405 /* --- Read a host name --- */
409 die("string too long in `" file_SERVER "'");
410 if (ch != EOF && !isspace((unsigned char)ch) && ch != ':') {
417 if ((h = gethostbyname(buff)) == 0)
418 die("unknown host `%s' in `" file_SERVER "'", buff);
419 memcpy(&t_host, h->h_addr, sizeof(t_host));
424 /* --- Waiting for a colon coming up --- */
429 else if (isspace((unsigned char)ch))
431 else if (ch == ':') {
439 /* --- Clearing whitespace before a port number --- */
444 else if (isspace((unsigned char)ch))
452 /* --- Read a port number --- */
456 die("string too long in `" file_SERVER "'");
457 if (ch != EOF && !isspace((unsigned char)ch) && ch != ':') {
464 s = getservbyname(buff, "udp");
465 if (!s && isdigit((unsigned char)buff[0]))
466 t_port = htons(atoi(buff));
468 die("unknown service `%s' in `" file_SERVER "'", buff);
475 /* --- A server has been read successfully --- */
478 if (n_serv == max_serv) {
480 serv = xrealloc(serv, max_serv * sizeof(*serv));
482 serv[n_serv].sin_family = AF_INET;
483 serv[n_serv].sin_addr = t_host;
484 serv[n_serv].sin_port = t_port;
491 /* --- A safety net for a broken parser --- */
494 die("internal error: can't get here in check__client");
502 /* --- Now start sending requests --- */
505 die("no servers specified in `" file_SERVER "'");
507 IF_TRACING(TRACE_CLIENT, {
510 for (i = 0; i < n_serv; i++) {
511 trace(TRACE_CLIENT, "client: server %s port %i",
512 inet_ntoa(serv[i].sin_addr), ntohs(serv[i].sin_port));
515 return (check__ask(rq, serv, n_serv));
520 /*----- Main checking function --------------------------------------------*/
524 * Arguments: @request *rq@ = pointer to request buffer
526 * Returns: Nonzero if OK, zero if forbidden
528 * Use: Checks to see if the request is acceptable.
531 int check(request *rq)
535 /* --- Check if we need to talk to a server --- */
538 if ((fp = fopen(file_SERVER, "r")) != 0)
539 return (check__client(rq, fp));
542 /* --- Otherwise do this all the old-fashioned way --- */
544 if ((fp = fopen(file_RULES, "r")) == 0) {
545 die("couldn't read configuration file `%s': %s",
546 file_RULES, strerror(errno));
558 return (rule_check(rq));
561 /*----- That's all, folks -------------------------------------------------*/