1 #pragma ident "@(#)auth_time.c 1.4 92/11/10 SMI"
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.
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.
20 * Copyright (c) 1992 Sun Microsystems Inc.
21 * All rights reserved.
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.
29 * NOTE: This code has had the crap beaten out it in order to convert
30 * it from TI-RPC back to TD-RPC for use on FreeBSD.
32 * $FreeBSD: src/lib/libc/rpc/auth_time.c,v 1.4 2000/01/27 23:06:35 jasone Exp $
33 * $DragonFly: src/lib/libc/rpc/auth_time.c,v 1.4 2005/11/13 12:27:04 swildner Exp $
35 #include "namespace.h"
42 #include <sys/signal.h>
43 #include <sys/errno.h>
44 #include <sys/socket.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
48 #include <rpc/rpc_com.h>
50 #include <rpcsvc/nis.h>
51 #include "un-namespace.h"
54 * FreeBSD currently uses RPC 4.0, which uses portmap rather than
55 * rpcbind. Consequently, we need to fake up these values here.
56 * Luckily, the RPCB_GETTIME procedure uses only base XDR data types
57 * so we don't need anything besides these magic numbers.
59 #define RPCBPROG (u_long)100000
60 #define RPCBVERS (u_long)3
61 #define RPCBPROC_GETTIME (u_long)6
64 #define msg(x) printf("ERROR: %s\n", x)
65 /* #define msg(x) syslog(LOG_ERR, "%s", x) */
70 static int saw_alarm
= 0;
80 * The internet time server defines the epoch to be Jan 1, 1900
81 * whereas UNIX defines it to be Jan 1, 1970. To adjust the result
82 * from internet time-service time, into UNIX time we subtract the
85 #define NYEARS (1970 - 1900)
86 #define TOFFSET ((u_long)60*60*24*(365*NYEARS + (NYEARS/4)))
90 * Stolen from rpc.nisd:
91 * Turn a 'universal address' into a struct sockaddr_in.
95 uaddr_to_sockaddr(char *uaddr
, struct sockaddr_in
*sin
)
97 unsigned char p_bytes
[2];
101 i
= sscanf(uaddr
, "%lu.%lu.%lu.%lu.%lu.%lu", &a
[0], &a
[1], &a
[2],
102 &a
[3], &a
[4], &a
[5]);
107 for (i
= 0; i
< 4; i
++)
108 sin
->sin_addr
.s_addr
|= (a
[i
] & 0x000000FF) << (8 * i
);
110 p_bytes
[0] = (unsigned char)a
[4] & 0x000000FF;
111 p_bytes
[1] = (unsigned char)a
[5] & 0x000000FF;
113 sin
->sin_family
= AF_INET
; /* always */
114 bcopy((char *)&p_bytes
, (char *)&sin
->sin_port
, 2);
122 * Free the strings that were strduped into the eps structure.
125 free_eps(endpoint eps
[], int num
)
129 for (i
= 0; i
< num
; i
++) {
140 * This function constructs a nis_server structure description for the
141 * indicated hostname.
143 * NOTE: There is a chance we may end up recursing here due to the
144 * fact that gethostbyname() could do an NIS search. Ideally, the
145 * NIS+ server will call __rpc_get_time_offset() with the nis_server
146 * structure already populated.
149 get_server(struct sockaddr_in
*sin
,
150 char *host
, /* name of the time host */
151 nis_server
*srv
, /* nis_server struct to use. */
152 endpoint eps
[], /* array of endpoints */
153 int maxep
) /* max array size */
158 struct hostent dummy
;
161 if (host
== NULL
&& sin
== NULL
)
165 he
= gethostbyname(host
);
170 ptr
[0] = (char *)&sin
->sin_addr
.s_addr
;
172 dummy
.h_addr_list
= ptr
;
176 * This is lame. We go around once for TCP, then again
179 for (i
= 0; (he
->h_addr_list
[i
] != NULL
) && (num_ep
< maxep
);
183 a
= (struct in_addr
*)he
->h_addr_list
[i
];
184 snprintf(hname
, sizeof(hname
), "%s.0.111", inet_ntoa(*a
));
185 eps
[num_ep
].uaddr
= strdup(hname
);
186 eps
[num_ep
].family
= strdup("inet");
187 eps
[num_ep
].proto
= strdup("tcp");
190 for (i
= 0; (he
->h_addr_list
[i
] != NULL
) && (num_ep
< maxep
);
194 a
= (struct in_addr
*)he
->h_addr_list
[i
];
195 snprintf(hname
, sizeof(hname
), "%s.0.111", inet_ntoa(*a
));
196 eps
[num_ep
].uaddr
= strdup(hname
);
197 eps
[num_ep
].family
= strdup("inet");
198 eps
[num_ep
].proto
= strdup("udp");
201 srv
->name
= (nis_name
) host
;
202 srv
->ep
.ep_len
= num_ep
;
203 srv
->ep
.ep_val
= eps
;
204 srv
->key_type
= NIS_PK_NONE
;
205 srv
->pkey
.n_bytes
= NULL
;
211 * __rpc_get_time_offset()
213 * This function uses a nis_server structure to contact the a remote
214 * machine (as named in that structure) and returns the offset in time
215 * between that machine and this one. This offset is returned in seconds
216 * and may be positive or negative.
218 * The first time through, a lot of fiddling is done with the netconfig
219 * stuff to find a suitable transport. The function is very aggressive
220 * about choosing UDP or at worst TCP if it can. This is because
221 * those transports support both the RCPBIND call and the internet
224 * Once through, *uaddr is set to the universal address of
225 * the machine and *netid is set to the local netid for the transport
226 * that uaddr goes with. On the second call, the netconfig stuff
227 * is skipped and the uaddr/netid pair are used to fetch the netconfig
228 * structure and to then contact the machine for the time.
230 * td = "server" - "client"
233 __rpc_get_time_offset(struct timeval
*td
, /* Time difference */
234 nis_server
*srv
, /* NIS Server description */
235 char *thost
, /* if no server, this is the timehost */
236 char **uaddr
, /* known universal address */
237 struct sockaddr_in
*netid
)/* known network identifier */
239 CLIENT
*clnt
; /* Client handle */
240 endpoint
*ep
, /* useful endpoints */
241 *useep
= NULL
; /* endpoint of xp */
242 char *useua
= NULL
; /* uaddr of selected xp */
243 int epl
, i
; /* counters */
244 enum clnt_stat status
; /* result of clnt_call */
245 u_long thetime
, delta
;
249 int udp_ep
= -1, tcp_ep
= -1;
251 char ut
[64], ipuaddr
[64];
254 void (*oldsig
)() = NULL
; /* old alarm handler */
255 struct sockaddr_in sin
;
256 int s
= RPC_ANYSOCK
, len
;
263 * First check to see if we need to find and address for this
266 if (*uaddr
== NULL
) {
267 if ((srv
!= NULL
) && (thost
!= NULL
)) {
268 msg("both timehost and srv pointer used!");
272 srv
= get_server(netid
, thost
, &tsrv
, teps
, 32);
274 msg("unable to contruct server data.");
277 needfree
= 1; /* need to free data in endpoints */
281 epl
= srv
->ep
.ep_len
;
283 /* Identify the TCP and UDP endpoints */
285 (i
< epl
) && ((udp_ep
== -1) || (tcp_ep
== -1)); i
++) {
286 if (strcasecmp(ep
[i
].proto
, "udp") == 0)
288 if (strcasecmp(ep
[i
].proto
, "tcp") == 0)
292 /* Check to see if it is UDP or TCP */
295 useua
= ep
[tcp_ep
].uaddr
;
297 } else if (udp_ep
> -1) {
299 useua
= ep
[udp_ep
].uaddr
;
304 msg("no acceptable transport endpoints.");
306 free_eps(teps
, tsrv
.ep
.ep_len
);
312 * Create a sockaddr from the uaddr.
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
);
322 bzero((char *)&sin
, sizeof(sin
));
323 if (uaddr_to_sockaddr(useua
, &sin
)) {
324 msg("unable to translate uaddr to sockaddr.");
326 free_eps(teps
, tsrv
.ep
.ep_len
);
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.
337 clnt
= clnttcp_create(&sin
, RPCBPROG
, RPCBVERS
, &s
, 0, 0);
339 msg("unable to create client handle to rpcbind.");
341 free_eps(teps
, tsrv
.ep
.ep_len
);
348 status
= clnt_call(clnt
, RPCBPROC_GETTIME
, xdr_void
, NULL
,
349 xdr_u_long
, (char *)&thetime
, tv
);
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.
355 if (status
== RPC_SUCCESS
)
360 /* Blow away possible stale CLNT handle. */
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.
371 * We also know that the internet timeservice is always
372 * listening on port 37.
374 sscanf(useua
, "%d.%d.%d.%d.", &a1
, &a2
, &a3
, &a4
);
375 sprintf(ut
, "%d.%d.%d.%d.0.37", a1
, a2
, a3
, a4
);
377 if (uaddr_to_sockaddr(ut
, &sin
)) {
378 msg("cannot convert timeservice uaddr to sockaddr.");
382 s
= _socket(AF_INET
, type
, 0);
384 msg("unable to open fd to network.");
389 * Now depending on whether or not we're talking to
390 * UDP we set a timeout or not.
392 if (type
== SOCK_DGRAM
) {
393 struct timeval timeout
= { 20, 0 };
394 struct sockaddr_in from
;
398 if (_sendto(s
, &thetime
, sizeof(thetime
), 0,
399 (struct sockaddr
*)&sin
, sizeof(sin
)) == -1) {
400 msg("udp : sendto failed.");
406 res
= _select(_rpc_dtablesize(), &readfds
,
407 (fd_set
*)NULL
, (fd_set
*)NULL
, &timeout
);
408 } while (res
< 0 && errno
== EINTR
);
412 res
= _recvfrom(s
, (char *)&thetime
, sizeof(thetime
), 0,
413 (struct sockaddr
*)&from
, &len
);
415 msg("recvfrom failed on udp transport.");
422 oldsig
= (void (*)())signal(SIGALRM
, alarm_hndler
);
423 saw_alarm
= 0; /* global tracking the alarm */
424 alarm(20); /* only wait 20 seconds */
425 res
= _connect(s
, (struct sockaddr
*)&sin
, sizeof(sin
));
427 msg("failed to connect to tcp endpoint.");
431 msg("alarm caught it, must be unreachable.");
434 res
= _read(s
, (char *)&thetime
, sizeof(thetime
));
435 if (res
!= sizeof(thetime
)) {
437 msg("timed out TCP call.");
439 msg("wrong size of results returned");
451 thetime
= ntohl(thetime
);
452 thetime
= thetime
- TOFFSET
; /* adjust to UNIX time */
457 gettimeofday(&tv
, 0);
461 * clean up our allocated data structures.
464 if (s
!= RPC_ANYSOCK
)
470 alarm(0); /* reset that alarm if its outstanding */
472 signal(SIGALRM
, oldsig
);
476 * note, don't free uaddr strings until after we've made a
481 *uaddr
= strdup(useua
);
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
:
487 td
->tv_sec
= (thetime
< tv
.tv_sec
) ? - delta
: delta
;
490 msg("unable to get the server's time.");
494 free_eps(teps
, tsrv
.ep
.ep_len
);