hwclock: coding style clean up

Despide amount of the change this change should be harmless.
Everything is about indendation, comment restructuring etc not
code changes.

Signed-off-by: Sami Kerola <kerolasa@iki.fi>

5 files changed, 2159 insertions, 2067 deletions

diff --git a/hwclock/clock.h b/hwclock/clock.h
index e4eb7eba8..8d1befe8f 100644
--- a/hwclock/clock.h
+++ b/hwclock/clock.h
@@ -1,20 +1,20 @@
 #ifndef HWCLOCK_CLOCK_H
 #define HWCLOCK_CLOCK_H
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>		/* for errno, EPERM, EINVAL, ENOENT */
 #include <time.h>
 
 #include "c.h"
 
 struct clock_ops {
 	char *interface_name;
-        int (*get_permissions)(void);
-        int (*read_hardware_clock)(struct tm *tm);
-        int (*set_hardware_clock)(const struct tm *tm);
-	int (*synchronize_to_clock_tick)(void);
+	int (*get_permissions) (void);
+	int (*read_hardware_clock) (struct tm * tm);
+	int (*set_hardware_clock) (const struct tm * tm);
+	int (*synchronize_to_clock_tick) (void);
 };
 
 extern struct clock_ops *probe_for_cmos_clock(void);
@@ -29,9 +29,9 @@ extern int debug;
 extern int epoch_option;
 extern void outsyserr(char *msg, ...)
 #ifdef __GNUC__
-        __attribute__ ((format (printf, 1, 2)));
+    __attribute__ ((format(printf, 1, 2)));
 #else
-        ;
+    ;
 #endif
 extern double time_diff(struct timeval subtrahend, struct timeval subtractor);
 /* cmos.c */
@@ -50,4 +50,4 @@ extern void hwaudit_exit(int status);
 # define hwclock_exit(_status)	exit(_status)
 #endif
 
-#endif /* HWCLOCK_CLOCK_H */
+#endif				/* HWCLOCK_CLOCK_H */
diff --git a/hwclock/cmos.c b/hwclock/cmos.c
index 0178ef7d3..d6216717f 100644
--- a/hwclock/cmos.c
+++ b/hwclock/cmos.c
@@ -1,47 +1,48 @@
 /*
- * i386 CMOS starts out with 14 bytes clock data
- * alpha has something similar, but with details
- * depending on the machine type.
+ * i386 CMOS starts out with 14 bytes clock data alpha has something
+ * similar, but with details depending on the machine type.
  *
- * byte 0: seconds (0-59)
- * byte 2: minutes (0-59)
- * byte 4: hours (0-23 in 24hr mode,
- *                1-12 in 12hr mode, with high bit unset/set if am/pm)
- * byte 6: weekday (1-7, Sunday=1)
- * byte 7: day of the month (1-31)
- * byte 8: month (1-12)
- * byte 9: year (0-99)
- * Numbers are stored in BCD/binary if bit 2 of byte 11 is unset/set
- * The clock is in 12hr/24hr mode if bit 1 of byte 11 is unset/set
- * The clock is undefined (being updated) if bit 7 of byte 10 is set.
- * The clock is frozen (to be updated) by setting bit 7 of byte 11
- * Bit 7 of byte 14 indicates whether the CMOS clock is reliable:
- * it is 1 if RTC power has been good since this bit was last read;
- * it is 0 when the battery is dead and system power has been off.
+ * byte 0: seconds		0-59
+ * byte 2: minutes		0-59
+ * byte 4: hours		0-23 in 24hr mode,
+ *				1-12 in 12hr mode, with high bit unset/set
+ *					if am/pm.
+ * byte 6: weekday		1-7, Sunday=1
+ * byte 7: day of the month	1-31
+ * byte 8: month		1-12
+ * byte 9: year			0-99
  *
- * Avoid setting the RTC clock within 2 seconds of the day rollover
- * that starts a new month or enters daylight saving time.
+ * Numbers are stored in BCD/binary if bit 2 of byte 11 is unset/set The
+ * clock is in 12hr/24hr mode if bit 1 of byte 11 is unset/set The clock is
+ * undefined (being updated) if bit 7 of byte 10 is set. The clock is frozen
+ * (to be updated) by setting bit 7 of byte 11 Bit 7 of byte 14 indicates
+ * whether the CMOS clock is reliable: it is 1 if RTC power has been good
+ * since this bit was last read; it is 0 when the battery is dead and system
+ * power has been off.
+ *
+ * Avoid setting the RTC clock within 2 seconds of the day rollover that
+ * starts a new month or enters daylight saving time.
  *
  * The century situation is messy:
- * Usually byte 50 (0x32) gives the century (in BCD, so 19 or 20 hex),
- * but IBM PS/2 has (part of) a checksum there and uses byte 55 (0x37).
- * Sometimes byte 127 (0x7f) or Bank 1, byte 0x48 gives the century.
- * The original RTC will not access any century byte; some modern
- * versions will. If a modern RTC or BIOS increments the century byte
- * it may go from 0x19 to 0x20, but in some buggy cases 0x1a is produced.
+ *
+ * Usually byte 50 (0x32) gives the century (in BCD, so 19 or 20 hex), but
+ * IBM PS/2 has (part of) a checksum there and uses byte 55 (0x37).
+ * Sometimes byte 127 (0x7f) or Bank 1, byte 0x48 gives the century. The
+ * original RTC will not access any century byte; some modern versions will.
+ * If a modern RTC or BIOS increments the century byte it may go from 0x19
+ * to 0x20, but in some buggy cases 0x1a is produced.
  */
-
 /*
  * A struct tm has int fields
- *   tm_sec (0-59, 60 or 61 only for leap seconds)
- *   tm_min (0-59)
- *   tm_hour (0-23)
- *   tm_mday (1-31)
- *   tm_mon (0-11)
- *   tm_year (number of years since 1900)
- *   tm_wday (0-6, 0=Sunday)
- *   tm_yday (0-365)
- *   tm_isdst (>0: yes, 0: no, <0: unknown)
+ *   tm_sec	0-59, 60 or 61 only for leap seconds
+ *   tm_min	0-59
+ *   tm_hour	0-23
+ *   tm_mday	1-31
+ *   tm_mon	0-11
+ *   tm_year	number of years since 1900
+ *   tm_wday	0-6, 0=Sunday
+ *   tm_yday	0-365
+ *   tm_isdst	>0: yes, 0: no, <0: unknown
  */
 
 #include <unistd.h>		/* for geteuid() */
@@ -50,27 +51,40 @@
 #include "nls.h"
 
 #if defined(__i386__)
-
 # ifdef HAVE_SYS_IO_H
-#   include <sys/io.h>
+#  include <sys/io.h>
 # elif defined(HAVE_ASM_IO_H)
-#  include <asm/io.h>	/* for inb, outb */
+#  include <asm/io.h>		/* for inb, outb */
 # else
-/* Disable cmos access; we can no longer use asm/io.h, since
- * the kernel does not export that header. */
-#  undef __i386__
-void outb(int a, int b){}
-int inb(int c){ return 0; }
-# endif
+/*
+ * Disable cmos access; we can no longer use asm/io.h, since the kernel does
+ * not export that header.
+ */
+#undef __i386__
+void outb(int a, int b)
+{
+}
+
+int inb(int c)
+{
+	return 0;
+}
+#endif				/* __i386__ */
 
 #elif defined(__alpha__)
 /* <asm/io.h> fails to compile, probably because of u8 etc */
-extern unsigned int     inb(unsigned long port);
-extern void             outb(unsigned char b,unsigned long port);
+extern unsigned int inb(unsigned long port);
+extern void outb(unsigned char b, unsigned long port);
 #else
-void outb(int a, int b){}
-int inb(int c){ return 0; }
-#endif
+void outb(int a, int b)
+{
+}
+
+int inb(int c)
+{
+	return 0;
+}
+#endif				/* __alpha__ */
 
 #include "clock.h"
 
@@ -80,39 +94,40 @@ int inb(int c){ return 0; }
 /*
  * The epoch.
  *
- * Unix uses 1900 as epoch for a struct tm, and 1970 for a time_t.
- * But what was written to CMOS?
- * Digital DECstations use 1928 - this is on a mips or alpha
- * Digital Unix uses 1952, e.g. on AXPpxi33
- * Windows NT uses 1980.
- * The ARC console expects to boot Windows NT and uses 1980.
- * (But a Ruffian uses 1900, just like SRM.)
- * It is reported that ALPHA_PRE_V1_2_SRM_CONSOLE uses 1958.
+ * Unix uses 1900 as epoch for a struct tm, and 1970 for a time_t. But what
+ * was written to CMOS?
+ *
+ * Digital DECstations use 1928 - this is on a mips or alpha Digital Unix
+ * uses 1952, e.g. on AXPpxi33. Windows NT uses 1980. The ARC console
+ * expects to boot Windows NT and uses 1980. (But a Ruffian uses 1900, just
+ * like SRM.) It is reported that ALPHA_PRE_V1_2_SRM_CONSOLE uses 1958.
  */
 #define TM_EPOCH 1900
 int cmos_epoch = 1900;
 
-/* Martin Ostermann writes:
-The problem with the Jensen is twofold: First, it has the clock at a
-different address. Secondly, it has a distinction beween "local" and
-normal bus addresses. The local ones pertain to the hardware integrated
-into the chipset, like serial/parallel ports and of course, the RTC.
-Those need to be addressed differently. This is handled fine in the kernel,
-and it's not a problem, since this usually gets totally optimized by the
-compile. But the i/o routines of (g)libc lack this support so far.
-The result of this is, that the old clock program worked only on the
-Jensen when USE_DEV_PORT was defined, but not with the normal inb/outb
-functions.
+/*
+ * Martin Ostermann writes:
+ *
+ * The problem with the Jensen is twofold: First, it has the clock at a
+ * different address. Secondly, it has a distinction beween "local" and
+ * normal bus addresses. The local ones pertain to the hardware integrated
+ * into the chipset, like serial/parallel ports and of course, the RTC.
+ * Those need to be addressed differently. This is handled fine in the
+ * kernel, and it's not a problem, since this usually gets totally optimized
+ * by the compile. But the i/o routines of (g)libc lack this support so far.
+ * The result of this is, that the old clock program worked only on the
+ * Jensen when USE_DEV_PORT was defined, but not with the normal inb/outb
+ * functions.
  */
 int use_dev_port = 0;		/* 1 for Jensen */
 int dev_port_fd;
 unsigned short clock_ctl_addr = 0x70;	/* 0x170 for Jensen */
-unsigned short clock_data_addr = 0x71; 	/* 0x171 for Jensen */
-
+unsigned short clock_data_addr = 0x71;	/* 0x171 for Jensen */
 
 int century_byte = 0;		/* 0: don't access a century byte
-				  50 (0x32): usual PC value
-				  55 (0x37): PS/2 */
+				 * 50 (0x32): usual PC value
+				 * 55 (0x37): PS/2
+				 */
 
 #ifdef __alpha__
 int funkyTOY = 0;		/* 1 for PC164/LX164/SX164 type alpha */
@@ -120,217 +135,242 @@ int funkyTOY = 0;		/* 1 for PC164/LX164/SX164 type alpha */
 
 #ifdef __alpha
 
-static int
-is_in_cpuinfo(char *fmt, char *str)
+static int is_in_cpuinfo(char *fmt, char *str)
 {
-    FILE *cpuinfo;
-    char field[256];
-    char format[256];
-    int found = 0;
-
-    sprintf(format, "%s : %s", fmt, "%255s");
-
-    if ((cpuinfo = fopen ("/proc/cpuinfo", "r")) != NULL) {
-	while (!feof(cpuinfo)) {
-	    if (fscanf (cpuinfo, format, field) == 1) {
-		if (strncmp(field, str, strlen(str)) == 0)
-		    found = 1;
-		break;
-	    }
-	    fgets (field, 256, cpuinfo);
+	FILE *cpuinfo;
+	char field[256];
+	char format[256];
+	int found = 0;
+
+	sprintf(format, "%s : %s", fmt, "%255s");
+
+	if ((cpuinfo = fopen("/proc/cpuinfo", "r")) != NULL) {
+		while (!feof(cpuinfo)) {
+			if (fscanf(cpuinfo, format, field) == 1) {
+				if (strncmp(field, str, strlen(str)) == 0)
+					found = 1;
+				break;
+			}
+			fgets(field, 256, cpuinfo);
+		}
+		fclose(cpuinfo);
 	}
-	fclose(cpuinfo);
-    }
-    return found;
+	return found;
 }
 
-/* Set cmos_epoch, either from user options, or by asking the kernel,
-   or by looking at /proc/cpu_info */
-void
-set_cmos_epoch(int ARCconsole, int SRM) {
-  unsigned long epoch;
-
-  /* Believe the user */
-  if (epoch_option != -1) {
-    cmos_epoch = epoch_option;
-    return;
-  }
+/*
+ * Set cmos_epoch, either from user options, or by asking the kernel, or by
+ * looking at /proc/cpu_info
+ */
+void set_cmos_epoch(int ARCconsole, int SRM)
+{
+	unsigned long epoch;
 
-  if (ARCconsole)
-    cmos_epoch = 1980;
+	/* Believe the user */
+	if (epoch_option != -1) {
+		cmos_epoch = epoch_option;
+		return;
+	}
 
-  if (ARCconsole || SRM)
-    return;
+	if (ARCconsole)
+		cmos_epoch = 1980;
 
+	if (ARCconsole || SRM)
+		return;
 
 #ifdef __linux__
-  /* If we can ask the kernel, we don't need guessing from /proc/cpuinfo */
-  if (get_epoch_rtc(&epoch, 1) == 0) {
-     cmos_epoch = epoch;
-     return;
-  }
+	/*
+	 * If we can ask the kernel, we don't need guessing from
+	 * /proc/cpuinfo
+	 */
+	if (get_epoch_rtc(&epoch, 1) == 0) {
+		cmos_epoch = epoch;
+		return;
+	}
 #endif
 
-  /* The kernel source today says: read the year.
-     If it is in 0-19 then the epoch is 2000.
-     If it is in 20-47 then the epoch is 1980.
-     If it is in 48-69 then the epoch is 1952.
-     If it is in 70-99 then the epoch is 1928.
-     Otherwise the epoch is 1900.
-     Clearly, this must be changed before 2019. */
-
-  /* See whether we are dealing with SRM or MILO, as they have
-     different "epoch" ideas. */
-  if (is_in_cpuinfo("system serial number", "MILO")) {
-      ARCconsole = 1;
-      if (debug) printf (_("booted from MILO\n"));
-  }
-
-  /* See whether we are dealing with a RUFFIAN aka Alpha PC-164 UX (or BX),
-     as they have REALLY different TOY (TimeOfYear) format: BCD, and not
-     an ARC-style epoch.
-     BCD is detected dynamically, but we must NOT adjust like ARC. */
-  if (ARCconsole && is_in_cpuinfo("system type", "Ruffian")) {
-    ARCconsole = 0;
-    if (debug) printf (_("Ruffian BCD clock\n"));
-  }
-
-  if (ARCconsole)
-    cmos_epoch = 1980;
-}
+	/*
+	 * The kernel source today says: read the year.
+	 *
+	 * If it is in  0-19 then the epoch is 2000.
+	 * If it is in 20-47 then the epoch is 1980.
+	 * If it is in 48-69 then the epoch is 1952.
+	 * If it is in 70-99 then the epoch is 1928.
+	 *
+	 * Otherwise the epoch is 1900.
+	 * TODO: Clearly, this must be changed before 2019.
+	 */
+	/*
+	 * See whether we are dealing with SRM or MILO, as they have
+	 * different "epoch" ideas.
+	 */
+	if (is_in_cpuinfo("system serial number", "MILO")) {
+		ARCconsole = 1;
+		if (debug)
+			printf(_("booted from MILO\n"));
+	}
 
-void
-set_cmos_access(int Jensen, int funky_toy) {
-
-  /* See whether we're dealing with a Jensen---it has a weird I/O
-     system.  DEC was just learning how to build Alpha PCs.  */
-  if (Jensen || is_in_cpuinfo("system type", "Jensen")) {
-    use_dev_port = 1;
-    clock_ctl_addr = 0x170;
-    clock_data_addr = 0x171;
-    if (debug) printf (_("clockport adjusted to 0x%x\n"), clock_ctl_addr);
-  }
-
-  /* see whether we are dealing with PC164/LX164/SX164, as they have a TOY
-     that must be accessed differently to work correctly. */
-  /* Nautilus stuff reported by Neoklis Kyriazis */
-  if (funky_toy ||
-      is_in_cpuinfo("system variation", "PC164") ||
-      is_in_cpuinfo("system variation", "LX164") ||
-      is_in_cpuinfo("system variation", "SX164") ||
-      is_in_cpuinfo("system type", "Nautilus")) {
-      funkyTOY = 1;
-      if (debug) printf (_("funky TOY!\n"));
-  }
+	/*
+	 * See whether we are dealing with a RUFFIAN aka Alpha PC-164 UX (or
+	 * BX), as they have REALLY different TOY (TimeOfYear) format: BCD,
+	 * and not an ARC-style epoch. BCD is detected dynamically, but we
+	 * must NOT adjust like ARC.
+	 */
+	if (ARCconsole && is_in_cpuinfo("system type", "Ruffian")) {
+		ARCconsole = 0;
+		if (debug)
+			printf(_("Ruffian BCD clock\n"));
+	}
+
+	if (ARCconsole)
+		cmos_epoch = 1980;
 }
-#endif
 
+void set_cmos_access(int Jensen, int funky_toy)
+{
+
+	/*
+	 * See whether we're dealing with a Jensen---it has a weird I/O
+	 * system. DEC was just learning how to build Alpha PCs.
+	 */
+	if (Jensen || is_in_cpuinfo("system type", "Jensen")) {
+		use_dev_port = 1;
+		clock_ctl_addr = 0x170;
+		clock_data_addr = 0x171;
+		if (debug)
+			printf(_("clockport adjusted to 0x%x\n"),
+			       clock_ctl_addr);
+	}
+
+	/*
+	 * See whether we are dealing with PC164/LX164/SX164, as they have a
+	 * TOY that must be accessed differently to work correctly.
+	 */
+	/* Nautilus stuff reported by Neoklis Kyriazis */
+	if (funky_toy ||
+	    is_in_cpuinfo("system variation", "PC164") ||
+	    is_in_cpuinfo("system variation", "LX164") ||
+	    is_in_cpuinfo("system variation", "SX164") ||
+	    is_in_cpuinfo("system type", "Nautilus")) {
+		funkyTOY = 1;
+		if (debug)
+			printf(_("funky TOY!\n"));
+	}
+}
+#endif				/* __alpha */
 
 #if __alpha__
 /*
- * The Alpha doesn't allow user-level code to disable interrupts (for
- * good reasons).  Instead, we ensure atomic operation by performing
- * the operation and checking whether the high 32 bits of the cycle
- * counter changed.  If they did, a context switch must have occurred
- * and we redo the operation.  As long as the operation is reasonably
- * short, it will complete atomically, eventually.
+ * The Alpha doesn't allow user-level code to disable interrupts (for good
+ * reasons). Instead, we ensure atomic operation by performing the operation
+ * and checking whether the high 32 bits of the cycle counter changed. If
+ * they did, a context switch must have occurred and we redo the operation.
+ * As long as the operation is reasonably short, it will complete
+ * atomically, eventually.
  */
-
 static unsigned long
-atomic(const char *name, unsigned long (*op)(unsigned long),
-       unsigned long arg)
+atomic(const char *name, unsigned long (*op) (unsigned long), unsigned long arg)
 {
-  unsigned long ts1, ts2, n, v;
-
-  for (n = 0; n < 1000; ++n) {
-    asm volatile ("rpcc %0" : "r="(ts1));
-    v = (*op)(arg);
-    asm volatile ("rpcc %0" : "r="(ts2));
-
-    if ((ts1 ^ ts2) >> 32 == 0) {
-      return v;
-    }
-  }
-  fprintf(stderr, _("%s: atomic %s failed for 1000 iterations!"), progname, name);
-  exit(1);
+	unsigned long ts1, ts2, n, v;
+
+	for (n = 0; n < 1000; ++n) {
+		asm volatile ("rpcc %0":"r=" (ts1));
+		v = (*op) (arg);
+		asm volatile ("rpcc %0":"r=" (ts2));
+
+		if ((ts1 ^ ts2) >> 32 == 0) {
+			return v;
+		}
+	}
+	fprintf(stderr, _("%s: atomic %s failed for 1000 iterations!"),
+		progname, name);
+	exit(1);
 }
 #else
 
 /*
- * Hmmh, this isn't very atomic.  Maybe we should force an error
- * instead?
+ * Hmmh, this isn't very atomic. Maybe we should force an error instead?
  *
- * TODO: optimize the access to CMOS by mlockall(MCL_CURRENT)
- *       and SCHED_FIFO
+ * TODO: optimize the access to CMOS by mlockall(MCL_CURRENT) and SCHED_FIFO
  */
 static unsigned long
-atomic(const char *name, unsigned long (*op)(unsigned long),
-       unsigned long arg)
+atomic(const char *name, unsigned long (*op) (unsigned long), unsigned long arg)
 {
-    return (*op)(arg);
+	return (*op) (arg);
 }
 
 #endif
 
-
-static inline
-unsigned long cmos_read(unsigned long reg)
+static inline unsigned long cmos_read(unsigned long reg)
 {
-  if (use_dev_port) {
-    unsigned char v = reg | 0x80;
-    lseek(dev_port_fd, clock_ctl_addr, 0);
-    if (write(dev_port_fd, &v, 1) == -1 && debug)
-      printf(_("cmos_read(): write to control address %X failed: %s\n"), clock_ctl_addr, strerror(errno));
-    lseek(dev_port_fd, clock_data_addr, 0);
-    if (read(dev_port_fd, &v, 1) == -1 && debug)
-      printf(_("cmos_read(): read data address %X failed: %s\n"), clock_data_addr, strerror(errno));
-    return v;
-  } else {
-    /* We only want to read CMOS data, but unfortunately
-       writing to bit 7 disables (1) or enables (0) NMI;
-       since this bit is read-only we have to guess the old status.
-       Various docs suggest that one should disable NMI while
-       reading/writing CMOS data, and enable it again afterwards.
-       This would yield the sequence
-	  outb (reg | 0x80, 0x70);
-	  val = inb(0x71);
-	  outb (0x0d, 0x70);	// 0x0d: random read-only location
-       Other docs state that "any write to 0x70 should be followed
-       by an action to 0x71 or the RTC wil be left in an unknown state".
-       Most docs say that it doesnt matter at all what one does.
-     */
-    /* bit 0x80: disable NMI while reading - should we?
-       Let us follow the kernel and not disable.
-       Called only with 0 <= reg < 128 */
-    outb (reg, clock_ctl_addr);
-    return inb (clock_data_addr);
-  }
+	if (use_dev_port) {
+		unsigned char v = reg | 0x80;
+		lseek(dev_port_fd, clock_ctl_addr, 0);
+		if (write(dev_port_fd, &v, 1) == -1 && debug)
+			printf(_
+			       ("cmos_read(): write to control address %X failed: %s\n"),
+			       clock_ctl_addr, strerror(errno));
+		lseek(dev_port_fd, clock_data_addr, 0);
+		if (read(dev_port_fd, &v, 1) == -1 && debug)
+			printf(_
+			       ("cmos_read(): read data address %X failed: %s\n"),
+			       clock_data_addr, strerror(errno));
+		return v;
+	} else {
+		/*
+		 * We only want to read CMOS data, but unfortunately writing
+		 * to bit 7 disables (1) or enables (0) NMI; since this bit
+		 * is read-only we have to guess the old status. Various
+		 * docs suggest that one should disable NMI while
+		 * reading/writing CMOS data, and enable it again
+		 * afterwards. This would yield the sequence
+		 *
+		 *  outb (reg | 0x80, 0x70);
+		 *  val = inb(0x71);
+		 *  outb (0x0d, 0x70);  // 0x0d: random read-only location
+		 *
+		 * Other docs state that "any write to 0x70 should be
+		 * followed by an action to 0x71 or the RTC wil be left in
+		 * an unknown state". Most docs say that it doesnt matter at
+		 * all what one does.
+		 */
+		/*
+		 * bit 0x80: disable NMI while reading - should we? Let us
+		 * follow the kernel and not disable. Called only with 0 <=
+		 * reg < 128
+		 */
+		outb(reg, clock_ctl_addr);
+		return inb(clock_data_addr);
+	}
 }
 
-static inline
-unsigned long cmos_write(unsigned long reg, unsigned long val)
+static inline unsigned long cmos_write(unsigned long reg, unsigned long val)
 {
-  if (use_dev_port) {
-    unsigned char v = reg | 0x80;
-    lseek(dev_port_fd, clock_ctl_addr, 0);
-    if (write(dev_port_fd, &v, 1) == -1 && debug)
-      printf(_("cmos_write(): write to control address %X failed: %s\n"), clock_ctl_addr, strerror(errno));
-    v = (val & 0xff);
-    lseek(dev_port_fd, clock_data_addr, 0);
-    if (write(dev_port_fd, &v, 1) == -1 && debug)
-      printf(_("cmos_write(): write to data address %X failed: %s\n"), clock_data_addr, strerror(errno));
-  } else {
-    outb (reg, clock_ctl_addr);
-    outb (val, clock_data_addr);
-  }
-  return 0;
+	if (use_dev_port) {
+		unsigned char v = reg | 0x80;
+		lseek(dev_port_fd, clock_ctl_addr, 0);
+		if (write(dev_port_fd, &v, 1) == -1 && debug)
+			printf(_
+			       ("cmos_write(): write to control address %X failed: %s\n"),
+			       clock_ctl_addr, strerror(errno));
+		v = (val & 0xff);
+		lseek(dev_port_fd, clock_data_addr, 0);
+		if (write(dev_port_fd, &v, 1) == -1 && debug)
+			printf(_
+			       ("cmos_write(): write to data address %X failed: %s\n"),
+			       clock_data_addr, strerror(errno));
+	} else {
+		outb(reg, clock_ctl_addr);
+		outb(val, clock_data_addr);
+	}
+	return 0;
 }
 
 static unsigned long cmos_set_time(unsigned long arg)
 {
-  unsigned char save_control, save_freq_select, pmbit = 0;
-  struct tm tm = *(struct tm *) arg;
-  unsigned int century;
+	unsigned char save_control, save_freq_select, pmbit = 0;
+	struct tm tm = *(struct tm *)arg;
+	unsigned int century;
 
 /*
  * CMOS byte 10 (clock status register A) has 3 bitfields:
@@ -349,260 +389,261 @@ static unsigned long cmos_set_time(unsigned long arg)
  *         1111 500 milliseconds (maximum, 2 Hz)
  *         0110 976.562 microseconds (default 1024 Hz)
  */
+	save_control = cmos_read(11);	/* tell the clock it's being set */
+	cmos_write(11, (save_control | 0x80));
+	save_freq_select = cmos_read(10);	/* stop and reset prescaler */
+	cmos_write(10, (save_freq_select | 0x70));
+
+	tm.tm_year += TM_EPOCH;
+	century = tm.tm_year / 100;
+	tm.tm_year -= cmos_epoch;
+	tm.tm_year %= 100;
+	tm.tm_mon += 1;
+	tm.tm_wday += 1;
+
+	if (!(save_control & 0x02)) {	/* 12hr mode; the default is 24hr mode */
+		if (tm.tm_hour == 0)
+			tm.tm_hour = 24;
+		if (tm.tm_hour > 12) {
+			tm.tm_hour -= 12;
+			pmbit = 0x80;
+		}
+	}
+
+	if (!(save_control & 0x04)) {	/* BCD mode - the default */
+		BIN_TO_BCD(tm.tm_sec);
+		BIN_TO_BCD(tm.tm_min);
+		BIN_TO_BCD(tm.tm_hour);
+		BIN_TO_BCD(tm.tm_wday);
+		BIN_TO_BCD(tm.tm_mday);
+		BIN_TO_BCD(tm.tm_mon);
+		BIN_TO_BCD(tm.tm_year);
+		BIN_TO_BCD(century);
+	}
 
-  save_control = cmos_read (11);   /* tell the clock it's being set */
-  cmos_write (11, (save_control | 0x80));
-  save_freq_select = cmos_read (10);       /* stop and reset prescaler */
-  cmos_write (10, (save_freq_select | 0x70));
-
-  tm.tm_year += TM_EPOCH;
-  century = tm.tm_year/100;
-  tm.tm_year -= cmos_epoch;
-  tm.tm_year %= 100;
-  tm.tm_mon += 1;
-  tm.tm_wday += 1;
-
-  if (!(save_control & 0x02)) {	/* 12hr mode; the default is 24hr mode */
-      if (tm.tm_hour == 0)
-          tm.tm_hour = 24;
-      if (tm.tm_hour > 12) {
-	  tm.tm_hour -= 12;
-	  pmbit = 0x80;
-      }
-  }
-
-  if (!(save_control & 0x04)) { /* BCD mode - the default */
-      BIN_TO_BCD(tm.tm_sec);
-      BIN_TO_BCD(tm.tm_min);
-      BIN_TO_BCD(tm.tm_hour);
-      BIN_TO_BCD(tm.tm_wday);
-      BIN_TO_BCD(tm.tm_mday);
-      BIN_TO_BCD(tm.tm_mon);
-      BIN_TO_BCD(tm.tm_year);
-      BIN_TO_BCD(century);
-  }
-
-  cmos_write (0, tm.tm_sec);
-  cmos_write (2, tm.tm_min);
-  cmos_write (4, tm.tm_hour | pmbit);
-  cmos_write (6, tm.tm_wday);
-  cmos_write (7, tm.tm_mday);
-  cmos_write (8, tm.tm_mon);
-  cmos_write (9, tm.tm_year);
-  if (century_byte)
-	  cmos_write (century_byte, century);
-
-
-    /* The kernel sources, linux/arch/i386/kernel/time.c, have the
-       following comment:
-
-       The following flags have to be released exactly in this order,
-       otherwise the DS12887 (popular MC146818A clone with integrated
-       battery and quartz) will not reset the oscillator and will not
-       update precisely 500 ms later.  You won't find this mentioned
-       in the Dallas Semiconductor data sheets, but who believes data
-       sheets anyway ...  -- Markus Kuhn
-    */
-
-  cmos_write (11, save_control);
-  cmos_write (10, save_freq_select);
-  return 0;
+	cmos_write(0, tm.tm_sec);
+	cmos_write(2, tm.tm_min);
+	cmos_write(4, tm.tm_hour | pmbit);
+	cmos_write(6, tm.tm_wday);
+	cmos_write(7, tm.tm_mday);
+	cmos_write(8, tm.tm_mon);
+	cmos_write(9, tm.tm_year);
+	if (century_byte)
+		cmos_write(century_byte, century);
+
+	/*
+	 * The kernel sources, linux/arch/i386/kernel/time.c, have the
+	 * following comment:
+	 *
+	 * The following flags have to be released exactly in this order,
+	 * otherwise the DS12887 (popular MC146818A clone with integrated
+	 * battery and quartz) will not reset the oscillator and will not
+	 * update precisely 500 ms later. You won't find this mentioned in
+	 * the Dallas Semiconductor data sheets, but who believes data
+	 * sheets anyway ... -- Markus Kuhn
+	 */
+	cmos_write(11, save_control);
+	cmos_write(10, save_freq_select);
+	return 0;
 }
 
-static int
-hclock_read(unsigned long reg) {
+static int hclock_read(unsigned long reg)
+{
 	return atomic("clock read", cmos_read, (reg));
 }
 
-static void
-hclock_set_time(const struct tm *tm) {
+static void hclock_set_time(const struct tm *tm)
+{
 	atomic("set time", cmos_set_time, (unsigned long)(tm));
 }
 
-static inline int
-cmos_clock_busy(void) {
+static inline int cmos_clock_busy(void)
+{
 	return
 #ifdef __alpha__
-	                /* poll bit 4 (UF) of Control Register C */
+	    /* poll bit 4 (UF) of Control Register C */
 	    funkyTOY ? (hclock_read(12) & 0x10) :
 #endif
-		        /* poll bit 7 (UIP) of Control Register A */
+	    /* poll bit 7 (UIP) of Control Register A */
 	    (hclock_read(10) & 0x80);
 }
 
-
-static int
-synchronize_to_clock_tick_cmos(void) {
-  int i;
-
-  /* Wait for rise.  Should be within a second, but in case something
-     weird happens, we have a limit on this loop to reduce the impact
-     of this failure.
-     */
-  for (i = 0; !cmos_clock_busy(); i++)
-	  if (i >= 10000000)
-		  return 1;
-
-  /* Wait for fall.  Should be within 2.228 ms. */
-  for (i = 0; cmos_clock_busy(); i++)
-	  if (i >= 1000000)
-		  return 1;
-  return 0;
+static int synchronize_to_clock_tick_cmos(void)
+{
+	int i;
+
+	/*
+	 * Wait for rise. Should be within a second, but in case something
+	 * weird happens, we have a limit on this loop to reduce the impact
+	 * of this failure.
+	 */
+	for (i = 0; !cmos_clock_busy(); i++)
+		if (i >= 10000000)
+			return 1;
+
+	/* Wait for fall.  Should be within 2.228 ms. */
+	for (i = 0; cmos_clock_busy(); i++)
+		if (i >= 1000000)
+			return 1;
+	return 0;
 }
 
-
-
-static int
-read_hardware_clock_cmos(struct tm *tm) {
-/*----------------------------------------------------------------------------
-  Read the hardware clock and return the current time via <tm> argument.
-  Assume we have an ISA machine and read the clock directly with CPU I/O
-  instructions.
-
-  This function is not totally reliable.  It takes a finite and
-  unpredictable amount of time to execute the code below.  During that
-  time, the clock may change and we may even read an invalid value in
-  the middle of an update.  We do a few checks to minimize this
-  possibility, but only the kernel can actually read the clock
-  properly, since it can execute code in a short and predictable
-  amount of time (by turning of interrupts).
-
-  In practice, the chance of this function returning the wrong time is
-  extremely remote.
-
------------------------------------------------------------------------------*/
-  bool got_time = FALSE;
-  unsigned char status, pmbit;
-
-  status = pmbit = 0;		/* just for gcc */
-
-  while (!got_time) {
-    /* Bit 7 of Byte 10 of the Hardware Clock value is the Update In Progress
-       (UIP) bit, which is on while and 244 uS before the Hardware Clock
-       updates itself.  It updates the counters individually, so reading
-       them during an update would produce garbage.  The update takes 2mS,
-       so we could be spinning here that long waiting for this bit to turn
-       off.
-
-       Furthermore, it is pathologically possible for us to be in this
-       code so long that even if the UIP bit is not on at first, the
-       clock has changed while we were running.  We check for that too,
-       and if it happens, we start over.
-       */
-
-    if (!cmos_clock_busy()) {
-      /* No clock update in progress, go ahead and read */
-      tm->tm_sec = hclock_read(0);
-      tm->tm_min = hclock_read(2);
-      tm->tm_hour = hclock_read(4);
-      tm->tm_wday = hclock_read(6);
-      tm->tm_mday = hclock_read(7);
-      tm->tm_mon = hclock_read(8);
-      tm->tm_year = hclock_read(9);
-      status = hclock_read(11);
+/*
+ * Read the hardware clock and return the current time via <tm> argument.
+ * Assume we have an ISA machine and read the clock directly with CPU I/O
+ * instructions.
+ *
+ * This function is not totally reliable.  It takes a finite and
+ * unpredictable amount of time to execute the code below. During that time,
+ * the clock may change and we may even read an invalid value in the middle
+ * of an update. We do a few checks to minimize this possibility, but only
+ * the kernel can actually read the clock properly, since it can execute
+ * code in a short and predictable amount of time (by turning of
+ * interrupts).
+ *
+ * In practice, the chance of this function returning the wrong time is
+ * extremely remote.
+ */
+static int read_hardware_clock_cmos(struct tm *tm)
+{
+	bool got_time = FALSE;
+	unsigned char status, pmbit;
+
+	status = pmbit = 0;	/* just for gcc */
+
+	while (!got_time) {
+		/*
+		 * Bit 7 of Byte 10 of the Hardware Clock value is the
+		 * Update In Progress (UIP) bit, which is on while and 244
+		 * uS before the Hardware Clock updates itself. It updates
+		 * the counters individually, so reading them during an
+		 * update would produce garbage. The update takes 2mS, so we
+		 * could be spinning here that long waiting for this bit to
+		 * turn off.
+		 *
+		 * Furthermore, it is pathologically possible for us to be
+		 * in this code so long that even if the UIP bit is not on
+		 * at first, the clock has changed while we were running. We
+		 * check for that too, and if it happens, we start over.
+		 */
+		if (!cmos_clock_busy()) {
+			/* No clock update in progress, go ahead and read */
+			tm->tm_sec = hclock_read(0);
+			tm->tm_min = hclock_read(2);
+			tm->tm_hour = hclock_read(4);
+			tm->tm_wday = hclock_read(6);
+			tm->tm_mday = hclock_read(7);
+			tm->tm_mon = hclock_read(8);
+			tm->tm_year = hclock_read(9);
+			status = hclock_read(11);
 #if 0
-      if (century_byte)
-	  century = hclock_read(century_byte);
+			if (century_byte)
+				century = hclock_read(century_byte);
 #endif
+			/*
+			 * Unless the clock changed while we were reading,
+			 * consider this a good clock read .
+			 */
+			if (tm->tm_sec == hclock_read(0))
+				got_time = TRUE;
+		}
+		/*
+		 * Yes, in theory we could have been running for 60 seconds
+		 * and the above test wouldn't work!
+		 */
+	}
 
-      /* Unless the clock changed while we were reading, consider this
-         a good clock read .
-       */
-      if (tm->tm_sec == hclock_read (0))
-	got_time = TRUE;
-    }
-    /* Yes, in theory we could have been running for 60 seconds and
-       the above test wouldn't work!
-       */
-  }
-
-  if (!(status & 0x04)) { /* BCD mode - the default */
-      BCD_TO_BIN(tm->tm_sec);
-      BCD_TO_BIN(tm->tm_min);
-      pmbit = (tm->tm_hour & 0x80);
-      tm->tm_hour &= 0x7f;
-      BCD_TO_BIN(tm->tm_hour);
-      BCD_TO_BIN(tm->tm_wday);
-      BCD_TO_BIN(tm->tm_mday);
-      BCD_TO_BIN(tm->tm_mon);
-      BCD_TO_BIN(tm->tm_year);
+	if (!(status & 0x04)) {	/* BCD mode - the default */
+		BCD_TO_BIN(tm->tm_sec);
+		BCD_TO_BIN(tm->tm_min);
+		pmbit = (tm->tm_hour & 0x80);
+		tm->tm_hour &= 0x7f;
+		BCD_TO_BIN(tm->tm_hour);
+		BCD_TO_BIN(tm->tm_wday);
+		BCD_TO_BIN(tm->tm_mday);
+		BCD_TO_BIN(tm->tm_mon);
+		BCD_TO_BIN(tm->tm_year);
 #if 0
-      BCD_TO_BIN(century);
+		BCD_TO_BIN(century);
 #endif
-  }
-
-  /* We don't use the century byte of the Hardware Clock
-     since we don't know its address (usually 50 or 55).
-     Here, we follow the advice of the X/Open Base Working Group:
-     "if century is not specified, then values in the range [69-99]
-      refer to years in the twentieth century (1969 to 1999 inclusive),
-      and values in the range [00-68] refer to years in the twenty-first
-      century (2000 to 2068 inclusive)."
-   */
-
-  tm->tm_wday -= 1;
-  tm->tm_mon -= 1;
-  tm->tm_year += (cmos_epoch - TM_EPOCH);
-  if (tm->tm_year < 69)
-	  tm->tm_year += 100;
-  if (pmbit) {
-	  tm->tm_hour += 12;
-	  if (tm->tm_hour == 24)
-		  tm->tm_hour = 0;
-  }
-
-  tm->tm_isdst = -1;        /* don't know whether it's daylight */
-  return 0;
-}
+	}
 
+	/*
+	 * We don't use the century byte of the Hardware Clock since we
+	 * don't know its address (usually 50 or 55). Here, we follow the
+	 * advice of the X/Open Base Working Group: "if century is not
+	 * specified, then values in the range [69-99] refer to years in the
+	 * twentieth century (1969 to 1999 inclusive), and values in the
+	 * range [00-68] refer to years in the twenty-first century (2000 to
+	 * 2068 inclusive)."
+	 */
+	tm->tm_wday -= 1;
+	tm->tm_mon -= 1;
+	tm->tm_year += (cmos_epoch - TM_EPOCH);
+	if (tm->tm_year < 69)
+		tm->tm_year += 100;
+	if (pmbit) {
+		tm->tm_hour += 12;
+		if (tm->tm_hour == 24)
+			tm->tm_hour = 0;
+	}
 
+	tm->tm_isdst = -1;	/* don't know whether it's daylight */
+	return 0;
+}
 
-static int
-set_hardware_clock_cmos(const struct tm *new_broken_time) {
+static int set_hardware_clock_cmos(const struct tm *new_broken_time)
+{
 
-    hclock_set_time(new_broken_time);
-    return 0;
+	hclock_set_time(new_broken_time);
+	return 0;
 }
 
-static int
-i386_iopl(const int level) {
+static int i386_iopl(const int level)
+{
 #if defined(__i386__) || defined(__alpha__)
 #if defined(HAVE_IOPL)
-  extern int iopl(const int lvl);
-  return iopl(level);
+	extern int iopl(const int lvl);
+	return iopl(level);
 #else
-  extern int ioperm(unsigned long from, unsigned long num, int turn_on);
-  return ioperm(clock_ctl_addr, 2, 1);
+	extern int ioperm(unsigned long from, unsigned long num, int turn_on);
+	return ioperm(clock_ctl_addr, 2, 1);
 #endif
 #else
-  return -2;
+	return -2;
 #endif
 }
 
-static int
-get_permissions_cmos(void) {
-  int rc;
-
-  if (use_dev_port) {
-    if ((dev_port_fd = open("/dev/port", O_RDWR)) < 0) {
-      int errsv = errno;
-      fprintf(stderr, _("Cannot open /dev/port: %s"), strerror(errsv));
-      rc = 1;
-    } else
-      rc = 0;
-  } else {
-    rc = i386_iopl(3);
-    if (rc == -2) {
-      fprintf(stderr, _("I failed to get permission because I didn't try.\n"));
-    } else if (rc != 0) {
-      rc = errno;
-      fprintf(stderr, _("%s is unable to get I/O port access:  "
-              "the iopl(3) call failed.\n"), progname);
-      if(rc == EPERM && geteuid())
-        fprintf(stderr, _("Probably you need root privileges.\n"));
-    }
-  }
-  return rc ? 1 : 0;
+static int get_permissions_cmos(void)
+{
+	int rc;
+
+	if (use_dev_port) {
+		if ((dev_port_fd = open("/dev/port", O_RDWR)) < 0) {
+			int errsv = errno;
+			fprintf(stderr, _("Cannot open /dev/port: %s"),
+				strerror(errsv));
+			rc = 1;
+		} else
+			rc = 0;
+	} else {
+		rc = i386_iopl(3);
+		if (rc == -2) {
+			fprintf(stderr,
+				_
+				("I failed to get permission because I didn't try.\n"));
+		} else if (rc != 0) {
+			rc = errno;
+			fprintf(stderr,
+				_("%s is unable to get I/O port access:  "
+				  "the iopl(3) call failed.\n"), progname);
+			if (rc == EPERM && geteuid())
+				fprintf(stderr,
+					_
+					("Probably you need root privileges.\n"));
+		}
+	}
+	return rc ? 1 : 0;
 }
 
 static struct clock_ops cmos = {
@@ -613,17 +654,17 @@ static struct clock_ops cmos = {
 	synchronize_to_clock_tick_cmos,
 };
 
-
-/* return &cmos if cmos clock present, NULL otherwise */
-/* choose this construction to avoid gcc messages about unused variables */
-
-struct clock_ops *
-probe_for_cmos_clock(void){
-    int have_cmos =
+/*
+ * return &cmos if cmos clock present, NULL otherwise choose this
+ * construction to avoid gcc messages about unused variables
+ */
+struct clock_ops *probe_for_cmos_clock(void)
+{
+	int have_cmos =
 #if defined(__i386__) || defined(__alpha__)
 	    TRUE;
 #else
 	    FALSE;
 #endif
-    return have_cmos ? &cmos : NULL;
+	return have_cmos ? &cmos : NULL;
 }
diff --git a/hwclock/hwclock.c b/hwclock/hwclock.c
index 68e76b896..0c6b0f6cd 100644
--- a/hwclock/hwclock.c
+++ b/hwclock/hwclock.c
@@ -8,35 +8,24 @@
  *
  * Major rewrite by Bryan Henderson <bryanh@giraffe-data.com>, 96.09.19.
  * The new program is called hwclock. New features:
- * - You can set the hardware clock without also modifying the system clock.
- * - You can read and set the clock with finer than 1 second precision.
- * - When you set the clock, hwclock automatically refigures the drift
- *   rate, based on how far off the clock was before you set it.
+ *
+ *	- You can set the hardware clock without also modifying the system
+ *	  clock.
+ *	- You can read and set the clock with finer than 1 second precision.
+ *	- When you set the clock, hwclock automatically refigures the drift
+ *	  rate, based on how far off the clock was before you set it.
  *
  * Reshuffled things, added sparc code, and re-added alpha stuff
  * by David Mosberger <davidm@azstarnet.com>
  * and Jay Estabrook <jestabro@amt.tay1.dec.com>
  * and Martin Ostermann <ost@coments.rwth-aachen.de>, aeb@cwi.nl, 990212.
  *
- * Fix for Award 2094 bug, Dave Coffin  (dcoffin@shore.net)  11/12/98
+ * Fix for Award 2094 bug, Dave Coffin (dcoffin@shore.net) 11/12/98
  * Change of local time handling, Stefan Ring <e9725446@stud3.tuwien.ac.at>
  * Change of adjtime handling, James P. Rutledge <ao112@rgfn.epcc.edu>.
  *
  * Distributed under GPL
  */
-
-/*
- * clock [-u] -r  - read hardware clock
- * clock [-u] -w  - write hardware clock from system time
- * clock [-u] -s  - set system time from hardware clock
- * clock [-u] -a  - set system time from hardware clock, adjust the time
- *                  to correct for systematic error, and write it back to
- *                  the hardware clock
- * -u indicates cmos clock is kept in universal time
- * -A indicates cmos clock is kept in Alpha ARC console time (0 == 1980)
- * -J indicates we're dealing with a Jensen (early DEC Alpha PC)
- */
-
 /*
  * Explanation of `adjusting' (Rob Hooft):
  *
@@ -49,23 +38,23 @@
  * to determine the correction, and to save its data. In this file are
  * three numbers:
  *
- * 1) the correction in seconds per day. (So if your clock runs 5
- *    seconds per day fast, the first number should read -5.0)
- * 2) the number of seconds since 1/1/1970 the last time the program
- *    was used
- * 3) the remaining part of a second which was leftover after the last
- *    adjustment
+ *	1) the correction in seconds per day. (So if your clock runs 5
+ *	   seconds per day fast, the first number should read -5.0)
+ *	2) the number of seconds since 1/1/1970 the last time the program
+ *	   was used
+ *	3) the remaining part of a second which was leftover after the last
+ *	   adjustment
  *
  * Installation and use of this program:
  *
- * a) create a file '/etc/adjtime' containing as the first and only line:
- *    '0.0 0 0.0'
- * b) run 'clock -au' or 'clock -a', depending on whether your cmos is in
- *    universal or local time. This updates the second number.
- * c) set your system time using the 'date' command.
- * d) update your cmos time using 'clock -wu' or 'clock -w'
- * e) replace the first number in /etc/adjtime by your correction.
- * f) put the command 'clock -au' or 'clock -a' in your '/etc/rc.local'
+ *	a) create a file '/etc/adjtime' containing as the first and only
+ *	   line: '0.0 0 0.0'
+ *	b) run 'clock -au' or 'clock -a', depending on whether your cmos is
+ *	   in universal or local time. This updates the second number.
+ *	c) set your system time using the 'date' command.
+ *	d) update your cmos time using 'clock -wu' or 'clock -w'
+ *	e) replace the first number in /etc/adjtime by your correction.
+ *	f) put the command 'clock -au' or 'clock -a' in your '/etc/rc.local'
  */
 
 #include <string.h>
@@ -108,115 +97,125 @@ const char *adj_file_name = NULL;
 #define LASTDATE "/var/lib/lastdate"
 
 struct adjtime {
-  /* This is information we keep in the adjtime file that tells us how
-     to do drift corrections.  Elements are all straight from the
-     adjtime file, so see documentation of that file for details.
-     Exception is <dirty>, which is an indication that what's in this
-     structure is not what's in the disk file (because it has been
-     updated since read from the disk file).
-     */
-  bool dirty;
-
-  /* line 1 */
-  double drift_factor;
-  time_t last_adj_time;
-  double not_adjusted;
-
-  /* line 2 */
-  time_t last_calib_time;
-      /* The most recent time that we set the clock from an external
-	 authority (as opposed to just doing a drift adjustment) */
-
-  /* line 3 */
-  enum a_local_utc {LOCAL, UTC, UNKNOWN} local_utc;
-      /* To which time zone, local or UTC, we most recently set the
-	 hardware clock. */
+	/*
+	 * This is information we keep in the adjtime file that tells us how
+	 * to do drift corrections. Elements are all straight from the
+	 * adjtime file, so see documentation of that file for details.
+	 * Exception is <dirty>, which is an indication that what's in this
+	 * structure is not what's in the disk file (because it has been
+	 * updated since read from the disk file).
+	 */
+	bool dirty;
+	/* line 1 */
+	double drift_factor;
+	time_t last_adj_time;
+	double not_adjusted;
+	/* line 2 */
+	time_t last_calib_time;
+	/*
+	 * The most recent time that we set the clock from an external
+	 * authority (as opposed to just doing a drift adjustment)
+	 */
+	/* line 3 */
+	enum a_local_utc { LOCAL, UTC, UNKNOWN } local_utc;
+	/*
+	 * To which time zone, local or UTC, we most recently set the
+	 * hardware clock.
+	 */
 };
 
+
+/*
+ * We are running in debug mode, wherein we put a lot of information about
+ * what we're doing to standard output.
+ */
 bool debug;
-  /* We are running in debug mode, wherein we put a lot of information about
-     what we're doing to standard output. */
 
+/* Workaround for Award 4.50g BIOS bug: keep the year in a file. */
 bool badyear;
-  /* Workaround for Award 4.50g BIOS bug: keep the year in a file. */
 
+/* User-specified epoch, used when rtc fails to return epoch. */
 int epoch_option = -1;
-  /* User-specified epoch, used when rtc fails to return epoch. */
 
 /*
- * Almost all Award BIOS's made between 04/26/94 and 05/31/95
- * have a nasty bug limiting the RTC year byte to the range 94-99.
- * Any year between 2000 and 2093 gets changed to 2094, every time
- * you start the system.
- * With the --badyear option, we write the date to file and hope
- * that the file is updated at least once a year.
- * I recommend putting this command "hwclock --badyear" in the monthly
- * crontab, just to be safe. --  Dave Coffin  11/12/98
+ * Almost all Award BIOS's made between 04/26/94 and 05/31/95 have a nasty
+ * bug limiting the RTC year byte to the range 94-99. Any year between 2000
+ * and 2093 gets changed to 2094, every time you start the system.
+ *
+ * With the --badyear option, we write the date to file and hope that the
+ * file is updated at least once a year. I recommend putting this command
+ * "hwclock --badyear" in the monthly crontab, just to be safe.
+ *
+ * -- Dave Coffin 11/12/98
  */
-static void
-write_date_to_file (struct tm *tm) {
-  FILE *fp;
-
-  if ((fp = fopen(LASTDATE,"w"))) {
-    fprintf(fp,"%02d.%02d.%04d\n", tm->tm_mday, tm->tm_mon+1,
-	    tm->tm_year+1900);
-    fclose(fp);
-  } else
-    perror(LASTDATE);
+static void write_date_to_file(struct tm *tm)
+{
+	FILE *fp;
+
+	if ((fp = fopen(LASTDATE, "w"))) {
+		fprintf(fp, "%02d.%02d.%04d\n", tm->tm_mday, tm->tm_mon + 1,
+			tm->tm_year + 1900);
+		fclose(fp);
+	} else
+		perror(LASTDATE);
 }
 
-static void
-read_date_from_file (struct tm *tm) {
-  int last_mday, last_mon, last_year;
-  FILE *fp;
-
-  if ((fp = fopen(LASTDATE,"r"))) {
-    if (fscanf (fp,"%d.%d.%d\n", &last_mday, &last_mon, &last_year) == 3) {
-      tm->tm_year = last_year-1900;
-      if ((tm->tm_mon << 5) + tm->tm_mday < ((last_mon-1) << 5) + last_mday)
-	tm->tm_year ++;
-    }
-    fclose(fp);
-  }
-  write_date_to_file (tm);
+static void read_date_from_file(struct tm *tm)
+{
+	int last_mday, last_mon, last_year;
+	FILE *fp;
+
+	if ((fp = fopen(LASTDATE, "r"))) {
+		if (fscanf(fp, "%d.%d.%d\n", &last_mday, &last_mon, &last_year)
+		    == 3) {
+			tm->tm_year = last_year - 1900;
+			if ((tm->tm_mon << 5) + tm->tm_mday <
+			    ((last_mon - 1) << 5) + last_mday)
+				tm->tm_year++;
+		}
+		fclose(fp);
+	}
+	write_date_to_file(tm);
 }
 
-double
-time_diff(struct timeval subtrahend, struct timeval subtractor) {
-/*---------------------------------------------------------------------------
-  The difference in seconds between two times in "timeval" format.
-----------------------------------------------------------------------------*/
-  return (subtrahend.tv_sec - subtractor.tv_sec)
-           + (subtrahend.tv_usec - subtractor.tv_usec) / 1E6;
+/*
+ * The difference in seconds between two times in "timeval" format.
+ */
+double time_diff(struct timeval subtrahend, struct timeval subtractor)
+{
+	return (subtrahend.tv_sec - subtractor.tv_sec)
+	    + (subtrahend.tv_usec - subtractor.tv_usec) / 1E6;
 }
 
-
-static struct timeval
-time_inc(struct timeval addend, double increment) {
-/*----------------------------------------------------------------------------
-  The time, in "timeval" format, which is <increment> seconds after
-  the time <addend>.  Of course, <increment> may be negative.
------------------------------------------------------------------------------*/
-  struct timeval newtime;
-
-  newtime.tv_sec = addend.tv_sec + (int) increment;
-  newtime.tv_usec = addend.tv_usec + (increment - (int) increment) * 1E6;
-
-  /* Now adjust it so that the microsecond value is between 0 and 1 million */
-  if (newtime.tv_usec < 0) {
-    newtime.tv_usec += 1E6;
-    newtime.tv_sec -= 1;
-  } else if (newtime.tv_usec >= 1E6) {
-    newtime.tv_usec -= 1E6;
-    newtime.tv_sec += 1;
-  }
-  return newtime;
+/*
+ * The time, in "timeval" format, which is <increment> seconds after the
+ * time <addend>. Of course, <increment> may be negative.
+ */
+static struct timeval time_inc(struct timeval addend, double increment)
+{
+	struct timeval newtime;
+
+	newtime.tv_sec = addend.tv_sec + (int)increment;
+	newtime.tv_usec = addend.tv_usec + (increment - (int)increment) * 1E6;
+
+	/*
+	 * Now adjust it so that the microsecond value is between 0 and 1
+	 * million.
+	 */
+	if (newtime.tv_usec < 0) {
+		newtime.tv_usec += 1E6;
+		newtime.tv_sec -= 1;
+	} else if (newtime.tv_usec >= 1E6) {
+		newtime.tv_usec -= 1E6;
+		newtime.tv_sec += 1;
+	}
+	return newtime;
 }
 
-
 static bool
 hw_clock_is_utc(const bool utc, const bool local_opt,
-		const struct adjtime adjtime) {
+		const struct adjtime adjtime)
+{
 	bool ret;
 
 	if (utc)
@@ -224,7 +223,7 @@ hw_clock_is_utc(const bool utc, const bool local_opt,
 	else if (local_opt)
 		ret = FALSE;	/* --localtime explicitly given */
 	else
-				/* get info from adjtime file - default is UTC */
+		/* get info from adjtime file - default is UTC */
 		ret = (adjtime.local_utc != LOCAL);
 	if (debug)
 		printf(_("Assuming hardware clock is kept in %s time.\n"),
@@ -232,122 +231,120 @@ hw_clock_is_utc(const bool utc, const bool local_opt,
 	return ret;
 }
 
+/*
+ * Read the adjustment parameters out of the /etc/adjtime file.
+ *
+ * Return them as the adjtime structure <*adjtime_p>. If there is no
+ * /etc/adjtime file, return defaults. If values are missing from the file,
+ * return defaults for them.
+ *
+ * return value 0 if all OK, !=0 otherwise.
+ */
+static int read_adjtime(struct adjtime *adjtime_p)
+{
+	FILE *adjfile;
+	int rc;			/* local return code */
+	struct stat statbuf;	/* We don't even use the contents of this. */
+	char line1[81];		/* String: first line of adjtime file */
+	char line2[81];		/* String: second line of adjtime file */
+	char line3[81];		/* String: third line of adjtime file */
+	long timeval;
+
+	rc = stat(adj_file_name, &statbuf);
+	if (rc < 0 && errno == ENOENT) {
+		/* He doesn't have a adjtime file, so we'll use defaults. */
+		adjtime_p->drift_factor = 0;
+		adjtime_p->last_adj_time = 0;
+		adjtime_p->not_adjusted = 0;
+		adjtime_p->last_calib_time = 0;
+		adjtime_p->local_utc = UNKNOWN;
+		adjtime_p->dirty = FALSE;	/* don't create a zero adjfile */
+
+		return 0;
+	}
 
-
-static int
-read_adjtime(struct adjtime *adjtime_p) {
-/*----------------------------------------------------------------------------
-  Read the adjustment parameters out of the /etc/adjtime file.
-
-  Return them as the adjtime structure <*adjtime_p>.
-  If there is no /etc/adjtime file, return defaults.
-  If values are missing from the file, return defaults for them.
-
-  return value 0 if all OK, !=0 otherwise.
-
------------------------------------------------------------------------------*/
-  FILE *adjfile;
-  int rc;  /* local return code */
-  struct stat statbuf;  /* We don't even use the contents of this. */
-
-    rc = stat(adj_file_name, &statbuf);
-    if (rc < 0 && errno == ENOENT) {
-      /* He doesn't have a adjtime file, so we'll use defaults. */
-      adjtime_p->drift_factor = 0;
-      adjtime_p->last_adj_time = 0;
-      adjtime_p->not_adjusted = 0;
-      adjtime_p->last_calib_time = 0;
-      adjtime_p->local_utc = UNKNOWN;
-      adjtime_p->dirty = FALSE;        /* don't create a zero adjfile */
-
-      return 0;
-    }
-
-    adjfile = fopen(adj_file_name, "r");   /* open file for reading */
-    if (adjfile == NULL) {
-      outsyserr("cannot open file %s", adj_file_name);
-      return EX_OSFILE;
-    }
-
-    {
-      char line1[81];           /* String: first line of adjtime file */
-      char line2[81];           /* String: second line of adjtime file */
-      char line3[81];           /* String: third line of adjtime file */
-      long timeval;
-
-      if (!fgets(line1, sizeof(line1), adjfile))
-        line1[0] = '\0';          /* In case fgets fails */
-      if (!fgets(line2, sizeof(line2), adjfile))
-        line2[0] = '\0';          /* In case fgets fails */
-      if (!fgets(line3, sizeof(line3), adjfile))
-        line3[0] = '\0';          /* In case fgets fails */
-
-      fclose(adjfile);
-
-      /* Set defaults in case values are missing from file */
-      adjtime_p->drift_factor = 0;
-      adjtime_p->last_adj_time = 0;
-      adjtime_p->not_adjusted = 0;
-      adjtime_p->last_calib_time = 0;
-      timeval = 0;
-
-      sscanf(line1, "%lf %ld %lf",
-             &adjtime_p->drift_factor,
-             &timeval,
-             &adjtime_p->not_adjusted);
-      adjtime_p->last_adj_time = timeval;
-
-      sscanf(line2, "%ld", &timeval);
-      adjtime_p->last_calib_time = timeval;
-
-      if (!strcmp(line3, "UTC\n"))
-	adjtime_p->local_utc = UTC;
-      else if (!strcmp(line3, "LOCAL\n"))
-	adjtime_p->local_utc = LOCAL;
-      else {
-	adjtime_p->local_utc = UNKNOWN;
-	if (line3[0]) {
-	  fprintf(stderr,
-		  _("%s: Warning: unrecognized third line in adjtime file\n"),
-		  MYNAME);
-	  fprintf(stderr, _("(Expected: `UTC' or `LOCAL' or nothing.)\n"));
+	adjfile = fopen(adj_file_name, "r");	/* open file for reading */
+	if (adjfile == NULL) {
+		outsyserr("cannot open file %s", adj_file_name);
+		return EX_OSFILE;
 	}
-      }
-    }
-    adjtime_p->dirty = FALSE;
-
-    if (debug) {
-      printf(_("Last drift adjustment done at %ld seconds after 1969\n"),
-             (long) adjtime_p->last_adj_time);
-      printf(_("Last calibration done at %ld seconds after 1969\n"),
-             (long) adjtime_p->last_calib_time);
-      printf(_("Hardware clock is on %s time\n"),
-	     (adjtime_p->local_utc == LOCAL) ? _("local") :
-	     (adjtime_p->local_utc == UTC) ? _("UTC") : _("unknown"));
-    }
-
-    return 0;
-}
 
 
-static int
-synchronize_to_clock_tick(void) {
-/*-----------------------------------------------------------------------------
-  Wait until the falling edge of the Hardware Clock's update flag so
-  that any time that is read from the clock immediately after we
-  return will be exact.
+	if (!fgets(line1, sizeof(line1), adjfile))
+		line1[0] = '\0';	/* In case fgets fails */
+	if (!fgets(line2, sizeof(line2), adjfile))
+		line2[0] = '\0';	/* In case fgets fails */
+	if (!fgets(line3, sizeof(line3), adjfile))
+		line3[0] = '\0';	/* In case fgets fails */
+
+	fclose(adjfile);
+
+	/* Set defaults in case values are missing from file */
+	adjtime_p->drift_factor = 0;
+	adjtime_p->last_adj_time = 0;
+	adjtime_p->not_adjusted = 0;
+	adjtime_p->last_calib_time = 0;
+	timeval = 0;
+
+	sscanf(line1, "%lf %ld %lf",
+	       &adjtime_p->drift_factor,
+	       &timeval, &adjtime_p->not_adjusted);
+	adjtime_p->last_adj_time = timeval;
+
+	sscanf(line2, "%ld", &timeval);
+	adjtime_p->last_calib_time = timeval;
+
+	if (!strcmp(line3, "UTC\n")) {
+		adjtime_p->local_utc = UTC;
+	} else if (!strcmp(line3, "LOCAL\n")) {
+		adjtime_p->local_utc = LOCAL;
+	} else {
+		adjtime_p->local_utc = UNKNOWN;
+		if (line3[0]) {
+			fprintf(stderr,
+				_("%s: Warning: unrecognized third line in adjtime file\n"),
+				MYNAME);
+			fprintf(stderr,
+				_("(Expected: `UTC' or `LOCAL' or nothing.)\n"));
+		}
+	}
 
-  The clock only has 1 second precision, so it gives the exact time only
-  once per second, right on the falling edge of the update flag.
+	adjtime_p->dirty = FALSE;
 
-  We wait (up to one second) either blocked waiting for an rtc device
-  or in a CPU spin loop.  The former is probably not very accurate.
+	if (debug) {
+		printf(_
+		       ("Last drift adjustment done at %ld seconds after 1969\n"),
+		       (long)adjtime_p->last_adj_time);
+		printf(_("Last calibration done at %ld seconds after 1969\n"),
+		       (long)adjtime_p->last_calib_time);
+		printf(_("Hardware clock is on %s time\n"),
+		       (adjtime_p->local_utc ==
+			LOCAL) ? _("local") : (adjtime_p->local_utc ==
+					       UTC) ? _("UTC") : _("unknown"));
+	}
+
+	return 0;
+}
 
-  Return 0 if it worked, nonzero if it didn't.
------------------------------------------------------------------------------*/
+/*
+ * Wait until the falling edge of the Hardware Clock's update flag so that
+ * any time that is read from the clock immediately after we return will be
+ * exact.
+ *
+ * The clock only has 1 second precision, so it gives the exact time only
+ * once per second, right on the falling edge of the update flag.
+ *
+ * We wait (up to one second) either blocked waiting for an rtc device or in
+ * a CPU spin loop. The former is probably not very accurate.
+ *
+ * Return 0 if it worked, nonzero if it didn't.
+ */
+static int synchronize_to_clock_tick(void)
+{
 	int rc;
 
-	if (debug) printf(_("Waiting for clock tick...\n"));
+	if (debug)
+		printf(_("Waiting for clock tick...\n"));
 
 	rc = ur->synchronize_to_clock_tick();
 
@@ -361,254 +358,259 @@ synchronize_to_clock_tick(void) {
 	return rc;
 }
 
-
-
+/*
+ * Convert a time in broken down format (hours, minutes, etc.) into standard
+ * unix time (seconds into epoch). Return it as *systime_p.
+ *
+ * The broken down time is argument <tm>. This broken down time is either
+ * in local time zone or UTC, depending on value of logical argument
+ * "universal". True means it is in UTC.
+ *
+ * If the argument contains values that do not constitute a valid time, and
+ * mktime() recognizes this, return *valid_p == false and *systime_p
+ * undefined. However, mktime() sometimes goes ahead and computes a
+ * fictional time "as if" the input values were valid, e.g. if they indicate
+ * the 31st day of April, mktime() may compute the time of May 1. In such a
+ * case, we return the same fictional value mktime() does as *systime_p and
+ * return *valid_p == true.
+ */
 static void
 mktime_tz(struct tm tm, const bool universal,
-          bool *valid_p, time_t *systime_p) {
-/*-----------------------------------------------------------------------------
-  Convert a time in broken down format (hours, minutes, etc.) into standard
-  unix time (seconds into epoch).  Return it as *systime_p.
-
-  The broken down time is argument <tm>.  This broken down time is either in
-  local time zone or UTC, depending on value of logical argument "universal".
-  True means it is in UTC.
-
-  If the argument contains values that do not constitute a valid time,
-  and mktime() recognizes this, return *valid_p == false and
-  *systime_p undefined.  However, mktime() sometimes goes ahead and
-  computes a fictional time "as if" the input values were valid,
-  e.g. if they indicate the 31st day of April, mktime() may compute
-  the time of May 1.  In such a case, we return the same fictional
-  value mktime() does as *systime_p and return *valid_p == true.
-
------------------------------------------------------------------------------*/
-  time_t mktime_result;  /* The value returned by our mktime() call */
-  char *zone;       /* Local time zone name */
-
-  /* We use the C library function mktime(), but since it only works on
-     local time zone input, we may have to fake it out by temporarily
-     changing the local time zone to UTC.
-     */
-  zone = getenv("TZ");	/* remember original time zone */
-  if (universal) {
-    /* Set timezone to UTC */
-    setenv("TZ", "", TRUE);
-    /* Note: tzset() gets called implicitly by the time code, but only the
-       first time.  When changing the environment variable, better call
-       tzset() explicitly.
-       */
-    tzset();
-  }
-  mktime_result = mktime(&tm);
-  if (mktime_result == -1) {
-    /* This apparently (not specified in mktime() documentation) means
-       the 'tm' structure does not contain valid values (however, not
-       containing valid values does _not_ imply mktime() returns -1).
-       */
-    *valid_p = FALSE;
-    *systime_p = 0;
-    if (debug)
-      printf(_("Invalid values in hardware clock: "
-             "%4d/%.2d/%.2d %.2d:%.2d:%.2d\n"),
-             tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
-             tm.tm_hour, tm.tm_min, tm.tm_sec);
-  } else {
-    *valid_p = TRUE;
-    *systime_p = mktime_result;
-    if (debug)
-      printf(_("Hw clock time : %4d/%.2d/%.2d %.2d:%.2d:%.2d = "
-	       "%ld seconds since 1969\n"),
-	     tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
-             tm.tm_hour, tm.tm_min, tm.tm_sec, (long) *systime_p);
-  }
-  /* now put back the original zone.  */
-  if (zone) setenv("TZ", zone, TRUE);
-  else unsetenv("TZ");
-  tzset();
+	  bool * valid_p, time_t * systime_p)
+{
+	time_t mktime_result;	/* The value returned by our mktime() call */
+	char *zone;		/* Local time zone name */
+
+	/*
+	 * We use the C library function mktime(), but since it only works
+	 * on local time zone input, we may have to fake it out by
+	 * temporarily changing the local time zone to UTC.
+	 */
+	zone = getenv("TZ");	/* remember original time zone */
+	if (universal) {
+		/* Set timezone to UTC */
+		setenv("TZ", "", TRUE);
+		/*
+		 * Note: tzset() gets called implicitly by the time code,
+		 * but only the first time. When changing the environment
+		 * variable, better call tzset() explicitly.
+		 */
+		tzset();
+	}
+	mktime_result = mktime(&tm);
+	if (mktime_result == -1) {
+		/*
+		 * This apparently (not specified in mktime() documentation)
+		 * means the 'tm' structure does not contain valid values
+		 * (however, not containing valid values does _not_ imply
+		 * mktime() returns -1).
+		 */
+		*valid_p = FALSE;
+		*systime_p = 0;
+		if (debug)
+			printf(_("Invalid values in hardware clock: "
+				 "%4d/%.2d/%.2d %.2d:%.2d:%.2d\n"),
+			       tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+			       tm.tm_hour, tm.tm_min, tm.tm_sec);
+	} else {
+		*valid_p = TRUE;
+		*systime_p = mktime_result;
+		if (debug)
+			printf(_
+			       ("Hw clock time : %4d/%.2d/%.2d %.2d:%.2d:%.2d = "
+				"%ld seconds since 1969\n"), tm.tm_year + 1900,
+			       tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min,
+			       tm.tm_sec, (long)*systime_p);
+	}
+	/* now put back the original zone. */
+	if (zone)
+		setenv("TZ", zone, TRUE);
+	else
+		unsetenv("TZ");
+	tzset();
 }
 
-
+/*
+ * Read the hardware clock and return the current time via <tm> argument.
+ *
+ * Use the method indicated by <method> argument to access the hardware
+ * clock.
+ */
 static int
-read_hardware_clock(const bool universal, bool *valid_p, time_t *systime_p){
-/*----------------------------------------------------------------------------
-  Read the hardware clock and return the current time via <tm> argument.
-
-  Use the method indicated by <method> argument to access the hardware clock.
------------------------------------------------------------------------------*/
-  struct tm tm;
-  int err;
+read_hardware_clock(const bool universal, bool * valid_p, time_t * systime_p)
+{
+	struct tm tm;
+	int err;
 
-  err = ur->read_hardware_clock(&tm);
-  if (err)
-	  return err;
+	err = ur->read_hardware_clock(&tm);
+	if (err)
+		return err;
 
-  if (badyear)
-    read_date_from_file(&tm);
+	if (badyear)
+		read_date_from_file(&tm);
 
-  if (debug)
-    printf (_("Time read from Hardware Clock: %4d/%.2d/%.2d %02d:%02d:%02d\n"),
-	    tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
-            tm.tm_hour, tm.tm_min, tm.tm_sec);
-  mktime_tz(tm, universal, valid_p, systime_p);
+	if (debug)
+		printf(_
+		       ("Time read from Hardware Clock: %4d/%.2d/%.2d %02d:%02d:%02d\n"),
+		       tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
+		       tm.tm_min, tm.tm_sec);
+	mktime_tz(tm, universal, valid_p, systime_p);
 
-  return 0;
+	return 0;
 }
 
-
+/*
+ * Set the Hardware Clock to the time <newtime>, in local time zone or UTC,
+ * according to <universal>.
+ */
 static void
 set_hardware_clock(const time_t newtime,
-                   const bool universal,
-                   const bool testing) {
-/*----------------------------------------------------------------------------
-  Set the Hardware Clock to the time <newtime>, in local time zone or UTC,
-  according to <universal>.
-----------------------------------------------------------------------------*/
-  struct tm new_broken_time;
-    /* Time to which we will set Hardware Clock, in broken down format, in
-       the time zone of caller's choice
-       */
-
-  if (universal)
-	  new_broken_time = *gmtime(&newtime);
-  else
-	  new_broken_time = *localtime(&newtime);
-
-  if (debug)
-    printf(_("Setting Hardware Clock to %.2d:%.2d:%.2d "
-           "= %ld seconds since 1969\n"),
-           new_broken_time.tm_hour, new_broken_time.tm_min,
-           new_broken_time.tm_sec, (long) newtime);
-
-  if (testing)
-    printf(_("Clock not changed - testing only.\n"));
-  else {
-    if (badyear) {
-      /*
-       * Write the real year to a file, then write a fake year
-       * between 1995 and 1998 to the RTC.  This way, Award BIOS boots
-       * on 29 Feb 2000 thinking that it's 29 Feb 1996.
-       */
-      write_date_to_file (&new_broken_time);
-      new_broken_time.tm_year = 95 + ((new_broken_time.tm_year+1) & 3);
-    }
-    ur->set_hardware_clock(&new_broken_time);
-  }
-}
+		   const bool universal, const bool testing)
+{
+	struct tm new_broken_time;
+	/*
+	 * Time to which we will set Hardware Clock, in broken down format,
+	 * in the time zone of caller's choice
+	 */
+
+	if (universal)
+		new_broken_time = *gmtime(&newtime);
+	else
+		new_broken_time = *localtime(&newtime);
 
+	if (debug)
+		printf(_("Setting Hardware Clock to %.2d:%.2d:%.2d "
+			 "= %ld seconds since 1969\n"),
+		       new_broken_time.tm_hour, new_broken_time.tm_min,
+		       new_broken_time.tm_sec, (long)newtime);
 
+	if (testing)
+		printf(_("Clock not changed - testing only.\n"));
+	else {
+		if (badyear) {
+			/*
+			 * Write the real year to a file, then write a fake
+			 * year between 1995 and 1998 to the RTC. This way,
+			 * Award BIOS boots on 29 Feb 2000 thinking that
+			 * it's 29 Feb 1996.
+			 */
+			write_date_to_file(&new_broken_time);
+			new_broken_time.tm_year =
+			    95 + ((new_broken_time.tm_year + 1) & 3);
+		}
+		ur->set_hardware_clock(&new_broken_time);
+	}
+}
 
+/*
+ * Set the Hardware Clock to the time "sethwtime", in local time zone or
+ * UTC, according to "universal".
+ *
+ * Wait for a fraction of a second so that "sethwtime" is the value of the
+ * Hardware Clock as of system time "refsystime", which is in the past. For
+ * example, if "sethwtime" is 14:03:05 and "refsystime" is 12:10:04.5 and
+ * the current system time is 12:10:06.0: Wait .5 seconds (to make exactly 2
+ * seconds since "refsystime") and then set the Hardware Clock to 14:03:07,
+ * thus getting a precise and retroactive setting of the clock.
+ *
+ * (Don't be confused by the fact that the system clock and the Hardware
+ * Clock differ by two hours in the above example. That's just to remind you
+ * that there are two independent time scales here).
+ *
+ * This function ought to be able to accept set times as fractional times.
+ * Idea for future enhancement.
+ */
 static void
 set_hardware_clock_exact(const time_t sethwtime,
-                         const struct timeval refsystime,
-                         const bool universal,
-                         const bool testing) {
-/*----------------------------------------------------------------------------
-  Set the Hardware Clock to the time "sethwtime", in local time zone or UTC,
-  according to "universal".
-
-  Wait for a fraction of a second so that "sethwtime" is the value of
-  the Hardware Clock as of system time "refsystime", which is in the past.
-  For example, if "sethwtime" is 14:03:05 and "refsystime" is 12:10:04.5
-  and the current system time is 12:10:06.0: Wait .5 seconds (to make
-  exactly 2 seconds since "refsystime") and then set the Hardware Clock
-  to 14:03:07, thus getting a precise and retroactive setting of the clock.
-
-  (Don't be confused by the fact that the system clock and the Hardware
-  Clock differ by two hours in the above example.  That's just to remind
-  you that there are two independent time scales here).
-
-  This function ought to be able to accept set times as fractional times.
-  Idea for future enhancement.
------------------------------------------------------------------------------*/
-
-  time_t newhwtime;
-  struct timeval beginsystime, nowsystime;
-  double tdiff;
+			 const struct timeval refsystime,
+			 const bool universal, const bool testing)
+{
+	time_t newhwtime;
+	struct timeval beginsystime, nowsystime;
+	double tdiff;
 
  time_resync:
-  gettimeofday(&beginsystime, NULL);
-  tdiff = time_diff(beginsystime, refsystime);
-  newhwtime = sethwtime + (int) (tdiff + 0.5);
-  if (debug)
-    printf(_("Time elapsed since reference time has been %.6f seconds.\n"
-           "Delaying further to reach the new time.\n"), tdiff);
-
-  /*
-   * Now delay some more until Hardware Clock time newhwtime arrives.  The 0.5 s
-   * is because the Hardware Clock always sets to your set time plus 500 ms
-   * (because it is designed to update to the next second precisely 500 ms
-   * after you finish the setting).
-   */
-  do {
-	  gettimeofday(&nowsystime, NULL);
-	  tdiff = time_diff(nowsystime, beginsystime);
-	  if (tdiff < 0)
-		  goto time_resync;	/* probably backward time reset */
-	  if (tdiff > 0.1)
-		  goto time_resync;	/* probably forward time reset */
-	  beginsystime = nowsystime;
-	  tdiff = time_diff(nowsystime, refsystime);
-  } while (newhwtime == sethwtime + (int) (tdiff + 0.5));
-
-  set_hardware_clock(newhwtime, universal, testing);
+	gettimeofday(&beginsystime, NULL);
+	tdiff = time_diff(beginsystime, refsystime);
+	newhwtime = sethwtime + (int)(tdiff + 0.5);
+	if (debug)
+		printf(_
+		       ("Time elapsed since reference time has been %.6f seconds.\n"
+			"Delaying further to reach the new time.\n"), tdiff);
+
+	/*
+	 * Now delay some more until Hardware Clock time newhwtime arrives.
+	 * The 0.5 s is because the Hardware Clock always sets to your set
+	 * time plus 500 ms (because it is designed to update to the next
+	 * second precisely 500 ms after you finish the setting).
+	 */
+	do {
+		gettimeofday(&nowsystime, NULL);
+		tdiff = time_diff(nowsystime, beginsystime);
+		if (tdiff < 0)
+			goto time_resync;	/* probably backward time reset */
+		if (tdiff > 0.1)
+			goto time_resync;	/* probably forward time reset */
+		beginsystime = nowsystime;
+		tdiff = time_diff(nowsystime, refsystime);
+	} while (newhwtime == sethwtime + (int)(tdiff + 0.5));
+
+	set_hardware_clock(newhwtime, universal, testing);
 }
 
-
-
+/*
+ * Put the time "systime" on standard output in display format. Except if
+ * hclock_valid == false, just tell standard output that we don't know what
+ * time it is.
+ *
+ * Include in the output the adjustment "sync_duration".
+ */
 static void
 display_time(const bool hclock_valid, const time_t systime,
-             const double sync_duration) {
-/*----------------------------------------------------------------------------
-  Put the time "systime" on standard output in display format.
-  Except if hclock_valid == false, just tell standard output that we don't
-  know what time it is.
-
-  Include in the output the adjustment "sync_duration".
------------------------------------------------------------------------------*/
-  if (!hclock_valid)
-    fprintf(stderr, _("The Hardware Clock registers contain values that are "
-            "either invalid (e.g. 50th day of month) or beyond the range "
-            "we can handle (e.g. Year 2095).\n"));
-  else {
-    struct tm *lt;
-    char *format = "%c";
-    char ctime_now[200];
-
-    lt = localtime(&systime);
-    strftime(ctime_now, sizeof(ctime_now), format, lt);
-    printf(_("%s  %.6f seconds\n"), ctime_now, -(sync_duration));
-  }
-}
-
-
-
-static int
-interpret_date_string(const char *date_opt, time_t * const time_p) {
-/*----------------------------------------------------------------------------
-  Interpret the value of the --date option, which is something like
-  "13:05:01".  In fact, it can be any of the myriad ASCII strings that specify
-  a time which the "date" program can understand.  The date option value in
-  question is our "dateopt" argument.
-
-  The specified time is in the local time zone.
-
-  Our output, "*time_p", is a seconds-into-epoch time.
+	     const double sync_duration)
+{
+	if (!hclock_valid)
+		fprintf(stderr,
+			_
+			("The Hardware Clock registers contain values that are "
+			 "either invalid (e.g. 50th day of month) or beyond the range "
+			 "we can handle (e.g. Year 2095).\n"));
+	else {
+		struct tm *lt;
+		char *format = "%c";
+		char ctime_now[200];
 
-  We use the "date" program to interpret the date string.  "date" must be
-  runnable by issuing the command "date" to the /bin/sh shell.  That means
-  in must be in the current PATH.
+		lt = localtime(&systime);
+		strftime(ctime_now, sizeof(ctime_now), format, lt);
+		printf(_("%s  %.6f seconds\n"), ctime_now, -(sync_duration));
+	}
+}
 
-  If anything goes wrong (and many things can), we return return code
-  10 and arbitrary *time_p.  Otherwise, return code is 0 and *time_p
-  is valid.
-----------------------------------------------------------------------------*/
+/*
+ * Interpret the value of the --date option, which is something like
+ * "13:05:01". In fact, it can be any of the myriad ASCII strings that
+ * specify a time which the "date" program can understand. The date option
+ * value in question is our "dateopt" argument.
+ *
+ * The specified time is in the local time zone.
+ *
+ * Our output, "*time_p", is a seconds-into-epoch time.
+ *
+ * We use the "date" program to interpret the date string. "date" must be
+ * runnable by issuing the command "date" to the /bin/sh shell. That means
+ * in must be in the current PATH.
+ *
+ * If anything goes wrong (and many things can), we return return code 10
+ * and arbitrary *time_p. Otherwise, return code is 0 and *time_p is valid.
+ */
+static int interpret_date_string(const char *date_opt, time_t * const time_p)
+{
 	FILE *date_child_fp;
 	char date_resp[100];
-	const char magic[]="seconds-into-epoch=";
+	const char magic[] = "seconds-into-epoch=";
 	char date_command[100];
-	int retcode;  /* our eventual return code */
-	int rc;  /* local return code */
+	int retcode;		/* our eventual return code */
+	int rc;			/* local return code */
 
 	if (date_opt == NULL) {
 		fprintf(stderr, _("No --date option specified.\n"));
@@ -624,8 +626,9 @@ interpret_date_string(const char *date_opt, time_t * const time_p) {
 	/* Quotes in date_opt would ruin the date command we construct. */
 	if (strchr(date_opt, '"') != NULL) {
 		fprintf(stderr,
-			_("The value of the --date option is not a valid date.\n"
-			  "In particular, it contains quotation marks.\n"));
+			_
+			("The value of the --date option is not a valid date.\n"
+			 "In particular, it contains quotation marks.\n"));
 		return 12;
 	}
 
@@ -642,10 +645,10 @@ interpret_date_string(const char *date_opt, time_t * const time_p) {
 	}
 
 	if (!fgets(date_resp, sizeof(date_resp), date_child_fp))
-		date_resp[0] = '\0';  /* in case fgets fails */
+		date_resp[0] = '\0';	/* in case fgets fails */
 	if (debug)
 		printf(_("response from date command = %s\n"), date_resp);
-	if (strncmp(date_resp, magic, sizeof(magic)-1) != 0) {
+	if (strncmp(date_resp, magic, sizeof(magic) - 1) != 0) {
 		fprintf(stderr, _("The date command issued by %s returned "
 				  "unexpected results.\n"
 				  "The command was:\n  %s\n"
@@ -654,7 +657,7 @@ interpret_date_string(const char *date_opt, time_t * const time_p) {
 		retcode = 8;
 	} else {
 		long seconds_since_epoch;
-		rc = sscanf(date_resp + sizeof(magic)-1, "%ld",
+		rc = sscanf(date_resp + sizeof(magic) - 1, "%ld",
 			    &seconds_since_epoch);
 		if (rc < 1) {
 			fprintf(stderr,
@@ -671,7 +674,7 @@ interpret_date_string(const char *date_opt, time_t * const time_p) {
 			if (debug)
 				printf(_("date string %s equates to "
 					 "%ld seconds since 1969.\n"),
-				       date_opt, (long) *time_p);
+				       date_opt, (long)*time_p);
 		}
 	}
 	pclose(date_child_fp);
@@ -679,173 +682,181 @@ interpret_date_string(const char *date_opt, time_t * const time_p) {
 	return retcode;
 }
 
-
-
+/*
+ * Set the System Clock to time 'newtime'.
+ *
+ * Also set the kernel time zone value to the value indicated by the TZ
+ * environment variable and/or /usr/lib/zoneinfo/, interpreted as tzset()
+ * would interpret them.
+ *
+ * EXCEPT: if hclock_valid is false, just issue an error message saying
+ * there is no valid time in the Hardware Clock to which to set the system
+ * time.
+ *
+ * If 'testing' is true, don't actually update anything -- just say we would
+ * have.
+ */
 static int
 set_system_clock(const bool hclock_valid, const time_t newtime,
-                 const bool testing) {
-/*----------------------------------------------------------------------------
-   Set the System Clock to time 'newtime'.
-
-   Also set the kernel time zone value to the value indicated by the
-   TZ environment variable and/or /usr/lib/zoneinfo/, interpreted as
-   tzset() would interpret them.
-
-   EXCEPT: if hclock_valid is false, just issue an error message
-   saying there is no valid time in the Hardware Clock to which to set
-   the system time.
-
-   If 'testing' is true, don't actually update anything -- just say we
-   would have.
------------------------------------------------------------------------------*/
-  int retcode;
-
-  if (!hclock_valid) {
-    fprintf(stderr, _("The Hardware Clock does not contain a valid time, so "
-            "we cannot set the System Time from it.\n"));
-    retcode = 1;
-  } else {
-    struct timeval tv;
-    struct tm *broken;
-    int minuteswest;
-    int rc;
-
-    tv.tv_sec = newtime;
-    tv.tv_usec = 0;
-
-    broken = localtime(&newtime);
+		 const bool testing)
+{
+	int retcode;
+
+	if (!hclock_valid) {
+		fprintf(stderr,
+			_
+			("The Hardware Clock does not contain a valid time, so "
+			 "we cannot set the System Time from it.\n"));
+		retcode = 1;
+	} else {
+		struct timeval tv;
+		struct tm *broken;
+		int minuteswest;
+		int rc;
+
+		tv.tv_sec = newtime;
+		tv.tv_usec = 0;
+
+		broken = localtime(&newtime);
 #ifdef HAVE_TM_GMTOFF
-    minuteswest = -broken->tm_gmtoff/60;		/* GNU extension */
+		minuteswest = -broken->tm_gmtoff / 60;	/* GNU extension */
 #else
-    minuteswest = timezone/60;
-    if (broken->tm_isdst)
-	    minuteswest -= 60;
+		minuteswest = timezone / 60;
+		if (broken->tm_isdst)
+			minuteswest -= 60;
 #endif
 
-    if (debug) {
-      printf(_("Calling settimeofday:\n"));
-      printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"),
-             (long) tv.tv_sec, (long) tv.tv_usec);
-      printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest);
-    }
-    if (testing) {
-      printf(_("Not setting system clock because running in test mode.\n"));
-      retcode = 0;
-    } else {
-      const struct timezone tz = { minuteswest, 0 };
-
-      rc = settimeofday(&tv, &tz);
-      if (rc) {
-	      if (errno == EPERM) {
-		      fprintf(stderr,
-			      _("Must be superuser to set system clock.\n"));
-		      retcode = EX_NOPERM;
-	      } else {
-		      outsyserr(_("settimeofday() failed"));
-		      retcode = 1;
-	      }
-      } else retcode = 0;
-    }
-  }
-  return retcode;
+		if (debug) {
+			printf(_("Calling settimeofday:\n"));
+			printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"),
+			       (long)tv.tv_sec, (long)tv.tv_usec);
+			printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest);
+		}
+		if (testing) {
+			printf(_
+			       ("Not setting system clock because running in test mode.\n"));
+			retcode = 0;
+		} else {
+			const struct timezone tz = { minuteswest, 0 };
+
+			rc = settimeofday(&tv, &tz);
+			if (rc) {
+				if (errno == EPERM) {
+					fprintf(stderr,
+						_
+						("Must be superuser to set system clock.\n"));
+					retcode = EX_NOPERM;
+				} else {
+					outsyserr(_("settimeofday() failed"));
+					retcode = 1;
+				}
+			} else
+				retcode = 0;
+		}
+	}
+	return retcode;
 }
 
+/*
+ * Reset the System Clock from local time to UTC, based on its current value
+ * and the timezone unless universal is TRUE.
+ *
+ * Also set the kernel time zone value to the value indicated by the TZ
+ * environment variable and/or /usr/lib/zoneinfo/, interpreted as tzset()
+ * would interpret them.
+ *
+ * If 'testing' is true, don't actually update anything -- just say we would
+ * have.
+ */
+static int set_system_clock_timezone(const bool universal, const bool testing)
+{
+	int retcode;
+	struct timeval tv;
+	struct tm *broken;
+	int minuteswest;
+	int rc;
+
+	gettimeofday(&tv, NULL);
+	if (debug) {
+		struct tm broken_time;
+		char ctime_now[200];
+
+		broken_time = *gmtime(&tv.tv_sec);
+		strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S",
+			 &broken_time);
+		printf(_("Current system time: %ld = %s\n"), (long)tv.tv_sec,
+		       ctime_now);
+	}
 
-static int
-set_system_clock_timezone(const bool universal, const bool testing) {
-/*----------------------------------------------------------------------------
-   Reset the System Clock from local time to UTC, based on its current
-   value and the timezone unless universal is TRUE.
-
-   Also set the kernel time zone value to the value indicated by the
-   TZ environment variable and/or /usr/lib/zoneinfo/, interpreted as
-   tzset() would interpret them.
-
-   If 'testing' is true, don't actually update anything -- just say we
-   would have.
------------------------------------------------------------------------------*/
-  int retcode;
-  struct timeval tv;
-  struct tm *broken;
-  int minuteswest;
-  int rc;
-
-  gettimeofday(&tv, NULL);
-  if (debug) {
-    struct tm broken_time;
-    char ctime_now[200];
-
-    broken_time = *gmtime(&tv.tv_sec);
-    strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S", &broken_time);
-    printf(_("Current system time: %ld = %s\n"), (long) tv.tv_sec, ctime_now);
-  }
-
-  broken = localtime(&tv.tv_sec);
+	broken = localtime(&tv.tv_sec);
 #ifdef HAVE_TM_GMTOFF
-  minuteswest = -broken->tm_gmtoff/60;		/* GNU extension */
+	minuteswest = -broken->tm_gmtoff / 60;	/* GNU extension */
 #else
-  minuteswest = timezone/60;
-  if (broken->tm_isdst)
-	  minuteswest -= 60;
+	minuteswest = timezone / 60;
+	if (broken->tm_isdst)
+		minuteswest -= 60;
 #endif
 
-  gettimeofday(&tv, NULL);
-  if (!universal)
-    tv.tv_sec += minuteswest * 60;
-
-  if (debug) {
-    struct tm broken_time;
-    char ctime_now[200];
-
-    broken_time = *gmtime(&tv.tv_sec);
-    strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S", &broken_time);
-
-    printf(_("Calling settimeofday:\n"));
-    printf(_("\tUTC: %s\n"), ctime_now);
-    printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"),
-           (long) tv.tv_sec, (long) tv.tv_usec);
-    printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest);
-  }
-  if (testing) {
-    printf(_("Not setting system clock because running in test mode.\n"));
-    retcode = 0;
-  } else {
-    const struct timezone tz = { minuteswest, 0 };
-
-    rc = settimeofday(&tv, &tz);
-    if (rc) {
-	    if (errno == EPERM) {
-		    fprintf(stderr,
-			    _("Must be superuser to set system clock.\n"));
-		    retcode = EX_NOPERM;
-	    } else {
-		    outsyserr(_("settimeofday() failed"));
-		    retcode = 1;
-	    }
-    } else retcode = 0;
-  }
-  return retcode;
-}
+	gettimeofday(&tv, NULL);
+	if (!universal)
+		tv.tv_sec += minuteswest * 60;
 
+	if (debug) {
+		struct tm broken_time;
+		char ctime_now[200];
+
+		broken_time = *gmtime(&tv.tv_sec);
+		strftime(ctime_now, sizeof(ctime_now), "%Y/%m/%d %H:%M:%S",
+			 &broken_time);
+
+		printf(_("Calling settimeofday:\n"));
+		printf(_("\tUTC: %s\n"), ctime_now);
+		printf(_("\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"),
+		       (long)tv.tv_sec, (long)tv.tv_usec);
+		printf(_("\ttz.tz_minuteswest = %d\n"), minuteswest);
+	}
+	if (testing) {
+		printf(_
+		       ("Not setting system clock because running in test mode.\n"));
+		retcode = 0;
+	} else {
+		const struct timezone tz = { minuteswest, 0 };
 
+		rc = settimeofday(&tv, &tz);
+		if (rc) {
+			if (errno == EPERM) {
+				fprintf(stderr,
+					_
+					("Must be superuser to set system clock.\n"));
+				retcode = EX_NOPERM;
+			} else {
+				outsyserr(_("settimeofday() failed"));
+				retcode = 1;
+			}
+		} else
+			retcode = 0;
+	}
+	return retcode;
+}
+
+/*
+ * Update the drift factor in <*adjtime_p> to reflect the fact that the
+ * Hardware Clock was calibrated to <nowtime> and before that was set to
+ * <hclocktime>.
+ *
+ * We record in the adjtime file the time at which we last calibrated the
+ * clock so we can compute the drift rate each time we calibrate.
+ *
+ * EXCEPT: if <hclock_valid> is false, assume Hardware Clock was not set
+ * before to anything meaningful and regular adjustments have not been done,
+ * so don't adjust the drift factor.
+ */
 static void
 adjust_drift_factor(struct adjtime *adjtime_p,
-                    const time_t nowtime,
-                    const bool hclock_valid,
-		    const time_t hclocktime,
-		    const double sync_delay) {
-/*------------------------------------------------------------------------
-  Update the drift factor in <*adjtime_p> to reflect the fact that the
-  Hardware Clock was calibrated to <nowtime> and before that was set
-  to <hclocktime>.
-
-  We record in the adjtime file the time at which we last calibrated
-  the clock so we can compute the drift rate each time we calibrate.
-
-  EXCEPT: if <hclock_valid> is false, assume Hardware Clock was not set
-  before to anything meaningful and regular adjustments have not been
-  done, so don't adjust the drift factor.
-  ------------------------------------------------------------------------*/
+		    const time_t nowtime,
+		    const bool hclock_valid,
+		    const time_t hclocktime, const double sync_delay)
+{
 	if (!hclock_valid) {
 		if (debug)
 			printf(_("Not adjusting drift factor because the "
@@ -867,9 +878,9 @@ adjust_drift_factor(struct adjtime *adjtime_p,
 		 * At adjustment time we adjust the hardware clock according
 		 * to the contents of /etc/adjtime.
 		 *
-		 * At calibration time we set the hardware clock and
-		 * update /etc/adjtime, that is, for each calibration
-		 * (except the first) we also do an adjustment.
+		 * At calibration time we set the hardware clock and update
+		 * /etc/adjtime, that is, for each calibration (except the
+		 * first) we also do an adjustment.
 		 *
 		 * We are now at calibration time.
 		 *
@@ -887,21 +898,21 @@ adjust_drift_factor(struct adjtime *adjtime_p,
 
 		/* Days since last adjustment (in hardware clock time) */
 		adj_days = (double)(hclocktime - adjtime_p->last_adj_time)
-			/ sec_per_day;
+		    / sec_per_day;
 
 		/* Expected drift (sec) since last adjustment */
 		exp_drift = adj_days * adjtime_p->drift_factor
-			+ adjtime_p->not_adjusted;
+		    + adjtime_p->not_adjusted;
 
 		/* Uncorrected drift (sec) since last calibration */
 		unc_drift = (double)(nowtime - hclocktime)
-			+ sync_delay - exp_drift;
+		    + sync_delay - exp_drift;
 
 		/* Days since last calibration (in hardware clock time) */
 		cal_days = ((double)(adjtime_p->last_adj_time
-				    - adjtime_p->last_calib_time)
+				     - adjtime_p->last_calib_time)
 			    + adjtime_p->not_adjusted)
-			/ (sec_per_day * atime_per_htime) + adj_days;
+		    / (sec_per_day * atime_per_htime) + adj_days;
 
 		/* Amount to add to previous drift factor */
 		factor_adjust = unc_drift / cal_days;
@@ -912,9 +923,8 @@ adjust_drift_factor(struct adjtime *adjtime_p,
 				 "%f seconds/day.\n"
 				 "Adjusting drift factor by %f seconds/day\n"),
 			       unc_drift,
-			       (int) (nowtime - adjtime_p->last_calib_time),
-			       adjtime_p->drift_factor,
-			       factor_adjust);
+			       (int)(nowtime - adjtime_p->last_calib_time),
+			       adjtime_p->drift_factor, factor_adjust);
 
 		adjtime_p->drift_factor += factor_adjust;
 	}
@@ -927,383 +937,403 @@ adjust_drift_factor(struct adjtime *adjtime_p,
 	adjtime_p->dirty = TRUE;
 }
 
-
-
+/*
+ * Do the drift adjustment calculation.
+ *
+ * The way we have to set the clock, we need the adjustment in two parts:
+ *
+ *	1) an integer number of seconds (return as *adjustment_p)
+ *	2) a positive fraction of a second (less than 1) (return as *retro_p)
+ *
+ * The sum of these two values is the adjustment needed. Positive means to
+ * advance the clock or insert seconds. Negative means to retard the clock
+ * or remove seconds.
+ */
 static void
 calculate_adjustment(const double factor,
-                     const time_t last_time,
-                     const double not_adjusted,
-                     const time_t systime,
-                     int *adjustment_p,
-                     double *retro_p) {
-/*----------------------------------------------------------------------------
-  Do the drift adjustment calculation.
-
-  The way we have to set the clock, we need the adjustment in two parts:
-
-    1) an integer number of seconds (return as *adjustment_p)
-
-    2) a positive fraction of a second (less than 1) (return as *retro_p)
-
-  The sum of these two values is the adjustment needed.  Positive means to
-  advance the clock or insert seconds.  Negative means to retard the clock
-  or remove seconds.
-----------------------------------------------------------------------------*/
-  double exact_adjustment;
-
-  exact_adjustment = ((double) (systime - last_time)) * factor / (24 * 60 * 60)
-                     + not_adjusted;
-  *adjustment_p = FLOOR(exact_adjustment);
-
-  *retro_p = exact_adjustment - (double) *adjustment_p;
-  if (debug) {
-    printf (_("Time since last adjustment is %d seconds\n"),
-            (int) (systime - last_time));
-    printf (_("Need to insert %d seconds and refer time back "
-            "%.6f seconds ago\n"),
-            *adjustment_p, *retro_p);
-  }
-}
-
+		     const time_t last_time,
+		     const double not_adjusted,
+		     const time_t systime, int *adjustment_p, double *retro_p)
+{
+	double exact_adjustment;
 
+	exact_adjustment =
+	    ((double)(systime - last_time)) * factor / (24 * 60 * 60)
+	    + not_adjusted;
+	*adjustment_p = FLOOR(exact_adjustment);
 
-static void
-save_adjtime(const struct adjtime adjtime, const bool testing) {
-/*-----------------------------------------------------------------------------
-  Write the contents of the <adjtime> structure to its disk file.
-
-  But if the contents are clean (unchanged since read from disk), don't
-  bother.
------------------------------------------------------------------------------*/
-  char newfile[412];   /* Stuff to write to disk file */
-
-  if (adjtime.dirty) {
-    /* snprintf is not always available, but this is safe
-       as long as libc does not use more than 100 positions for %ld or %f */
-    sprintf(newfile, "%f %ld %f\n%ld\n%s\n",
-             adjtime.drift_factor,
-             (long) adjtime.last_adj_time,
-             adjtime.not_adjusted,
-             (long) adjtime.last_calib_time,
-	     (adjtime.local_utc == UTC) ? "UTC" : "LOCAL");
-
-    if (testing) {
-      printf(_("Not updating adjtime file because of testing mode.\n"));
-      printf(_("Would have written the following to %s:\n%s"),
-             adj_file_name, newfile);
-    } else {
-      FILE *adjfile;
-      int err = 0;
-
-      adjfile = fopen(adj_file_name, "w");
-      if (adjfile == NULL) {
-        outsyserr(_("Could not open file with the clock adjustment parameters "
-               "in it (%s) for writing"), adj_file_name);
-	err = 1;
-      } else {
-        if (fputs(newfile, adjfile) < 0) {
-	  outsyserr(_("Could not update file with the clock adjustment "
-		    "parameters (%s) in it"), adj_file_name);
-	  err = 1;
-        }
-        if (fclose(adjfile) < 0) {
-          outsyserr(_("Could not update file with the clock adjustment "
-		    "parameters (%s) in it"), adj_file_name);
-	  err = 1;
-        }
-      }
-      if (err)
-	fprintf(stderr, _("Drift adjustment parameters not updated.\n"));
-    }
-  }
+	*retro_p = exact_adjustment - (double)*adjustment_p;
+	if (debug) {
+		printf(_("Time since last adjustment is %d seconds\n"),
+		       (int)(systime - last_time));
+		printf(_("Need to insert %d seconds and refer time back "
+			 "%.6f seconds ago\n"), *adjustment_p, *retro_p);
+	}
 }
 
+/*
+ * Write the contents of the <adjtime> structure to its disk file.
+ *
+ * But if the contents are clean (unchanged since read from disk), don't
+ * bother.
+ */
+static void save_adjtime(const struct adjtime adjtime, const bool testing)
+{
+	char newfile[412];	/* Stuff to write to disk file */
 
+	if (adjtime.dirty) {
+		/*
+		 * snprintf is not always available, but this is safe as
+		 * long as libc does not use more than 100 positions for %ld
+		 * or %f
+		 */
+		sprintf(newfile, "%f %ld %f\n%ld\n%s\n",
+			adjtime.drift_factor,
+			(long)adjtime.last_adj_time,
+			adjtime.not_adjusted,
+			(long)adjtime.last_calib_time,
+			(adjtime.local_utc == UTC) ? "UTC" : "LOCAL");
+
+		if (testing) {
+			printf(_
+			       ("Not updating adjtime file because of testing mode.\n"));
+			printf(_("Would have written the following to %s:\n%s"),
+			       adj_file_name, newfile);
+		} else {
+			FILE *adjfile;
+			int err = 0;
+
+			adjfile = fopen(adj_file_name, "w");
+			if (adjfile == NULL) {
+				outsyserr(_
+					  ("Could not open file with the clock adjustment parameters "
+					   "in it (%s) for writing"),
+					  adj_file_name);
+				err = 1;
+			} else {
+				if (fputs(newfile, adjfile) < 0) {
+					outsyserr(_
+						  ("Could not update file with the clock adjustment "
+						   "parameters (%s) in it"),
+						  adj_file_name);
+					err = 1;
+				}
+				if (fclose(adjfile) < 0) {
+					outsyserr(_
+						  ("Could not update file with the clock adjustment "
+						   "parameters (%s) in it"),
+						  adj_file_name);
+					err = 1;
+				}
+			}
+			if (err)
+				fprintf(stderr,
+					_
+					("Drift adjustment parameters not updated.\n"));
+		}
+	}
+}
 
+/*
+ * Do the adjustment requested, by 1) setting the Hardware Clock (if
+ * necessary), and 2) updating the last-adjusted time in the adjtime
+ * structure.
+ *
+ * Do not update anything if the Hardware Clock does not currently present a
+ * valid time.
+ *
+ * Arguments <factor> and <last_time> are current values from the adjtime
+ * file.
+ *
+ * <hclock_valid> means the Hardware Clock contains a valid time, and that
+ * time is <hclocktime>.
+ *
+ * <read_time> is the current system time (to be precise, it is the system
+ * time at the time <hclocktime> was read, which due to computational delay
+ * could be a short time ago).
+ *
+ * <universal>: the Hardware Clock is kept in UTC.
+ *
+ * <testing>:  We are running in test mode (no updating of clock).
+ *
+ * We do not bother to update the clock if the adjustment would be less than
+ * one second. This is to avoid cumulative error and needless CPU hogging
+ * (remember we use an infinite loop for some timing) if the user runs us
+ * frequently.
+ */
 static void
 do_adjustment(struct adjtime *adjtime_p,
-              const bool hclock_valid, const time_t hclocktime,
-              const struct timeval read_time,
-              const bool universal, const bool testing) {
-/*---------------------------------------------------------------------------
-  Do the adjustment requested, by 1) setting the Hardware Clock (if
-  necessary), and 2) updating the last-adjusted time in the adjtime
-  structure.
-
-  Do not update anything if the Hardware Clock does not currently present
-  a valid time.
-
-  arguments <factor> and <last_time> are current values from the adjtime
-  file.
-
-  <hclock_valid> means the Hardware Clock contains a valid time, and that
-  time is <hclocktime>.
-
-  <read_time> is the current system time (to be precise, it is the system
-  time at the time <hclocktime> was read, which due to computational delay
-  could be a short time ago).
-
-  <universal>: the Hardware Clock is kept in UTC.
-
-  <testing>:  We are running in test mode (no updating of clock).
-
-  We do not bother to update the clock if the adjustment would be less than
-  one second.  This is to avoid cumulative error and needless CPU hogging
-  (remember we use an infinite loop for some timing) if the user runs us
-  frequently.
-
-----------------------------------------------------------------------------*/
-  if (!hclock_valid) {
-    fprintf(stderr, _("The Hardware Clock does not contain a valid time, "
-            "so we cannot adjust it.\n"));
-    adjtime_p->last_calib_time = 0;  /* calibration startover is required */
-    adjtime_p->last_adj_time = 0;
-    adjtime_p->not_adjusted = 0;
-    adjtime_p->dirty = TRUE;
-  } else if (adjtime_p->last_adj_time == 0) {
-    if (debug)
-      printf(_("Not setting clock because last adjustment time is zero, "
-	     "so history is bad."));
-  } else {
-    int adjustment;
-    /* Number of seconds we must insert in the Hardware Clock */
-    double retro;
-    /* Fraction of second we have to remove from clock after inserting
-       <adjustment> whole seconds.
-       */
-    calculate_adjustment(adjtime_p->drift_factor,
-                         adjtime_p->last_adj_time,
-                         adjtime_p->not_adjusted,
-                         hclocktime,
-                         &adjustment, &retro);
-    if (adjustment > 0 || adjustment < -1) {
-      set_hardware_clock_exact(hclocktime + adjustment,
-                               time_inc(read_time, -retro),
-                               universal, testing);
-      adjtime_p->last_adj_time = hclocktime + adjustment;
-      adjtime_p->not_adjusted = 0;
-      adjtime_p->dirty = TRUE;
-    } else
-      if (debug)
-        printf(_("Needed adjustment is less than one second, "
-               "so not setting clock.\n"));
-  }
+	      const bool hclock_valid, const time_t hclocktime,
+	      const struct timeval read_time,
+	      const bool universal, const bool testing)
+{
+	if (!hclock_valid) {
+		fprintf(stderr,
+			_("The Hardware Clock does not contain a valid time, "
+			  "so we cannot adjust it.\n"));
+		adjtime_p->last_calib_time = 0;	/* calibration startover is required */
+		adjtime_p->last_adj_time = 0;
+		adjtime_p->not_adjusted = 0;
+		adjtime_p->dirty = TRUE;
+	} else if (adjtime_p->last_adj_time == 0) {
+		if (debug)
+			printf(_
+			       ("Not setting clock because last adjustment time is zero, "
+				"so history is bad."));
+	} else {
+		int adjustment;
+		/* Number of seconds we must insert in the Hardware Clock */
+		double retro;
+		/*
+		 * Fraction of second we have to remove from clock after
+		 * inserting <adjustment> whole seconds.
+		 */
+		calculate_adjustment(adjtime_p->drift_factor,
+				     adjtime_p->last_adj_time,
+				     adjtime_p->not_adjusted,
+				     hclocktime, &adjustment, &retro);
+		if (adjustment > 0 || adjustment < -1) {
+			set_hardware_clock_exact(hclocktime + adjustment,
+						 time_inc(read_time, -retro),
+						 universal, testing);
+			adjtime_p->last_adj_time = hclocktime + adjustment;
+			adjtime_p->not_adjusted = 0;
+			adjtime_p->dirty = TRUE;
+		} else if (debug)
+			printf(_("Needed adjustment is less than one second, "
+				 "so not setting clock.\n"));
+	}
 }
 
+static void determine_clock_access_method(const bool user_requests_ISA)
+{
+	ur = NULL;
 
-
-static void
-determine_clock_access_method(const bool user_requests_ISA) {
-
-  ur = NULL;
-
-  if (user_requests_ISA)
-	  ur = probe_for_cmos_clock();
+	if (user_requests_ISA)
+		ur = probe_for_cmos_clock();
 
 #ifdef __linux__
-  if (!ur)
-	  ur = probe_for_rtc_clock();
+	if (!ur)
+		ur = probe_for_rtc_clock();
 #endif
 
-  if (!ur)
-	  ur = probe_for_kd_clock();
+	if (!ur)
+		ur = probe_for_kd_clock();
 
-  if (!ur && !user_requests_ISA)
-	  ur = probe_for_cmos_clock();
+	if (!ur && !user_requests_ISA)
+		ur = probe_for_cmos_clock();
 
-  if (debug) {
-	  if (ur)
-		  printf(_("Using %s.\n"), ur->interface_name);
-	  else
-		  printf(_("No usable clock interface found.\n"));
-  }
+	if (debug) {
+		if (ur)
+			printf(_("Using %s.\n"), ur->interface_name);
+		else
+			printf(_("No usable clock interface found.\n"));
+	}
 }
 
+/*
+ * Do all the normal work of hwclock - read, set clock, etc.
+ *
+ * Issue output to stdout and error message to stderr where appropriate.
+ *
+ * Return rc == 0 if everything went OK, rc != 0 if not.
+ */
 static int
 manipulate_clock(const bool show, const bool adjust, const bool noadjfile,
-                 const bool set, const time_t set_time,
-                 const bool hctosys, const bool systohc, const bool systz,
-                 const struct timeval startup_time,
-                 const bool utc, const bool local_opt,
-		 const bool testing, const bool predict) {
-/*---------------------------------------------------------------------------
-  Do all the normal work of hwclock - read, set clock, etc.
-
-  Issue output to stdout and error message to stderr where appropriate.
-
-  Return rc == 0 if everything went OK, rc != 0 if not.
-----------------------------------------------------------------------------*/
-    struct adjtime adjtime;
-      /* Contents of the adjtime file, or what they should be. */
-    int rc;  /* local return code */
-    bool no_auth;  /* User lacks necessary authorization to access the clock */
-
-    if (!systz && !predict) {
-      no_auth = ur->get_permissions();
-      if (no_auth)
-              return EX_NOPERM;
-    }
-
-    if (!noadjfile && (adjust || set || systohc || (!utc && !local_opt) || predict)) {
-      rc = read_adjtime(&adjtime);
-      if (rc)
-	      return rc;
-    } else {
-      /* A little trick to avoid reading the file if we don't have to */
-      adjtime.dirty = FALSE;
-      rc = 0;
-    }
-
-    {
-      const bool universal = hw_clock_is_utc(utc, local_opt, adjtime);
-
-      if ((set || systohc || adjust) &&
-	  (adjtime.local_utc == UTC) != universal) {
-	adjtime.local_utc = universal ? UTC : LOCAL;
-	adjtime.dirty = TRUE;
-      }
-
-      {
-        struct timeval read_time;
-          /* The time at which we read the Hardware Clock */
-
-        bool hclock_valid = FALSE;
-          /* The Hardware Clock gives us a valid time, or at least something
-             close enough to fool mktime().
-             */
-
-        time_t hclocktime = 0;
-          /* The time the hardware clock had just after we
-             synchronized to its next clock tick when we started up.
-             Defined only if hclock_valid is true.
-             */
+		 const bool set, const time_t set_time,
+		 const bool hctosys, const bool systohc, const bool systz,
+		 const struct timeval startup_time,
+		 const bool utc, const bool local_opt,
+		 const bool testing, const bool predict)
+{
+	/* Contents of the adjtime file, or what they should be. */
+	struct adjtime adjtime;
+	bool universal;
+	/* Set if user lacks necessary authorization to access the clock */
+	bool no_auth;
+	/* The time at which we read the Hardware Clock */
+	struct timeval read_time;
+	/*
+	 * The Hardware Clock gives us a valid time, or at
+	 * least something close enough to fool mktime().
+	 */
+	bool hclock_valid = FALSE;
+	/*
+	 * The time the hardware clock had just after we
+	 * synchronized to its next clock tick when we
+	 * started up. Defined only if hclock_valid is true.
+	 */
+	time_t hclocktime = 0;
+	/* local return code */
+	int rc;
+
+	if (!systz && !predict) {
+		no_auth = ur->get_permissions();
+		if (no_auth)
+			return EX_NOPERM;
+	}
+
+	if (!noadjfile
+	    && (adjust || set || systohc || (!utc && !local_opt) || predict)) {
+		rc = read_adjtime(&adjtime);
+		if (rc)
+			return rc;
+	} else {
+		/* A little trick to avoid reading the file if we don't have to */
+		adjtime.dirty = FALSE;
+		rc = 0;
+	}
+
+	universal = hw_clock_is_utc(utc, local_opt, adjtime);
+
+	if ((set || systohc || adjust) &&
+	    (adjtime.local_utc == UTC) != universal) {
+		adjtime.local_utc = universal ? UTC : LOCAL;
+		adjtime.dirty = TRUE;
+	}
 
 	if (show || adjust || hctosys || (!noadjfile && !systz && !predict)) {
-          /* data from HW-clock are required */
-          rc = synchronize_to_clock_tick();
-
-          /* 2 = synchronization timeout.  We don't error out if the user is
-             attempting to set the RTC - the RTC could be functioning but
-             contain invalid time data so we still want to allow a user to set
-             the RTC time.
-             */
-
-          if (rc && rc != 2 && !set && !systohc)
-            return EX_IOERR;
-          gettimeofday(&read_time, NULL);
-
-          /* If we can't synchronize to a clock tick, we likely can't read
-             from the RTC so don't bother reading it again. */
-          if (!rc) {
-            rc = read_hardware_clock(universal, &hclock_valid, &hclocktime);
-            if (rc && !set && !systohc)
-              return EX_IOERR;
-	  }
+		/* data from HW-clock are required */
+		rc = synchronize_to_clock_tick();
+
+		/*
+		 * 2 = synchronization timeout. We don't
+		 * error out if the user is attempting to
+		 * set the RTC - the RTC could be
+		 * functioning but contain invalid time data
+		 * so we still want to allow a user to set
+		 * the RTC time.
+		 */
+		if (rc && rc != 2 && !set && !systohc)
+			return EX_IOERR;
+		gettimeofday(&read_time, NULL);
+
+		/*
+		 * If we can't synchronize to a clock tick,
+		 * we likely can't read from the RTC so
+		 * don't bother reading it again.
+		 */
+		if (!rc) {
+			rc = read_hardware_clock(universal,
+						 &hclock_valid, &hclocktime);
+			if (rc && !set && !systohc)
+				return EX_IOERR;
+		}
 	}
 
-        if (show) {
-          display_time(hclock_valid, hclocktime,
-                       time_diff(read_time, startup_time));
-        } else if (set) {
-          set_hardware_clock_exact(set_time, startup_time,
-				      universal, testing);
-	  if (!noadjfile)
-            adjust_drift_factor(&adjtime, set_time, hclock_valid, hclocktime,
-			        time_diff(read_time, startup_time));
-        } else if (adjust) {
-          do_adjustment(&adjtime, hclock_valid, hclocktime,
-                        read_time, universal, testing);
-        } else if (systohc) {
-          struct timeval nowtime, reftime;
-          /* We can only set_hardware_clock_exact to a whole seconds
-             time, so we set it with reference to the most recent
-             whole seconds time.
-             */
-          gettimeofday(&nowtime, NULL);
-          reftime.tv_sec = nowtime.tv_sec;
-          reftime.tv_usec = 0;
-
-          set_hardware_clock_exact((time_t) reftime.tv_sec, reftime,
-                                   universal, testing);
-	  if (!noadjfile)
-            adjust_drift_factor(&adjtime, (time_t) reftime.tv_sec, hclock_valid,
-                                hclocktime, (double) read_time.tv_usec / 1E6);
-        } else if (hctosys) {
-          rc = set_system_clock(hclock_valid, hclocktime, testing);
-          if (rc) {
-            printf(_("Unable to set system clock.\n"));
-	    return rc;
-          }
+	if (show) {
+		display_time(hclock_valid, hclocktime,
+			     time_diff(read_time, startup_time));
+	} else if (set) {
+		set_hardware_clock_exact(set_time, startup_time,
+					 universal, testing);
+		if (!noadjfile)
+			adjust_drift_factor(&adjtime, set_time,
+					    hclock_valid,
+					    hclocktime,
+					    time_diff(read_time, startup_time));
+	} else if (adjust) {
+		do_adjustment(&adjtime, hclock_valid,
+			      hclocktime, read_time, universal, testing);
+	} else if (systohc) {
+		struct timeval nowtime, reftime;
+		/*
+		 * We can only set_hardware_clock_exact to a
+		 * whole seconds time, so we set it with
+		 * reference to the most recent whole
+		 * seconds time.
+		 */
+		gettimeofday(&nowtime, NULL);
+		reftime.tv_sec = nowtime.tv_sec;
+		reftime.tv_usec = 0;
+		set_hardware_clock_exact((time_t)
+					 reftime.tv_sec,
+					 reftime, universal, testing);
+		if (!noadjfile)
+			adjust_drift_factor(&adjtime, (time_t)
+					    reftime.tv_sec,
+					    hclock_valid, hclocktime, (double)
+					    read_time.tv_usec / 1E6);
+	} else if (hctosys) {
+		rc = set_system_clock(hclock_valid, hclocktime, testing);
+		if (rc) {
+			printf(_("Unable to set system clock.\n"));
+			return rc;
+		}
 	} else if (systz) {
-	  rc = set_system_clock_timezone(universal, testing);
-	  if (rc) {
-	    printf(_("Unable to set system clock.\n"));
-	    return rc;
-	  }
-        } else if (predict) {
-            int adjustment;
-            double retro;
-
-            calculate_adjustment(adjtime.drift_factor,
-                                 adjtime.last_adj_time,
-                                 adjtime.not_adjusted,
-                                 set_time,
-                                 &adjustment, &retro);
-            if (debug) {
-                printf(_("At %ld seconds after 1969, RTC is predicted to read %ld seconds after 1969.\n"),
-                       set_time, set_time + adjustment);
-            }
-            display_time(TRUE, set_time + adjustment, -retro);
-        }
-        if (!noadjfile)
-         save_adjtime(adjtime, testing);
-      }
-    }
-    return 0;
+		rc = set_system_clock_timezone(universal, testing);
+		if (rc) {
+			printf(_("Unable to set system clock.\n"));
+			return rc;
+		}
+	} else if (predict) {
+		int adjustment;
+		double retro;
+
+		calculate_adjustment(adjtime.drift_factor,
+				     adjtime.last_adj_time,
+				     adjtime.not_adjusted,
+				     set_time, &adjustment, &retro);
+		if (debug) {
+			printf(_
+			       ("At %ld seconds after 1969, RTC is predicted to read %ld seconds after 1969.\n"),
+			       set_time, set_time + adjustment);
+		}
+		display_time(TRUE, set_time + adjustment, -retro);
+	}
+	if (!noadjfile)
+		save_adjtime(adjtime, testing);
+	return 0;
 }
 
-
+/*
+ * Get or set the Hardware Clock epoch value in the kernel, as appropriate.
+ * <getepoch>, <setepoch>, and <epoch> are hwclock invocation options.
+ *
+ * <epoch> == -1 if the user did not specify an "epoch" option.
+ */
 #ifdef __linux__
 static void
 manipulate_epoch(const bool getepoch, const bool setepoch,
-                 const int epoch_opt, const bool testing) {
-/*----------------------------------------------------------------------------
-   Get or set the Hardware Clock epoch value in the kernel, as appropriate.
-   <getepoch>, <setepoch>, and <epoch> are hwclock invocation options.
-
-   <epoch> == -1 if the user did not specify an "epoch" option.
-
------------------------------------------------------------------------------*/
-  /*
-   Maintenance note:  This should work on non-Alpha machines, but the
-   evidence today (98.03.04) indicates that the kernel only keeps the
-   epoch value on Alphas.  If that is ever fixed, this function should be
-   changed.
-   */
-
+		 const int epoch_opt, const bool testing)
+{
+	/*
+	 * Maintenance note: This should work on non-Alpha machines, but the
+	 * evidence today (98.03.04) indicates that the kernel only keeps
+	 * the epoch value on Alphas. If that is ever fixed, this function
+	 * should be changed.
+	 */
 #ifndef __alpha__
-    fprintf(stderr, _("The kernel keeps an epoch value for the Hardware Clock "
-            "only on an Alpha machine.\nThis copy of hwclock was built for "
-            "a machine other than Alpha\n(and thus is presumably not running "
-            "on an Alpha now).  No action taken.\n"));
+	fprintf(stderr,
+		_("The kernel keeps an epoch value for the Hardware Clock "
+		  "only on an Alpha machine.\nThis copy of hwclock was built for "
+		  "a machine other than Alpha\n(and thus is presumably not running "
+		  "on an Alpha now).  No action taken.\n"));
 #else
-    if (getepoch) {
-      unsigned long epoch;
-
-      if (get_epoch_rtc(&epoch, 0))
-        fprintf(stderr, _("Unable to get the epoch value from the kernel.\n"));
-      else
-        printf(_("Kernel is assuming an epoch value of %lu\n"), epoch);
-    } else if (setepoch) {
-      if (epoch_opt == -1)
-        fprintf(stderr, _("To set the epoch value, you must use the 'epoch' "
-                "option to tell to what value to set it.\n"));
-      else if (testing)
-        printf(_("Not setting the epoch to %d - testing only.\n"),
-	       epoch_opt);
-      else if (set_epoch_rtc(epoch_opt))
-        printf(_("Unable to set the epoch value in the kernel.\n"));
-    }
+	if (getepoch) {
+		unsigned long epoch;
+
+		if (get_epoch_rtc(&epoch, 0))
+			fprintf(stderr,
+				_
+				("Unable to get the epoch value from the kernel.\n"));
+		else
+			printf(_("Kernel is assuming an epoch value of %lu\n"),
+			       epoch);
+	} else if (setepoch) {
+		if (epoch_opt == -1)
+			fprintf(stderr,
+				_
+				("To set the epoch value, you must use the 'epoch' "
+				 "option to tell to what value to set it.\n"));
+		else if (testing)
+			printf(_
+			       ("Not setting the epoch to %d - testing only.\n"),
+			       epoch_opt);
+		else if (set_epoch_rtc(epoch_opt))
+			printf(_
+			       ("Unable to set the epoch value in the kernel.\n"));
+	}
 #endif
 }
 #endif
@@ -1314,123 +1344,118 @@ manipulate_epoch(const bool getepoch, const bool setepoch,
 #define RTC_DEV "/dev/rtc"
 #endif
 
-static void
-out_version(void) {
+static void out_version(void)
+{
 	printf(_("%s from %s\n"), MYNAME, PACKAGE_STRING);
 }
 
 /*
-    usage - Output (error and) usage information
-
-    This function is called both directly from main to show usage
-    information and as fatal function from shhopt if some argument is
-    not understood. In case of normal usage info FMT should be NULL.
-    In that case the info is printed to stdout. If FMT is given
-    usage will act like fprintf( stderr, fmt, ... ), show a usage
-    information and terminate the program afterwards.
-*/
-static void
-usage( const char *fmt, ... ) {
-  FILE    *usageto;
-  va_list ap;
-
-  usageto = fmt ? stderr : stdout;
-
-  fprintf( usageto, _(
-    "hwclock - query and set the hardware clock (RTC)\n\n"
-    "Usage: hwclock [function] [options...]\n\n"
-    "Functions:\n"
-	"  -h | --help         show this help\n"
-	"  -r | --show         read hardware clock and print result\n"
-	"       --set          set the rtc to the time given with --date\n"
-	"  -s | --hctosys      set the system time from the hardware clock\n"
-	"  -w | --systohc      set the hardware clock to the current system time\n"
-	"       --systz        set the system time based on the current timezone\n"
-	"       --adjust       adjust the rtc to account for systematic drift since\n"
-	"                      the clock was last set or adjusted\n"
+ * usage - Output (error and) usage information
+ *
+ * This function is called both directly from main to show usage information
+ * and as fatal function from shhopt if some argument is not understood. In
+ * case of normal usage info FMT should be NULL. In that case the info is
+ * printed to stdout. If FMT is given usage will act like fprintf( stderr,
+ * fmt, ... ), show a usage information and terminate the program
+ * afterwards.
+ */
+static void usage(const char *fmt, ...)
+{
+	FILE *usageto;
+	va_list ap;
+
+	usageto = fmt ? stderr : stdout;
+
+	fprintf(usageto,
+		_("hwclock - query and set the hardware clock (RTC)\n\n"
+		  "Usage: hwclock [function] [options...]\n\n" "Functions:\n"
+		  "  -h | --help         show this help\n"
+		  "  -r | --show         read hardware clock and print result\n"
+		  "       --set          set the rtc to the time given with --date\n"
+		  "  -s | --hctosys      set the system time from the hardware clock\n"
+		  "  -w | --systohc      set the hardware clock to the current system time\n"
+		  "       --systz        set the system time based on the current timezone\n"
+		  "       --adjust       adjust the rtc to account for systematic drift since\n"
+		  "                      the clock was last set or adjusted\n"
 #ifdef __linux__
-	"       --getepoch     print out the kernel's hardware clock epoch value\n"
-	"       --setepoch     set the kernel's hardware clock epoch value to the \n"
-	"                      value given with --epoch\n"
+		  "       --getepoch     print out the kernel's hardware clock epoch value\n"
+		  "       --setepoch     set the kernel's hardware clock epoch value to the \n"
+		  "                      value given with --epoch\n"
 #endif
-	"       --predict      predict rtc reading at time given with --date\n"
-	"  -v | --version      print out the version of hwclock to stdout\n"
-	"\nOptions: \n"
-	"  -u | --utc          the hardware clock is kept in UTC\n"
-	"       --localtime    the hardware clock is kept in local time\n"
+		  "       --predict      predict rtc reading at time given with --date\n"
+		  "  -v | --version      print out the version of hwclock to stdout\n"
+		  "\nOptions: \n"
+		  "  -u | --utc          the hardware clock is kept in UTC\n"
+		  "       --localtime    the hardware clock is kept in local time\n"
 #ifdef __linux__
-	"  -f | --rtc=path     special /dev/... file to use instead of default\n"
+		  "  -f | --rtc=path     special /dev/... file to use instead of default\n"
 #endif
-	"       --directisa    access the ISA bus directly instead of %s\n"
-	"       --badyear      ignore rtc's year because the bios is broken\n"
-	"       --date         specifies the time to which to set the hardware clock\n"
-	"       --epoch=year   specifies the year which is the beginning of the \n"
-	"                      hardware clock's epoch value\n"
-	"       --noadjfile    do not access /etc/adjtime. Requires the use of\n"
-	"                      either --utc or --localtime\n"
-	"       --adjfile=path specifies the path to the adjust file (default is\n"
-	"                      /etc/adjtime)\n"
-	"       --test         do everything except actually updating the hardware\n"
-	"                      clock or anything else\n"
-	"  -D | --debug        debug mode\n"
-	"\n"
-    ),RTC_DEV);
+		  "       --directisa    access the ISA bus directly instead of %s\n"
+		  "       --badyear      ignore rtc's year because the bios is broken\n"
+		  "       --date         specifies the time to which to set the hardware clock\n"
+		  "       --epoch=year   specifies the year which is the beginning of the \n"
+		  "                      hardware clock's epoch value\n"
+		  "       --noadjfile    do not access /etc/adjtime. Requires the use of\n"
+		  "                      either --utc or --localtime\n"
+		  "       --adjfile=path specifies the path to the adjust file (default is\n"
+		  "                      /etc/adjtime)\n"
+		  "       --test         do everything except actually updating the hardware\n"
+		  "                      clock or anything else\n"
+		  "  -D | --debug        debug mode\n" "\n"), RTC_DEV);
 #ifdef __alpha__
-  fprintf(usageto, _(
-	"  -J|--jensen, -A|--arc, -S|--srm, -F|--funky-toy\n"
-	"       tell hwclock the type of alpha you have (see hwclock(8))\n"
-	"\n"
-    ) );
+	fprintf(usageto, _("  -J|--jensen, -A|--arc, -S|--srm, -F|--funky-toy\n"
+			   "       tell hwclock the type of alpha you have (see hwclock(8))\n"
+			   "\n"));
 #endif
 
-  fflush(stdout);
-  if (fmt) {
-    usageto = stderr;
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    va_end(ap);
-  }
+	fflush(stdout);
+	if (fmt) {
+		usageto = stderr;
+		va_start(ap, fmt);
+		vfprintf(stderr, fmt, ap);
+		va_end(ap);
+	}
 
-  hwclock_exit(fmt ? EX_USAGE : 0);
+	hwclock_exit(fmt ? EX_USAGE : 0);
 }
 
 static const struct option longopts[] = {
-	{ "adjust", 0, 0, 'a' },
-	{ "help", 0, 0, 'h' },
-	{ "show", 0, 0, 'r' },
-	{ "hctosys", 0, 0, 's' },
-	{ "utc", 0, 0, 'u' },
-	{ "version", 0, 0, 'v' },
-	{ "systohc", 0, 0, 'w' },
-	{ "debug", 0, 0, 'D' },
+	{"adjust",	0, 0, 'a'},
+	{"help",	0, 0, 'h'},
+	{"show",	0, 0, 'r'},
+	{"hctosys",	0, 0, 's'},
+	{"utc",		0, 0, 'u'},
+	{"version",	0, 0, 'v'},
+	{"systohc",	0, 0, 'w'},
+	{"debug",	0, 0, 'D'},
 #ifdef __alpha__
-	{ "ARC", 0, 0, 'A' },
-	{ "arc", 0, 0, 'A' },
-	{ "Jensen", 0, 0, 'J' },
-	{ "jensen", 0, 0, 'J' },
-	{ "SRM", 0, 0, 'S' },
-	{ "srm", 0, 0, 'S' },
-	{ "funky-toy", 0, 0, 'F'},
+	{"ARC",		0, 0, 'A'},
+	{"arc",		0, 0, 'A'},
+	{"Jensen",	0, 0, 'J'},
+	{"jensen",	0, 0, 'J'},
+	{"SRM",		0, 0, 'S'},
+	{"srm",		0, 0, 'S'},
+	{"funky-toy",	0, 0, 'F'},
 #endif
-	{ "set", 0, 0, 128 },
+	{"set",		0, 0, 128},
 #ifdef __linux__
-	{ "getepoch", 0, 0, 129 },
-	{ "setepoch", 0, 0, 130 },
+	{"getepoch",	0, 0, 129},
+	{"setepoch",	0, 0, 130},
 #endif
-	{ "noadjfile", 0, 0, 131 },
-	{ "localtime", 0, 0, 132 },
-	{ "badyear", 0, 0, 133 },
-	{ "directisa", 0, 0, 134 },
-	{ "test", 0, 0, 135 },
-	{ "date", 1, 0, 136 },
-	{ "epoch", 1, 0, 137 },
+	{"noadjfile",	0, 0, 131},
+	{"localtime",	0, 0, 132},
+	{"badyear",	0, 0, 133},
+	{"directisa",	0, 0, 134},
+	{"test",	0, 0, 135},
+	{"date",	1, 0, 136},
+	{"epoch",	1, 0, 137},
 #ifdef __linux__
-	{ "rtc", 1, 0, 'f' },
+	{"rtc",		1, 0, 'f'},
 #endif
-	{ "adjfile", 1, 0, 138 },
-	{ "systz", 0, 0, 139 },
-	{ "predict-hc", 0, 0, 140 },
-	{ NULL, 0, 0, 0 }
+	{"adjfile",	1, 0, 138},
+	{"systz",	0, 0, 139},
+	{"predict-hc",	0, 0, 140},
+	{NULL, 0, 0, 0}
 };
 
 /*
@@ -1442,20 +1467,22 @@ static const struct option longopts[] = {
  *  0: OK (or not)
  *  1: failure
  */
-int
-main(int argc, char **argv) {
-
+int main(int argc, char **argv)
+{
 	struct timeval startup_time;
-	/* The time we started up, in seconds into the epoch, including
-	   fractions. */
-	time_t set_time = 0;  /* Time to which user said to set Hardware Clock */
+	/*
+	 * The time we started up, in seconds into the epoch, including
+	 * fractions.
+	 */
+	time_t set_time = 0;	/* Time to which user said to set Hardware Clock */
 
-	bool permitted;  /* User is permitted to do the function */
+	bool permitted;		/* User is permitted to do the function */
 	int rc, c;
 
 	/* Variables set by various options; show may also be set later */
 	/* The options debug, badyear and epoch_option are global */
-	bool show, set, systohc, hctosys, systz, adjust, getepoch, setepoch, predict;
+	bool show, set, systohc, hctosys, systz, adjust, getepoch, setepoch,
+	    predict;
 	bool utc, testing, local_opt, noadjfile, directisa;
 	char *date_opt;
 #ifdef __alpha__
@@ -1468,32 +1495,37 @@ main(int argc, char **argv) {
 	hwaudit_fd = audit_open();
 	if (hwaudit_fd < 0 && !(errno == EINVAL || errno == EPROTONOSUPPORT ||
 				errno == EAFNOSUPPORT)) {
-		/* You get these error codes only when the kernel doesn't have
-		 * audit compiled in. */
+		/*
+		 * You get these error codes only when the kernel doesn't
+		 * have audit compiled in.
+		 */
 		fprintf(stderr, _("%s: Unable to connect to audit system\n"),
-				MYNAME);
+			MYNAME);
 		return EX_NOPERM;
 	}
 #endif
 	setlocale(LC_ALL, "");
 #ifdef LC_NUMERIC
-	/* We need LC_CTYPE and LC_TIME and LC_MESSAGES, but must avoid
-	   LC_NUMERIC since it gives problems when we write to /etc/adjtime.
-	   - gqueri@mail.dotcom.fr */
+	/*
+	 * We need LC_CTYPE and LC_TIME and LC_MESSAGES, but must avoid
+	 * LC_NUMERIC since it gives problems when we write to /etc/adjtime.
+	 *  - gqueri@mail.dotcom.fr
+	 */
 	setlocale(LC_NUMERIC, "C");
 #endif
 	bindtextdomain(PACKAGE, LOCALEDIR);
 	textdomain(PACKAGE);
 
 	/* Set option defaults */
-	show = set = systohc = hctosys = systz = adjust = noadjfile = predict = FALSE;
+	show = set = systohc = hctosys = systz = adjust = noadjfile = predict =
+	    FALSE;
 	getepoch = setepoch = utc = local_opt = testing = debug = FALSE;
 #ifdef __alpha__
 	ARCconsole = Jensen = SRM = funky_toy = directisa = badyear = FALSE;
 #endif
 	date_opt = NULL;
 
-	while ((c = getopt_long (argc, argv, "?hvVDarsuwAJSFf:", longopts, NULL))
+	while ((c = getopt_long(argc, argv, "?hvVDarsuwAJSFf:", longopts, NULL))
 	       != -1) {
 		switch (c) {
 		case 'D':
@@ -1543,7 +1575,7 @@ main(int argc, char **argv) {
 			noadjfile = TRUE;
 			break;
 		case 132:
-			local_opt = TRUE;		/* --localtime */
+			local_opt = TRUE;	/* --localtime */
 			break;
 		case 133:
 			badyear = TRUE;
@@ -1552,33 +1584,33 @@ main(int argc, char **argv) {
 			directisa = TRUE;
 			break;
 		case 135:
-			testing = TRUE;			/* --test */
+			testing = TRUE;		/* --test */
 			break;
 		case 136:
-			date_opt = optarg;		/* --date */
+			date_opt = optarg;	/* --date */
 			break;
 		case 137:
 			epoch_option = atoi(optarg);	/* --epoch */
 			break;
 		case 138:
-			adj_file_name = optarg;		/* --adjfile */
+			adj_file_name = optarg;	/* --adjfile */
 			break;
 		case 139:
-			systz = TRUE;			/* --systz */
+			systz = TRUE;		/* --systz */
 			break;
 		case 140:
-			predict = TRUE;			/* --predict-hc */
+			predict = TRUE;		/* --predict-hc */
 			break;
 #ifdef __linux__
 		case 'f':
-			rtc_dev_name = optarg;		/* --rtc */
+			rtc_dev_name = optarg;	/* --rtc */
 			break;
 #endif
-		case 'v':				/* --version */
+		case 'v':			/* --version */
 		case 'V':
 			out_version();
 			return 0;
-		case 'h':				/* --help */
+		case 'h':			/* --help */
 		case '?':
 		default:
 			usage(NULL);
@@ -1591,19 +1623,18 @@ main(int argc, char **argv) {
 #ifdef HAVE_LIBAUDIT
 	if (testing != TRUE) {
 		if (adjust == TRUE || hctosys == TRUE || systohc == TRUE ||
-					set == TRUE || setepoch == TRUE) {
+		    set == TRUE || setepoch == TRUE) {
 			hwaudit_on = TRUE;
 		}
 	}
 #endif
 	if (argc > 0) {
 		usage(_("%s takes no non-option arguments.  "
-			"You supplied %d.\n"),
-		      MYNAME, argc);
+			"You supplied %d.\n"), MYNAME, argc);
 	}
 
 	if (show + set + systohc + hctosys + systz + adjust + getepoch
-	    + setepoch + predict > 1){
+	    + setepoch + predict > 1) {
 		fprintf(stderr, _("You have specified multiple functions.\n"
 				  "You can only perform one function "
 				  "at a time.\n"));
@@ -1638,7 +1669,6 @@ main(int argc, char **argv) {
 				  "either --utc or --localtime\n"), MYNAME);
 		hwclock_exit(EX_USAGE);
 	}
-
 #ifdef __alpha__
 	set_cmos_epoch(ARCconsole, SRM);
 	set_cmos_access(Jensen, funky_toy);
@@ -1656,8 +1686,7 @@ main(int argc, char **argv) {
 
 	if (!(show | set | systohc | hctosys | systz | adjust | getepoch
 	      | setepoch | predict))
-		show = 1; /* default to show */
-
+		show = 1;	/* default to show */
 
 	if (getuid() == 0)
 		permitted = TRUE;
@@ -1710,15 +1739,15 @@ main(int argc, char **argv) {
 	}
 
 	rc = manipulate_clock(show, adjust, noadjfile, set, set_time,
-				hctosys, systohc, systz, startup_time, utc,
-				local_opt, testing, predict);
+			      hctosys, systohc, systz, startup_time, utc,
+			      local_opt, testing, predict);
 	hwclock_exit(rc);
-	return rc;	/* Not reached */
+	return rc;		/* Not reached */
 }
 
 /* A single routine for greater uniformity */
-void
-outsyserr(char *msg, ...) {
+void outsyserr(char *msg, ...)
+{
 	va_list args;
 	int errsv = errno;
 
@@ -1726,144 +1755,130 @@ outsyserr(char *msg, ...) {
 	va_start(args, msg);
 	vfprintf(stderr, msg, args);
 	va_end(args);
-	fprintf(stderr, ", errno=%d: %s.\n",
-		errsv, strerror(errsv));
+	fprintf(stderr, ", errno=%d: %s.\n", errsv, strerror(errsv));
 }
 
-
 #ifdef HAVE_LIBAUDIT
-void
-hwaudit_exit(int status)
+void hwaudit_exit(int status)
 {
 	if (hwaudit_on) {
 		audit_log_user_message(hwaudit_fd, AUDIT_USYS_CONFIG,
-			"changing system time", NULL, NULL, NULL, status ? 0 : 1);
+				       "changing system time", NULL, NULL, NULL,
+				       status ? 0 : 1);
 		close(hwaudit_fd);
 	}
 	exit(status);
 }
 #endif
 
-/****************************************************************************
-
-  History of this program:
-
-  98.08.12 BJH   Version 2.4
-
-  Don't use century byte from Hardware Clock.  Add comments telling why.
-
-
-  98.06.20 BJH   Version 2.3.
-
-  Make --hctosys set the kernel timezone from TZ environment variable
-  and/or /usr/lib/zoneinfo.  From Klaus Ripke (klaus@ripke.com).
-
-  98.03.05 BJH.  Version 2.2.
-
-  Add --getepoch and --setepoch.
-
-  Fix some word length things so it works on Alpha.
-
-  Make it work when /dev/rtc doesn't have the interrupt functions.
-  In this case, busywait for the top of a second instead of blocking and
-  waiting for the update complete interrupt.
-
-  Fix a bunch of bugs too numerous to mention.
-
-  97.06.01: BJH.  Version 2.1.  Read and write the century byte (Byte
-  50) of the ISA Hardware Clock when using direct ISA I/O.  Problem
-  discovered by job (jei@iclnl.icl.nl).
-
-  Use the rtc clock access method in preference to the KDGHWCLK method.
-  Problem discovered by Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>.
-
-  November 1996: Version 2.0.1.  Modifications by Nicolai Langfeldt
-  (janl@math.uio.no) to make it compile on linux 1.2 machines as well
-  as more recent versions of the kernel. Introduced the NO_CLOCK
-  access method and wrote feature test code to detect absense of rtc
-  headers.
-
-
-**************************************************************************
-  Maintenance notes
-
-  To compile this, you must use GNU compiler optimization (-O option)
-  in order to make the "extern inline" functions from asm/io.h (inb(),
-  etc.)  compile.  If you don't optimize, which means the compiler
-  will generate no inline functions, the references to these functions
-  in this program will be compiled as external references.  Since you
-  probably won't be linking with any functions by these names, you will
-  have unresolved external references when you link.
-
-  The program is designed to run setuid superuser, since we need to be
-  able to do direct I/O.  (More to the point: we need permission to
-  execute the iopl() system call).  (However, if you use one of the
-  methods other than direct ISA I/O to access the clock, no setuid is
-  required).
-
-  Here's some info on how we must deal with the time that elapses while
-  this program runs: There are two major delays as we run:
-
-    1) Waiting up to 1 second for a transition of the Hardware Clock so
-       we are synchronized to the Hardware Clock.
-
-    2) Running the "date" program to interpret the value of our --date
-       option.
-
-  Reading the /etc/adjtime file is the next biggest source of delay and
-  uncertainty.
-
-  The user wants to know what time it was at the moment he invoked us,
-  not some arbitrary time later.  And in setting the clock, he is
-  giving us the time at the moment we are invoked, so if we set the
-  clock some time later, we have to add some time to that.
-
-  So we check the system time as soon as we start up, then run "date"
-  and do file I/O if necessary, then wait to synchronize with a
-  Hardware Clock edge, then check the system time again to see how
-  much time we spent.  We immediately read the clock then and (if
-  appropriate) report that time, and additionally, the delay we measured.
-
-  If we're setting the clock to a time given by the user, we wait some
-  more so that the total delay is an integral number of seconds, then
-  set the Hardware Clock to the time the user requested plus that
-  integral number of seconds.  N.B. The Hardware Clock can only be set
-  in integral seconds.
-
-  If we're setting the clock to the system clock value, we wait for
-  the system clock to reach the top of a second, and then set the
-  Hardware Clock to the system clock's value.
-
-  Here's an interesting point about setting the Hardware Clock:  On my
-  machine, when you set it, it sets to that precise time.  But one can
-  imagine another clock whose update oscillator marches on a steady one
-  second period, so updating the clock between any two oscillator ticks
-  is the same as updating it right at the earlier tick.  To avoid any
-  complications that might cause, we set the clock as soon as possible
-  after an oscillator tick.
-
-
-  About synchronizing to the Hardware Clock when reading the time: The
-  precision of the Hardware Clock counters themselves is one second.
-  You can't read the counters and find out that is 12:01:02.5.  But if
-  you consider the location in time of the counter's ticks as part of
-  its value, then its precision is as infinite as time is continuous!
-  What I'm saying is this: To find out the _exact_ time in the
-  hardware clock, we wait until the next clock tick (the next time the
-  second counter changes) and measure how long we had to wait.  We
-  then read the value of the clock counters and subtract the wait time
-  and we know precisely what time it was when we set out to query the
-  time.
-
-  hwclock uses this method, and considers the Hardware Clock to have
-  infinite precision.
-
-
-  Enhancements needed:
-
-   - When waiting for whole second boundary in set_hardware_clock_exact,
-     fail if we miss the goal by more than .1 second, as could happen if
-     we get pre-empted (by the kernel dispatcher).
-
-****************************************************************************/
-
+/*
+ * History of this program:
+ *
+ * 98.08.12 BJH Version 2.4
+ *
+ * Don't use century byte from Hardware Clock. Add comments telling why.
+ *
+ * 98.06.20 BJH Version 2.3.
+ *
+ * Make --hctosys set the kernel timezone from TZ environment variable
+ * and/or /usr/lib/zoneinfo. From Klaus Ripke (klaus@ripke.com).
+ *
+ * 98.03.05 BJH. Version 2.2.
+ *
+ * Add --getepoch and --setepoch.
+ *
+ * Fix some word length things so it works on Alpha.
+ *
+ * Make it work when /dev/rtc doesn't have the interrupt functions. In this
+ * case, busywait for the top of a second instead of blocking and waiting
+ * for the update complete interrupt.
+ *
+ * Fix a bunch of bugs too numerous to mention.
+ *
+ * 97.06.01: BJH. Version 2.1. Read and write the century byte (Byte 50) of
+ * the ISA Hardware Clock when using direct ISA I/O. Problem discovered by
+ * job (jei@iclnl.icl.nl).
+ *
+ * Use the rtc clock access method in preference to the KDGHWCLK method.
+ * Problem discovered by Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>.
+ *
+ * November 1996: Version 2.0.1. Modifications by Nicolai Langfeldt
+ * (janl@math.uio.no) to make it compile on linux 1.2 machines as well as
+ * more recent versions of the kernel. Introduced the NO_CLOCK access method
+ * and wrote feature test code to detect absense of rtc headers.
+ *
+ ***************************************************************************
+ * Maintenance notes
+ *
+ * To compile this, you must use GNU compiler optimization (-O option) in
+ * order to make the "extern inline" functions from asm/io.h (inb(), etc.)
+ * compile. If you don't optimize, which means the compiler will generate no
+ * inline functions, the references to these functions in this program will
+ * be compiled as external references. Since you probably won't be linking
+ * with any functions by these names, you will have unresolved external
+ * references when you link.
+ *
+ * The program is designed to run setuid superuser, since we need to be able
+ * to do direct I/O. (More to the point: we need permission to execute the
+ * iopl() system call). (However, if you use one of the methods other than
+ * direct ISA I/O to access the clock, no setuid is required).
+ *
+ * Here's some info on how we must deal with the time that elapses while
+ * this program runs: There are two major delays as we run:
+ *
+ *	1) Waiting up to 1 second for a transition of the Hardware Clock so
+ *	   we are synchronized to the Hardware Clock.
+ *	2) Running the "date" program to interpret the value of our --date
+ *	   option.
+ *
+ * Reading the /etc/adjtime file is the next biggest source of delay and
+ * uncertainty.
+ *
+ * The user wants to know what time it was at the moment he invoked us, not
+ * some arbitrary time later. And in setting the clock, he is giving us the
+ * time at the moment we are invoked, so if we set the clock some time
+ * later, we have to add some time to that.
+ *
+ * So we check the system time as soon as we start up, then run "date" and
+ * do file I/O if necessary, then wait to synchronize with a Hardware Clock
+ * edge, then check the system time again to see how much time we spent. We
+ * immediately read the clock then and (if appropriate) report that time,
+ * and additionally, the delay we measured.
+ *
+ * If we're setting the clock to a time given by the user, we wait some more
+ * so that the total delay is an integral number of seconds, then set the
+ * Hardware Clock to the time the user requested plus that integral number
+ * of seconds. N.B. The Hardware Clock can only be set in integral seconds.
+ *
+ * If we're setting the clock to the system clock value, we wait for the
+ * system clock to reach the top of a second, and then set the Hardware
+ * Clock to the system clock's value.
+ *
+ * Here's an interesting point about setting the Hardware Clock:  On my
+ * machine, when you set it, it sets to that precise time. But one can
+ * imagine another clock whose update oscillator marches on a steady one
+ * second period, so updating the clock between any two oscillator ticks is
+ * the same as updating it right at the earlier tick. To avoid any
+ * complications that might cause, we set the clock as soon as possible
+ * after an oscillator tick.
+ *
+ * About synchronizing to the Hardware Clock when reading the time: The
+ * precision of the Hardware Clock counters themselves is one second. You
+ * can't read the counters and find out that is 12:01:02.5. But if you
+ * consider the location in time of the counter's ticks as part of its
+ * value, then its precision is as infinite as time is continuous! What I'm
+ * saying is this: To find out the _exact_ time in the hardware clock, we
+ * wait until the next clock tick (the next time the second counter changes)
+ * and measure how long we had to wait. We then read the value of the clock
+ * counters and subtract the wait time and we know precisely what time it
+ * was when we set out to query the time.
+ *
+ * hwclock uses this method, and considers the Hardware Clock to have
+ * infinite precision.
+ *
+ * TODO: Enhancements needed:
+ *
+ *  - When waiting for whole second boundary in set_hardware_clock_exact,
+ *    fail if we miss the goal by more than .1 second, as could happen if we
+ *    get pre-empted (by the kernel dispatcher).
+ */
diff --git a/hwclock/kd.c b/hwclock/kd.c
index 66ff579bb..f4957ac64 100644
--- a/hwclock/kd.c
+++ b/hwclock/kd.c
@@ -1,19 +1,21 @@
-/* kd.c - KDGHWCLK stuff, possibly m68k only - deprecated */
+/*
+ * kd.c - KDGHWCLK stuff, possibly m68k only, likely to be deprecated
+ */
 
 #include "clock.h"
 
 #ifdef __m68k__
 
-#include <unistd.h>		/* for close() */
-#include <fcntl.h>		/* for O_RDONLY */
-#include <sysexits.h>
-#include <sys/ioctl.h>
+# include <unistd.h>		/* for close() */
+# include <fcntl.h>		/* for O_RDONLY */
+# include <sysexits.h>
+# include <sys/ioctl.h>
 
-#include "nls.h"
-#include "usleep.h"
+# include "nls.h"
+# include "usleep.h"
 
 /* Get defines for KDGHWCLK and KDSHWCLK (m68k) */
-#include <linux/kd.h>
+# include <linux/kd.h>
 
 /* Even on m68k, if KDGHWCLK (antique) is not defined, don't build this */
 
@@ -21,124 +23,126 @@
 
 #if !defined(__m68k__) || !defined(KDGHWCLK)
 
-struct clock_ops *
-probe_for_kd_clock() {
+struct clock_ops *probe_for_kd_clock()
+{
 	return NULL;
 }
 
-#else /* __m68k__ && KDGHWCLK */
+#else				/* __m68k__ && KDGHWCLK */
 
-static int con_fd = -1;		/* opened by probe_for_kd_clock() */
-				/* never closed */
+/* Opened by probe_for_kd_clock(), and never closed. */
+static int con_fd = -1;
 static char *con_fd_filename;	/* usually "/dev/tty1" */
 
-static int
-synchronize_to_clock_tick_kd(void) {
-/*----------------------------------------------------------------------------
-   Wait for the top of a clock tick by calling KDGHWCLK in a busy loop until
-   we see it.
------------------------------------------------------------------------------*/
-
-  /* The time when we were called (and started waiting) */
-  struct hwclk_time start_time, nowtime;
-  struct timeval begin, now;
-
-  if (debug)
-    printf(_("Waiting in loop for time from KDGHWCLK to change\n"));
-
-  if (ioctl(con_fd, KDGHWCLK, &start_time) == -1) {
-    outsyserr(_("KDGHWCLK ioctl to read time failed"));
-    return 3;
-  }
-
-  /* Wait for change.  Should be within a second, but in case something
-   * weird happens, we have a time limit (1.5s) on this loop to reduce the
-   * impact of this failure.
-   */
-  gettimeofday(&begin, NULL);
-  do {
-    /* Added by Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
-     * "The culprit is the fast loop with KDGHWCLK ioctls. It seems
-     *  the kernel gets confused by those on Amigas with A2000 RTCs
-     *  and simply hangs after some time. Inserting a sleep helps."
-     */
-    usleep(1);
-
-    if (ioctl(con_fd, KDGHWCLK, &nowtime) == -1) {
-      outsyserr(_("KDGHWCLK ioctl to read time failed in loop"));
-      return 3;
-    }
-    if (start_time.tm_sec != nowtime.tm_sec)
-      break;
-    gettimeofday(&now, NULL);
-    if (time_diff(now, begin) > 1.5) {
-      fprintf(stderr, _("Timed out waiting for time change.\n"));
-      return 2;
-    }
-  } while(1);
-
-  return 0;
+/*
+ * Wait for the top of a clock tick by calling KDGHWCLK in a busy loop until
+ * we see it.
+ */
+static int synchronize_to_clock_tick_kd(void)
+{
+	/* The time when we were called (and started waiting) */
+	struct hwclk_time start_time, nowtime;
+	struct timeval begin, now;
+
+	if (debug)
+		printf(_("Waiting in loop for time from KDGHWCLK to change\n"));
+
+	if (ioctl(con_fd, KDGHWCLK, &start_time) == -1) {
+		outsyserr(_("KDGHWCLK ioctl to read time failed"));
+		return 3;
+	}
+
+	/*
+	 * Wait for change. Should be within a second, but in case something
+	 * weird happens, we have a time limit (1.5s) on this loop to reduce
+	 * the impact of this failure.
+	 */
+	gettimeofday(&begin, NULL);
+	do {
+		/*
+		 * Added by Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
+		 *
+		 * "The culprit is the fast loop with KDGHWCLK ioctls. It
+		 *  seems the kernel gets confused by those on Amigas with
+		 *  A2000 RTCs and simply hangs after some time. Inserting a
+		 *  sleep helps."
+		 */
+		usleep(1);
+
+		if (ioctl(con_fd, KDGHWCLK, &nowtime) == -1) {
+			outsyserr(_
+				  ("KDGHWCLK ioctl to read time failed in loop"));
+			return 3;
+		}
+		if (start_time.tm_sec != nowtime.tm_sec)
+			break;
+		gettimeofday(&now, NULL);
+		if (time_diff(now, begin) > 1.5) {
+			fprintf(stderr,
+				_("Timed out waiting for time change.\n"));
+			return 2;
+		}
+	} while (1);
+
+	return 0;
 }
 
+/*
+ * Read the hardware clock and return the current time via <tm> argument.
+ * Use ioctls to /dev/tty1 on what we assume is an m68k machine.
+ *
+ * Note that we don't use /dev/console here. That might be a serial console.
+ */
+static int read_hardware_clock_kd(struct tm *tm)
+{
+	struct hwclk_time t;
+
+	if (ioctl(con_fd, KDGHWCLK, &t) == -1) {
+		outsyserr(_("ioctl() failed to read time from %s"),
+			  con_fd_filename);
+		hwclock_exit(EX_IOERR);
+	}
+
+	tm->tm_sec = t.sec;
+	tm->tm_min = t.min;
+	tm->tm_hour = t.hour;
+	tm->tm_mday = t.day;
+	tm->tm_mon = t.mon;
+	tm->tm_year = t.year;
+	tm->tm_wday = t.wday;
+	tm->tm_isdst = -1;	/* Don't know if it's Daylight Savings Time */
 
-static int
-read_hardware_clock_kd(struct tm *tm) {
-/*----------------------------------------------------------------------------
-  Read the hardware clock and return the current time via <tm>
-  argument.  Use ioctls to /dev/tty1 on what we assume is an m68k
-  machine.
-
-  Note that we don't use /dev/console here.  That might be a serial
-  console.
------------------------------------------------------------------------------*/
-  struct hwclk_time t;
-
-  if (ioctl(con_fd, KDGHWCLK, &t) == -1) {
-    outsyserr(_("ioctl() failed to read time from %s"), con_fd_filename);
-    hwclock_exit(EX_IOERR);
-  }
-
-  tm->tm_sec  = t.sec;
-  tm->tm_min  = t.min;
-  tm->tm_hour = t.hour;
-  tm->tm_mday = t.day;
-  tm->tm_mon  = t.mon;
-  tm->tm_year = t.year;
-  tm->tm_wday = t.wday;
-  tm->tm_isdst = -1;     /* Don't know if it's Daylight Savings Time */
-
-  return 0;
+	return 0;
 }
 
+/*
+ * Set the Hardware Clock to the time <new_broken_time>. Use ioctls to
+ * /dev/tty1 on what we assume is an m68k machine.
+ *
+ * Note that we don't use /dev/console here. That might be a serial console.
+ */
+static int set_hardware_clock_kd(const struct tm *new_broken_time)
+{
+	struct hwclk_time t;
 
-static int
-set_hardware_clock_kd(const struct tm *new_broken_time) {
-/*----------------------------------------------------------------------------
-  Set the Hardware Clock to the time <new_broken_time>.  Use ioctls to
-  /dev/tty1 on what we assume is an m68k machine.
-
-  Note that we don't use /dev/console here.  That might be a serial console.
-----------------------------------------------------------------------------*/
-  struct hwclk_time t;
-
-  t.sec  = new_broken_time->tm_sec;
-  t.min  = new_broken_time->tm_min;
-  t.hour = new_broken_time->tm_hour;
-  t.day  = new_broken_time->tm_mday;
-  t.mon  = new_broken_time->tm_mon;
-  t.year = new_broken_time->tm_year;
-  t.wday = new_broken_time->tm_wday;
-
-  if (ioctl(con_fd, KDSHWCLK, &t ) == -1) {
-    outsyserr(_("ioctl KDSHWCLK failed"));
-    hwclock_exit(1);
-  }
-  return 0;
+	t.sec = new_broken_time->tm_sec;
+	t.min = new_broken_time->tm_min;
+	t.hour = new_broken_time->tm_hour;
+	t.day = new_broken_time->tm_mday;
+	t.mon = new_broken_time->tm_mon;
+	t.year = new_broken_time->tm_year;
+	t.wday = new_broken_time->tm_wday;
+
+	if (ioctl(con_fd, KDSHWCLK, &t) == -1) {
+		outsyserr(_("ioctl KDSHWCLK failed"));
+		hwclock_exit(1);
+	}
+	return 0;
 }
 
-static int
-get_permissions_kd(void) {
-  return 0;
+static int get_permissions_kd(void)
+{
+	return 0;
 }
 
 static struct clock_ops kd = {
@@ -150,8 +154,8 @@ static struct clock_ops kd = {
 };
 
 /* return &kd if KDGHWCLK works, NULL otherwise */
-struct clock_ops *
-probe_for_kd_clock() {
+struct clock_ops *probe_for_kd_clock()
+{
 	struct clock_ops *ret = NULL;
 	struct hwclk_time t;
 
@@ -176,4 +180,4 @@ probe_for_kd_clock() {
 	}
 	return ret;
 }
-#endif /* __m68k__ && KDGHWCLK */
+#endif				/* __m68k__ && KDGHWCLK */
diff --git a/hwclock/rtc.c b/hwclock/rtc.c
index 2e053856a..21c7d746d 100644
--- a/hwclock/rtc.c
+++ b/hwclock/rtc.c
@@ -1,4 +1,6 @@
-/* rtc.c - Use /dev/rtc for clock access */
+/*
+ * rtc.c - Use /dev/rtc for clock access
+ */
 #include <unistd.h>		/* for close() */
 #include <fcntl.h>		/* for O_RDONLY */
 #include <errno.h>
@@ -12,77 +14,83 @@
 /*
  * Get defines for rtc stuff.
  *
- * Getting the rtc defines is nontrivial.
- * The obvious way is by including <linux/mc146818rtc.h>
- * but that again includes <asm/io.h> which again includes ...
- * and on sparc and alpha this gives compilation errors for
- * many kernel versions. So, we give the defines ourselves here.
- * Moreover, some Sparc person decided to be incompatible, and
- * used a struct rtc_time different from that used in mc146818rtc.h.
+ * Getting the rtc defines is nontrivial. The obvious way is by including
+ * <linux/mc146818rtc.h> but that again includes <asm/io.h> which again
+ * includes ... and on sparc and alpha this gives compilation errors for
+ * many kernel versions. So, we give the defines ourselves here. Moreover,
+ * some Sparc person decided to be incompatible, and used a struct rtc_time
+ * different from that used in mc146818rtc.h.
  */
 
-/* On Sparcs, there is a <asm/rtc.h> that defines different ioctls
-   (that are required on my machine). However, this include file
-   does not exist on other architectures. */
+/*
+ * On Sparcs, there is a <asm/rtc.h> that defines different ioctls (that are
+ * required on my machine). However, this include file does not exist on
+ * other architectures.
+ */
 /* One might do:
 #ifdef __sparc__
-#include <asm/rtc.h>
+# include <asm/rtc.h>
 #endif
  */
 /* The following is roughly equivalent */
 struct sparc_rtc_time
 {
-        int     sec;    /* Seconds (0-59) */
-        int     min;    /* Minutes (0-59) */
-        int     hour;   /* Hour (0-23) */
-        int     dow;    /* Day of the week (1-7) */
-        int     dom;    /* Day of the month (1-31) */
-        int     month;  /* Month of year (1-12) */
-        int     year;   /* Year (0-99) */
+	int sec;	/* Seconds		0-59 */
+	int min;	/* Minutes		0-59 */
+	int hour;	/* Hour			0-23 */
+	int dow;	/* Day of the week	1-7  */
+	int dom;	/* Day of the month	1-31 */
+	int month;	/* Month of year	1-12 */
+	int year;	/* Year			0-99 */
 };
 
 #define RTCGET _IOR('p', 20, struct sparc_rtc_time)
 #define RTCSET _IOW('p', 21, struct sparc_rtc_time)
 
-
 /* non-sparc stuff */
 #if 0
-#include <linux/version.h>
-/* Check if the /dev/rtc interface is available in this version of
-   the system headers.  131072 is linux 2.0.0. */
-#if LINUX_VERSION_CODE >= 131072
-#include <linux/mc146818rtc.h>
-#endif
+# include <linux/version.h>
+/*
+ * Check if the /dev/rtc interface is available in this version of the
+ * system headers. 131072 is linux 2.0.0.
+ */
+# if LINUX_VERSION_CODE >= 131072
+#  include <linux/mc146818rtc.h>
+# endif
 #endif
 
-/* struct rtc_time is present since 1.3.99 */
-/* Earlier (since 1.3.89), a struct tm was used. */
+/*
+ * struct rtc_time is present since 1.3.99.
+ * Earlier (since 1.3.89), a struct tm was used.
+ */
 struct linux_rtc_time {
-        int tm_sec;
-        int tm_min;
-        int tm_hour;
-        int tm_mday;
-        int tm_mon;
-        int tm_year;
-        int tm_wday;
-        int tm_yday;
-        int tm_isdst;
+	int tm_sec;
+	int tm_min;
+	int tm_hour;
+	int tm_mday;
+	int tm_mon;
+	int tm_year;
+	int tm_wday;
+	int tm_yday;
+	int tm_isdst;
 };
 
 /* RTC_RD_TIME etc have this definition since 1.99.9 (pre2.0-9) */
 #ifndef RTC_RD_TIME
-#define RTC_RD_TIME       _IOR('p', 0x09, struct linux_rtc_time)
-#define RTC_SET_TIME      _IOW('p', 0x0a, struct linux_rtc_time)
-#define RTC_UIE_ON        _IO('p', 0x03)	/* Update int. enable on */
-#define RTC_UIE_OFF       _IO('p', 0x04)	/* Update int. enable off */
+# define RTC_RD_TIME	_IOR('p', 0x09, struct linux_rtc_time)
+# define RTC_SET_TIME	_IOW('p', 0x0a, struct linux_rtc_time)
+# define RTC_UIE_ON	_IO('p', 0x03)	/* Update int. enable on */
+# define RTC_UIE_OFF	_IO('p', 0x04)	/* Update int. enable off */
 #endif
+
 /* RTC_EPOCH_READ and RTC_EPOCH_SET are present since 2.0.34 and 2.1.89 */
 #ifndef RTC_EPOCH_READ
-#define RTC_EPOCH_READ	_IOR('p', 0x0d, unsigned long)	 /* Read epoch */
-#define RTC_EPOCH_SET	_IOW('p', 0x0e, unsigned long)	 /* Set epoch */
+# define RTC_EPOCH_READ	_IOR('p', 0x0d, unsigned long)	/* Read epoch */
+# define RTC_EPOCH_SET	_IOW('p', 0x0e, unsigned long)	/* Set epoch */
 #endif
 
-/* /dev/rtc is conventionally chardev 10/135
+/*
+ * /dev/rtc is conventionally chardev 10/135
  * ia64 uses /dev/efirtc, chardev 10/136
  * devfs (obsolete) used /dev/misc/... for miscdev
  * new RTC framework + udev uses dynamic major and /dev/rtc0.../dev/rtcN
@@ -94,15 +102,15 @@ char *rtc_dev_name;
 
 static int rtc_dev_fd = -1;
 
-static void
-close_rtc(void) {
+static void close_rtc(void)
+{
 	if (rtc_dev_fd != -1)
 		close(rtc_dev_fd);
 	rtc_dev_fd = -1;
 }
 
-static int
-open_rtc(void) {
+static int open_rtc(void)
+{
 	char *fls[] = {
 #ifdef __ia64__
 		"/dev/efirtc",
@@ -122,10 +130,11 @@ open_rtc(void) {
 	if (rtc_dev_name)
 		rtc_dev_fd = open(rtc_dev_name, O_RDONLY);
 	else {
-		for (p=fls; *p; ++p) {
+		for (p = fls; *p; ++p) {
 			rtc_dev_fd = open(*p, O_RDONLY);
 
-			if (rtc_dev_fd < 0 && (errno == ENOENT || errno == ENODEV))
+			if (rtc_dev_fd < 0
+			    && (errno == ENOENT || errno == ENODEV))
 				continue;
 			rtc_dev_name = *p;
 			break;
@@ -139,8 +148,8 @@ open_rtc(void) {
 	return rtc_dev_fd;
 }
 
-static int
-open_rtc_or_exit(void) {
+static int open_rtc_or_exit(void)
+{
 	int rtc_fd = open_rtc();
 
 	if (rtc_fd < 0) {
@@ -150,8 +159,8 @@ open_rtc_or_exit(void) {
 	return rtc_fd;
 }
 
-static int
-do_rtc_read_ioctl(int rtc_fd, struct tm *tm) {
+static int do_rtc_read_ioctl(int rtc_fd, struct tm *tm)
+{
 	int rc = -1;
 	char *ioctlname;
 
@@ -169,7 +178,7 @@ do_rtc_read_ioctl(int rtc_fd, struct tm *tm) {
 		tm->tm_mon = stm.month - 1;
 		tm->tm_year = stm.year - 1900;
 		tm->tm_wday = stm.dow - 1;
-		tm->tm_yday = -1;		/* day in the year */
+		tm->tm_yday = -1;	/* day in the year */
 	}
 #endif
 	if (rc == -1) {		/* no sparc, or RTCGET failed */
@@ -183,134 +192,153 @@ do_rtc_read_ioctl(int rtc_fd, struct tm *tm) {
 		return -1;
 	}
 
-	tm->tm_isdst = -1;          /* don't know whether it's dst */
+	tm->tm_isdst = -1;	/* don't know whether it's dst */
 	return 0;
 }
 
-static int
-busywait_for_rtc_clock_tick(const int rtc_fd) {
-/*----------------------------------------------------------------------------
-   Wait for the top of a clock tick by reading /dev/rtc in a busy loop until
-   we see it.
------------------------------------------------------------------------------*/
-  struct tm start_time;
-    /* The time when we were called (and started waiting) */
-  struct tm nowtime;
-  int rc;
-  struct timeval begin, now;
-
-  if (debug)
-    printf(_("Waiting in loop for time from %s to change\n"),
-	   rtc_dev_name);
-
-  rc = do_rtc_read_ioctl(rtc_fd, &start_time);
-  if (rc)
-    return 1;
-
-  /* Wait for change.  Should be within a second, but in case something
-   * weird happens, we have a time limit (1.5s) on this loop to reduce the
-   * impact of this failure.
-   */
-  gettimeofday(&begin, NULL);
-  do {
-    rc = do_rtc_read_ioctl(rtc_fd, &nowtime);
-    if (rc || start_time.tm_sec != nowtime.tm_sec)
-      break;
-    gettimeofday(&now, NULL);
-    if (time_diff(now, begin) > 1.5) {
-      fprintf(stderr, _("Timed out waiting for time change.\n"));
-      return 2;
-    }
-  } while(1);
-
-  if (rc)
-    return 3;
-  return 0;
+/*
+ * Wait for the top of a clock tick by reading /dev/rtc in a busy loop until
+ * we see it.
+ */
+static int busywait_for_rtc_clock_tick(const int rtc_fd)
+{
+	struct tm start_time;
+	/* The time when we were called (and started waiting) */
+	struct tm nowtime;
+	int rc;
+	struct timeval begin, now;
+
+	if (debug)
+		printf(_("Waiting in loop for time from %s to change\n"),
+		       rtc_dev_name);
+
+	rc = do_rtc_read_ioctl(rtc_fd, &start_time);
+	if (rc)
+		return 1;
+
+	/*
+	 * Wait for change.  Should be within a second, but in case
+	 * something weird happens, we have a time limit (1.5s) on this loop
+	 * to reduce the impact of this failure.
+	 */
+	gettimeofday(&begin, NULL);
+	do {
+		rc = do_rtc_read_ioctl(rtc_fd, &nowtime);
+		if (rc || start_time.tm_sec != nowtime.tm_sec)
+			break;
+		gettimeofday(&now, NULL);
+		if (time_diff(now, begin) > 1.5) {
+			fprintf(stderr,
+				_("Timed out waiting for time change.\n"));
+			return 2;
+		}
+	} while (1);
+
+	if (rc)
+		return 3;
+	return 0;
 }
 
-static int
-synchronize_to_clock_tick_rtc(void) {
-/*----------------------------------------------------------------------------
-  Same as synchronize_to_clock_tick(), but just for /dev/rtc.
------------------------------------------------------------------------------*/
-int rtc_fd;  /* File descriptor of /dev/rtc */
-int ret;
-
-  rtc_fd = open_rtc();
-  if (rtc_fd == -1) {
-    outsyserr(_("open() of %s failed"), rtc_dev_name);
-    ret = 1;
-  } else {
-    int rc;  /* Return code from ioctl */
-    /* Turn on update interrupts (one per second) */
+/*
+ * Same as synchronize_to_clock_tick(), but just for /dev/rtc.
+ */
+static int synchronize_to_clock_tick_rtc(void)
+{
+	int rtc_fd;		/* File descriptor of /dev/rtc */
+	int ret;
+
+	rtc_fd = open_rtc();
+	if (rtc_fd == -1) {
+		outsyserr(_("open() of %s failed"), rtc_dev_name);
+		ret = 1;
+	} else {
+		int rc;		/* Return code from ioctl */
+		/* Turn on update interrupts (one per second) */
 #if defined(__alpha__) || defined(__sparc__)
-    /* Not all alpha kernels reject RTC_UIE_ON, but probably they should. */
-    rc = -1;
-    errno = EINVAL;
+		/*
+		 * Not all alpha kernels reject RTC_UIE_ON, but probably
+		 * they should.
+		 */
+		rc = -1;
+		errno = EINVAL;
 #else
-    rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
+		rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
 #endif
-    if (rc == -1 && (errno == ENOTTY || errno == EINVAL)) {
-      /* This rtc device doesn't have interrupt functions.  This is typical
-         on an Alpha, where the Hardware Clock interrupts are used by the
-         kernel for the system clock, so aren't at the user's disposal.
-         */
-      if (debug)
-	      printf(_("%s does not have interrupt functions. "),
-		     rtc_dev_name);
-      ret = busywait_for_rtc_clock_tick(rtc_fd);
-    } else if (rc == 0) {
+		if (rc == -1 && (errno == ENOTTY || errno == EINVAL)) {
+			/*
+			 * This rtc device doesn't have interrupt functions.
+			 * This is typical on an Alpha, where the Hardware
+			 * Clock interrupts are used by the kernel for the
+			 * system clock, so aren't at the user's disposal.
+			 */
+			if (debug)
+				printf(_
+				       ("%s does not have interrupt functions. "),
+				       rtc_dev_name);
+			ret = busywait_for_rtc_clock_tick(rtc_fd);
+		} else if (rc == 0) {
 #ifdef Wait_until_update_interrupt
-      unsigned long dummy;
-
-      /* this blocks until the next update interrupt */
-      rc = read(rtc_fd, &dummy, sizeof(dummy));
-      ret = 1;
-      if (rc == -1)
-        outsyserr(_("read() to %s to wait for clock tick failed"),
-		  rtc_dev_name);
-      else
-        ret = 0;
+			unsigned long dummy;
+
+			/* this blocks until the next update interrupt */
+			rc = read(rtc_fd, &dummy, sizeof(dummy));
+			ret = 1;
+			if (rc == -1)
+				outsyserr(_
+					  ("read() to %s to wait for clock tick failed"),
+					  rtc_dev_name);
+			else
+				ret = 0;
 #else
-      /* Just reading rtc_fd fails on broken hardware: no update
-	 interrupt comes and a bootscript with a hwclock call hangs */
-      fd_set rfds;
-      struct timeval tv;
-
-      /* Wait up to five seconds for the next update interrupt */
-      FD_ZERO(&rfds);
-      FD_SET(rtc_fd, &rfds);
-      tv.tv_sec = 5;
-      tv.tv_usec = 0;
-      rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
-      ret = 1;
-      if (rc == -1)
-        outsyserr(_("select() to %s to wait for clock tick failed"),
-		  rtc_dev_name);
-      else if (rc == 0)
-	fprintf(stderr, _("select() to %s to wait for clock tick timed out\n"),
-			  rtc_dev_name);
-      else
-        ret = 0;
+			/*
+			 * Just reading rtc_fd fails on broken hardware: no
+			 * update interrupt comes and a bootscript with a
+			 * hwclock call hangs
+			 */
+			fd_set rfds;
+			struct timeval tv;
+
+			/*
+			 * Wait up to five seconds for the next update
+			 * interrupt
+			 */
+			FD_ZERO(&rfds);
+			FD_SET(rtc_fd, &rfds);
+			tv.tv_sec = 5;
+			tv.tv_usec = 0;
+			rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
+			ret = 1;
+			if (rc == -1)
+				outsyserr(_
+					  ("select() to %s to wait for clock tick failed"),
+					  rtc_dev_name);
+			else if (rc == 0)
+				fprintf(stderr,
+					_
+					("select() to %s to wait for clock tick timed out\n"),
+					rtc_dev_name);
+			else
+				ret = 0;
 #endif
 
-      /* Turn off update interrupts */
-      rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
-      if (rc == -1)
-        outsyserr(_("ioctl() to %s to turn off update interrupts failed"),
-		  rtc_dev_name);
-    } else {
-      outsyserr(_("ioctl() to %s to turn on update interrupts "
-		"failed unexpectedly"), rtc_dev_name);
-      ret = 1;
-    }
-  }
-  return ret;
+			/* Turn off update interrupts */
+			rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
+			if (rc == -1)
+				outsyserr(_
+					  ("ioctl() to %s to turn off update interrupts failed"),
+					  rtc_dev_name);
+		} else {
+			outsyserr(_
+				  ("ioctl() to %s to turn on update interrupts "
+				   "failed unexpectedly"), rtc_dev_name);
+			ret = 1;
+		}
+	}
+	return ret;
 }
 
-
-static int
-read_hardware_clock_rtc(struct tm *tm) {
+static int read_hardware_clock_rtc(struct tm *tm)
+{
 	int rtc_fd, rc;
 
 	rtc_fd = open_rtc_or_exit();
@@ -321,13 +349,12 @@ read_hardware_clock_rtc(struct tm *tm) {
 	return rc;
 }
 
-
-static int
-set_hardware_clock_rtc(const struct tm *new_broken_time) {
-/*-------------------------------------------------------------------------
-  Set the Hardware Clock to the broken down time <new_broken_time>.
-  Use ioctls to "rtc" device /dev/rtc.
-  -------------------------------------------------------------------------*/
+/*
+ * Set the Hardware Clock to the broken down time <new_broken_time>. Use
+ * ioctls to "rtc" device /dev/rtc.
+ */
+static int set_hardware_clock_rtc(const struct tm *new_broken_time)
+{
 	int rc = -1;
 	int rtc_fd;
 	char *ioctlname;
@@ -368,9 +395,8 @@ set_hardware_clock_rtc(const struct tm *new_broken_time) {
 	return 0;
 }
 
-
-static int
-get_permissions_rtc(void) {
+static int get_permissions_rtc(void)
+{
 	return 0;
 }
 
@@ -383,8 +409,8 @@ static struct clock_ops rtc = {
 };
 
 /* return &rtc if /dev/rtc can be opened, NULL otherwise */
-struct clock_ops *
-probe_for_rtc_clock(){
+struct clock_ops *probe_for_rtc_clock()
+{
 	int rtc_fd = open_rtc();
 	if (rtc_fd >= 0)
 		return &rtc;
@@ -393,85 +419,91 @@ probe_for_rtc_clock(){
 	return NULL;
 }
 
+/*
+ * Get the Hardware Clock epoch setting from the kernel.
+ */
+int get_epoch_rtc(unsigned long *epoch_p, int silent)
+{
+	int rtc_fd;
+
+	rtc_fd = open_rtc();
+	if (rtc_fd < 0) {
+		if (!silent) {
+			if (errno == ENOENT)
+				fprintf(stderr,
+					_
+					("To manipulate the epoch value in the kernel, we must "
+					 "access the Linux 'rtc' device driver via the device special "
+					 "file %s.  This file does not exist on this system.\n"),
+					rtc_dev_name);
+			else
+				outsyserr(_("Unable to open %s"), rtc_dev_name);
+		}
+		return 1;
+	}
+
+	if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
+		if (!silent)
+			outsyserr(_("ioctl(RTC_EPOCH_READ) to %s failed"),
+				  rtc_dev_name);
+		return 1;
+	}
 
+	if (debug)
+		printf(_("we have read epoch %ld from %s "
+			 "with RTC_EPOCH_READ ioctl.\n"), *epoch_p,
+		       rtc_dev_name);
 
-int
-get_epoch_rtc(unsigned long *epoch_p, int silent) {
-/*----------------------------------------------------------------------------
-  Get the Hardware Clock epoch setting from the kernel.
-----------------------------------------------------------------------------*/
-  int rtc_fd;
-
-  rtc_fd = open_rtc();
-  if (rtc_fd < 0) {
-    if (!silent) {
-      if (errno == ENOENT)
-        fprintf(stderr, _(
-		"To manipulate the epoch value in the kernel, we must "
-                "access the Linux 'rtc' device driver via the device special "
-                "file %s.  This file does not exist on this system.\n"),
-		rtc_dev_name);
-      else
-        outsyserr(_("Unable to open %s"), rtc_dev_name);
-    }
-    return 1;
-  }
-
-  if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
-    if (!silent)
-      outsyserr(_("ioctl(RTC_EPOCH_READ) to %s failed"), rtc_dev_name);
-    return 1;
-  }
-
-  if (debug)
-	  printf(_("we have read epoch %ld from %s "
-		 "with RTC_EPOCH_READ ioctl.\n"), *epoch_p, rtc_dev_name);
-
-  return 0;
+	return 0;
 }
 
+/*
+ * Set the Hardware Clock epoch in the kernel.
+ */
+int set_epoch_rtc(unsigned long epoch)
+{
+	int rtc_fd;
+
+	if (epoch < 1900) {
+		/* kernel would not accept this epoch value
+		 *
+		 * Bad habit, deciding not to do what the user asks just
+		 * because one believes that the kernel might not like it.
+		 */
+		fprintf(stderr, _("The epoch value may not be less than 1900.  "
+				  "You requested %ld\n"), epoch);
+		return 1;
+	}
+
+	rtc_fd = open_rtc();
+	if (rtc_fd < 0) {
+		if (errno == ENOENT)
+			fprintf(stderr,
+				_
+				("To manipulate the epoch value in the kernel, we must "
+				 "access the Linux 'rtc' device driver via the device special "
+				 "file %s.  This file does not exist on this system.\n"),
+				rtc_dev_name);
+		else
+			outsyserr(_("Unable to open %s"), rtc_dev_name);
+		return 1;
+	}
 
+	if (debug)
+		printf(_("setting epoch to %ld "
+			 "with RTC_EPOCH_SET ioctl to %s.\n"), epoch,
+		       rtc_dev_name);
+
+	if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
+		if (errno == EINVAL)
+			fprintf(stderr, _("The kernel device driver for %s "
+					  "does not have the RTC_EPOCH_SET ioctl.\n"),
+				rtc_dev_name);
+		else
+			outsyserr(_("ioctl(RTC_EPOCH_SET) to %s failed"),
+				  rtc_dev_name);
+		return 1;
+	}
 
-int
-set_epoch_rtc(unsigned long epoch) {
-/*----------------------------------------------------------------------------
-  Set the Hardware Clock epoch in the kernel.
-----------------------------------------------------------------------------*/
-  int rtc_fd;
-
-  if (epoch < 1900) {
-    /* kernel would not accept this epoch value */
-    /* Hmm - bad habit, deciding not to do what the user asks
-       just because one believes that the kernel might not like it. */
-    fprintf(stderr, _("The epoch value may not be less than 1900.  "
-            "You requested %ld\n"), epoch);
-    return 1;
-  }
-
-  rtc_fd = open_rtc();
-  if (rtc_fd < 0) {
-    if (errno == ENOENT)
-      fprintf(stderr, _("To manipulate the epoch value in the kernel, we must "
-              "access the Linux 'rtc' device driver via the device special "
-              "file %s.  This file does not exist on this system.\n"),
-	      rtc_dev_name);
-    else
-      outsyserr(_("Unable to open %s"), rtc_dev_name);
-    return 1;
-  }
-
-  if (debug)
-    printf(_("setting epoch to %ld "
-	   "with RTC_EPOCH_SET ioctl to %s.\n"), epoch, rtc_dev_name);
-
-  if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
-    if (errno == EINVAL)
-      fprintf(stderr, _("The kernel device driver for %s "
-	      "does not have the RTC_EPOCH_SET ioctl.\n"), rtc_dev_name);
-    else
-      outsyserr(_("ioctl(RTC_EPOCH_SET) to %s failed"), rtc_dev_name);
-    return 1;
-  }
-
-  return 0;
+	return 0;
 }