usr/src/cmd/rtc/rtc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2018 Gary Mills
  24  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <sys/types.h>
  32 #include <sys/sysi86.h>
  33 #include <errno.h>
  34 #include <time.h>
  35 #include <string.h>
  36 #include <sys/stat.h>
  37
  38 /* RTC modes */
  39 #define M_UNSET 0 /* Mode never set */
  40 #define M_VAR   1 /* Tracks local time including DST */
  41 #define M_UTC   2 /* Clock runs in UTC */
  42 #define M_STD   3 /* Clock runs in local standard time */
  43
  44 static char *progname;
  45 static char *zonefile = "/etc/rtc_config";
  46 static FILE *zonefptr;
  47 static char zone_info[256];
  48 static char zone_lag[256];
  49 static char tz[256] = "TZ=";
  50 static char *utc_zone = "UTC";
  51 int debug = 0;
  52 int rtc_mode = M_UNSET;
  53 int lag;
  54 int errors_ok = 0; /* allow "rtc no-args" to be quiet when not configured */
  55 static time_t clock_val;
  56 static char zone_comment[] =
  57         "#\n"
  58         "#      This file (%s) contains information used to manage the\n"
  59         "#      x86 real time clock hardware.  The hardware is kept in\n"
  60         "#      the machine's local time for compatibility with other x86\n"
  61         "#      operating systems.  This file is read by the kernel at\n"
  62         "#      boot time.  It is set and updated by the /usr/sbin/rtc\n"
  63         "#      command.  The 'zone_info' field designates the local\n"
  64         "#      time zone.  The 'zone_lag' field indicates the number\n"
  65         "#      of seconds between local time and Greenwich Mean Time.\n"
  66         "#\n";
  67
  68 /*
  69  *      Open the configuration file and extract the
  70  *      zone_info and the zone_lag.  Return 0 if successful.
  71  */
  72 int
  73 open_zonefile()
  74 {
  75         char b[256], *s;
  76         int lag_hrs;
  77
  78         if ((zonefptr = fopen(zonefile, "r")) == NULL) {
  79                 if (errors_ok == 0)
  80                         (void) fprintf(stderr,
  81                             "%s: cannot open %s: errno = %d\n",
  82                             progname, zonefile, errno);
  83                 return (1);
  84         }
  85
  86         for (;;) {
  87                 if ((s = fgets(b, sizeof (b), zonefptr)) == NULL)
  88                         break;
  89                 if ((s = strchr(s, 'z')) == NULL)
  90                         continue;
  91                 if (strncmp(s, "zone_info", 9) == 0) {
  92                         s += 9;
  93                         while (*s != 0 && *s != '=')
  94                                 s++;
  95                         if (*s == '=') {
  96                                 s++;
  97                                 while (*s != 0 && (*s == ' ' || *s == '\t'))
  98                                         s++;
  99                                 (void) strncpy(zone_info, s,
 100                                     sizeof (zone_info));
 101                                 s = zone_info;
 102                                 while (*s != 0 && *s != '\n')
 103                                         s++;
 104                                 if (*s == '\n')
 105                                         *s = 0;
 106                         }
 107                 } else if (strncmp(s, "zone_lag", 8) == 0) {
 108                         s += 8;
 109                         while (*s != 0 && *s != '=')
 110                                 s++;
 111                         if (*s == '=') {
 112                                 s++;
 113                                 while (*s != 0 && (*s == ' ' || *s == '\t'))
 114                                         s++;
 115                                 (void) strncpy(zone_lag, s, sizeof (zone_lag));
 116                                 s = zone_lag;
 117                                 while (*s != 0 && *s != '\n')
 118                                         s++;
 119                                 if (*s == '\n')
 120                                         *s = 0;
 121                         }
 122                 }
 123         }
 124         lag = atoi(zone_lag);
 125         lag_hrs = lag / 3600;
 126         if (zone_info[0] == 0) {
 127                 (void) fprintf(stderr, "%s: zone_info field is invalid\n",
 128                     progname);
 129                 zone_info[0] = 0;
 130                 zone_lag[0] = 0;
 131                 return (1);
 132         }
 133         if (zone_lag[0] == 0) {
 134                 (void) fprintf(stderr, "%s: zone_lag field is invalid\n",
 135                     progname);
 136                 zone_lag[0] = 0;
 137                 return (1);
 138         }
 139         if ((lag_hrs < -24) || (lag_hrs > 24)) {
 140                 (void) fprintf(stderr, "%s: a GMT lag of %d is out of range\n",
 141                     progname, lag_hrs);
 142                 zone_info[0] = 0;
 143                 zone_lag[0] = 0;
 144                 return (1);
 145         }
 146         if (debug)
 147                 (void) fprintf(stderr, "zone_info = %s,   zone_lag = %s\n",
 148                     zone_info, zone_lag);
 149         if (debug)
 150                 (void) fprintf(stderr, "lag (decimal) is %d\n", lag);
 151
 152         (void) fclose(zonefptr);
 153         zonefptr = NULL;
 154         return (0);
 155 }
 156
 157 void
 158 display_zone_string(void)
 159 {
 160         if (open_zonefile() == 0)
 161                 (void) printf("%s\n", zone_info);
 162         else
 163                 (void) printf("GMT\n");
 164 }
 165
 166 int
 167 get_local(char *z)
 168 {
 169         struct tm *tm;
 170
 171         tz[3] = 0;
 172         (void) strncat(tz, z, 253);
 173         if (debug)
 174                 (void) fprintf(stderr, "Time Zone string is '%s'\n", tz);
 175
 176         (void) putenv(tz);
 177         if (debug)
 178                 (void) system("env | grep TZ");
 179
 180         (void) time(&clock_val);
 181
 182         tm = localtime(&clock_val);
 183         return (tm->tm_isdst);
 184 }
 185
 186 long
 187 set_zone(char *zone_string)
 188 {
 189         int isdst;
 190         long current_lag;
 191
 192         (void) umask(0022);
 193         if ((zonefptr = fopen(zonefile, "w")) == NULL) {
 194                 (void) fprintf(stderr, "%s: cannot open %s: errno = %d\n",
 195                     progname, zonefile, errno);
 196                 return (0);
 197         }
 198
 199         switch (rtc_mode) {
 200         case M_VAR:
 201                 isdst = get_local(zone_string);
 202                 current_lag = isdst ? altzone : timezone;
 203                 break;
 204         case M_STD:
 205                 isdst = get_local(zone_string);
 206                 current_lag = timezone;
 207                 break;
 208         default:        /* Includes M_UTC */
 209                 isdst = 0;
 210                 current_lag = 0;
 211                 zone_string = utc_zone;
 212                 break;
 213         }
 214         if (debug)
 215                 (void) printf("%s DST.    Lag is %ld.\n", isdst ? "Is" :
 216                     "Is NOT",  current_lag);
 217
 218         (void) fprintf(zonefptr, zone_comment, zonefile);
 219         (void) fprintf(zonefptr, "zone_info=%s\n", zone_string);
 220         (void) fprintf(zonefptr, "zone_lag=%ld\n", current_lag);
 221         (void) fclose(zonefptr);
 222         zonefptr = NULL;
 223         return (current_lag);
 224 }
 225
 226 void
 227 correct_rtc_and_lag()
 228 {
 229         int isdst;
 230         long kernels_lag;
 231         long current_lag;
 232
 233         if (open_zonefile())
 234                 return;
 235
 236         switch (rtc_mode) {
 237         case M_VAR:
 238                 isdst = get_local(zone_info);
 239                 current_lag = isdst ? altzone : timezone;
 240                 break;
 241         case M_STD:
 242                 (void) get_local(zone_info);
 243                 current_lag = timezone;
 244                 break;
 245         default:        /* Includes M_UTC */
 246                 current_lag = 0;
 247                 break;
 248         }
 249
 250         if (current_lag != lag) {       /* if file is wrong */
 251                 if (debug)
 252                         (void) fprintf(stderr, "correcting file\n");
 253                 (void) set_zone(zone_info);     /* then rewrite file */
 254         }
 255
 256         (void) sysi86(GGMTL, &kernels_lag);
 257         if (current_lag != kernels_lag) {
 258                 if (debug)
 259                         (void) fprintf(stderr, "correcting kernel's lag\n");
 260                 (void) sysi86(SGMTL, current_lag);      /* correct the lag */
 261                 (void) sysi86(WTODC);                   /* set the rtc to */
 262                                                         /* new local time */
 263         }
 264 }
 265
 266 void
 267 initialize_zone(char *zone_string)
 268 {
 269         long current_lag;
 270
 271         /* write the config file */
 272         current_lag = set_zone(zone_string);
 273
 274         /* correct the lag */
 275         (void) sysi86(SGMTL, current_lag);
 276
 277         /*
 278          * set the unix time from the rtc,
 279          * assuming the rtc was the correct
 280          * local time.
 281          */
 282         (void) sysi86(RTCSYNC);
 283 }
 284
 285 void
 286 usage()
 287 {
 288         static char Usage[] = "Usage:\n\
 289 rtc [-w] [-s|-u|-v] [-c] [-z time_zone] [-?]\n";
 290
 291         (void) fprintf(stderr, Usage);
 292 }
 293
 294 void
 295 verbose_usage()
 296 {
 297         static char Usage1[] = "\
 298         Options:\n\
 299             -w\t\tDoes nothing.\n\
 300             -s\t\tRTC runs in local standard time.\n\
 301             -u\t\tRTC runs in UTC time.\n\
 302             -v\t\tRTC tracks local time (with cron command).\n\
 303             -c\t\tCheck and correct for daylight savings time rollover.\n\
 304             -z [zone]\tRecord the zone info in the config file.\n";
 305
 306         (void) fprintf(stderr, Usage1);
 307 }
 308
 309 void
 310 set_default()
 311 {
 312         switch (rtc_mode) {
 313         default:        /* Includes M_UNSET */
 314                 rtc_mode = M_VAR;
 315                 break;
 316         case M_VAR:
 317                 /*FALLTHROUGH*/
 318         case M_UTC:
 319                 /*FALLTHROUGH*/
 320         case M_STD:
 321                 break;
 322         }
 323 }
 324
 325 void
 326 check_mode(int letter, int mode)
 327 {
 328         if (rtc_mode == M_UNSET || rtc_mode == mode) {
 329                 rtc_mode = mode;
 330                 return;
 331         }
 332         (void) fprintf(stderr, "%s: option -%c conflicts with other options\n",
 333             progname, letter);
 334         exit(1);
 335 }
 336
 337
 338 int
 339 main(int argc, char *argv[])
 340 {
 341         int c;
 342         int cflg = 0;
 343         char *zone_name = NULL;
 344
 345         progname = argv[0];
 346
 347         if (argc == 1) {
 348                 errors_ok = 1;
 349                 display_zone_string();
 350                 exit(0);
 351         }
 352
 353         while ((c = getopt(argc, argv, "suvwcz:d")) != EOF) {
 354                 switch (c) {
 355                 case 'c':
 356                         cflg++;
 357                         continue;
 358                 case 'z':
 359                         zone_name = optarg;
 360                         continue;
 361                 case 'd':
 362                         debug = 1;
 363                         continue;
 364                 case 's':       /* standard: RTC runs local standard time */
 365                         check_mode(c, M_STD);
 366                         continue;
 367                 case 'u':       /* utc: RTC runs UTC time */
 368                         check_mode(c, M_UTC);
 369                         continue;
 370                 case 'v':       /* varies: RTC tracks local time */
 371                         check_mode(c, M_VAR);
 372                         continue;
 373                 case 'w':       /* Does nothing */
 374                         continue;
 375                 case '?':
 376                         verbose_usage();
 377                         exit(0);
 378                 default:
 379                         usage();
 380                         exit(1);
 381                 }
 382         }
 383         set_default();
 384         if (zone_name != NULL)
 385                 initialize_zone(zone_name);
 386         if (cflg > 0)
 387                 correct_rtc_and_lag();
 388         exit(0);
 389         /*LINTED*/
 390 }