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