mirror of
https://github.com/git/git.git
synced 2024-11-30 21:44:02 +08:00
48fb7deb5b
Shifting 'unsigned char' or 'unsigned short' left can result in sign extension errors, since the C integer promotion rules means that the unsigned char/short will get implicitly promoted to a signed 'int' due to the shift (or due to other operations). This normally doesn't matter, but if you shift things up sufficiently, it will now set the sign bit in 'int', and a subsequent cast to a bigger type (eg 'long' or 'unsigned long') will now sign-extend the value despite the original expression being unsigned. One example of this would be something like unsigned long size; unsigned char c; size += c << 24; where despite all the variables being unsigned, 'c << 24' ends up being a signed entity, and will get sign-extended when then doing the addition in an 'unsigned long' type. Since git uses 'unsigned char' pointers extensively, we actually have this bug in a couple of places. I may have missed some, but this is the result of looking at git grep '[^0-9 ][ ]*<<[ ][a-z]' -- '*.c' '*.h' git grep '<<[ ]*24' which catches at least the common byte cases (shifting variables by a variable amount, and shifting by 24 bits). I also grepped for just 'unsigned char' variables in general, and converted the ones that most obviously ended up getting implicitly cast immediately anyway (eg hash_name(), encode_85()). In addition to just avoiding 'unsigned char', this patch also tries to use a common idiom for the delta header size thing. We had three different variations on it: "& 0x7fUL" in one place (getting the sign extension right), and "& ~0x80" and "& 0x7f" in two other places (not getting it right). Apart from making them all just avoid using "unsigned char" at all, I also unified them to then use a simple "& 0x7f". I considered making a sparse extension which warns about doing implicit casts from unsigned types to signed types, but it gets rather complex very quickly, so this is just a hack. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>
105 lines
3.4 KiB
C
105 lines
3.4 KiB
C
#ifndef DELTA_H
|
|
#define DELTA_H
|
|
|
|
/* opaque object for delta index */
|
|
struct delta_index;
|
|
|
|
/*
|
|
* create_delta_index: compute index data from given buffer
|
|
*
|
|
* This returns a pointer to a struct delta_index that should be passed to
|
|
* subsequent create_delta() calls, or to free_delta_index(). A NULL pointer
|
|
* is returned on failure. The given buffer must not be freed nor altered
|
|
* before free_delta_index() is called. The returned pointer must be freed
|
|
* using free_delta_index().
|
|
*/
|
|
extern struct delta_index *
|
|
create_delta_index(const void *buf, unsigned long bufsize);
|
|
|
|
/*
|
|
* free_delta_index: free the index created by create_delta_index()
|
|
*
|
|
* Given pointer must be what create_delta_index() returned, or NULL.
|
|
*/
|
|
extern void free_delta_index(struct delta_index *index);
|
|
|
|
/*
|
|
* sizeof_delta_index: returns memory usage of delta index
|
|
*
|
|
* Given pointer must be what create_delta_index() returned, or NULL.
|
|
*/
|
|
extern unsigned long sizeof_delta_index(struct delta_index *index);
|
|
|
|
/*
|
|
* create_delta: create a delta from given index for the given buffer
|
|
*
|
|
* This function may be called multiple times with different buffers using
|
|
* the same delta_index pointer. If max_delta_size is non-zero and the
|
|
* resulting delta is to be larger than max_delta_size then NULL is returned.
|
|
* On success, a non-NULL pointer to the buffer with the delta data is
|
|
* returned and *delta_size is updated with its size. The returned buffer
|
|
* must be freed by the caller.
|
|
*/
|
|
extern void *
|
|
create_delta(const struct delta_index *index,
|
|
const void *buf, unsigned long bufsize,
|
|
unsigned long *delta_size, unsigned long max_delta_size);
|
|
|
|
/*
|
|
* diff_delta: create a delta from source buffer to target buffer
|
|
*
|
|
* If max_delta_size is non-zero and the resulting delta is to be larger
|
|
* than max_delta_size then NULL is returned. On success, a non-NULL
|
|
* pointer to the buffer with the delta data is returned and *delta_size is
|
|
* updated with its size. The returned buffer must be freed by the caller.
|
|
*/
|
|
static inline void *
|
|
diff_delta(const void *src_buf, unsigned long src_bufsize,
|
|
const void *trg_buf, unsigned long trg_bufsize,
|
|
unsigned long *delta_size, unsigned long max_delta_size)
|
|
{
|
|
struct delta_index *index = create_delta_index(src_buf, src_bufsize);
|
|
if (index) {
|
|
void *delta = create_delta(index, trg_buf, trg_bufsize,
|
|
delta_size, max_delta_size);
|
|
free_delta_index(index);
|
|
return delta;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* patch_delta: recreate target buffer given source buffer and delta data
|
|
*
|
|
* On success, a non-NULL pointer to the target buffer is returned and
|
|
* *trg_bufsize is updated with its size. On failure a NULL pointer is
|
|
* returned. The returned buffer must be freed by the caller.
|
|
*/
|
|
extern void *patch_delta(const void *src_buf, unsigned long src_size,
|
|
const void *delta_buf, unsigned long delta_size,
|
|
unsigned long *dst_size);
|
|
|
|
/* the smallest possible delta size is 4 bytes */
|
|
#define DELTA_SIZE_MIN 4
|
|
|
|
/*
|
|
* This must be called twice on the delta data buffer, first to get the
|
|
* expected source buffer size, and again to get the target buffer size.
|
|
*/
|
|
static inline unsigned long get_delta_hdr_size(const unsigned char **datap,
|
|
const unsigned char *top)
|
|
{
|
|
const unsigned char *data = *datap;
|
|
unsigned long cmd, size = 0;
|
|
int i = 0;
|
|
do {
|
|
cmd = *data++;
|
|
size |= (cmd & 0x7f) << i;
|
|
i += 7;
|
|
} while (cmd & 0x80 && data < top);
|
|
*datap = data;
|
|
return size;
|
|
}
|
|
|
|
#endif
|