fira959
diff --git a/‎ChangeLog
+743 b/‎ChangeLog
+743
diff --git a/‎crypt/cert.c
+4-5 b/‎crypt/cert.c
+4-5
diff --git a/‎crypt/crypt-entry.c
+2-6 b/‎crypt/crypt-entry.c
+2-6
diff --git a/‎crypt/crypt_util.c
+12-34 b/‎crypt/crypt_util.c
+12-34
diff --git a/‎crypt/md5.c
+6-19 b/‎crypt/md5.c
+6-19
diff --git a/‎crypt/sha256.c
+3-9 b/‎crypt/sha256.c
+3-9
diff --git a/‎crypt/sha512.c
+3-9 b/‎crypt/sha512.c
+3-9
diff --git a/‎ctype/isctype.c
+1-3 b/‎ctype/isctype.c
+1-3
diff --git a/‎debug/backtrace.c
+1-3 b/‎debug/backtrace.c
+1-3
diff --git a/‎debug/backtracesymsfd.c
+1-4 b/‎debug/backtracesymsfd.c
+1-4
diff --git a/‎debug/fgets_chk.c
+1-5 b/‎debug/fgets_chk.c
+1-5
diff --git a/‎debug/fgets_u_chk.c
+1-5 b/‎debug/fgets_u_chk.c
+1-5
diff --git a/‎debug/memcpy_chk.c
+1-5 b/‎debug/memcpy_chk.c
+1-5
@@ -17,7 +17,8 @@ void get8 (char *cp);
 void put8 (char *cp);
 void good_bye (void) __attribute__ ((noreturn));
 
-void good_bye ()
+void
+good_bye (void)
 {
   if(totfails == 0) {
     printf("Passed DES validation suite\n");
@@ -80,8 +81,7 @@ main(argc, argv)
 	good_bye();
 }
 void
-get8(cp)
-char *cp;
+get8 (char *cp)
 {
 	int i,j,t;
 
@@ -95,8 +95,7 @@ char *cp;
 	}
 }
 void
-put8(cp)
-char *cp;
+put8 (char *cp)
 {
 	int i,j,t;
 
 
@@ -148,9 +148,7 @@ __crypt_r (key, salt, data)
 weak_alias (__crypt_r, crypt_r)
 
 char *
-crypt (key, salt)
-     const char *key;
-     const char *salt;
+crypt (const char *key, const char *salt)
 {
 #ifdef _LIBC
   /* Try to find out whether we have to use MD5 encryption replacement.  */
@@ -180,9 +178,7 @@ crypt (key, salt)
 weak_alias (crypt, fcrypt)
 #else
 char *
-__fcrypt (key, salt)
-     const char *key;
-     const char *salt;
+__fcrypt (const char *key, const char *salt)
 {
   return crypt (key, salt);
 }
 
@@ -261,9 +261,7 @@ __libc_lock_define_initialized (static, _ufc_tables_lock)
 #ifdef DEBUG
 
 void
-_ufc_prbits(a, n)
-     ufc_long *a;
-     int n;
+_ufc_prbits (ufc_long *a, int n)
 {
   ufc_long i, j, t, tmp;
   n /= 8;
@@ -279,9 +277,7 @@ _ufc_prbits(a, n)
 }
 
 static void
-_ufc_set_bits(v, b)
-     ufc_long v;
-     ufc_long *b;
+_ufc_set_bits (ufc_long v, ufc_long *b)
 {
   ufc_long i;
   *b = 0;
@@ -301,9 +297,7 @@ _ufc_set_bits(v, b)
  */
 
 void
-_ufc_clearmem(start, cnt)
-     char *start;
-     int cnt;
+_ufc_clearmem (char *start, int cnt)
 {
   while(cnt--)
     *start++ = '\0';
@@ -332,8 +326,7 @@ _ufc_copymem(from, to, cnt)
  */
 
 void
-__init_des_r(__data)
-     struct crypt_data * __restrict __data;
+__init_des_r (struct crypt_data * __restrict __data)
 {
   int comes_from_bit;
   int bit, sg;
@@ -558,9 +551,7 @@ __init_des (void)
 
 #ifdef _UFC_32_
 STATIC void
-shuffle_sb(k, saltbits)
-     long32 *k;
-     ufc_long saltbits;
+shuffle_sb (long32 *k, ufc_long saltbits)
 {
   ufc_long j;
   long32 x;
@@ -574,9 +565,7 @@ shuffle_sb(k, saltbits)
 
 #ifdef _UFC_64_
 STATIC void
-shuffle_sb(k, saltbits)
-     long64 *k;
-     ufc_long saltbits;
+shuffle_sb (long64 *k, ufc_long saltbits)
 {
   ufc_long j;
   long64 x;
@@ -614,9 +603,7 @@ bad_for_salt (char c)
  */
 
 bool
-_ufc_setup_salt_r(s, __data)
-     const char *s;
-     struct crypt_data * __restrict __data;
+_ufc_setup_salt_r (const char *s, struct crypt_data * __restrict __data)
 {
   ufc_long i, j, saltbits;
   char s0, s1;
@@ -675,9 +662,7 @@ _ufc_setup_salt_r(s, __data)
 }
 
 void
-_ufc_mk_keytab_r(key, __data)
-     const char *key;
-     struct crypt_data * __restrict __data;
+_ufc_mk_keytab_r (const char *key, struct crypt_data * __restrict __data)
 {
   ufc_long v1, v2, *k1;
   int i;
@@ -735,9 +720,7 @@ _ufc_mk_keytab_r(key, __data)
  */
 
 void
-_ufc_dofinalperm_r(res, __data)
-     ufc_long *res;
-     struct crypt_data * __restrict __data;
+_ufc_dofinalperm_r (ufc_long *res, struct crypt_data * __restrict __data)
 {
   ufc_long v1, v2, x;
   ufc_long l1,l2,r1,r2;
@@ -910,9 +893,7 @@ __encrypt_r(__block, __edflag, __data)
 weak_alias (__encrypt_r, encrypt_r)
 
 void
-encrypt(__block, __edflag)
-     char *__block;
-     int __edflag;
+encrypt (char *__block, int __edflag)
 {
   __encrypt_r(__block, __edflag, &_ufc_foobar);
 }
@@ -924,9 +905,7 @@ encrypt(__block, __edflag)
  */
 
 void
-__setkey_r(__key, __data)
-     const char *__key;
-     struct crypt_data * __restrict __data;
+__setkey_r (const char *__key, struct crypt_data * __restrict __data)
 {
   int i,j;
   unsigned char c;
@@ -944,8 +923,7 @@ __setkey_r(__key, __data)
 weak_alias (__setkey_r, setkey_r)
 
 void
-setkey(__key)
-     const char *__key;
+setkey (const char *__key)
 {
   __setkey_r(__key, &_ufc_foobar);
 }
 
@@ -67,8 +67,7 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
 void
-md5_init_ctx (ctx)
-     struct md5_ctx *ctx;
+md5_init_ctx (struct md5_ctx *ctx)
 {
   ctx->A = 0x67452301;
   ctx->B = 0xefcdab89;
@@ -85,9 +84,7 @@ md5_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-md5_read_ctx (ctx, resbuf)
-     const struct md5_ctx *ctx;
-     void *resbuf;
+md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 {
   ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
   ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
@@ -103,9 +100,7 @@ md5_read_ctx (ctx, resbuf)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-md5_finish_ctx (ctx, resbuf)
-     struct md5_ctx *ctx;
-     void *resbuf;
+md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   md5_uint32 bytes = ctx->buflen;
@@ -134,9 +129,7 @@ md5_finish_ctx (ctx, resbuf)
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
 int
-md5_stream (stream, resblock)
-     FILE *stream;
-     void *resblock;
+md5_stream (FILE *stream, void *resblock)
 {
   /* Important: BLOCKSIZE must be a multiple of 64.  */
 #define BLOCKSIZE 4096
@@ -191,10 +184,7 @@ md5_stream (stream, resblock)
    output yields to the wanted ASCII representation of the message
    digest.  */
 void *
-md5_buffer (buffer, len, resblock)
-     const char *buffer;
-     size_t len;
-     void *resblock;
+md5_buffer (const char *buffer, size_t len, void *resblock)
 {
   struct md5_ctx ctx;
 
@@ -210,10 +200,7 @@ md5_buffer (buffer, len, resblock)
 
 
 void
-md5_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct md5_ctx *ctx;
+md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
 
@@ -87,8 +87,7 @@ sha256_process_block (const void *, size_t, struct sha256_ctx *);
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.2)  */
 void
-__sha256_init_ctx (ctx)
-     struct sha256_ctx *ctx;
+__sha256_init_ctx (struct sha256_ctx *ctx)
 {
   ctx->H[0] = 0x6a09e667;
   ctx->H[1] = 0xbb67ae85;
@@ -110,9 +109,7 @@ __sha256_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-__sha256_finish_ctx (ctx, resbuf)
-     struct sha256_ctx *ctx;
-     void *resbuf;
+__sha256_finish_ctx (struct sha256_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint32_t bytes = ctx->buflen;
@@ -145,10 +142,7 @@ __sha256_finish_ctx (ctx, resbuf)
 
 
 void
-__sha256_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct sha256_ctx *ctx;
+__sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
 
@@ -107,8 +107,7 @@ sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx);
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.3)  */
 void
-__sha512_init_ctx (ctx)
-     struct sha512_ctx *ctx;
+__sha512_init_ctx (struct sha512_ctx *ctx)
 {
   ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
   ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
@@ -130,9 +129,7 @@ __sha512_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-__sha512_finish_ctx (ctx, resbuf)
-     struct sha512_ctx *ctx;
-     void *resbuf;
+__sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint64_t bytes = ctx->buflen;
@@ -167,10 +164,7 @@ __sha512_finish_ctx (ctx, resbuf)
 
 
 void
-__sha512_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct sha512_ctx *ctx;
+__sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
 
@@ -20,9 +20,7 @@
 #undef __isctype
 
 int
-__isctype (ch, mask)
-     int ch;
-     int mask;
+__isctype (int ch, int mask)
 {
   return (((uint16_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_CLASS) + 128)
 	  [(int) (ch)] & mask);
 
@@ -58,9 +58,7 @@
 #endif
 
 int
-__backtrace (array, size)
-     void **array;
-     int size;
+__backtrace (void **array, int size)
 {
   struct layout *current;
   void *top_frame;
 
@@ -33,10 +33,7 @@
 
 
 void
-__backtrace_symbols_fd (array, size, fd)
-     void *const *array;
-     int size;
-     int fd;
+__backtrace_symbols_fd (void *const *array, int size, int fd)
 {
   struct iovec iov[9];
   int cnt;
 
@@ -29,11 +29,7 @@
 #include <sys/param.h>
 
 char *
-__fgets_chk (buf, size, n, fp)
-     char *buf;
-     size_t size;
-     int n;
-     _IO_FILE *fp;
+__fgets_chk (char *buf, size_t size, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
 
@@ -29,11 +29,7 @@
 #include <sys/param.h>
 
 char *
-__fgets_unlocked_chk (buf, size, n, fp)
-     char *buf;
-     size_t size;
-     int n;
-     _IO_FILE *fp;
+__fgets_unlocked_chk (char *buf, size_t size, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
 
@@ -22,11 +22,7 @@
 #include <memcopy.h>
 
 void *
-__memcpy_chk (dstpp, srcpp, len, dstlen)
-     void *dstpp;
-     const void *srcpp;
-     size_t len;
-     size_t dstlen;
+__memcpy_chk (void *dstpp, const void *srcpp, size_t len, size_t dstlen)
 {
   if (__glibc_unlikely (dstlen < len))
     __chk_fail ();
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,8 @@ void get8 (char *cp);`
`17`	`17`	`void put8 (char *cp);`
`18`	`18`	`void good_bye (void) __attribute__ ((noreturn));`
`19`	`19`
`20`		`-void good_bye ()`
	`20`	`+void`
	`21`	`+good_bye (void)`
`21`	`22`	`{`
`22`	`23`	`if(totfails == 0) {`
`23`	`24`	`printf("Passed DES validation suite\n");`
`@@ -80,8 +81,7 @@ main(argc, argv)`
`80`	`81`	`good_bye();`
`81`	`82`	`}`
`82`	`83`	`void`
`83`		`-get8(cp)`
`84`		`-char *cp;`
	`84`	`+get8 (char *cp)`
`85`	`85`	`{`
`86`	`86`	`int i,j,t;`
`87`	`87`
`@@ -95,8 +95,7 @@ char *cp;`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`	`void`
`98`		`-put8(cp)`
`99`		`-char *cp;`
	`98`	`+put8 (char *cp)`
`100`	`99`	`{`
`101`	`100`	`int i,j,t;`
`102`	`101`