/* * Read contents a file with conflicts, normalize the conflicts * by (1) discarding the common ancestor version in diff3-style, * (2) reordering our side and their side so that whichever sorts * alphabetically earlier comes before the other one, while * computing the "conflict ID", which is just an SHA-1 hash of * one side of the conflict, NUL, the other side of the conflict, * and NUL concatenated together. * * Return 1 if conflict hunks are found, 0 if there are no conflict * hunks and -1 if an error occured. */ static int handle_path(unsigned char *sha1, struct rerere_io *io, int marker_size) { git_SHA_CTX ctx; struct strbuf buf = STRBUF_INIT, out = STRBUF_INIT; int has_conflicts = 0; if (sha1) git_SHA1_Init(&ctx); while (!io->getline(&buf, io)) { if (is_cmarker(buf.buf, '<', marker_size)) { has_conflicts = handle_conflict(&out, io, marker_size, sha1 ? &ctx : NULL); if (has_conflicts < 0) break; rerere_io_putmem(out.buf, out.len, io); strbuf_reset(&out); } else rerere_io_putstr(buf.buf, io); } strbuf_release(&buf); strbuf_release(&out); if (sha1) git_SHA1_Final(sha1, &ctx); return has_conflicts; }
static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed) { struct remote_lock *lock = (struct remote_lock *)ctx->userData; git_SHA_CTX sha_ctx; unsigned char lock_token_sha1[20]; if (tag_closed && ctx->cdata) { if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) { lock->owner = xstrdup(ctx->cdata); } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TIMEOUT)) { const char *arg; if (skip_prefix(ctx->cdata, "Second-", &arg)) lock->timeout = strtol(arg, NULL, 10); } else if (!strcmp(ctx->name, DAV_ACTIVELOCK_TOKEN)) { lock->token = xstrdup(ctx->cdata); git_SHA1_Init(&sha_ctx); git_SHA1_Update(&sha_ctx, lock->token, strlen(lock->token)); git_SHA1_Final(lock_token_sha1, &sha_ctx); lock->tmpfile_suffix[0] = '_'; memcpy(lock->tmpfile_suffix + 1, sha1_to_hex(lock_token_sha1), 40); } } }
static char *open_pack_file(char *pack_name) { if (from_stdin) { input_fd = 0; if (!pack_name) { static char tmpfile[PATH_MAX]; snprintf(tmpfile, sizeof(tmpfile), "%s/pack/tmp_pack_XXXXXX", get_object_directory()); output_fd = xmkstemp(tmpfile); pack_name = xstrdup(tmpfile); } else output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600); if (output_fd < 0) die("unable to create %s: %s\n", pack_name, strerror(errno)); pack_fd = output_fd; } else { input_fd = open(pack_name, O_RDONLY); if (input_fd < 0) die("cannot open packfile '%s': %s", pack_name, strerror(errno)); output_fd = -1; pack_fd = input_fd; } git_SHA1_Init(&input_ctx); return pack_name; }
/** * Given projdir and strbuf containing the pushobject, update with new * pushobject and update head file as well as projdir struct. * TODO verify pushobj with PGP key */ static int append_pushobj(struct projdir * pd, struct strbuf * pobj, struct strbuf *sig) { unsigned char sha1[20]; char sha1_hex[41]; FILE * pobj_fp; char * file_path; git_SHA_CTX c; git_SHA1_Init(&c); git_SHA1_Update(&c, pobj->buf, pobj->len); git_SHA1_Final(sha1, &c); file_path = (char*)malloc(strlen(pd->projdir) + 40 + 1); strcpy(sha1_hex, sha1_to_hex(sha1)); sprintf(file_path, "%s/%s", pd->projdir, sha1_hex); if (access(file_path, F_OK) == 0) return error("Push object alread exists"); pobj_fp = fopen(file_path, "w"); fprintf(pobj_fp, "%s", pobj->buf); fprintf(pobj_fp, "%s", sig->buf); fprintf(pobj_fp, "%s PREV\n", pd->head); fclose(pobj_fp); update_proj_head(pd, sha1_hex); free(file_path); return 0; }
int main(int ac, char **av) { git_SHA_CTX ctx; unsigned char sha1[20]; unsigned bufsz = 8192; int binary = 0; char *buffer; if (ac == 2) { if (!strcmp(av[1], "-b")) binary = 1; else bufsz = strtoul(av[1], NULL, 10) * 1024 * 1024; } if (!bufsz) bufsz = 8192; while ((buffer = malloc(bufsz)) == NULL) { fprintf(stderr, "bufsz %u is too big, halving...\n", bufsz); bufsz /= 2; if (bufsz < 1024) die("OOPS"); } git_SHA1_Init(&ctx); while (1) { ssize_t sz, this_sz; char *cp = buffer; unsigned room = bufsz; this_sz = 0; while (room) { sz = xread(0, cp, room); if (sz == 0) break; if (sz < 0) die_errno("test-sha1"); this_sz += sz; cp += sz; room -= sz; } if (this_sz == 0) break; git_SHA1_Update(&ctx, buffer, this_sz); } git_SHA1_Final(sha1, &ctx); if (binary) fwrite(sha1, 1, 20, stdout); else puts(sha1_to_hex(sha1)); exit(0); }
static void flush_current_id(int patchlen, unsigned char *id, git_SHA_CTX *c) { unsigned char result[20]; char name[50]; if (!patchlen) return; git_SHA1_Final(result, c); memcpy(name, sha1_to_hex(id), 41); printf("%s %s\n", sha1_to_hex(result), name); git_SHA1_Init(c); }
static void hmac_sha1(unsigned char *out, const char *key_in, size_t key_len, const char *text, size_t text_len) { unsigned char key[HMAC_BLOCK_SIZE]; unsigned char k_ipad[HMAC_BLOCK_SIZE]; unsigned char k_opad[HMAC_BLOCK_SIZE]; int i; git_SHA_CTX ctx; /* RFC 2104 2. (1) */ memset(key, '\0', HMAC_BLOCK_SIZE); if (HMAC_BLOCK_SIZE < key_len) { git_SHA1_Init(&ctx); git_SHA1_Update(&ctx, key_in, key_len); git_SHA1_Final(key, &ctx); } else { memcpy(key, key_in, key_len); } /* RFC 2104 2. (2) & (5) */ for (i = 0; i < sizeof(key); i++) { k_ipad[i] = key[i] ^ 0x36; k_opad[i] = key[i] ^ 0x5c; } /* RFC 2104 2. (3) & (4) */ git_SHA1_Init(&ctx); git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad)); git_SHA1_Update(&ctx, text, text_len); git_SHA1_Final(out, &ctx); /* RFC 2104 2. (6) & (7) */ git_SHA1_Init(&ctx); git_SHA1_Update(&ctx, k_opad, sizeof(k_opad)); git_SHA1_Update(&ctx, out, 20); git_SHA1_Final(out, &ctx); }
int gidit_store_bundle(FILE *fp, const char * basepath, unsigned int flags) { char start_pobj_sha1[41]; char end_pobj_sha1[41]; unsigned char bundle_sha1[20]; struct strbuf bundle = STRBUF_INIT; git_SHA_CTX c; FILE * out; if (!read_sha1(fp, start_pobj_sha1) || !read_sha1(fp, end_pobj_sha1)) return error("protocol error: could not read sha1"); if (!enter_bundle_dir(basepath, start_pobj_sha1, end_pobj_sha1)) return error("Failed to enter gidit pushobj dir"); // now we need to read in the bundle, and store it in it's own sha1 strbuf_getline(&bundle, fp, EOF); if (bundle.len == 0) return error("Protocol error while reading bundle"); git_SHA1_Init(&c); git_SHA1_Update(&c, bundle.buf, bundle.len); git_SHA1_Final(bundle_sha1, &c); out = fopen(sha1_to_hex(bundle_sha1), "w"); if (!out) die("Error while writing bundle"); if (fwrite(bundle.buf, bundle.len, 1, out) != 1) die("Error while writing to bundle"); fclose(out); strbuf_release(&bundle); // create BUNDLE file pointing to sha1 out = fopen("BUNDLES", "a"); if (!out) die("Error while writing to BUNDLE"); fprintf(out, "%s\n", sha1_to_hex(bundle_sha1)); fclose(out); return 0; }
static void flush_one_hunk(struct object_id *result, git_SHA_CTX *ctx) { unsigned char hash[GIT_MAX_RAWSZ]; unsigned short carry = 0; int i; git_SHA1_Final(hash, ctx); git_SHA1_Init(ctx); /* 20-byte sum, with carry */ for (i = 0; i < GIT_SHA1_RAWSZ; ++i) { carry += result->hash[i] + hash[i]; result->hash[i] = carry; carry >>= 8; } }
static void generate_id_list(void) { unsigned char sha1[20], n[20]; git_SHA_CTX ctx; int patchlen; struct strbuf line_buf = STRBUF_INIT; git_SHA1_Init(&ctx); hashclr(sha1); while (!feof(stdin)) { patchlen = get_one_patchid(n, &ctx, &line_buf); flush_current_id(patchlen, sha1, &ctx); hashcpy(sha1, n); } strbuf_release(&line_buf); }
static const char *open_pack_file(const char *pack_name) { if (from_stdin) { input_fd = 0; if (!pack_name) { static char tmpfile[PATH_MAX]; output_fd = odb_mkstemp(tmpfile, sizeof(tmpfile), "pack/tmp_pack_XXXXXX"); pack_name = xstrdup(tmpfile); } else output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600); if (output_fd < 0) die_errno("unable to create '%s'", pack_name); pack_fd = output_fd; } else { input_fd = open(pack_name, O_RDONLY); if (input_fd < 0) die_errno("cannot open packfile '%s'", pack_name); output_fd = -1; pack_fd = input_fd; } git_SHA1_Init(&input_ctx); return pack_name; }
static int handle_path(unsigned char *sha1, struct rerere_io *io, int marker_size) { git_SHA_CTX ctx; int hunk_no = 0; enum { RR_CONTEXT = 0, RR_SIDE_1, RR_SIDE_2, RR_ORIGINAL } hunk = RR_CONTEXT; struct strbuf one = STRBUF_INIT, two = STRBUF_INIT; struct strbuf buf = STRBUF_INIT; if (sha1) git_SHA1_Init(&ctx); while (!io->getline(&buf, io)) { if (is_cmarker(buf.buf, '<', marker_size, 1)) { if (hunk != RR_CONTEXT) goto bad; hunk = RR_SIDE_1; } else if (is_cmarker(buf.buf, '|', marker_size, 0)) { if (hunk != RR_SIDE_1) goto bad; hunk = RR_ORIGINAL; } else if (is_cmarker(buf.buf, '=', marker_size, 0)) { if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL) goto bad; hunk = RR_SIDE_2; } else if (is_cmarker(buf.buf, '>', marker_size, 1)) { if (hunk != RR_SIDE_2) goto bad; if (strbuf_cmp(&one, &two) > 0) strbuf_swap(&one, &two); hunk_no++; hunk = RR_CONTEXT; rerere_io_putconflict('<', marker_size, io); rerere_io_putmem(one.buf, one.len, io); rerere_io_putconflict('=', marker_size, io); rerere_io_putmem(two.buf, two.len, io); rerere_io_putconflict('>', marker_size, io); if (sha1) { git_SHA1_Update(&ctx, one.buf ? one.buf : "", one.len + 1); git_SHA1_Update(&ctx, two.buf ? two.buf : "", two.len + 1); } strbuf_reset(&one); strbuf_reset(&two); } else if (hunk == RR_SIDE_1) strbuf_addbuf(&one, &buf); else if (hunk == RR_ORIGINAL) ; /* discard */ else if (hunk == RR_SIDE_2) strbuf_addbuf(&two, &buf); else rerere_io_putstr(buf.buf, io); continue; bad: hunk = 99; /* force error exit */ break; } strbuf_release(&one); strbuf_release(&two); strbuf_release(&buf); if (sha1) git_SHA1_Final(sha1, &ctx); if (hunk != RR_CONTEXT) return -1; return hunk_no; }
static int get_one_patchid(struct object_id *next_oid, struct object_id *result, struct strbuf *line_buf, int stable) { int patchlen = 0, found_next = 0; int before = -1, after = -1; git_SHA_CTX ctx; git_SHA1_Init(&ctx); oidclr(result); while (strbuf_getwholeline(line_buf, stdin, '\n') != EOF) { char *line = line_buf->buf; const char *p = line; int len; if (!skip_prefix(line, "diff-tree ", &p) && !skip_prefix(line, "commit ", &p) && !skip_prefix(line, "From ", &p) && starts_with(line, "\\ ") && 12 < strlen(line)) continue; if (!get_oid_hex(p, next_oid)) { found_next = 1; break; } /* Ignore commit comments */ if (!patchlen && !starts_with(line, "diff ")) continue; /* Parsing diff header? */ if (before == -1) { if (starts_with(line, "index ")) continue; else if (starts_with(line, "--- ")) before = after = 1; else if (!isalpha(line[0])) break; } /* Looking for a valid hunk header? */ if (before == 0 && after == 0) { if (starts_with(line, "@@ -")) { /* Parse next hunk, but ignore line numbers. */ scan_hunk_header(line, &before, &after); continue; } /* Split at the end of the patch. */ if (!starts_with(line, "diff ")) break; /* Else we're parsing another header. */ if (stable) flush_one_hunk(result, &ctx); before = after = -1; } /* If we get here, we're inside a hunk. */ if (line[0] == '-' || line[0] == ' ') before--; if (line[0] == '+' || line[0] == ' ') after--; /* Compute the sha without whitespace */ len = remove_space(line); patchlen += len; git_SHA1_Update(&ctx, line, len); } if (!found_next) oidclr(next_oid); flush_one_hunk(result, &ctx); return patchlen; }
static int handle_file(const char *path, unsigned char *sha1, const char *output) { git_SHA_CTX ctx; char buf[1024]; int hunk_no = 0; enum { RR_CONTEXT = 0, RR_SIDE_1, RR_SIDE_2, RR_ORIGINAL, } hunk = RR_CONTEXT; struct strbuf one = STRBUF_INIT, two = STRBUF_INIT; FILE *f = fopen(path, "r"); FILE *out = NULL; int wrerror = 0; if (!f) return error("Could not open %s", path); if (output) { out = fopen(output, "w"); if (!out) { fclose(f); return error("Could not write %s", output); } } if (sha1) git_SHA1_Init(&ctx); while (fgets(buf, sizeof(buf), f)) { if (!prefixcmp(buf, "<<<<<<< ")) { if (hunk != RR_CONTEXT) goto bad; hunk = RR_SIDE_1; } else if (!prefixcmp(buf, "|||||||") && isspace(buf[7])) { if (hunk != RR_SIDE_1) goto bad; hunk = RR_ORIGINAL; } else if (!prefixcmp(buf, "=======") && isspace(buf[7])) { if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL) goto bad; hunk = RR_SIDE_2; } else if (!prefixcmp(buf, ">>>>>>> ")) { if (hunk != RR_SIDE_2) goto bad; if (strbuf_cmp(&one, &two) > 0) strbuf_swap(&one, &two); hunk_no++; hunk = RR_CONTEXT; if (out) { ferr_puts("<<<<<<<\n", out, &wrerror); ferr_write(one.buf, one.len, out, &wrerror); ferr_puts("=======\n", out, &wrerror); ferr_write(two.buf, two.len, out, &wrerror); ferr_puts(">>>>>>>\n", out, &wrerror); } if (sha1) { git_SHA1_Update(&ctx, one.buf ? one.buf : "", one.len + 1); git_SHA1_Update(&ctx, two.buf ? two.buf : "", two.len + 1); } strbuf_reset(&one); strbuf_reset(&two); } else if (hunk == RR_SIDE_1) strbuf_addstr(&one, buf); else if (hunk == RR_ORIGINAL) ; /* discard */ else if (hunk == RR_SIDE_2) strbuf_addstr(&two, buf); else if (out) ferr_puts(buf, out, &wrerror); continue; bad: hunk = 99; /* force error exit */ break; } strbuf_release(&one); strbuf_release(&two); fclose(f); if (wrerror) error("There were errors while writing %s (%s)", path, strerror(wrerror)); if (out && fclose(out)) wrerror = error("Failed to flush %s: %s", path, strerror(errno)); if (sha1) git_SHA1_Final(sha1, &ctx); if (hunk != RR_CONTEXT) { if (output) unlink(output); return error("Could not parse conflict hunks in %s", path); } if (wrerror) return -1; return hunk_no; }
static void ipc_do_configure_client(struct bind_msg *bmsg) { int ret, i; char type[TYPNAMSIZ]; size_t num = 0, orig; git_SHA_CTX sha; unsigned char hashout[20], hash[40]; char hashopt[1024], str[64]; for (i = 0; i < MAX_PROPS; ++i) { if (bmsg->props[i] != 0) num++; } bind_elems_in_stack(lower_fb_name, bmsg->name); init_reconfig(bmsg->name, "ch.ethz.csg.pf_lana", lower_fb_name, "ch.ethz.csg.eth"); setopt_of_elem_in_stack(bmsg->name, "iface=eth0", strlen("iface=eth0")); //XXX printd("%s bound to eth0!\n", bmsg->name); memset(hashopt, 0, sizeof(hashopt)); git_SHA1_Init(&sha); git_SHA1_Update(&sha, "ch.ethz.csg.eth-ch.ethz.csg.pf_lana", strlen("ch.ethz.csg.eth-ch.ethz.csg.pf_lana")); git_SHA1_Final(hash, &sha); git_SHA1_Init(&sha); git_SHA1_Update(&sha, bmsg->app, strlen(bmsg->app)); git_SHA1_Final(&hash[20], &sha); git_SHA1_Init(&sha); git_SHA1_Update(&sha, hash, sizeof(hash)); git_SHA1_Final(hashout, &sha); snprintf(hashopt, sizeof(hashopt)-1, "%s=%s", bin2hex_compat(hashout, 8, str, sizeof(str)), bmsg->name); setopt_of_elem_in_stack(lower_fb_name, hashopt, strlen(hashopt)); printd("%s set with opt: %s\n", lower_fb_name, hashopt); strlcpy(srv_name, bmsg->name, FBNAMSIZ); strlcpy(srv_app, bmsg->app, FBNAMSIZ); if (bmsg->flags == TYPE_SERVER) { reconfig_tell_app(bmsg->app); printd("Registered server %s for app %s\n", srv_name, srv_app); start_negotiation_server(bmsg->name); server = 1; return; }else if (bmsg->flags == TYPE_CLIENT) { orig = num; server = 0; while ((ret = find_type_by_properties(type, bmsg->props, &num)) >= -32) { char name[FBNAMSIZ]; printd("Found match for %s: %s,%d (satisfied %zu of %zu)\n", bmsg->name, type, ret, orig - num, orig); insert_and_bind_elem_to_vstack(type, name, sizeof(name)); memset(type, 0, sizeof(type)); memset(name, 0, sizeof(name)); } if (num > 0) { printd("Cannot match requirements! Unable to connect socket!\n"); //XXX cleanup! return; } printd("Initiate negotiation with server....\n"); ret = init_negotiation(bmsg->name, bmsg->app); printd("client negotiation returned with %d!\n", ret); if (ret < 0) { printd("Remote end does not support stack config!\n"); return; } // commit_vstack(bmsg->app); } printd("IPC Client %s up and running!\n", bmsg->name); }
static int deflate_to_pack(struct bulk_checkin_state *state, unsigned char result_sha1[], int fd, size_t size, enum object_type type, const char *path, unsigned flags) { off_t seekback, already_hashed_to; git_SHA_CTX ctx; unsigned char obuf[16384]; unsigned header_len; struct sha1file_checkpoint checkpoint; struct pack_idx_entry *idx = NULL; seekback = lseek(fd, 0, SEEK_CUR); if (seekback == (off_t) -1) return error("cannot find the current offset"); header_len = xsnprintf((char *)obuf, sizeof(obuf), "%s %" PRIuMAX, typename(type), (uintmax_t)size) + 1; git_SHA1_Init(&ctx); git_SHA1_Update(&ctx, obuf, header_len); /* Note: idx is non-NULL when we are writing */ if ((flags & HASH_WRITE_OBJECT) != 0) idx = xcalloc(1, sizeof(*idx)); already_hashed_to = 0; while (1) { prepare_to_stream(state, flags); if (idx) { sha1file_checkpoint(state->f, &checkpoint); idx->offset = state->offset; crc32_begin(state->f); } if (!stream_to_pack(state, &ctx, &already_hashed_to, fd, size, type, path, flags)) break; /* * Writing this object to the current pack will make * it too big; we need to truncate it, start a new * pack, and write into it. */ if (!idx) die("BUG: should not happen"); sha1file_truncate(state->f, &checkpoint); state->offset = checkpoint.offset; finish_bulk_checkin(state); if (lseek(fd, seekback, SEEK_SET) == (off_t) -1) return error("cannot seek back"); } git_SHA1_Final(result_sha1, &ctx); if (!idx) return 0; idx->crc32 = crc32_end(state->f); if (already_written(state, result_sha1)) { sha1file_truncate(state->f, &checkpoint); state->offset = checkpoint.offset; free(idx); } else { hashcpy(idx->oid.hash, result_sha1); ALLOC_GROW(state->written, state->nr_written + 1, state->alloc_written); state->written[state->nr_written++] = idx; } return 0; }
/** * Initialize user directories, takes PGP */ int gidit_proj_init(FILE *fp, const char * basepath, unsigned int flags) { FILE * pgp_fp; struct strbuf pgp_key = STRBUF_INIT; struct strbuf proj_name = STRBUF_INIT; unsigned char sha1[20]; char pgp_sha1[41]; git_SHA_CTX c; strbuf_getline(&proj_name, fp, '\n'); if (proj_name.len == 0) { strbuf_release(&pgp_key); strbuf_release(&proj_name); return error("Error while reading project name\n"); } strbuf_getline(&pgp_key, fp, EOF); if (pgp_key.len == 0) { strbuf_release(&pgp_key); strbuf_release(&proj_name); return error("Error while reading pgp_key"); } // hash the pgp key git_SHA1_Init(&c); git_SHA1_Update(&c, pgp_key.buf, pgp_key.len); git_SHA1_Final(sha1, &c); // change dir to pushobjects dir if (chdir(basepath) || chdir(PUSHOBJ_DIR)) return error("Error going to pushobjects directory\n"); sprintf(pgp_sha1, "%s", sha1_to_hex(sha1)); if (safe_create_dir(pgp_sha1)) exit(1); chdir(pgp_sha1); // now ensure the project directories existence if (safe_create_dir(proj_name.buf)) exit(1); // if pgp key file already exists, not need to resave if (access("PGP", F_OK)) { // save the PGP key in there pgp_fp = fopen("PGP", "w"); if (!pgp_fp) die("Error while saving PGP key"); fwrite(pgp_key.buf, pgp_key.len, 1, pgp_fp); fclose(pgp_fp); } strbuf_release(&pgp_key); strbuf_release(&proj_name); return 0; }