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 64 alarm_hndler(s) 65 int s; 66 { 67 saw_alarm = 1; 68 return; 69 } 70 71 /* 72 * The internet time server defines the epoch to be Jan 1, 1900 73 * whereas UNIX defines it to be Jan 1, 1970. To adjust the result 74 * from internet time-service time, into UNIX time we subtract the 75 * following offset : 76 */ 77 #define NYEARS (1970 - 1900) 78 #define TOFFSET ((u_long)60*60*24*(365*NYEARS + (NYEARS/4))) 79 80 81 /* 82 * Stolen from rpc.nisd: 83 * Turn a 'universal address' into a struct sockaddr_in. 84 * Bletch. 85 */ 86 static int uaddr_to_sockaddr(uaddr, sin) 87 #ifdef foo 88 endpoint *endpt; 89 #endif 90 char *uaddr; 91 struct sockaddr_in *sin; 92 { 93 unsigned char p_bytes[2]; 94 int i; 95 unsigned long a[6]; 96 97 i = sscanf(uaddr, "%lu.%lu.%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], 98 &a[3], &a[4], &a[5]); 99 100 if (i < 6) 101 return(1); 102 103 for (i = 0; i < 4; i++) 104 sin->sin_addr.s_addr |= (a[i] & 0x000000FF) << (8 * i); 105 106 p_bytes[0] = (unsigned char)a[4] & 0x000000FF; 107 p_bytes[1] = (unsigned char)a[5] & 0x000000FF; 108 109 sin->sin_family = AF_INET; /* always */ 110 bcopy((char *)&p_bytes, (char *)&sin->sin_port, 2); 111 112 return (0); 113 } 114 115 /* 116 * free_eps() 117 * 118 * Free the strings that were strduped into the eps structure. 119 */ 120 static void 121 free_eps(eps, num) 122 endpoint eps[]; 123 int num; 124 { 125 int i; 126 127 for (i = 0; i < num; i++) { 128 free(eps[i].uaddr); 129 free(eps[i].proto); 130 free(eps[i].family); 131 } 132 return; 133 } 134 135 /* 136 * get_server() 137 * 138 * This function constructs a nis_server structure description for the 139 * indicated hostname. 140 * 141 * NOTE: There is a chance we may end up recursing here due to the 142 * fact that gethostbyname() could do an NIS search. Ideally, the 143 * NIS+ server will call __rpc_get_time_offset() with the nis_server 144 * structure already populated. 145 */ 146 static nis_server * 147 get_server(sin, host, srv, eps, maxep) 148 struct sockaddr_in *sin; 149 char *host; /* name of the time host */ 150 nis_server *srv; /* nis_server struct to use. */ 151 endpoint eps[]; /* array of endpoints */ 152 int maxep; /* max array size */ 153 { 154 char hname[256]; 155 int num_ep = 0, i; 156 struct hostent *he; 157 struct hostent dummy; 158 char *ptr[2]; 159 160 if (host == NULL && sin == NULL) 161 return (NULL); 162 163 if (sin == NULL) { 164 he = gethostbyname(host); 165 if (he == NULL) 166 return(NULL); 167 } else { 168 he = &dummy; 169 ptr[0] = (char *)&sin->sin_addr.s_addr; 170 ptr[1] = NULL; 171 dummy.h_addr_list = ptr; 172 } 173 174 /* 175 * This is lame. We go around once for TCP, then again 176 * for UDP. 177 */ 178 for (i = 0; (he->h_addr_list[i] != NULL) && (num_ep < maxep); 179 i++, num_ep++) { 180 struct in_addr *a; 181 182 a = (struct in_addr *)he->h_addr_list[i]; 183 snprintf(hname, sizeof(hname), "%s.0.111", inet_ntoa(*a)); 184 eps[num_ep].uaddr = strdup(hname); 185 eps[num_ep].family = strdup("inet"); 186 eps[num_ep].proto = strdup("tcp"); 187 } 188 189 for (i = 0; (he->h_addr_list[i] != NULL) && (num_ep < maxep); 190 i++, num_ep++) { 191 struct in_addr *a; 192 193 a = (struct in_addr *)he->h_addr_list[i]; 194 snprintf(hname, sizeof(hname), "%s.0.111", inet_ntoa(*a)); 195 eps[num_ep].uaddr = strdup(hname); 196 eps[num_ep].family = strdup("inet"); 197 eps[num_ep].proto = strdup("udp"); 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 */ 231 int 232 __rpc_get_time_offset(td, srv, thost, uaddr, netid) 233 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 */ 238 { 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; 246 int needfree = 0; 247 struct timeval tv; 248 int time_valid; 249 int udp_ep = -1, tcp_ep = -1; 250 int a1, a2, a3, a4; 251 char ut[64], ipuaddr[64]; 252 endpoint teps[32]; 253 nis_server tsrv; 254 void (*oldsig)() = NULL; /* old alarm handler */ 255 struct sockaddr_in sin; 256 socklen_t len; 257 int s = RPC_ANYSOCK; 258 int type = 0; 259 260 td->tv_sec = 0; 261 td->tv_usec = 0; 262 263 /* 264 * First check to see if we need to find and address for this 265 * server. 266 */ 267 if (*uaddr == NULL) { 268 if ((srv != NULL) && (thost != NULL)) { 269 msg("both timehost and srv pointer used!"); 270 return (0); 271 } 272 if (! srv) { 273 srv = get_server(netid, thost, &tsrv, teps, 32); 274 if (srv == NULL) { 275 msg("unable to contruct server data."); 276 return (0); 277 } 278 needfree = 1; /* need to free data in endpoints */ 279 } 280 281 ep = srv->ep.ep_val; 282 epl = srv->ep.ep_len; 283 284 /* Identify the TCP and UDP endpoints */ 285 for (i = 0; 286 (i < epl) && ((udp_ep == -1) || (tcp_ep == -1)); i++) { 287 if (strcasecmp(ep[i].proto, "udp") == 0) 288 udp_ep = i; 289 if (strcasecmp(ep[i].proto, "tcp") == 0) 290 tcp_ep = i; 291 } 292 293 /* Check to see if it is UDP or TCP */ 294 if (tcp_ep > -1) { 295 useep = &ep[tcp_ep]; 296 useua = ep[tcp_ep].uaddr; 297 type = SOCK_STREAM; 298 } else if (udp_ep > -1) { 299 useep = &ep[udp_ep]; 300 useua = ep[udp_ep].uaddr; 301 type = SOCK_DGRAM; 302 } 303 304 if (useep == NULL) { 305 msg("no acceptable transport endpoints."); 306 if (needfree) 307 free_eps(teps, tsrv.ep.ep_len); 308 return (0); 309 } 310 } 311 312 /* 313 * Create a sockaddr from the uaddr. 314 */ 315 if (*uaddr != NULL) 316 useua = *uaddr; 317 318 /* Fixup test for NIS+ */ 319 sscanf(useua, "%d.%d.%d.%d.", &a1, &a2, &a3, &a4); 320 sprintf(ipuaddr, "%d.%d.%d.%d.0.111", a1, a2, a3, a4); 321 useua = &ipuaddr[0]; 322 323 bzero((char *)&sin, sizeof(sin)); 324 if (uaddr_to_sockaddr(useua, &sin)) { 325 msg("unable to translate uaddr to sockaddr."); 326 if (needfree) 327 free_eps(teps, tsrv.ep.ep_len); 328 return (0); 329 } 330 331 /* 332 * Create the client handle to rpcbind. Note we always try 333 * version 3 since that is the earliest version that supports 334 * the RPCB_GETTIME call. Also it is the version that comes 335 * standard with SVR4. Since most everyone supports TCP/IP 336 * we could consider trying the rtime call first. 337 */ 338 clnt = clnttcp_create(&sin, RPCBPROG, RPCBVERS, &s, 0, 0); 339 if (clnt == NULL) { 340 msg("unable to create client handle to rpcbind."); 341 if (needfree) 342 free_eps(teps, tsrv.ep.ep_len); 343 return (0); 344 } 345 346 tv.tv_sec = 5; 347 tv.tv_usec = 0; 348 time_valid = 0; 349 status = clnt_call(clnt, RPCBPROC_GETTIME, (xdrproc_t)xdr_void, NULL, 350 (xdrproc_t)xdr_u_long, &thetime, tv); 351 /* 352 * The only error we check for is anything but success. In 353 * fact we could have seen PROGMISMATCH if talking to a 4.1 354 * machine (pmap v2) or TIMEDOUT if the net was busy. 355 */ 356 if (status == RPC_SUCCESS) 357 time_valid = 1; 358 else { 359 int save; 360 361 /* Blow away possible stale CLNT handle. */ 362 if (clnt != NULL) { 363 clnt_destroy(clnt); 364 clnt = NULL; 365 } 366 367 /* 368 * Convert PMAP address into timeservice address 369 * We take advantage of the fact that we "know" what 370 * the universal address looks like for inet transports. 371 * 372 * We also know that the internet timeservice is always 373 * listening on port 37. 374 */ 375 sscanf(useua, "%d.%d.%d.%d.", &a1, &a2, &a3, &a4); 376 sprintf(ut, "%d.%d.%d.%d.0.37", a1, a2, a3, a4); 377 378 if (uaddr_to_sockaddr(ut, &sin)) { 379 msg("cannot convert timeservice uaddr to sockaddr."); 380 goto error; 381 } 382 383 s = _socket(AF_INET, type, 0); 384 if (s == -1) { 385 msg("unable to open fd to network."); 386 goto error; 387 } 388 389 /* 390 * Now depending on whether or not we're talking to 391 * UDP we set a timeout or not. 392 */ 393 if (type == SOCK_DGRAM) { 394 struct timeval timeout = { 20, 0 }; 395 struct sockaddr_in from; 396 fd_set readfds; 397 int res; 398 399 if (_sendto(s, &thetime, sizeof(thetime), 0, 400 (struct sockaddr *)&sin, sizeof(sin)) == -1) { 401 msg("udp : sendto failed."); 402 goto error; 403 } 404 do { 405 FD_ZERO(&readfds); 406 FD_SET(s, &readfds); 407 res = _select(_rpc_dtablesize(), &readfds, 408 (fd_set *)NULL, (fd_set *)NULL, &timeout); 409 } while (res < 0 && errno == EINTR); 410 if (res <= 0) 411 goto error; 412 len = sizeof(from); 413 res = _recvfrom(s, (char *)&thetime, sizeof(thetime), 0, 414 (struct sockaddr *)&from, &len); 415 if (res == -1) { 416 msg("recvfrom failed on udp transport."); 417 goto error; 418 } 419 time_valid = 1; 420 } else { 421 int res; 422 423 oldsig = (void (*)())signal(SIGALRM, alarm_hndler); 424 saw_alarm = 0; /* global tracking the alarm */ 425 alarm(20); /* only wait 20 seconds */ 426 res = _connect(s, (struct sockaddr *)&sin, sizeof(sin)); 427 if (res == -1) { 428 msg("failed to connect to tcp endpoint."); 429 goto error; 430 } 431 if (saw_alarm) { 432 msg("alarm caught it, must be unreachable."); 433 goto error; 434 } 435 res = _read(s, (char *)&thetime, sizeof(thetime)); 436 if (res != sizeof(thetime)) { 437 if (saw_alarm) 438 msg("timed out TCP call."); 439 else 440 msg("wrong size of results returned"); 441 442 goto error; 443 } 444 time_valid = 1; 445 } 446 save = errno; 447 (void)_close(s); 448 errno = save; 449 s = RPC_ANYSOCK; 450 451 if (time_valid) { 452 thetime = ntohl(thetime); 453 thetime = thetime - TOFFSET; /* adjust to UNIX time */ 454 } else 455 thetime = 0; 456 } 457 458 gettimeofday(&tv, 0); 459 460 error: 461 /* 462 * clean up our allocated data structures. 463 */ 464 465 if (s != RPC_ANYSOCK) 466 (void)_close(s); 467 468 if (clnt != NULL) 469 clnt_destroy(clnt); 470 471 alarm(0); /* reset that alarm if its outstanding */ 472 if (oldsig) { 473 signal(SIGALRM, oldsig); 474 } 475 476 /* 477 * note, don't free uaddr strings until after we've made a 478 * copy of them. 479 */ 480 if (time_valid) { 481 if (*uaddr == NULL) 482 *uaddr = strdup(useua); 483 484 /* Round to the nearest second */ 485 tv.tv_sec += (tv.tv_sec > 500000) ? 1 : 0; 486 delta = (thetime > tv.tv_sec) ? thetime - tv.tv_sec : 487 tv.tv_sec - thetime; 488 td->tv_sec = (thetime < tv.tv_sec) ? - delta : delta; 489 td->tv_usec = 0; 490 } else { 491 msg("unable to get the server's time."); 492 } 493 494 if (needfree) 495 free_eps(teps, tsrv.ep.ep_len); 496 497 return (time_valid); 498 } 499