Minor changes: coding style (tabs, ident, etc...).

src/netif/ppp/randm.c

@@ -63,9 +63,10 @@ static long randCount = 0;      /* Pseudo-random incrementer */
  *  real-time clock.  We'll accumulate more randomness as soon
  *  as things start happening.
  */
-void avRandomInit()
+void
+avRandomInit()
 {
-    avChurnRand(NULL, 0);
+  avChurnRand(NULL, 0);
 }
 
 /*
@@ -78,26 +79,26 @@ void avRandomInit()
  *
  * Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427
  */
-void avChurnRand(char *randData, u32_t randLen)
+void
+avChurnRand(char *randData, u32_t randLen)
 {
-    MD5_CTX md5;
+  MD5_CTX md5;
 
-/*  ppp_trace(LOG_INFO, "churnRand: %u@%P\n", randLen, randData); */
+  /* ppp_trace(LOG_INFO, "churnRand: %u@%P\n", randLen, randData); */
-    MD5Init(&md5);
+  MD5Init(&md5);
-    MD5Update(&md5, (u_char *)randPool, sizeof(randPool));
+  MD5Update(&md5, (u_char *)randPool, sizeof(randPool));
-    if (randData)
+  if (randData) {
-        MD5Update(&md5, (u_char *)randData, randLen);
+    MD5Update(&md5, (u_char *)randData, randLen);
-    else {
+  } else {
-        struct {
+    struct {
-            /* INCLUDE fields for any system sources of randomness */
+      /* INCLUDE fields for any system sources of randomness */
-            char foobar;
+      char foobar;
-        } sysData;
+    } sysData;
 
-        /* Load sysData fields here. */
+    /* Load sysData fields here. */
-        ;
+    MD5Update(&md5, (u_char *)&sysData, sizeof(sysData));
-        MD5Update(&md5, (u_char *)&sysData, sizeof(sysData));
+  }
-    }
+  MD5Final((u_char *)randPool, &md5);
-    MD5Final((u_char *)randPool, &md5);
 /*  ppp_trace(LOG_INFO, "churnRand: -> 0\n"); */
 }
 
@@ -117,40 +118,41 @@ void avChurnRand(char *randData, u32_t randLen)
  *  randCount each time?  Probably there is a weakness but I wish that
  *  it was documented.
  */
-void avGenRand(char *buf, u32_t bufLen)
+void
+avGenRand(char *buf, u32_t bufLen)
 {
-    MD5_CTX md5;
+  MD5_CTX md5;
-    u_char tmp[16];
+  u_char tmp[16];
-    u32_t n;
+  u32_t n;
 
-    while (bufLen > 0) {
+  while (bufLen > 0) {
-        n = LWIP_MIN(bufLen, RANDPOOLSZ);
+    n = LWIP_MIN(bufLen, RANDPOOLSZ);
-        MD5Init(&md5);
+    MD5Init(&md5);
-        MD5Update(&md5, (u_char *)randPool, sizeof(randPool));
+    MD5Update(&md5, (u_char *)randPool, sizeof(randPool));
-        MD5Update(&md5, (u_char *)&randCount, sizeof(randCount));
+    MD5Update(&md5, (u_char *)&randCount, sizeof(randCount));
-        MD5Final(tmp, &md5);
+    MD5Final(tmp, &md5);
-        randCount++;
+    randCount++;
-        MEMCPY(buf, tmp, n);
+    MEMCPY(buf, tmp, n);
-        buf += n;
+    buf += n;
-        bufLen -= n;
+    bufLen -= n;
-    }
+  }
 }
 
 /*
  * Return a new random number.
  */
-u32_t avRandom()
+u32_t
+avRandom()
 {
-    u32_t newRand;
+  u32_t newRand;
 
-    avGenRand((char *)&newRand, sizeof(newRand));
+  avGenRand((char *)&newRand, sizeof(newRand));
 
-    return newRand;
+  return newRand;
 }
 
 #else /* MD5_SUPPORT */
 
-
 /*****************************/
 /*** LOCAL DATA STRUCTURES ***/
 /*****************************/
@@ -175,31 +177,32 @@ static u32_t avRandomSeed = 0;      /* Seed used for random number generation. *
  * operational.  Thus we call it again on the first random
  * event.
  */
-void avRandomInit()
+void
+avRandomInit()
 {
 #if 0
-    /* Get a pointer into the last 4 bytes of clockBuf. */
+  /* Get a pointer into the last 4 bytes of clockBuf. */
-    u32_t *lptr1 = (u32_t *)((char *)&clockBuf[3]);
+  u32_t *lptr1 = (u32_t *)((char *)&clockBuf[3]);
 
-    /*
+  /*
-     * Initialize our seed using the real-time clock, the idle
+   * Initialize our seed using the real-time clock, the idle
-     * counter, the millisecond timer, and the hardware timer
+   * counter, the millisecond timer, and the hardware timer
-     * tick counter.  The real-time clock and the hardware
+   * tick counter.  The real-time clock and the hardware
-     * tick counter are the best sources of randomness but
+   * tick counter are the best sources of randomness but
-     * since the tick counter is only 16 bit (and truncated
+   * since the tick counter is only 16 bit (and truncated
-     * at that), the idle counter and millisecond timer
+   * at that), the idle counter and millisecond timer
-     * (which may be small values) are added to help
+   * (which may be small values) are added to help
-     * randomize the lower 16 bits of the seed.
+   * randomize the lower 16 bits of the seed.
-     */
+   */
-    readClk();
+  readClk();
-    avRandomSeed += *(u32_t *)clockBuf + *lptr1 + OSIdleCtr
+  avRandomSeed += *(u32_t *)clockBuf + *lptr1 + OSIdleCtr
-             + ppp_mtime() + ((u32_t)TM1 << 16) + TM1;
+           + ppp_mtime() + ((u32_t)TM1 << 16) + TM1;
 #else
-    avRandomSeed += sys_jiffies(); /* XXX */
+  avRandomSeed += sys_jiffies(); /* XXX */
 #endif
 
-    /* Initialize the Borland random number generator. */
+  /* Initialize the Borland random number generator. */
-    srand((unsigned)avRandomSeed);
+  srand((unsigned)avRandomSeed);
 }
 
 /*
@@ -209,19 +212,20 @@ void avRandomInit()
  * value but we use the previous value to randomize the other 16
  * bits.
  */
-void avRandomize(void)
+void
+avRandomize(void)
 {
-    static u32_t last_jiffies;
+  static u32_t last_jiffies;
 
-    if (!avRandomized) {
+  if (!avRandomized) {
-        avRandomized = !0;
+    avRandomized = !0;
-        avRandomInit();
+    avRandomInit();
-        /* The initialization function also updates the seed. */
+    /* The initialization function also updates the seed. */
-    } else {
+  } else {
-/*        avRandomSeed += (avRandomSeed << 16) + TM1; */
+    /* avRandomSeed += (avRandomSeed << 16) + TM1; */
-    	avRandomSeed += (sys_jiffies() - last_jiffies); /* XXX */
+    avRandomSeed += (sys_jiffies() - last_jiffies); /* XXX */
-    }
+  }
-    last_jiffies = sys_jiffies();
+  last_jiffies = sys_jiffies();
 }
 
 /*
@@ -233,9 +237,10 @@ void avRandomize(void)
  * operator or network events in which case it will be pseudo random
  * seeded by the real time clock.
  */
-u32_t avRandom()
+u32_t
+avRandom()
 {
-    return ((((u32_t)rand() << 16) + rand()) + avRandomSeed);
+  return ((((u32_t)rand() << 16) + rand()) + avRandomSeed);
 }
 
 #endif /* MD5_SUPPORT */

src/netif/ppp/randm.h

@@ -28,7 +28,7 @@
 * 03-01-01 Marc Boucher <marc@mbsi.ca>
 *   Ported to lwIP.
 * 98-05-29 Guy Lancaster <glanca@gesn.com>, Global Election Systems Inc.
-*	Extracted from avos.
+* Extracted from avos.
 *****************************************************************************/
 
 #ifndef RANDM_H
@@ -44,11 +44,11 @@ void avRandomInit(void);
 
 /*
  * Churn the randomness pool on a random event.  Call this early and often
- *	on random and semi-random system events to build randomness in time for
+ * on random and semi-random system events to build randomness in time for
- *	usage.  For randomly timed events, pass a null pointer and a zero length
+ * usage.  For randomly timed events, pass a null pointer and a zero length
- *	and this will use the system timer and other sources to add randomness.
+ * and this will use the system timer and other sources to add randomness.
- *	If new random data is available, pass a pointer to that and it will be
+ * If new random data is available, pass a pointer to that and it will be
- *	included.
+ * included.
  */
 void avChurnRand(char *randData, u32_t randLen);
 
@@ -57,18 +57,18 @@ void avChurnRand(char *randData, u32_t randLen);
  * such as user operations and network traffic.
  */
 #if MD5_SUPPORT
-#define avRandomize()	avChurnRand(NULL, 0)
+#define avRandomize() avChurnRand(NULL, 0)
 #else  /* MD5_SUPPORT */
 void avRandomize(void);
 #endif /* MD5_SUPPORT */
 
 /*
  * Use the random pool to generate random data.  This degrades to pseudo
- *	random when used faster than randomness is supplied using churnRand().
+ * random when used faster than randomness is supplied using churnRand().
- *	Thus it's important to make sure that the results of this are not
+ * Thus it's important to make sure that the results of this are not
- *	published directly because one could predict the next result to at
+ * published directly because one could predict the next result to at
- *	least some degree.  Also, it's important to get a good seed before
+ * least some degree.  Also, it's important to get a good seed before
- *	the first use.
+ * the first use.
  */
 void avGenRand(char *buf, u32_t bufLen);