fyb/calcurse-edge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch to Linux kernel coding style

Browse Source 
Convert our code base to adhere to Linux kernel coding style using
Lindent, with the following exceptions:

* Use spaces, instead of tabs, for indentation.
* Use 2-character indentations (instead of 8 characters).

Rationale: We currently have too much levels of indentation. Using
8-character tabs would make huge code parts unreadable. These need to be
cleaned up before we can switch to 8 characters.

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>
This commit is contained in:
Lukas Fleischer
2012-05-21 10:13:05 +02:00
parent 47c52ae7bb
commit cfd8ede2b3
33 changed files with 9138 additions and 10647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
src/sha1.c
View File

@@ -67,61 +67,100 @@
#define R4(v, w, x, y, z, i) z += (w ^ x ^ y) + blk (i) + 0xCA62C1D6 + \
rol (v, 5); w = rol (w, 30);
static void
sha1_transform (uint32_t state[5], const uint8_t buffer[64])
static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
{
typedef union {
uint8_t c[64];
uint32_t l[16];
} b64_t;
b64_t *block = (b64_t *)buffer;
b64_t *block = (b64_t *) buffer;
uint32_t a = state[0];
uint32_t b = state[1];
uint32_t c = state[2];
uint32_t d = state[3];
uint32_t e = state[4];
R0 (a, b, c, d, e, 0); R0 (e, a, b, c, d, 1);
R0 (d, e, a, b, c, 2); R0 (c, d, e, a, b, 3);
R0 (b, c, d, e, a, 4); R0 (a, b, c, d, e, 5);
R0 (e, a, b, c, d, 6); R0 (d, e, a, b, c, 7);
R0 (c, d, e, a, b, 8); R0 (b, c, d, e, a, 9);
R0 (a, b, c, d, e, 10); R0 (e, a, b, c, d, 11);
R0 (d, e, a, b, c, 12); R0 (c, d, e, a, b, 13);
R0 (b, c, d, e, a, 14); R0 (a, b, c, d, e, 15);
R1 (e, a, b, c, d, 16); R1 (d, e, a, b, c, 17);
R1 (c, d, e, a, b, 18); R1 (b, c, d, e, a, 19);
R2 (a, b, c, d, e, 20); R2 (e, a, b, c, d, 21);
R2 (d, e, a, b, c, 22); R2 (c, d, e, a, b, 23);
R2 (b, c, d, e, a, 24); R2 (a, b, c, d, e, 25);
R2 (e, a, b, c, d, 26); R2 (d, e, a, b, c, 27);
R2 (c, d, e, a, b, 28); R2 (b, c, d, e, a, 29);
R2 (a, b, c, d, e, 30); R2 (e, a, b, c, d, 31);
R2 (d, e, a, b, c, 32); R2 (c, d, e, a, b, 33);
R2 (b, c, d, e, a, 34); R2 (a, b, c, d, e, 35);
R2 (e, a, b, c, d, 36); R2 (d, e, a, b, c, 37);
R2 (c, d, e, a, b, 38); R2 (b, c, d, e, a, 39);
R3 (a, b, c, d, e, 40); R3 (e, a, b, c, d, 41);
R3 (d, e, a, b, c, 42); R3 (c, d, e, a, b, 43);
R3 (b, c, d, e, a, 44); R3 (a, b, c, d, e, 45);
R3 (e, a, b, c, d, 46); R3 (d, e, a, b, c, 47);
R3 (c, d, e, a, b, 48); R3 (b, c, d, e, a, 49);
R3 (a, b, c, d, e, 50); R3 (e, a, b, c, d, 51);
R3 (d, e, a, b, c, 52); R3 (c, d, e, a, b, 53);
R3 (b, c, d, e, a, 54); R3 (a, b, c, d, e, 55);
R3 (e, a, b, c, d, 56); R3 (d, e, a, b, c, 57);
R3 (c, d, e, a, b, 58); R3 (b, c, d, e, a, 59);
R4 (a, b, c, d, e, 60); R4 (e, a, b, c, d, 61);
R4 (d, e, a, b, c, 62); R4 (c, d, e, a, b, 63);
R4 (b, c, d, e, a, 64); R4 (a, b, c, d, e, 65);
R4 (e, a, b, c, d, 66); R4 (d, e, a, b, c, 67);
R4 (c, d, e, a, b, 68); R4 (b, c, d, e, a, 69);
R4 (a, b, c, d, e, 70); R4 (e, a, b, c, d, 71);
R4 (d, e, a, b, c, 72); R4 (c, d, e, a, b, 73);
R4 (b, c, d, e, a, 74); R4 (a, b, c, d, e, 75);
R4 (e, a, b, c, d, 76); R4 (d, e, a, b, c, 77);
R4 (c, d, e, a, b, 78); R4 (b, c, d, e, a, 79);
R0(a, b, c, d, e, 0);
R0(e, a, b, c, d, 1);
R0(d, e, a, b, c, 2);
R0(c, d, e, a, b, 3);
R0(b, c, d, e, a, 4);
R0(a, b, c, d, e, 5);
R0(e, a, b, c, d, 6);
R0(d, e, a, b, c, 7);
R0(c, d, e, a, b, 8);
R0(b, c, d, e, a, 9);
R0(a, b, c, d, e, 10);
R0(e, a, b, c, d, 11);
R0(d, e, a, b, c, 12);
R0(c, d, e, a, b, 13);
R0(b, c, d, e, a, 14);
R0(a, b, c, d, e, 15);
R1(e, a, b, c, d, 16);
R1(d, e, a, b, c, 17);
R1(c, d, e, a, b, 18);
R1(b, c, d, e, a, 19);
R2(a, b, c, d, e, 20);
R2(e, a, b, c, d, 21);
R2(d, e, a, b, c, 22);
R2(c, d, e, a, b, 23);
R2(b, c, d, e, a, 24);
R2(a, b, c, d, e, 25);
R2(e, a, b, c, d, 26);
R2(d, e, a, b, c, 27);
R2(c, d, e, a, b, 28);
R2(b, c, d, e, a, 29);
R2(a, b, c, d, e, 30);
R2(e, a, b, c, d, 31);
R2(d, e, a, b, c, 32);
R2(c, d, e, a, b, 33);
R2(b, c, d, e, a, 34);
R2(a, b, c, d, e, 35);
R2(e, a, b, c, d, 36);
R2(d, e, a, b, c, 37);
R2(c, d, e, a, b, 38);
R2(b, c, d, e, a, 39);
R3(a, b, c, d, e, 40);
R3(e, a, b, c, d, 41);
R3(d, e, a, b, c, 42);
R3(c, d, e, a, b, 43);
R3(b, c, d, e, a, 44);
R3(a, b, c, d, e, 45);
R3(e, a, b, c, d, 46);
R3(d, e, a, b, c, 47);
R3(c, d, e, a, b, 48);
R3(b, c, d, e, a, 49);
R3(a, b, c, d, e, 50);
R3(e, a, b, c, d, 51);
R3(d, e, a, b, c, 52);
R3(c, d, e, a, b, 53);
R3(b, c, d, e, a, 54);
R3(a, b, c, d, e, 55);
R3(e, a, b, c, d, 56);
R3(d, e, a, b, c, 57);
R3(c, d, e, a, b, 58);
R3(b, c, d, e, a, 59);
R4(a, b, c, d, e, 60);
R4(e, a, b, c, d, 61);
R4(d, e, a, b, c, 62);
R4(c, d, e, a, b, 63);
R4(b, c, d, e, a, 64);
R4(a, b, c, d, e, 65);
R4(e, a, b, c, d, 66);
R4(d, e, a, b, c, 67);
R4(c, d, e, a, b, 68);
R4(b, c, d, e, a, 69);
R4(a, b, c, d, e, 70);
R4(e, a, b, c, d, 71);
R4(d, e, a, b, c, 72);
R4(c, d, e, a, b, 73);
R4(b, c, d, e, a, 74);
R4(a, b, c, d, e, 75);
R4(e, a, b, c, d, 76);
R4(d, e, a, b, c, 77);
R4(c, d, e, a, b, 78);
R4(b, c, d, e, a, 79);
state[0] += a;
state[1] += b;
@@ -132,9 +171,7 @@ sha1_transform (uint32_t state[5], const uint8_t buffer[64])
a = b = c = d = e = 0;
}
void
sha1_init (sha1_ctx_t *ctx)
void sha1_init(sha1_ctx_t * ctx)
{
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
@@ -145,8 +182,7 @@ sha1_init (sha1_ctx_t *ctx)
ctx->count[0] = ctx->count[1] = 0;
}
void
sha1_update (sha1_ctx_t *ctx, const uint8_t *data, unsigned int len)
void sha1_update(sha1_ctx_t * ctx, const uint8_t * data, unsigned int len)
{
unsigned int i, j;
@@ -155,67 +191,59 @@ sha1_update (sha1_ctx_t *ctx, const uint8_t *data, unsigned int len)
ctx->count[1]++;
ctx->count[1] += (len >> 29);
if (j + len > 63)
{
memcpy (&ctx->buffer[j], data, (i = 64 - j));
sha1_transform (ctx->state, ctx->buffer);
for (; i + 63 < len; i += 64)
sha1_transform (ctx->state, &data[i]);
j = 0;
}
else
if (j + len > 63) {
memcpy(&ctx->buffer[j], data, (i = 64 - j));
sha1_transform(ctx->state, ctx->buffer);
for (; i + 63 < len; i += 64)
sha1_transform(ctx->state, &data[i]);
j = 0;
} else
i = 0;
memcpy (&ctx->buffer[j], &data[i], len - i);
memcpy(&ctx->buffer[j], &data[i], len - i);
}
void
sha1_final (sha1_ctx_t *ctx, uint8_t digest[SHA1_DIGESTLEN])
void sha1_final(sha1_ctx_t * ctx, uint8_t digest[SHA1_DIGESTLEN])
{
uint32_t i, j;
uint8_t finalcount[8];
uint8_t finalcount[8];
for (i = 0; i < 8; i++)
{
finalcount[i] = (uint8_t)((ctx->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) & 255);
}
for (i = 0; i < 8; i++) {
finalcount[i] = (uint8_t) ((ctx->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) & 255);
}
sha1_update (ctx, (uint8_t *)"\200", 1);
sha1_update(ctx, (uint8_t *) "\200", 1);
while ((ctx->count[0] & 504) != 448)
sha1_update (ctx, (uint8_t *)"\0", 1);
sha1_update(ctx, (uint8_t *) "\0", 1);
sha1_update (ctx, finalcount, 8);
sha1_update(ctx, finalcount, 8);
for (i = 0; i < SHA1_DIGESTLEN; i++)
digest[i] = (uint8_t)((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
digest[i] = (uint8_t) ((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
i = j = 0;
memset (ctx->buffer, 0, SHA1_BLOCKLEN);
memset (ctx->state, 0, SHA1_DIGESTLEN);
memset (ctx->count, 0, 8);
memset (&finalcount, 0, 8);
memset(ctx->buffer, 0, SHA1_BLOCKLEN);
memset(ctx->state, 0, SHA1_DIGESTLEN);
memset(ctx->count, 0, 8);
memset(&finalcount, 0, 8);
}
void
sha1_digest (const char *data, char *buffer)
void sha1_digest(const char *data, char *buffer)
{
sha1_ctx_t ctx;
uint8_t digest[SHA1_DIGESTLEN];
int i;
sha1_init (&ctx);
sha1_update (&ctx, (const uint8_t *)data, strlen (data));
sha1_final (&ctx, (uint8_t *)digest);
sha1_init(&ctx);
sha1_update(&ctx, (const uint8_t *)data, strlen(data));
sha1_final(&ctx, (uint8_t *) digest);
for (i = 0; i < SHA1_DIGESTLEN; i++)
{
snprintf (buffer, 3, "%02x", digest[i]);
buffer += sizeof (char) * 2;
}
for (i = 0; i < SHA1_DIGESTLEN; i++) {
snprintf(buffer, 3, "%02x", digest[i]);
buffer += sizeof(char) * 2;
}
}
void
sha1_stream (FILE *fp, char *buffer)
void sha1_stream(FILE * fp, char *buffer)
{
sha1_ctx_t ctx;
uint8_t data[BUFSIZ];
@@ -223,19 +251,17 @@ sha1_stream (FILE *fp, char *buffer)
uint8_t digest[SHA1_DIGESTLEN];
int i;
sha1_init (&ctx);
sha1_init(&ctx);
while (!feof (fp))
{
bytes_read = fread (data, 1, BUFSIZ, fp);
sha1_update (&ctx, data, bytes_read);
}
while (!feof(fp)) {
bytes_read = fread(data, 1, BUFSIZ, fp);
sha1_update(&ctx, data, bytes_read);
}
sha1_final (&ctx, (uint8_t *)digest);
sha1_final(&ctx, (uint8_t *) digest);
for (i = 0; i < SHA1_DIGESTLEN; i++)
{
snprintf (buffer, 3, "%02x", digest[i]);
buffer += sizeof (char) * 2;
}
for (i = 0; i < SHA1_DIGESTLEN; i++) {
snprintf(buffer, 3, "%02x", digest[i]);
buffer += sizeof(char) * 2;
}
}