Replace all casts of NULL to something with NULL.
[dragonfly.git] / lib / libc / rpc / auth_time.c
CommitLineData
984263bc
MD
1/*
2 * auth_time.c
3 *
4 * This module contains the private function __rpc_get_time_offset()
5 * which will return the difference in seconds between the local system's
6 * notion of time and a remote server's notion of time. This must be
7 * possible without calling any functions that may invoke the name
8 * service. (netdir_getbyxxx, getXbyY, etc). The function is used in the
9 * synchronize call of the authdes code to synchronize clocks between
10 * NIS+ clients and their servers.
11 *
12 * Note to minimize the amount of duplicate code, portions of the
13 * synchronize() function were folded into this code, and the synchronize
14 * call becomes simply a wrapper around this function. Further, if this
15 * function is called with a timehost it *DOES* recurse to the name
16 * server so don't use it in that mode if you are doing name service code.
17 *
18 * Copyright (c) 1992 Sun Microsystems Inc.
19 * All rights reserved.
20 *
21 * Side effects :
22 * When called a client handle to a RPCBIND process is created
23 * and destroyed. Two strings "netid" and "uaddr" are malloc'd
24 * and returned. The SIGALRM processing is modified only if
25 * needed to deal with TCP connections.
26 *
ce0e08e2
PA
27 * @(#)auth_time.c 1.4 92/11/10 SMI
28 * $FreeBSD: src/lib/libc/rpc/auth_time.c,v 1.12 2007/09/20 22:35:24 matteo Exp $
c9b6181e 29 * $DragonFly: src/lib/libc/rpc/auth_time.c,v 1.4 2005/11/13 12:27:04 swildner Exp $
984263bc 30 */
ce0e08e2 31
17ea2221 32#include "namespace.h"
984263bc
MD
33#include <stdio.h>
34#include <syslog.h>
35#include <string.h>
36#include <stdlib.h>
37#include <unistd.h>
38#include <netdb.h>
39#include <sys/signal.h>
40#include <sys/errno.h>
41#include <sys/socket.h>
42#include <netinet/in.h>
43#include <arpa/inet.h>
44#include <rpc/rpc.h>
45#include <rpc/rpc_com.h>
ce0e08e2 46#include <rpc/rpcb_prot.h>
984263bc
MD
47#undef NIS
48#include <rpcsvc/nis.h>
17ea2221 49#include "un-namespace.h"
984263bc 50
ce0e08e2 51extern int _rpc_dtablesize(void);
984263bc
MD
52
53#ifdef TESTING
54#define msg(x) printf("ERROR: %s\n", x)
55/* #define msg(x) syslog(LOG_ERR, "%s", x) */
56#else
57#define msg(x)
58#endif
59
60static int saw_alarm = 0;
61
62static void
c9b6181e 63alarm_hndler(int s)
984263bc
MD
64{
65 saw_alarm = 1;
66 return;
67}
68
69/*
70 * The internet time server defines the epoch to be Jan 1, 1900
71 * whereas UNIX defines it to be Jan 1, 1970. To adjust the result
72 * from internet time-service time, into UNIX time we subtract the
73 * following offset :
74 */
75#define NYEARS (1970 - 1900)
76#define TOFFSET ((u_long)60*60*24*(365*NYEARS + (NYEARS/4)))
77
78
79/*
80 * Stolen from rpc.nisd:
81 * Turn a 'universal address' into a struct sockaddr_in.
82 * Bletch.
83 */
c9b6181e
SW
84static int
85uaddr_to_sockaddr(char *uaddr, struct sockaddr_in *sin)
984263bc
MD
86{
87 unsigned char p_bytes[2];
88 int i;
89 unsigned long a[6];
90
91 i = sscanf(uaddr, "%lu.%lu.%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2],
92 &a[3], &a[4], &a[5]);
93
94 if (i < 6)
95 return(1);
96
97 for (i = 0; i < 4; i++)
98 sin->sin_addr.s_addr |= (a[i] & 0x000000FF) << (8 * i);
99
100 p_bytes[0] = (unsigned char)a[4] & 0x000000FF;
101 p_bytes[1] = (unsigned char)a[5] & 0x000000FF;
102
103 sin->sin_family = AF_INET; /* always */
104 bcopy((char *)&p_bytes, (char *)&sin->sin_port, 2);
105
106 return (0);
107}
108
109/*
110 * free_eps()
111 *
112 * Free the strings that were strduped into the eps structure.
113 */
114static void
c9b6181e 115free_eps(endpoint eps[], int num)
984263bc
MD
116{
117 int i;
118
119 for (i = 0; i < num; i++) {
120 free(eps[i].uaddr);
121 free(eps[i].proto);
122 free(eps[i].family);
123 }
124 return;
125}
126
127/*
128 * get_server()
129 *
130 * This function constructs a nis_server structure description for the
131 * indicated hostname.
132 *
133 * NOTE: There is a chance we may end up recursing here due to the
134 * fact that gethostbyname() could do an NIS search. Ideally, the
135 * NIS+ server will call __rpc_get_time_offset() with the nis_server
136 * structure already populated.
137 */
138static nis_server *
c9b6181e
SW
139get_server(struct sockaddr_in *sin,
140 char *host, /* name of the time host */
141 nis_server *srv, /* nis_server struct to use. */
142 endpoint eps[], /* array of endpoints */
143 int maxep) /* max array size */
984263bc
MD
144{
145 char hname[256];
146 int num_ep = 0, i;
147 struct hostent *he;
148 struct hostent dummy;
149 char *ptr[2];
ce0e08e2 150 endpoint *ep;
984263bc
MD
151
152 if (host == NULL && sin == NULL)
153 return (NULL);
154
155 if (sin == NULL) {
156 he = gethostbyname(host);
157 if (he == NULL)
158 return(NULL);
159 } else {
160 he = &dummy;
161 ptr[0] = (char *)&sin->sin_addr.s_addr;
162 ptr[1] = NULL;
163 dummy.h_addr_list = ptr;
164 }
165
166 /*
167 * This is lame. We go around once for TCP, then again
168 * for UDP.
169 */
ce0e08e2
PA
170 for (i = 0, ep = eps; (he->h_addr_list[i] != NULL) && (num_ep < maxep);
171 i++, ep++, num_ep++) {
984263bc
MD
172 struct in_addr *a;
173
174 a = (struct in_addr *)he->h_addr_list[i];
175 snprintf(hname, sizeof(hname), "%s.0.111", inet_ntoa(*a));
ce0e08e2
PA
176 ep->uaddr = strdup(hname);
177 ep->family = strdup("inet");
178 ep->proto = strdup("tcp");
179 if (ep->uaddr == NULL || ep->family == NULL || ep->proto == NULL) {
180 free_eps(eps, num_ep + 1);
181 return (NULL);
182 }
984263bc
MD
183 }
184
185 for (i = 0; (he->h_addr_list[i] != NULL) && (num_ep < maxep);
ce0e08e2 186 i++, ep++, num_ep++) {
984263bc
MD
187 struct in_addr *a;
188
189 a = (struct in_addr *)he->h_addr_list[i];
190 snprintf(hname, sizeof(hname), "%s.0.111", inet_ntoa(*a));
ce0e08e2
PA
191 ep->uaddr = strdup(hname);
192 ep->family = strdup("inet");
193 ep->proto = strdup("udp");
194 if (ep->uaddr == NULL || ep->family == NULL || ep->proto == NULL) {
195 free_eps(eps, num_ep + 1);
196 return (NULL);
197 }
984263bc
MD
198 }
199
200 srv->name = (nis_name) host;
201 srv->ep.ep_len = num_ep;
202 srv->ep.ep_val = eps;
203 srv->key_type = NIS_PK_NONE;
204 srv->pkey.n_bytes = NULL;
205 srv->pkey.n_len = 0;
206 return (srv);
207}
208
209/*
210 * __rpc_get_time_offset()
211 *
212 * This function uses a nis_server structure to contact the a remote
213 * machine (as named in that structure) and returns the offset in time
214 * between that machine and this one. This offset is returned in seconds
215 * and may be positive or negative.
216 *
217 * The first time through, a lot of fiddling is done with the netconfig
218 * stuff to find a suitable transport. The function is very aggressive
219 * about choosing UDP or at worst TCP if it can. This is because
220 * those transports support both the RCPBIND call and the internet
221 * time service.
222 *
223 * Once through, *uaddr is set to the universal address of
224 * the machine and *netid is set to the local netid for the transport
225 * that uaddr goes with. On the second call, the netconfig stuff
226 * is skipped and the uaddr/netid pair are used to fetch the netconfig
227 * structure and to then contact the machine for the time.
228 *
229 * td = "server" - "client"
230 */
231int
c9b6181e
SW
232__rpc_get_time_offset(struct timeval *td, /* Time difference */
233 nis_server *srv, /* NIS Server description */
234 char *thost, /* if no server, this is the timehost */
235 char **uaddr, /* known universal address */
236 struct sockaddr_in *netid)/* known network identifier */
984263bc
MD
237{
238 CLIENT *clnt; /* Client handle */
239 endpoint *ep, /* useful endpoints */
240 *useep = NULL; /* endpoint of xp */
241 char *useua = NULL; /* uaddr of selected xp */
242 int epl, i; /* counters */
243 enum clnt_stat status; /* result of clnt_call */
244 u_long thetime, delta;
245 int needfree = 0;
246 struct timeval tv;
247 int time_valid;
248 int udp_ep = -1, tcp_ep = -1;
249 int a1, a2, a3, a4;
250 char ut[64], ipuaddr[64];
251 endpoint teps[32];
252 nis_server tsrv;
253 void (*oldsig)() = NULL; /* old alarm handler */
254 struct sockaddr_in sin;
ce0e08e2
PA
255 socklen_t len;
256 int s = RPC_ANYSOCK;
984263bc
MD
257 int type = 0;
258
259 td->tv_sec = 0;
260 td->tv_usec = 0;
261
262 /*
263 * First check to see if we need to find and address for this
264 * server.
265 */
266 if (*uaddr == NULL) {
267 if ((srv != NULL) && (thost != NULL)) {
268 msg("both timehost and srv pointer used!");
269 return (0);
270 }
271 if (! srv) {
272 srv = get_server(netid, thost, &tsrv, teps, 32);
273 if (srv == NULL) {
274 msg("unable to contruct server data.");
275 return (0);
276 }
277 needfree = 1; /* need to free data in endpoints */
278 }
279
280 ep = srv->ep.ep_val;
281 epl = srv->ep.ep_len;
282
283 /* Identify the TCP and UDP endpoints */
284 for (i = 0;
285 (i < epl) && ((udp_ep == -1) || (tcp_ep == -1)); i++) {
286 if (strcasecmp(ep[i].proto, "udp") == 0)
287 udp_ep = i;
288 if (strcasecmp(ep[i].proto, "tcp") == 0)
289 tcp_ep = i;
290 }
291
292 /* Check to see if it is UDP or TCP */
293 if (tcp_ep > -1) {
294 useep = &ep[tcp_ep];
295 useua = ep[tcp_ep].uaddr;
296 type = SOCK_STREAM;
297 } else if (udp_ep > -1) {
298 useep = &ep[udp_ep];
299 useua = ep[udp_ep].uaddr;
300 type = SOCK_DGRAM;
301 }
302
303 if (useep == NULL) {
304 msg("no acceptable transport endpoints.");
305 if (needfree)
306 free_eps(teps, tsrv.ep.ep_len);
307 return (0);
308 }
309 }
310
311 /*
312 * Create a sockaddr from the uaddr.
313 */
314 if (*uaddr != NULL)
315 useua = *uaddr;
316
317 /* Fixup test for NIS+ */
318 sscanf(useua, "%d.%d.%d.%d.", &a1, &a2, &a3, &a4);
319 sprintf(ipuaddr, "%d.%d.%d.%d.0.111", a1, a2, a3, a4);
320 useua = &ipuaddr[0];
321
322 bzero((char *)&sin, sizeof(sin));
323 if (uaddr_to_sockaddr(useua, &sin)) {
324 msg("unable to translate uaddr to sockaddr.");
325 if (needfree)
326 free_eps(teps, tsrv.ep.ep_len);
327 return (0);
328 }
329
330 /*
331 * Create the client handle to rpcbind. Note we always try
332 * version 3 since that is the earliest version that supports
333 * the RPCB_GETTIME call. Also it is the version that comes
334 * standard with SVR4. Since most everyone supports TCP/IP
335 * we could consider trying the rtime call first.
336 */
337 clnt = clnttcp_create(&sin, RPCBPROG, RPCBVERS, &s, 0, 0);
338 if (clnt == NULL) {
339 msg("unable to create client handle to rpcbind.");
340 if (needfree)
341 free_eps(teps, tsrv.ep.ep_len);
342 return (0);
343 }
344
345 tv.tv_sec = 5;
346 tv.tv_usec = 0;
347 time_valid = 0;
ce0e08e2
PA
348 status = clnt_call(clnt, RPCBPROC_GETTIME, (xdrproc_t)xdr_void, NULL,
349 (xdrproc_t)xdr_u_long, &thetime, tv);
984263bc
MD
350 /*
351 * The only error we check for is anything but success. In
352 * fact we could have seen PROGMISMATCH if talking to a 4.1
353 * machine (pmap v2) or TIMEDOUT if the net was busy.
354 */
355 if (status == RPC_SUCCESS)
356 time_valid = 1;
357 else {
358 int save;
359
360 /* Blow away possible stale CLNT handle. */
361 if (clnt != NULL) {
362 clnt_destroy(clnt);
363 clnt = NULL;
364 }
365
366 /*
367 * Convert PMAP address into timeservice address
368 * We take advantage of the fact that we "know" what
369 * the universal address looks like for inet transports.
370 *
371 * We also know that the internet timeservice is always
372 * listening on port 37.
373 */
374 sscanf(useua, "%d.%d.%d.%d.", &a1, &a2, &a3, &a4);
375 sprintf(ut, "%d.%d.%d.%d.0.37", a1, a2, a3, a4);
376
377 if (uaddr_to_sockaddr(ut, &sin)) {
378 msg("cannot convert timeservice uaddr to sockaddr.");
379 goto error;
380 }
381
17ea2221 382 s = _socket(AF_INET, type, 0);
984263bc
MD
383 if (s == -1) {
384 msg("unable to open fd to network.");
385 goto error;
386 }
387
388 /*
389 * Now depending on whether or not we're talking to
390 * UDP we set a timeout or not.
391 */
392 if (type == SOCK_DGRAM) {
393 struct timeval timeout = { 20, 0 };
394 struct sockaddr_in from;
395 fd_set readfds;
396 int res;
397
17ea2221 398 if (_sendto(s, &thetime, sizeof(thetime), 0,
984263bc
MD
399 (struct sockaddr *)&sin, sizeof(sin)) == -1) {
400 msg("udp : sendto failed.");
401 goto error;
402 }
403 do {
404 FD_ZERO(&readfds);
405 FD_SET(s, &readfds);
17ea2221 406 res = _select(_rpc_dtablesize(), &readfds,
2038fb68 407 NULL, NULL, &timeout);
984263bc
MD
408 } while (res < 0 && errno == EINTR);
409 if (res <= 0)
410 goto error;
411 len = sizeof(from);
17ea2221 412 res = _recvfrom(s, (char *)&thetime, sizeof(thetime), 0,
984263bc
MD
413 (struct sockaddr *)&from, &len);
414 if (res == -1) {
415 msg("recvfrom failed on udp transport.");
416 goto error;
417 }
418 time_valid = 1;
419 } else {
420 int res;
421
422 oldsig = (void (*)())signal(SIGALRM, alarm_hndler);
423 saw_alarm = 0; /* global tracking the alarm */
424 alarm(20); /* only wait 20 seconds */
17ea2221 425 res = _connect(s, (struct sockaddr *)&sin, sizeof(sin));
984263bc
MD
426 if (res == -1) {
427 msg("failed to connect to tcp endpoint.");
428 goto error;
429 }
430 if (saw_alarm) {
431 msg("alarm caught it, must be unreachable.");
432 goto error;
433 }
434 res = _read(s, (char *)&thetime, sizeof(thetime));
435 if (res != sizeof(thetime)) {
436 if (saw_alarm)
437 msg("timed out TCP call.");
438 else
439 msg("wrong size of results returned");
440
441 goto error;
442 }
443 time_valid = 1;
444 }
445 save = errno;
c9b6181e 446 _close(s);
984263bc
MD
447 errno = save;
448 s = RPC_ANYSOCK;
449
450 if (time_valid) {
451 thetime = ntohl(thetime);
452 thetime = thetime - TOFFSET; /* adjust to UNIX time */
453 } else
454 thetime = 0;
455 }
456
457 gettimeofday(&tv, 0);
458
459error:
460 /*
461 * clean up our allocated data structures.
462 */
463
464 if (s != RPC_ANYSOCK)
c9b6181e 465 _close(s);
984263bc
MD
466
467 if (clnt != NULL)
468 clnt_destroy(clnt);
469
470 alarm(0); /* reset that alarm if its outstanding */
471 if (oldsig) {
472 signal(SIGALRM, oldsig);
473 }
474
475 /*
476 * note, don't free uaddr strings until after we've made a
477 * copy of them.
478 */
479 if (time_valid) {
480 if (*uaddr == NULL)
481 *uaddr = strdup(useua);
482
483 /* Round to the nearest second */
484 tv.tv_sec += (tv.tv_sec > 500000) ? 1 : 0;
485 delta = (thetime > tv.tv_sec) ? thetime - tv.tv_sec :
486 tv.tv_sec - thetime;
487 td->tv_sec = (thetime < tv.tv_sec) ? - delta : delta;
488 td->tv_usec = 0;
489 } else {
490 msg("unable to get the server's time.");
491 }
492
493 if (needfree)
494 free_eps(teps, tsrv.ep.ep_len);
495
496 return (time_valid);
497}