1/* 2 * Check-out files from the "current cache directory" 3 * 4 * Copyright (C) 2005 Linus Torvalds 5 * 6 * Careful: order of argument flags does matter. For example, 7 * 8 * checkout-cache -a -f file.c 9 * 10 * Will first check out all files listed in the cache (but not 11 * overwrite any old ones), and then force-checkout "file.c" a 12 * second time (ie that one _will_ overwrite any old contents 13 * with the same filename). 14 * 15 * Also, just doing "checkout-cache" does nothing. You probably 16 * meant "checkout-cache -a". And if you want to force it, you 17 * want "checkout-cache -f -a". 18 * 19 * Intuitiveness is not the goal here. Repeatability is. The 20 * reason for the "no arguments means no work" thing is that 21 * from scripts you are supposed to be able to do things like 22 * 23 * find . -name '*.h' -print0 | xargs -0 checkout-cache -f -- 24 * 25 * which will force all existing *.h files to be replaced with 26 * their cached copies. If an empty command line implied "all", 27 * then this would force-refresh everything in the cache, which 28 * was not the point. 29 * 30 * Oh, and the "--" is just a good idea when you know the rest 31 * will be filenames. Just so that you wouldn't have a filename 32 * of "-a" causing problems (not possible in the above example, 33 * but get used to it in scripting!). 34 */ 35#include <sys/param.h> 36 37#include "cache.h" 38 39static int force = 0, quiet = 0; 40 41static void create_directories(const char *path) 42{ 43 int len = strlen(path); 44 char *buf = malloc(len + 1); 45 const char *slash = path; 46 47 while ((slash = strchr(slash+1, '/')) != NULL) { 48 len = slash - path; 49 memcpy(buf, path, len); 50 buf[len] = 0; 51 mkdir(buf, 0755); 52 } 53} 54 55static int create_file(const char *path, unsigned int mode) 56{ 57 int fd; 58 59 mode = (mode & 0100) ? 0777 : 0666; 60 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 61 if (fd < 0) { 62 if (errno == ENOENT) { 63 create_directories(path); 64 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode); 65 } 66 } 67 return fd; 68} 69 70static int write_entry(struct cache_entry *ce, const char *path) 71{ 72 int fd; 73 void *new; 74 unsigned long size; 75 long wrote; 76 char type[20]; 77 78 new = read_sha1_file(ce->sha1, type, &size); 79 if (!new || strcmp(type, "blob")) { 80 return error("checkout-cache: unable to read sha1 file of %s (%s)", 81 path, sha1_to_hex(ce->sha1)); 82 } 83 fd = create_file(path, ntohl(ce->ce_mode)); 84 if (fd < 0) { 85 free(new); 86 return error("checkout-cache: unable to create %s (%s)", 87 path, strerror(errno)); 88 } 89 wrote = write(fd, new, size); 90 close(fd); 91 free(new); 92 if (wrote != size) 93 return error("checkout-cache: unable to write %s", path); 94 return 0; 95} 96 97static int checkout_entry(struct cache_entry *ce, const char *base_dir) 98{ 99 struct stat st; 100 static char path[MAXPATHLEN+1]; 101 int len = strlen(base_dir); 102 103 memcpy(path, base_dir, len); 104 strcpy(path + len, ce->name); 105 106 if (!stat(path, &st)) { 107 unsigned changed = cache_match_stat(ce, &st); 108 if (!changed) 109 return 0; 110 if (!force) { 111 if (!quiet) 112 fprintf(stderr, "checkout-cache: %s already exists\n", path); 113 return 0; 114 } 115 116 /* 117 * We unlink the old file, to get the new one with the 118 * right permissions (including umask, which is nasty 119 * to emulate by hand - much easier to let the system 120 * just do the right thing) 121 */ 122 unlink(path); 123 } 124 return write_entry(ce, path); 125} 126 127static int checkout_file(const char *name, const char *base_dir) 128{ 129 int pos = cache_name_pos(name, strlen(name)); 130 if (pos < 0) { 131 if (!quiet) { 132 pos = -pos - 1; 133 fprintf(stderr, 134 "checkout-cache: %s is %s.\n", 135 name, 136 (pos < active_nr && 137 !strcmp(active_cache[pos]->name, name)) ? 138 "unmerged" : "not in the cache"); 139 } 140 return -1; 141 } 142 return checkout_entry(active_cache[pos], base_dir); 143} 144 145static int checkout_all(const char *base_dir) 146{ 147 int i; 148 149 for (i = 0; i < active_nr ; i++) { 150 struct cache_entry *ce = active_cache[i]; 151 if (ce_stage(ce)) 152 continue; 153 if (checkout_entry(ce, base_dir) < 0) 154 return -1; 155 } 156 return 0; 157} 158 159int main(int argc, char **argv) 160{ 161 int i, force_filename = 0; 162 const char *base_dir = ""; 163 164 if (read_cache() < 0) { 165 die("invalid cache"); 166 } 167 168 for (i = 1; i < argc; i++) { 169 const char *arg = argv[i]; 170 if (!force_filename) { 171 if (!strcmp(arg, "-a")) { 172 checkout_all(base_dir); 173 continue; 174 } 175 if (!strcmp(arg, "--")) { 176 force_filename = 1; 177 continue; 178 } 179 if (!strcmp(arg, "-f")) { 180 force = 1; 181 continue; 182 } 183 if (!strcmp(arg, "-q")) { 184 quiet = 1; 185 continue; 186 } 187 if (!memcmp(arg, "--prefix=", 9)) { 188 base_dir = arg+9; 189 continue; 190 } 191 } 192 checkout_file(arg, base_dir); 193 } 194 return 0; 195}