9126f0091f
On ARM I have the following compilation errors:
CC fast-import.o
In file included from cache.h:8,
from builtin.h:6,
from fast-import.c:142:
arm/sha1.h:14: error: conflicting types for 'SHA_CTX'
/usr/include/openssl/sha.h:105: error: previous declaration of 'SHA_CTX' was here
arm/sha1.h:16: error: conflicting types for 'SHA1_Init'
/usr/include/openssl/sha.h:115: error: previous declaration of 'SHA1_Init' was here
arm/sha1.h:17: error: conflicting types for 'SHA1_Update'
/usr/include/openssl/sha.h:116: error: previous declaration of 'SHA1_Update' was here
arm/sha1.h:18: error: conflicting types for 'SHA1_Final'
/usr/include/openssl/sha.h:117: error: previous declaration of 'SHA1_Final' was here
make: *** [fast-import.o] Error 1
This is because openssl header files are always included in
git-compat-util.h since commit 684ec6c63c whenever NO_OPENSSL is not
set, which somehow brings in <openssl/sha1.h> clashing with the custom
ARM version. Compilation of git is probably broken on PPC too for the
same reason.
Turns out that the only file requiring openssl/ssl.h and openssl/err.h
is imap-send.c. But only moving those problematic includes there
doesn't solve the issue as it also includes cache.h which brings in the
conflicting local SHA1 header file.
As suggested by Jeff King, the best solution is to rename our references
to SHA1 functions and structure to something git specific, and define those
according to the implementation used.
Signed-off-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
123 lines
2.5 KiB
C
123 lines
2.5 KiB
C
/*
|
|
* csum-file.c
|
|
*
|
|
* Copyright (C) 2005 Linus Torvalds
|
|
*
|
|
* Simple file write infrastructure for writing SHA1-summed
|
|
* files. Useful when you write a file that you want to be
|
|
* able to verify hasn't been messed with afterwards.
|
|
*/
|
|
#include "cache.h"
|
|
#include "progress.h"
|
|
#include "csum-file.h"
|
|
|
|
static void sha1flush(struct sha1file *f, void *buf, unsigned int count)
|
|
{
|
|
for (;;) {
|
|
int ret = xwrite(f->fd, buf, count);
|
|
if (ret > 0) {
|
|
f->total += ret;
|
|
display_throughput(f->tp, f->total);
|
|
buf = (char *) buf + ret;
|
|
count -= ret;
|
|
if (count)
|
|
continue;
|
|
return;
|
|
}
|
|
if (!ret)
|
|
die("sha1 file '%s' write error. Out of diskspace", f->name);
|
|
die("sha1 file '%s' write error (%s)", f->name, strerror(errno));
|
|
}
|
|
}
|
|
|
|
int sha1close(struct sha1file *f, unsigned char *result, unsigned int flags)
|
|
{
|
|
int fd;
|
|
unsigned offset = f->offset;
|
|
|
|
if (offset) {
|
|
git_SHA1_Update(&f->ctx, f->buffer, offset);
|
|
sha1flush(f, f->buffer, offset);
|
|
f->offset = 0;
|
|
}
|
|
git_SHA1_Final(f->buffer, &f->ctx);
|
|
if (result)
|
|
hashcpy(result, f->buffer);
|
|
if (flags & (CSUM_CLOSE | CSUM_FSYNC)) {
|
|
/* write checksum and close fd */
|
|
sha1flush(f, f->buffer, 20);
|
|
if (flags & CSUM_FSYNC)
|
|
fsync_or_die(f->fd, f->name);
|
|
if (close(f->fd))
|
|
die("%s: sha1 file error on close (%s)",
|
|
f->name, strerror(errno));
|
|
fd = 0;
|
|
} else
|
|
fd = f->fd;
|
|
free(f);
|
|
return fd;
|
|
}
|
|
|
|
int sha1write(struct sha1file *f, void *buf, unsigned int count)
|
|
{
|
|
while (count) {
|
|
unsigned offset = f->offset;
|
|
unsigned left = sizeof(f->buffer) - offset;
|
|
unsigned nr = count > left ? left : count;
|
|
void *data;
|
|
|
|
if (f->do_crc)
|
|
f->crc32 = crc32(f->crc32, buf, nr);
|
|
|
|
if (nr == sizeof(f->buffer)) {
|
|
/* process full buffer directly without copy */
|
|
data = buf;
|
|
} else {
|
|
memcpy(f->buffer + offset, buf, nr);
|
|
data = f->buffer;
|
|
}
|
|
|
|
count -= nr;
|
|
offset += nr;
|
|
buf = (char *) buf + nr;
|
|
left -= nr;
|
|
if (!left) {
|
|
git_SHA1_Update(&f->ctx, data, offset);
|
|
sha1flush(f, data, offset);
|
|
offset = 0;
|
|
}
|
|
f->offset = offset;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct sha1file *sha1fd(int fd, const char *name)
|
|
{
|
|
return sha1fd_throughput(fd, name, NULL);
|
|
}
|
|
|
|
struct sha1file *sha1fd_throughput(int fd, const char *name, struct progress *tp)
|
|
{
|
|
struct sha1file *f = xmalloc(sizeof(*f));
|
|
f->fd = fd;
|
|
f->offset = 0;
|
|
f->total = 0;
|
|
f->tp = tp;
|
|
f->name = name;
|
|
f->do_crc = 0;
|
|
git_SHA1_Init(&f->ctx);
|
|
return f;
|
|
}
|
|
|
|
void crc32_begin(struct sha1file *f)
|
|
{
|
|
f->crc32 = crc32(0, Z_NULL, 0);
|
|
f->do_crc = 1;
|
|
}
|
|
|
|
uint32_t crc32_end(struct sha1file *f)
|
|
{
|
|
f->do_crc = 0;
|
|
return f->crc32;
|
|
}
|