generic-library/libbsd
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libbsd/libbsd.git synced 2025-02-15 19:05:57 +01:00
Code Issues Projects Releases Wiki Activity

Use stdint integer types instead of BSD legacy ones

Browse Source
This commit is contained in:
Guillem Jover 2014-08-12 12:32:34 +02:00
parent 6378351169
commit 02b55488c5
7 changed files with 44 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/bsd/md5.h
View File

@ -15,26 +15,28 @@
#ifndef _MD5_H_ #ifndef _MD5_H_
#define _MD5_H_ #define _MD5_H_
#include <stdint.h>
#define MD5_BLOCK_LENGTH 64 #define MD5_BLOCK_LENGTH 64
#define MD5_DIGEST_LENGTH 16 #define MD5_DIGEST_LENGTH 16
#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1) #define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1)
typedef struct MD5Context { typedef struct MD5Context {
u_int32_t state[4]; /* state */ uint32_t state[4]; /* state */
u_int64_t count; /* number of bits, mod 2^64 */ uint64_t count; /* number of bits, mod 2^64 */
u_int8_t buffer[MD5_BLOCK_LENGTH]; /* input buffer */ uint8_t buffer[MD5_BLOCK_LENGTH]; /* input buffer */
} MD5_CTX; } MD5_CTX;
#include <sys/cdefs.h> #include <sys/cdefs.h>
__BEGIN_DECLS __BEGIN_DECLS
void MD5Init(MD5_CTX *); void MD5Init(MD5_CTX *);
void MD5Update(MD5_CTX *, const u_int8_t *, size_t) void MD5Update(MD5_CTX *, const uint8_t *, size_t)
__attribute__((__bounded__(__string__,2,3))); __attribute__((__bounded__(__string__,2,3)));
void MD5Pad(MD5_CTX *); void MD5Pad(MD5_CTX *);
void MD5Final(u_int8_t [MD5_DIGEST_LENGTH], MD5_CTX *) void MD5Final(uint8_t [MD5_DIGEST_LENGTH], MD5_CTX *)
__attribute__((__bounded__(__minbytes__,1,MD5_DIGEST_LENGTH))); __attribute__((__bounded__(__minbytes__,1,MD5_DIGEST_LENGTH)));
void MD5Transform(u_int32_t [4], const u_int8_t [MD5_BLOCK_LENGTH]) void MD5Transform(uint32_t [4], const uint8_t [MD5_BLOCK_LENGTH])
__attribute__((__bounded__(__minbytes__,1,4))) __attribute__((__bounded__(__minbytes__,1,4)))
__attribute__((__bounded__(__minbytes__,2,MD5_BLOCK_LENGTH))); __attribute__((__bounded__(__minbytes__,2,MD5_BLOCK_LENGTH)));
char *MD5End(MD5_CTX *, char *) char *MD5End(MD5_CTX *, char *)
@ -43,7 +45,7 @@ char *MD5File(const char *, char *)
__attribute__((__bounded__(__minbytes__,2,MD5_DIGEST_STRING_LENGTH))); __attribute__((__bounded__(__minbytes__,2,MD5_DIGEST_STRING_LENGTH)));
char *MD5FileChunk(const char *, char *, off_t, off_t) char *MD5FileChunk(const char *, char *, off_t, off_t)
__attribute__((__bounded__(__minbytes__,2,MD5_DIGEST_STRING_LENGTH))); __attribute__((__bounded__(__minbytes__,2,MD5_DIGEST_STRING_LENGTH)));
char *MD5Data(const u_int8_t *, size_t, char *) char *MD5Data(const uint8_t *, size_t, char *)
__attribute__((__bounded__(__string__,1,2))) __attribute__((__bounded__(__string__,1,2)))
__attribute__((__bounded__(__minbytes__,3,MD5_DIGEST_STRING_LENGTH))); __attribute__((__bounded__(__minbytes__,3,MD5_DIGEST_STRING_LENGTH)));
__END_DECLS __END_DECLS

4
include/bsd/stdlib.h
View File

@ -47,11 +47,11 @@
#include <stdint.h> #include <stdint.h>
__BEGIN_DECLS __BEGIN_DECLS
u_int32_t arc4random(void); uint32_t arc4random(void);
void arc4random_stir(void); void arc4random_stir(void);
void arc4random_addrandom(u_char *dat, int datlen); void arc4random_addrandom(u_char *dat, int datlen);
void arc4random_buf(void *_buf, size_t n); void arc4random_buf(void *_buf, size_t n);
u_int32_t arc4random_uniform(u_int32_t upper_bound); uint32_t arc4random_uniform(uint32_t upper_bound);
int dehumanize_number(const char *str, int64_t *size); int dehumanize_number(const char *str, int64_t *size);

6
man/arc4random.3
View File

@ -45,12 +45,12 @@
.Lb libbsd .Lb libbsd
.Sh SYNOPSIS .Sh SYNOPSIS
.In bsd/stdlib.h .In bsd/stdlib.h
.Ft u_int32_t .Ft uint32_t
.Fn arc4random "void" .Fn arc4random "void"
.Ft void .Ft void
.Fn arc4random_buf "void *buf" "size_t nbytes" .Fn arc4random_buf "void *buf" "size_t nbytes"
.Ft u_int32_t .Ft uint32_t
.Fn arc4random_uniform "u_int32_t upper_bound" .Fn arc4random_uniform "uint32_t upper_bound"
.Ft void .Ft void
.Fn arc4random_stir "void" .Fn arc4random_stir "void"
.Ft void .Ft void

8
man/mdX.3bsd
View File

@ -32,13 +32,13 @@
.Ft void .Ft void
.Fn MDXInit "MDX_CTX *context" .Fn MDXInit "MDX_CTX *context"
.Ft void .Ft void
.Fn MDXUpdate "MDX_CTX *context" "const u_int8_t *data" "size_t len" .Fn MDXUpdate "MDX_CTX *context" "const uint8_t *data" "size_t len"
.Ft void .Ft void
.Fn MDXPad "MDX_CTX *context" .Fn MDXPad "MDX_CTX *context"
.Ft void .Ft void
.Fn MDXFinal "u_int8_t digest[MDX_DIGEST_LENGTH]" "MDX_CTX *context" .Fn MDXFinal "uint8_t digest[MDX_DIGEST_LENGTH]" "MDX_CTX *context"
.Ft void .Ft void
.Fn MDXTransform "u_int32_t state[4]" "u_int8_t block[MDX_BLOCK_LENGTH]" .Fn MDXTransform "uint32_t state[4]" "uint8_t block[MDX_BLOCK_LENGTH]"
.Ft "char *" .Ft "char *"
.Fn MDXEnd "MDX_CTX *context" "char *buf" .Fn MDXEnd "MDX_CTX *context" "char *buf"
.Ft "char *" .Ft "char *"
@ -46,7 +46,7 @@
.Ft "char *" .Ft "char *"
.Fn MDXFileChunk "const char *filename" "char *buf" "off_t offset" "off_t length" .Fn MDXFileChunk "const char *filename" "char *buf" "off_t offset" "off_t length"
.Ft "char *" .Ft "char *"
.Fn MDXData "const u_int8_t *data" "size_t len" "char *buf" .Fn MDXData "const uint8_t *data" "size_t len" "char *buf"
.Sh DESCRIPTION .Sh DESCRIPTION
The MDX functions calculate a 128-bit cryptographic checksum (digest) The MDX functions calculate a 128-bit cryptographic checksum (digest)
for any number of input bytes. for any number of input bytes.

30
src/arc4random.c
View File

@ -43,9 +43,9 @@ __FBSDID("$FreeBSD$");
#include <pthread.h> #include <pthread.h>
struct arc4_stream { struct arc4_stream {
u_int8_t i; uint8_t i;
u_int8_t j; uint8_t j;
u_int8_t s[256]; uint8_t s[256];
}; };
#define RANDOMDEV "/dev/urandom" #define RANDOMDEV "/dev/urandom"
@ -65,7 +65,7 @@ static int rs_initialized;
static int rs_stired; static int rs_stired;
static int arc4_count; static int arc4_count;
static inline u_int8_t arc4_getbyte(void); static inline uint8_t arc4_getbyte(void);
static void arc4_stir(void); static void arc4_stir(void);
static inline void static inline void
@ -83,7 +83,7 @@ static inline void
arc4_addrandom(u_char *dat, int datlen) arc4_addrandom(u_char *dat, int datlen)
{ {
int n; int n;
u_int8_t si; uint8_t si;
rs.i--; rs.i--;
for (n = 0; n < 256; n++) { for (n = 0; n < 256; n++) {
@ -103,7 +103,7 @@ arc4_stir(void)
struct { struct {
struct timeval tv; struct timeval tv;
pid_t pid; pid_t pid;
u_int8_t rnd[KEYSIZE]; uint8_t rnd[KEYSIZE];
} rdat; } rdat;
fd = open(RANDOMDEV, O_RDONLY, 0); fd = open(RANDOMDEV, O_RDONLY, 0);
@ -133,10 +133,10 @@ arc4_stir(void)
arc4_count = 1600000; arc4_count = 1600000;
} }
static inline u_int8_t static inline uint8_t
arc4_getbyte(void) arc4_getbyte(void)
{ {
u_int8_t si, sj; uint8_t si, sj;
rs.i = (rs.i + 1); rs.i = (rs.i + 1);
si = rs.s[rs.i]; si = rs.s[rs.i];
@ -148,10 +148,10 @@ arc4_getbyte(void)
return (rs.s[(si + sj) & 0xff]); return (rs.s[(si + sj) & 0xff]);
} }
static inline u_int32_t static inline uint32_t
arc4_getword(void) arc4_getword(void)
{ {
u_int32_t val; uint32_t val;
val = arc4_getbyte() << 24; val = arc4_getbyte() << 24;
val |= arc4_getbyte() << 16; val |= arc4_getbyte() << 16;
@ -199,10 +199,10 @@ arc4random_addrandom(u_char *dat, int datlen)
THREAD_UNLOCK(); THREAD_UNLOCK();
} }
u_int32_t uint32_t
arc4random(void) arc4random(void)
{ {
u_int32_t rnd; uint32_t rnd;
THREAD_LOCK(); THREAD_LOCK();
arc4_check_init(); arc4_check_init();
@ -239,10 +239,10 @@ arc4random_buf(void *_buf, size_t n)
* [2**32 % upper_bound, 2**32) which maps back to [0, upper_bound) * [2**32 % upper_bound, 2**32) which maps back to [0, upper_bound)
* after reduction modulo upper_bound. * after reduction modulo upper_bound.
*/ */
u_int32_t uint32_t
arc4random_uniform(u_int32_t upper_bound) arc4random_uniform(uint32_t upper_bound)
{ {
u_int32_t r, min; uint32_t r, min;
if (upper_bound < 2) if (upper_bound < 2)
return (0); return (0);

2
src/hash/helper.c
View File

@ -27,7 +27,7 @@ char *
HASHEnd(HASH_CTX *ctx, char *buf) HASHEnd(HASH_CTX *ctx, char *buf)
{ {
int i; int i;
u_int8_t digest[HASH_DIGEST_LENGTH]; uint8_t digest[HASH_DIGEST_LENGTH];
#ifdef HASH_DIGEST_UPPERCASE #ifdef HASH_DIGEST_UPPERCASE
static const char hex[] = "0123456789ABCDEF"; static const char hex[] = "0123456789ABCDEF";
#else #else

20
src/hash/md5.c
View File

@ -37,7 +37,7 @@
(cp)[1] = (value) >> 8; \ (cp)[1] = (value) >> 8; \
(cp)[0] = (value); } while (0) (cp)[0] = (value); } while (0)
static u_int8_t PADDING[MD5_BLOCK_LENGTH] = { static uint8_t PADDING[MD5_BLOCK_LENGTH] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
@ -71,7 +71,7 @@ MD5Update(MD5_CTX *ctx, const unsigned char *input, size_t len)
need = MD5_BLOCK_LENGTH - have; need = MD5_BLOCK_LENGTH - have;
/* Update bitcount */ /* Update bitcount */
ctx->count += (u_int64_t)len << 3; ctx->count += (uint64_t)len << 3;
if (len >= need) { if (len >= need) {
if (have != 0) { if (have != 0) {
@ -102,7 +102,7 @@ MD5Update(MD5_CTX *ctx, const unsigned char *input, size_t len)
void void
MD5Pad(MD5_CTX *ctx) MD5Pad(MD5_CTX *ctx)
{ {
u_int8_t count[8]; uint8_t count[8];
size_t padlen; size_t padlen;
/* Convert count to 8 bytes in little endian order. */ /* Convert count to 8 bytes in little endian order. */
@ -152,19 +152,19 @@ MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5_CTX *ctx)
* the data and converts bytes into longwords for this routine. * the data and converts bytes into longwords for this routine.
*/ */
void void
MD5Transform(u_int32_t state[4], const u_int8_t block[MD5_BLOCK_LENGTH]) MD5Transform(uint32_t state[4], const uint8_t block[MD5_BLOCK_LENGTH])
{ {
u_int32_t a, b, c, d, in[MD5_BLOCK_LENGTH / 4]; uint32_t a, b, c, d, in[MD5_BLOCK_LENGTH / 4];
#if BYTE_ORDER == LITTLE_ENDIAN #if BYTE_ORDER == LITTLE_ENDIAN
memcpy(in, block, sizeof(in)); memcpy(in, block, sizeof(in));
#else #else
for (a = 0; a < MD5_BLOCK_LENGTH / 4; a++) { for (a = 0; a < MD5_BLOCK_LENGTH / 4; a++) {
in[a] = (u_int32_t)( in[a] = (uint32_t)(
(u_int32_t)(block[a * 4 + 0]) | (uint32_t)(block[a * 4 + 0]) |
(u_int32_t)(block[a * 4 + 1]) << 8 | (uint32_t)(block[a * 4 + 1]) << 8 |
(u_int32_t)(block[a * 4 + 2]) << 16 | (uint32_t)(block[a * 4 + 2]) << 16 |
(u_int32_t)(block[a * 4 + 3]) << 24); (uint32_t)(block[a * 4 + 3]) << 24);
} }
#endif #endif