lib/libc/rpc/auth_time.c

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