lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-07-29 11:41:21 +03:00
Code Activity

Remove redundant nested function b64_from_24bit

Browse Source 
Move multiple definitions of the nested function b64_from_24bit into a
single function __b64_from_24bit.
This commit is contained in:
Konstantin Serebryany
2014-06-03 16:39:08 +05:30
committed by Siddhesh Poyarekar
parent d936d379eb
commit 8747cd034a
6 changed files with 121 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,3 +1,18 @@
2014-06-03 Kostya Serebryany <konstantin.s.serebryany@gmail.com>
* crypt/crypt-private.h: Include ufc-crypt.h.
(__b64_from_24bit): Declare extern.
* crypt/crypt_util.c(__b64_from_24bit): New function.
(b64t): New static const variable.
* crypt/md5-crypt.c (b64_from_24bit): Remove function.
(b64t): Remove variable.
(__md5_crypt_r): Replace b64_from_24bit with __b64_from_24bit.
* crypt/sha256-crypt.c: Include crypt-private.h.
(b64t): Remove variable.
(__sha256_crypt_r): Remove b64_from_24bit and replace
with __b64_from_24bit.
* crypt/sha512-crypt.c: Likewise.
2014-06-02 Roland McGrath <roland@hack.frob.com> 2014-06-02 Roland McGrath <roland@hack.frob.com>
* nptl/sysdeps/unix/sysv/linux/sh/vfork.S: Moved ... * nptl/sysdeps/unix/sysv/linux/sh/vfork.S: Moved ...

7
crypt/crypt-private.h
View File

@ -28,6 +28,9 @@
#include <features.h> #include <features.h>
#include <stdbool.h> #include <stdbool.h>
#include "ufc-crypt.h"
#include "crypt.h"
/* crypt.c */ /* crypt.c */
extern void _ufc_doit_r (ufc_long itr, struct crypt_data * __restrict __data, extern void _ufc_doit_r (ufc_long itr, struct crypt_data * __restrict __data,
ufc_long *res); ufc_long *res);
@ -57,4 +60,8 @@ extern char *__crypt_r (const char *__key, const char *__salt,
struct crypt_data * __restrict __data); struct crypt_data * __restrict __data);
extern char *fcrypt (const char *key, const char *salt); extern char *fcrypt (const char *key, const char *salt);
extern void __b64_from_24bit (char **cp, int *buflen,
unsigned int b2, unsigned int b1, unsigned int b0,
int n);
#endif /* crypt-private.h */ #endif /* crypt-private.h */

18
crypt/crypt_util.c
View File

@ -253,6 +253,10 @@ static ufc_long eperm32tab[4][256][2];
*/ */
static ufc_long efp[16][64][2]; static ufc_long efp[16][64][2];
/* Table with characters for base64 transformation. */
static const char b64t[64] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* /*
* For use by the old, non-reentrant routines * For use by the old, non-reentrant routines
* (crypt/encrypt/setkey) * (crypt/encrypt/setkey)
@ -956,3 +960,17 @@ setkey(__key)
{ {
__setkey_r(__key, &_ufc_foobar); __setkey_r(__key, &_ufc_foobar);
} }
void
__b64_from_24bit (char **cp, int *buflen,
unsigned int b2, unsigned int b1, unsigned int b0,
int n)
{
unsigned int w = (b2 << 16) | (b1 << 8) | b0;
while (n-- > 0 && (*buflen) > 0)
{
*(*cp)++ = b64t[w & 0x3f];
--(*buflen);
w >>= 6;
}
}

31
crypt/md5-crypt.c
View File

@ -25,6 +25,7 @@
#include <sys/param.h> #include <sys/param.h>
#include "md5.h" #include "md5.h"
#include "crypt-private.h"
#ifdef USE_NSS #ifdef USE_NSS
@ -78,30 +79,12 @@ typedef int PRBool;
encryption implementations. */ encryption implementations. */
static const char md5_salt_prefix[] = "$1$"; static const char md5_salt_prefix[] = "$1$";
/* Table with characters for base64 transformation. */
static const char b64t[64] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* Prototypes for local functions. */ /* Prototypes for local functions. */
extern char *__md5_crypt_r (const char *key, const char *salt, extern char *__md5_crypt_r (const char *key, const char *salt,
char *buffer, int buflen); char *buffer, int buflen);
extern char *__md5_crypt (const char *key, const char *salt); extern char *__md5_crypt (const char *key, const char *salt);
static void
b64_from_24bit (char **cp, int *buflen,
unsigned int b2, unsigned int b1, unsigned int b0,
int n)
{
unsigned int w = (b2 << 16) | (b1 << 8) | b0;
while (n-- > 0 && *buflen > 0)
{
*(*cp)++ = b64t[w & 0x3f];
--*buflen;
w >>= 6;
}
}
/* This entry point is equivalent to the `crypt' function in Unix /* This entry point is equivalent to the `crypt' function in Unix
libcs. */ libcs. */
@ -282,17 +265,17 @@ __md5_crypt_r (key, salt, buffer, buflen)
--buflen; --buflen;
} }
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
alt_result[0], alt_result[6], alt_result[12], 4); alt_result[0], alt_result[6], alt_result[12], 4);
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
alt_result[1], alt_result[7], alt_result[13], 4); alt_result[1], alt_result[7], alt_result[13], 4);
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
alt_result[2], alt_result[8], alt_result[14], 4); alt_result[2], alt_result[8], alt_result[14], 4);
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
alt_result[3], alt_result[9], alt_result[15], 4); alt_result[3], alt_result[9], alt_result[15], 4);
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
alt_result[4], alt_result[10], alt_result[5], 4); alt_result[4], alt_result[10], alt_result[5], 4);
b64_from_24bit (&cp, &buflen, __b64_from_24bit (&cp, &buflen,
0, 0, alt_result[11], 2); 0, 0, alt_result[11], 2);
if (buflen <= 0) if (buflen <= 0)
{ {

50
crypt/sha256-crypt.c
View File

@ -26,6 +26,7 @@
#include <sys/param.h> #include <sys/param.h>
#include "sha256.h" #include "sha256.h"
#include "crypt-private.h"
#ifdef USE_NSS #ifdef USE_NSS
@ -90,10 +91,6 @@ static const char sha256_rounds_prefix[] = "rounds=";
/* Maximum number of rounds. */ /* Maximum number of rounds. */
#define ROUNDS_MAX 999999999 #define ROUNDS_MAX 999999999
/* Table with characters for base64 transformation. */
static const char b64t[64] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* Prototypes for local functions. */ /* Prototypes for local functions. */
extern char *__sha256_crypt_r (const char *key, const char *salt, extern char *__sha256_crypt_r (const char *key, const char *salt,
@ -341,29 +338,28 @@ __sha256_crypt_r (key, salt, buffer, buflen)
--buflen; --buflen;
} }
void b64_from_24bit (unsigned int b2, unsigned int b1, unsigned int b0, __b64_from_24bit (&cp, &buflen,
int n) alt_result[0], alt_result[10], alt_result[20], 4);
{ __b64_from_24bit (&cp, &buflen,
unsigned int w = (b2 << 16) | (b1 << 8) | b0; alt_result[21], alt_result[1], alt_result[11], 4);
while (n-- > 0 && buflen > 0) __b64_from_24bit (&cp, &buflen,
{ alt_result[12], alt_result[22], alt_result[2], 4);
*cp++ = b64t[w & 0x3f]; __b64_from_24bit (&cp, &buflen,
--buflen; alt_result[3], alt_result[13], alt_result[23], 4);
w >>= 6; __b64_from_24bit (&cp, &buflen,
} alt_result[24], alt_result[4], alt_result[14], 4);
} __b64_from_24bit (&cp, &buflen,
alt_result[15], alt_result[25], alt_result[5], 4);
b64_from_24bit (alt_result[0], alt_result[10], alt_result[20], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[21], alt_result[1], alt_result[11], 4); alt_result[6], alt_result[16], alt_result[26], 4);
b64_from_24bit (alt_result[12], alt_result[22], alt_result[2], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[3], alt_result[13], alt_result[23], 4); alt_result[27], alt_result[7], alt_result[17], 4);
b64_from_24bit (alt_result[24], alt_result[4], alt_result[14], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[15], alt_result[25], alt_result[5], 4); alt_result[18], alt_result[28], alt_result[8], 4);
b64_from_24bit (alt_result[6], alt_result[16], alt_result[26], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[27], alt_result[7], alt_result[17], 4); alt_result[9], alt_result[19], alt_result[29], 4);
b64_from_24bit (alt_result[18], alt_result[28], alt_result[8], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[9], alt_result[19], alt_result[29], 4); 0, alt_result[31], alt_result[30], 3);
b64_from_24bit (0, alt_result[31], alt_result[30], 3);
if (buflen <= 0) if (buflen <= 0)
{ {
__set_errno (ERANGE); __set_errno (ERANGE);

83
crypt/sha512-crypt.c
View File

@ -26,6 +26,7 @@
#include <sys/param.h> #include <sys/param.h>
#include "sha512.h" #include "sha512.h"
#include "crypt-private.h"
#ifdef USE_NSS #ifdef USE_NSS
@ -90,10 +91,6 @@ static const char sha512_rounds_prefix[] = "rounds=";
/* Maximum number of rounds. */ /* Maximum number of rounds. */
#define ROUNDS_MAX 999999999 #define ROUNDS_MAX 999999999
/* Table with characters for base64 transformation. */
static const char b64t[64] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* Prototypes for local functions. */ /* Prototypes for local functions. */
extern char *__sha512_crypt_r (const char *key, const char *salt, extern char *__sha512_crypt_r (const char *key, const char *salt,
@ -340,40 +337,50 @@ __sha512_crypt_r (key, salt, buffer, buflen)
--buflen; --buflen;
} }
void b64_from_24bit (unsigned int b2, unsigned int b1, unsigned int b0, __b64_from_24bit (&cp, &buflen,
int n) alt_result[0], alt_result[21], alt_result[42], 4);
{ __b64_from_24bit (&cp, &buflen,
unsigned int w = (b2 << 16) | (b1 << 8) | b0; alt_result[22], alt_result[43], alt_result[1], 4);
while (n-- > 0 && buflen > 0) __b64_from_24bit (&cp, &buflen,
{ alt_result[44], alt_result[2], alt_result[23], 4);
*cp++ = b64t[w & 0x3f]; __b64_from_24bit (&cp, &buflen,
--buflen; alt_result[3], alt_result[24], alt_result[45], 4);
w >>= 6; __b64_from_24bit (&cp, &buflen,
} alt_result[25], alt_result[46], alt_result[4], 4);
} __b64_from_24bit (&cp, &buflen,
alt_result[47], alt_result[5], alt_result[26], 4);
b64_from_24bit (alt_result[0], alt_result[21], alt_result[42], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[22], alt_result[43], alt_result[1], 4); alt_result[6], alt_result[27], alt_result[48], 4);
b64_from_24bit (alt_result[44], alt_result[2], alt_result[23], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[3], alt_result[24], alt_result[45], 4); alt_result[28], alt_result[49], alt_result[7], 4);
b64_from_24bit (alt_result[25], alt_result[46], alt_result[4], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[47], alt_result[5], alt_result[26], 4); alt_result[50], alt_result[8], alt_result[29], 4);
b64_from_24bit (alt_result[6], alt_result[27], alt_result[48], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[28], alt_result[49], alt_result[7], 4); alt_result[9], alt_result[30], alt_result[51], 4);
b64_from_24bit (alt_result[50], alt_result[8], alt_result[29], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[9], alt_result[30], alt_result[51], 4); alt_result[31], alt_result[52], alt_result[10], 4);
b64_from_24bit (alt_result[31], alt_result[52], alt_result[10], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[53], alt_result[11], alt_result[32], 4); alt_result[53], alt_result[11], alt_result[32], 4);
b64_from_24bit (alt_result[12], alt_result[33], alt_result[54], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[34], alt_result[55], alt_result[13], 4); alt_result[12], alt_result[33], alt_result[54], 4);
b64_from_24bit (alt_result[56], alt_result[14], alt_result[35], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[15], alt_result[36], alt_result[57], 4); alt_result[34], alt_result[55], alt_result[13], 4);
b64_from_24bit (alt_result[37], alt_result[58], alt_result[16], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[59], alt_result[17], alt_result[38], 4); alt_result[56], alt_result[14], alt_result[35], 4);
b64_from_24bit (alt_result[18], alt_result[39], alt_result[60], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (alt_result[40], alt_result[61], alt_result[19], 4); alt_result[15], alt_result[36], alt_result[57], 4);
b64_from_24bit (alt_result[62], alt_result[20], alt_result[41], 4); __b64_from_24bit (&cp, &buflen,
b64_from_24bit (0, 0, alt_result[63], 2); alt_result[37], alt_result[58], alt_result[16], 4);
__b64_from_24bit (&cp, &buflen,
alt_result[59], alt_result[17], alt_result[38], 4);
__b64_from_24bit (&cp, &buflen,
alt_result[18], alt_result[39], alt_result[60], 4);
__b64_from_24bit (&cp, &buflen,
alt_result[40], alt_result[61], alt_result[19], 4);
__b64_from_24bit (&cp, &buflen,
alt_result[62], alt_result[20], alt_result[41], 4);
__b64_from_24bit (&cp, &buflen,
0, 0, alt_result[63], 2);
if (buflen <= 0) if (buflen <= 0)
{ {