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