Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 1 | #ifndef CACHE_H |
| 2 | #define CACHE_H |
| 3 | |
Linus Torvalds | 2dee060 | 2005-04-20 20:00:08 | [diff] [blame] | 4 | #include <unistd.h> |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 5 | #include <stdio.h> |
| 6 | #include <sys/stat.h> |
| 7 | #include <fcntl.h> |
| 8 | #include <stddef.h> |
| 9 | #include <stdlib.h> |
| 10 | #include <stdarg.h> |
Linus Torvalds | bf0c6e8 | 2005-04-08 16:16:38 | [diff] [blame] | 11 | #include <string.h> |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 12 | #include <errno.h> |
Linus Torvalds | 6b0c312 | 2005-05-22 18:54:17 | [diff] [blame] | 13 | #include <limits.h> |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 14 | #include <sys/mman.h> |
Linus Torvalds | bb233d6 | 2005-04-21 17:55:18 | [diff] [blame] | 15 | #include <sys/param.h> |
Linus Torvalds | ccc4feb | 2005-04-15 17:44:27 | [diff] [blame] | 16 | #include <netinet/in.h> |
Linus Torvalds | 575f497 | 2005-06-30 00:52:11 | [diff] [blame] | 17 | #include <sys/types.h> |
| 18 | #include <dirent.h> |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 19 | |
Linus Torvalds | cef661f | 2005-04-21 19:33:22 | [diff] [blame] | 20 | #include SHA1_HEADER |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 21 | #include <zlib.h> |
| 22 | |
Edgar Toernig | 9da3acf | 2005-04-30 16:51:03 | [diff] [blame] | 23 | #if ZLIB_VERNUM < 0x1200 |
| 24 | #define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11) |
| 25 | #endif |
| 26 | |
Edgar Toernig | b682969 | 2005-04-30 16:51:03 | [diff] [blame] | 27 | #ifdef DT_UNKNOWN |
| 28 | #define DTYPE(de) ((de)->d_type) |
| 29 | #else |
| 30 | #define DT_UNKNOWN 0 |
| 31 | #define DT_DIR 1 |
| 32 | #define DT_REG 2 |
Junio C Hamano | a15c1c6 | 2005-05-13 00:16:04 | [diff] [blame] | 33 | #define DT_LNK 3 |
Edgar Toernig | b682969 | 2005-04-30 16:51:03 | [diff] [blame] | 34 | #define DTYPE(de) DT_UNKNOWN |
| 35 | #endif |
| 36 | |
Linus Torvalds | 90334cf | 2005-06-06 17:12:31 | [diff] [blame] | 37 | #ifdef __GNUC__ |
| 38 | #define NORETURN __attribute__((__noreturn__)) |
| 39 | #else |
| 40 | #define NORETURN |
Timo Sirainen | 4ec99bf | 2005-08-09 15:30:22 | [diff] [blame] | 41 | #ifndef __attribute__ |
Jason Riedy | 75ea691 | 2005-08-19 04:10:08 | [diff] [blame] | 42 | #define __attribute__(x) |
Timo Sirainen | 4ec99bf | 2005-08-09 15:30:22 | [diff] [blame] | 43 | #endif |
Junio C Hamano | f1d090e | 2005-08-19 09:06:52 | [diff] [blame] | 44 | #endif |
Timo Sirainen | 4ec99bf | 2005-08-09 15:30:22 | [diff] [blame] | 45 | |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 46 | /* |
Linus Torvalds | 2386d65 | 2005-07-14 01:46:20 | [diff] [blame] | 47 | * Intensive research over the course of many years has shown that |
| 48 | * port 9418 is totally unused by anything else. Or |
| 49 | * |
| 50 | * Your search - "port 9418" - did not match any documents. |
| 51 | * |
| 52 | * as www.google.com puts it. |
Linus Torvalds | ba8a497 | 2005-09-12 18:23:00 | [diff] [blame] | 53 | * |
| 54 | * This port has been properly assigned for git use by IANA: |
| 55 | * git (Assigned-9418) [I06-050728-0001]. |
| 56 | * |
| 57 | * git 9418/tcp git pack transfer service |
| 58 | * git 9418/udp git pack transfer service |
| 59 | * |
| 60 | * with Linus Torvalds <torvalds@osdl.org> as the point of |
| 61 | * contact. September 2005. |
| 62 | * |
| 63 | * See http://www.iana.org/assignments/port-numbers |
Linus Torvalds | 2386d65 | 2005-07-14 01:46:20 | [diff] [blame] | 64 | */ |
| 65 | #define DEFAULT_GIT_PORT 9418 |
| 66 | |
| 67 | /* |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 68 | * Basic data structures for the directory cache |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 69 | */ |
| 70 | |
| 71 | #define CACHE_SIGNATURE 0x44495243 /* "DIRC" */ |
| 72 | struct cache_header { |
Linus Torvalds | ccc4feb | 2005-04-15 17:44:27 | [diff] [blame] | 73 | unsigned int hdr_signature; |
| 74 | unsigned int hdr_version; |
| 75 | unsigned int hdr_entries; |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 76 | }; |
| 77 | |
| 78 | /* |
| 79 | * The "cache_time" is just the low 32 bits of the |
| 80 | * time. It doesn't matter if it overflows - we only |
| 81 | * check it for equality in the 32 bits we save. |
| 82 | */ |
| 83 | struct cache_time { |
| 84 | unsigned int sec; |
| 85 | unsigned int nsec; |
| 86 | }; |
| 87 | |
| 88 | /* |
| 89 | * dev/ino/uid/gid/size are also just tracked to the low 32 bits |
| 90 | * Again - this is just a (very strong in practice) heuristic that |
| 91 | * the inode hasn't changed. |
Linus Torvalds | ccc4feb | 2005-04-15 17:44:27 | [diff] [blame] | 92 | * |
| 93 | * We save the fields in big-endian order to allow using the |
| 94 | * index file over NFS transparently. |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 95 | */ |
| 96 | struct cache_entry { |
Linus Torvalds | ccc4feb | 2005-04-15 17:44:27 | [diff] [blame] | 97 | struct cache_time ce_ctime; |
| 98 | struct cache_time ce_mtime; |
| 99 | unsigned int ce_dev; |
| 100 | unsigned int ce_ino; |
| 101 | unsigned int ce_mode; |
| 102 | unsigned int ce_uid; |
| 103 | unsigned int ce_gid; |
| 104 | unsigned int ce_size; |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 105 | unsigned char sha1[20]; |
Linus Torvalds | f5cabd1 | 2005-04-16 04:45:38 | [diff] [blame] | 106 | unsigned short ce_flags; |
Junio C Hamano | 2c04662 | 2005-08-29 19:41:03 | [diff] [blame] | 107 | char name[0]; |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 108 | }; |
| 109 | |
Linus Torvalds | 95fd5bf | 2005-04-16 05:51:44 | [diff] [blame] | 110 | #define CE_NAMEMASK (0x0fff) |
| 111 | #define CE_STAGEMASK (0x3000) |
Linus Torvalds | 220a0b5 | 2005-06-06 05:07:31 | [diff] [blame] | 112 | #define CE_UPDATE (0x4000) |
Junio C Hamano | aee4619 | 2005-04-16 15:33:23 | [diff] [blame] | 113 | #define CE_STAGESHIFT 12 |
Linus Torvalds | 95fd5bf | 2005-04-16 05:51:44 | [diff] [blame] | 114 | |
Junio C Hamano | aee4619 | 2005-04-16 15:33:23 | [diff] [blame] | 115 | #define create_ce_flags(len, stage) htons((len) | ((stage) << CE_STAGESHIFT)) |
| 116 | #define ce_namelen(ce) (CE_NAMEMASK & ntohs((ce)->ce_flags)) |
| 117 | #define ce_size(ce) cache_entry_size(ce_namelen(ce)) |
| 118 | #define ce_stage(ce) ((CE_STAGEMASK & ntohs((ce)->ce_flags)) >> CE_STAGESHIFT) |
| 119 | |
Linus Torvalds | e447947 | 2005-04-17 05:26:31 | [diff] [blame] | 120 | #define ce_permissions(mode) (((mode) & 0100) ? 0755 : 0644) |
Kay Sievers | 8ae0a8c | 2005-05-05 12:38:25 | [diff] [blame] | 121 | static inline unsigned int create_ce_mode(unsigned int mode) |
| 122 | { |
Kay Sievers | 8ae0a8c | 2005-05-05 12:38:25 | [diff] [blame] | 123 | if (S_ISLNK(mode)) |
| 124 | return htonl(S_IFLNK); |
Linus Torvalds | db823d4 | 2005-05-05 23:01:46 | [diff] [blame] | 125 | return htonl(S_IFREG | ce_permissions(mode)); |
Kay Sievers | 8ae0a8c | 2005-05-05 12:38:25 | [diff] [blame] | 126 | } |
Linus Torvalds | e447947 | 2005-04-17 05:26:31 | [diff] [blame] | 127 | |
Junio C Hamano | aee4619 | 2005-04-16 15:33:23 | [diff] [blame] | 128 | #define cache_entry_size(len) ((offsetof(struct cache_entry,name) + (len) + 8) & ~7) |
Linus Torvalds | f5cabd1 | 2005-04-16 04:45:38 | [diff] [blame] | 129 | |
Petr Baudis | 8835504 | 2005-05-10 22:58:16 | [diff] [blame] | 130 | extern struct cache_entry **active_cache; |
| 131 | extern unsigned int active_nr, active_alloc, active_cache_changed; |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 132 | |
Junio C Hamano | 8ac069a | 2005-05-10 05:57:58 | [diff] [blame] | 133 | #define GIT_DIR_ENVIRONMENT "GIT_DIR" |
| 134 | #define DEFAULT_GIT_DIR_ENVIRONMENT ".git" |
Junio C Hamano | d19938a | 2005-05-10 00:57:56 | [diff] [blame] | 135 | #define DB_ENVIRONMENT "GIT_OBJECT_DIRECTORY" |
Linus Torvalds | bb233d6 | 2005-04-21 17:55:18 | [diff] [blame] | 136 | #define INDEX_ENVIRONMENT "GIT_INDEX_FILE" |
Junio C Hamano | 5da5c8f | 2005-07-30 07:58:28 | [diff] [blame] | 137 | #define GRAFT_ENVIRONMENT "GIT_GRAFT_FILE" |
Linus Torvalds | bb233d6 | 2005-04-21 17:55:18 | [diff] [blame] | 138 | |
Sven Verdoolaege | 5da1606 | 2005-09-26 20:54:01 | [diff] [blame] | 139 | extern char *get_git_dir(void); |
Junio C Hamano | 8ac069a | 2005-05-10 05:57:58 | [diff] [blame] | 140 | extern char *get_object_directory(void); |
Daniel Barkalow | 95fc751 | 2005-06-06 20:31:29 | [diff] [blame] | 141 | extern char *get_refs_directory(void); |
Junio C Hamano | 8ac069a | 2005-05-10 05:57:58 | [diff] [blame] | 142 | extern char *get_index_file(void); |
Junio C Hamano | 5da5c8f | 2005-07-30 07:58:28 | [diff] [blame] | 143 | extern char *get_graft_file(void); |
Junio C Hamano | 8ac069a | 2005-05-10 05:57:58 | [diff] [blame] | 144 | |
| 145 | #define ALTERNATE_DB_ENVIRONMENT "GIT_ALTERNATE_OBJECT_DIRECTORIES" |
Linus Torvalds | bb233d6 | 2005-04-21 17:55:18 | [diff] [blame] | 146 | |
Junio C Hamano | 6b5ee13 | 2005-09-21 07:00:47 | [diff] [blame] | 147 | extern const char **get_pathspec(const char *prefix, const char **pathspec); |
Linus Torvalds | d288a70 | 2005-08-17 01:06:34 | [diff] [blame] | 148 | extern const char *setup_git_directory(void); |
Junio C Hamano | 6b5ee13 | 2005-09-21 07:00:47 | [diff] [blame] | 149 | extern const char *prefix_path(const char *prefix, int len, const char *path); |
Linus Torvalds | d288a70 | 2005-08-17 01:06:34 | [diff] [blame] | 150 | |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 151 | #define alloc_nr(x) (((x)+16)*3/2) |
| 152 | |
Linus Torvalds | 734aab7 | 2005-04-09 16:48:20 | [diff] [blame] | 153 | /* Initialize and use the cache information */ |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 154 | extern int read_cache(void); |
Linus Torvalds | 197ee8c | 2005-04-09 19:09:27 | [diff] [blame] | 155 | extern int write_cache(int newfd, struct cache_entry **cache, int entries); |
Linus Torvalds | eb38c22 | 2005-04-09 16:26:55 | [diff] [blame] | 156 | extern int cache_name_pos(const char *name, int namelen); |
Junio C Hamano | 192268c | 2005-05-08 04:55:21 | [diff] [blame] | 157 | #define ADD_CACHE_OK_TO_ADD 1 /* Ok to add */ |
| 158 | #define ADD_CACHE_OK_TO_REPLACE 2 /* Ok to replace file/directory */ |
Junio C Hamano | b155725 | 2005-06-25 09:25:29 | [diff] [blame] | 159 | #define ADD_CACHE_SKIP_DFCHECK 4 /* Ok to skip DF conflict checks */ |
Junio C Hamano | 192268c | 2005-05-08 04:55:21 | [diff] [blame] | 160 | extern int add_cache_entry(struct cache_entry *ce, int option); |
Brad Roberts | dbbce55 | 2005-05-15 02:04:25 | [diff] [blame] | 161 | extern int remove_cache_entry_at(int pos); |
Junio C Hamano | 6b5ee13 | 2005-09-21 07:00:47 | [diff] [blame] | 162 | extern int remove_file_from_cache(const char *path); |
Brad Roberts | dbbce55 | 2005-05-15 02:04:25 | [diff] [blame] | 163 | extern int ce_same_name(struct cache_entry *a, struct cache_entry *b); |
Brad Roberts | 5d728c8 | 2005-05-15 02:04:25 | [diff] [blame] | 164 | extern int ce_match_stat(struct cache_entry *ce, struct stat *st); |
Junio C Hamano | b039189 | 2005-09-19 22:11:15 | [diff] [blame] | 165 | extern int ce_modified(struct cache_entry *ce, struct stat *st); |
Linus Torvalds | c0fd1f5 | 2005-07-14 23:55:06 | [diff] [blame] | 166 | extern int ce_path_match(const struct cache_entry *ce, const char **pathspec); |
Bryan Larsen | 7672db2 | 2005-07-08 23:51:55 | [diff] [blame] | 167 | extern int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, const char *type); |
Junio C Hamano | 415e96c | 2005-05-15 21:23:12 | [diff] [blame] | 168 | extern void fill_stat_cache_info(struct cache_entry *ce, struct stat *st); |
| 169 | |
| 170 | struct cache_file { |
| 171 | struct cache_file *next; |
| 172 | char lockfile[PATH_MAX]; |
| 173 | }; |
| 174 | extern int hold_index_file_for_update(struct cache_file *, const char *path); |
| 175 | extern int commit_index_file(struct cache_file *); |
| 176 | extern void rollback_index_file(struct cache_file *); |
Linus Torvalds | 734aab7 | 2005-04-09 16:48:20 | [diff] [blame] | 177 | |
| 178 | #define MTIME_CHANGED 0x0001 |
| 179 | #define CTIME_CHANGED 0x0002 |
| 180 | #define OWNER_CHANGED 0x0004 |
| 181 | #define MODE_CHANGED 0x0008 |
| 182 | #define INODE_CHANGED 0x0010 |
| 183 | #define DATA_CHANGED 0x0020 |
Kay Sievers | 8ae0a8c | 2005-05-05 12:38:25 | [diff] [blame] | 184 | #define TYPE_CHANGED 0x0040 |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 185 | |
| 186 | /* Return a statically allocated filename matching the sha1 signature */ |
Timo Sirainen | 4ec99bf | 2005-08-09 15:30:22 | [diff] [blame] | 187 | extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2))); |
| 188 | extern char *git_path(const char *fmt, ...) __attribute__((format (printf, 1, 2))); |
Linus Torvalds | 73134b6 | 2005-04-10 21:03:58 | [diff] [blame] | 189 | extern char *sha1_file_name(const unsigned char *sha1); |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 190 | extern char *sha1_pack_name(const unsigned char *sha1); |
| 191 | extern char *sha1_pack_index_name(const unsigned char *sha1); |
Junio C Hamano | 88cd621 | 2005-09-30 21:02:47 | [diff] [blame] | 192 | extern const unsigned char null_sha1[20]; |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 193 | |
Holger Eitzenberger | f2db68e | 2005-08-04 20:43:03 | [diff] [blame] | 194 | int git_mkstemp(char *path, size_t n, const char *template); |
| 195 | |
Junio C Hamano | b2cb942 | 2005-07-06 08:11:52 | [diff] [blame] | 196 | int safe_create_leading_directories(char *path); |
Holger Eitzenberger | f2db68e | 2005-08-04 20:43:03 | [diff] [blame] | 197 | char *safe_strncpy(char *, const char *, size_t); |
Junio C Hamano | b2cb942 | 2005-07-06 08:11:52 | [diff] [blame] | 198 | |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 199 | /* Read and unpack a sha1 file into memory, write memory to a sha1 file */ |
Linus Torvalds | c448357 | 2005-06-02 00:54:59 | [diff] [blame] | 200 | extern int unpack_sha1_header(z_stream *stream, void *map, unsigned long mapsize, void *buffer, unsigned long size); |
Linus Torvalds | 5180cac | 2005-06-02 14:57:25 | [diff] [blame] | 201 | extern int parse_sha1_header(char *hdr, char *type, unsigned long *sizep); |
Junio C Hamano | 36e4d74 | 2005-06-27 10:34:06 | [diff] [blame] | 202 | extern int sha1_object_info(const unsigned char *, char *, unsigned long *); |
Linus Torvalds | 2ade934 | 2005-04-08 22:01:15 | [diff] [blame] | 203 | extern void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size); |
Linus Torvalds | 73134b6 | 2005-04-10 21:03:58 | [diff] [blame] | 204 | extern void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size); |
Brian Gerst | bf0f910 | 2005-05-18 12:14:09 | [diff] [blame] | 205 | extern int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *return_sha1); |
Bryan Larsen | 7672db2 | 2005-07-08 23:51:55 | [diff] [blame] | 206 | extern char *write_sha1_file_prepare(void *buf, |
| 207 | unsigned long len, |
| 208 | const char *type, |
| 209 | unsigned char *sha1, |
| 210 | unsigned char *hdr, |
| 211 | int *hdrlen); |
Daniel Barkalow | 8237b18 | 2005-04-24 01:47:23 | [diff] [blame] | 212 | |
Jason McMullan | 5d6ccf5 | 2005-06-03 15:05:39 | [diff] [blame] | 213 | extern int check_sha1_signature(const unsigned char *sha1, void *buf, unsigned long size, const char *type); |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 214 | |
Linus Torvalds | 94537c7 | 2005-04-22 23:42:37 | [diff] [blame] | 215 | /* Read a tree into the cache */ |
Linus Torvalds | 3e58763 | 2005-07-14 18:39:27 | [diff] [blame] | 216 | extern int read_tree(void *buffer, unsigned long size, int stage, const char **paths); |
Linus Torvalds | 94537c7 | 2005-04-22 23:42:37 | [diff] [blame] | 217 | |
barkalow@iabervon.org | 70b9829 | 2005-08-02 23:46:29 | [diff] [blame] | 218 | extern int write_sha1_from_fd(const unsigned char *sha1, int fd, char *buffer, |
| 219 | size_t bufsize, size_t *bufposn); |
Daniel Barkalow | a5eda52 | 2005-07-10 22:25:38 | [diff] [blame] | 220 | extern int write_sha1_to_fd(int fd, const unsigned char *sha1); |
Daniel Barkalow | 8237b18 | 2005-04-24 01:47:23 | [diff] [blame] | 221 | |
Linus Torvalds | dade09c | 2005-07-03 20:06:36 | [diff] [blame] | 222 | extern int has_sha1_pack(const unsigned char *sha1); |
Daniel Barkalow | 8237b18 | 2005-04-24 01:47:23 | [diff] [blame] | 223 | extern int has_sha1_file(const unsigned char *sha1); |
| 224 | |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 225 | extern int has_pack_file(const unsigned char *sha1); |
| 226 | extern int has_pack_index(const unsigned char *sha1); |
| 227 | |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 228 | /* Convert to/from hex/sha1 representation */ |
Linus Torvalds | 3c249c9 | 2005-05-01 23:36:56 | [diff] [blame] | 229 | extern int get_sha1(const char *str, unsigned char *sha1); |
Linus Torvalds | 197ee8c | 2005-04-09 19:09:27 | [diff] [blame] | 230 | extern int get_sha1_hex(const char *hex, unsigned char *sha1); |
| 231 | extern char *sha1_to_hex(const unsigned char *sha1); /* static buffer result! */ |
Linus Torvalds | ca8db14 | 2005-09-25 16:59:37 | [diff] [blame] | 232 | extern int read_ref(const char *filename, unsigned char *sha1); |
Junio C Hamano | a876ed8 | 2005-09-30 21:08:25 | [diff] [blame] | 233 | extern const char *resolve_ref(const char *path, unsigned char *sha1, int); |
Junio C Hamano | 8098a17 | 2005-09-30 21:26:57 | [diff] [blame] | 234 | extern int create_symref(const char *git_HEAD, const char *refs_heads_master); |
| 235 | extern int validate_symref(const char *git_HEAD); |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 236 | |
| 237 | /* General helper functions */ |
Linus Torvalds | 90334cf | 2005-06-06 17:12:31 | [diff] [blame] | 238 | extern void usage(const char *err) NORETURN; |
Timo Sirainen | 4ec99bf | 2005-08-09 15:30:22 | [diff] [blame] | 239 | extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2))); |
| 240 | extern int error(const char *err, ...) __attribute__((format (printf, 1, 2))); |
Petr Baudis | 2de381f | 2005-04-13 09:28:48 | [diff] [blame] | 241 | |
Linus Torvalds | 958ba6c | 2005-05-20 16:09:18 | [diff] [blame] | 242 | extern int base_name_compare(const char *name1, int len1, int mode1, const char *name2, int len2, int mode2); |
Linus Torvalds | 79517a0 | 2005-04-09 19:59:11 | [diff] [blame] | 243 | extern int cache_name_compare(const char *name1, int len1, const char *name2, int len2); |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 244 | |
Junio C Hamano | 40469ee | 2005-04-28 23:42:27 | [diff] [blame] | 245 | extern void *read_object_with_reference(const unsigned char *sha1, |
Brian Gerst | bf0f910 | 2005-05-18 12:14:09 | [diff] [blame] | 246 | const char *required_type, |
Junio C Hamano | 40469ee | 2005-04-28 23:42:27 | [diff] [blame] | 247 | unsigned long *size, |
| 248 | unsigned char *sha1_ret); |
Junio C Hamano | f4913f9 | 2005-04-21 01:06:49 | [diff] [blame] | 249 | |
Linus Torvalds | f80cd78 | 2005-05-06 22:28:59 | [diff] [blame] | 250 | const char *show_date(unsigned long time, int timezone); |
Linus Torvalds | 2a39064 | 2005-09-19 22:53:50 | [diff] [blame] | 251 | int parse_date(const char *date, char *buf, int bufsize); |
Edgar Toernig | ecee9d9 | 2005-04-30 16:46:49 | [diff] [blame] | 252 | void datestamp(char *buf, int bufsize); |
| 253 | |
Linus Torvalds | 6aa33f4 | 2005-07-12 18:49:27 | [diff] [blame] | 254 | extern int setup_ident(void); |
| 255 | extern char *get_ident(const char *name, const char *email, const char *date_str); |
Eric W. Biederman | d289d13 | 2005-07-15 00:50:33 | [diff] [blame] | 256 | extern char *git_author_info(void); |
| 257 | extern char *git_committer_info(void); |
Linus Torvalds | 6aa33f4 | 2005-07-12 18:49:27 | [diff] [blame] | 258 | |
Brad Roberts | 127cfd0 | 2005-05-15 02:04:25 | [diff] [blame] | 259 | static inline void *xmalloc(size_t size) |
Christopher Li | 812666c | 2005-04-26 19:00:58 | [diff] [blame] | 260 | { |
| 261 | void *ret = malloc(size); |
| 262 | if (!ret) |
| 263 | die("Out of memory, malloc failed"); |
| 264 | return ret; |
| 265 | } |
| 266 | |
Brad Roberts | 127cfd0 | 2005-05-15 02:04:25 | [diff] [blame] | 267 | static inline void *xrealloc(void *ptr, size_t size) |
Christopher Li | 812666c | 2005-04-26 19:00:58 | [diff] [blame] | 268 | { |
| 269 | void *ret = realloc(ptr, size); |
| 270 | if (!ret) |
| 271 | die("Out of memory, realloc failed"); |
| 272 | return ret; |
| 273 | } |
| 274 | |
Brad Roberts | 127cfd0 | 2005-05-15 02:04:25 | [diff] [blame] | 275 | static inline void *xcalloc(size_t nmemb, size_t size) |
| 276 | { |
| 277 | void *ret = calloc(nmemb, size); |
| 278 | if (!ret) |
| 279 | die("Out of memory, calloc failed"); |
| 280 | return ret; |
| 281 | } |
| 282 | |
Linus Torvalds | 12dccc1 | 2005-06-06 04:59:54 | [diff] [blame] | 283 | struct checkout { |
| 284 | const char *base_dir; |
| 285 | int base_dir_len; |
| 286 | unsigned force:1, |
| 287 | quiet:1, |
| 288 | not_new:1, |
| 289 | refresh_cache:1; |
| 290 | }; |
| 291 | |
| 292 | extern int checkout_entry(struct cache_entry *ce, struct checkout *state); |
| 293 | |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 294 | extern struct alternate_object_database { |
Junio C Hamano | d5a63b9 | 2005-08-15 00:25:57 | [diff] [blame] | 295 | struct alternate_object_database *next; |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 296 | char *name; |
Junio C Hamano | 2c04662 | 2005-08-29 19:41:03 | [diff] [blame] | 297 | char base[0]; /* more */ |
Junio C Hamano | d5a63b9 | 2005-08-15 00:25:57 | [diff] [blame] | 298 | } *alt_odb_list; |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 299 | extern void prepare_alt_odb(void); |
| 300 | |
| 301 | extern struct packed_git { |
| 302 | struct packed_git *next; |
| 303 | unsigned long index_size; |
| 304 | unsigned long pack_size; |
| 305 | unsigned int *index_base; |
| 306 | void *pack_base; |
| 307 | unsigned int pack_last_used; |
Junio C Hamano | f925339 | 2005-06-29 09:51:27 | [diff] [blame] | 308 | unsigned int pack_use_cnt; |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 309 | unsigned char sha1[20]; |
Junio C Hamano | 2c04662 | 2005-08-29 19:41:03 | [diff] [blame] | 310 | char pack_name[0]; /* something like ".git/objects/pack/xxxxx.pack" */ |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 311 | } *packed_git; |
Junio C Hamano | f3bf922 | 2005-07-01 00:15:39 | [diff] [blame] | 312 | |
| 313 | struct pack_entry { |
| 314 | unsigned int offset; |
| 315 | unsigned char sha1[20]; |
| 316 | struct packed_git *p; |
| 317 | }; |
| 318 | |
Linus Torvalds | d1c133f | 2005-07-16 20:55:50 | [diff] [blame] | 319 | struct ref { |
| 320 | struct ref *next; |
| 321 | unsigned char old_sha1[20]; |
| 322 | unsigned char new_sha1[20]; |
Junio C Hamano | ff27adf | 2005-08-24 07:40:14 | [diff] [blame] | 323 | unsigned char force; |
Junio C Hamano | f88395a | 2005-08-03 23:35:29 | [diff] [blame] | 324 | struct ref *peer_ref; /* when renaming */ |
Junio C Hamano | 2c04662 | 2005-08-29 19:41:03 | [diff] [blame] | 325 | char name[0]; |
Linus Torvalds | d1c133f | 2005-07-16 20:55:50 | [diff] [blame] | 326 | }; |
| 327 | |
Linus Torvalds | f719259 | 2005-07-04 18:57:58 | [diff] [blame] | 328 | extern int git_connect(int fd[2], char *url, const char *prog); |
| 329 | extern int finish_connect(pid_t pid); |
Linus Torvalds | 013e7c7 | 2005-07-04 20:24:30 | [diff] [blame] | 330 | extern int path_match(const char *path, int nr, char **match); |
Junio C Hamano | f88395a | 2005-08-03 23:35:29 | [diff] [blame] | 331 | extern int match_refs(struct ref *src, struct ref *dst, struct ref ***dst_tail, |
| 332 | int nr_refspec, char **refspec, int all); |
Linus Torvalds | 41cb748 | 2005-07-05 22:44:09 | [diff] [blame] | 333 | extern int get_ack(int fd, unsigned char *result_sha1); |
Linus Torvalds | d1c133f | 2005-07-16 20:55:50 | [diff] [blame] | 334 | extern struct ref **get_remote_heads(int in, struct ref **list, int nr_match, char **match); |
Linus Torvalds | f719259 | 2005-07-04 18:57:58 | [diff] [blame] | 335 | |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 336 | extern struct packed_git *parse_pack_index(unsigned char *sha1); |
Peter Hagervall | 2ab141a | 2005-09-02 12:17:10 | [diff] [blame] | 337 | extern struct packed_git *parse_pack_index_file(const unsigned char *sha1, |
Daniel Barkalow | c508df5 | 2005-08-16 04:10:03 | [diff] [blame] | 338 | char *idx_path); |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 339 | |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 340 | extern void prepare_packed_git(void); |
barkalow@iabervon.org | bf592c5 | 2005-08-01 00:53:44 | [diff] [blame] | 341 | extern void install_packed_git(struct packed_git *pack); |
| 342 | |
| 343 | extern struct packed_git *find_sha1_pack(const unsigned char *sha1, |
| 344 | struct packed_git *packs); |
| 345 | |
Junio C Hamano | f925339 | 2005-06-29 09:51:27 | [diff] [blame] | 346 | extern int use_packed_git(struct packed_git *); |
| 347 | extern void unuse_packed_git(struct packed_git *); |
| 348 | extern struct packed_git *add_packed_git(char *, int); |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 349 | extern int num_packed_objects(const struct packed_git *p); |
| 350 | extern int nth_packed_object_sha1(const struct packed_git *, int, unsigned char*); |
Junio C Hamano | f3bf922 | 2005-07-01 00:15:39 | [diff] [blame] | 351 | extern int find_pack_entry_one(const unsigned char *, struct pack_entry *, struct packed_git *); |
| 352 | extern void *unpack_entry_gently(struct pack_entry *, char *, unsigned long *); |
Junio C Hamano | ad8c80a | 2005-07-01 00:17:20 | [diff] [blame] | 353 | extern void packed_object_info_detail(struct pack_entry *, char *, unsigned long *, unsigned long *, int *, unsigned char *); |
Junio C Hamano | 9a217f2 | 2005-06-28 21:56:57 | [diff] [blame] | 354 | |
Junio C Hamano | 8f3f9b0 | 2005-07-24 00:54:41 | [diff] [blame] | 355 | /* Dumb servers support */ |
| 356 | extern int update_server_info(int); |
| 357 | |
Linus Torvalds | e83c516 | 2005-04-07 22:13:13 | [diff] [blame] | 358 | #endif /* CACHE_H */ |