static int replace_name(struct commit_name *e, int prio, const unsigned char *sha1, struct tag **tag) { if (!e || e->prio < prio) return 1; if (e->prio == 2 && prio == 2) { /* Multiple annotated tags point to the same commit. * Select one to keep based upon their tagger date. */ struct tag *t; if (!e->tag) { t = lookup_tag(e->sha1); if (!t || parse_tag(t)) return 1; e->tag = t; } t = lookup_tag(sha1); if (!t || parse_tag(t)) return 0; *tag = t; if (e->tag->date < t->date) return 1; } return 0; }
static int check_one_mergetag(struct commit *commit, struct commit_extra_header *extra, void *data) { struct check_mergetag_data *mergetag_data = (struct check_mergetag_data *)data; const char *ref = mergetag_data->argv[0]; struct object_id tag_oid; struct tag *tag; int i; hash_object_file(extra->value, extra->len, type_name(OBJ_TAG), &tag_oid); tag = lookup_tag(&tag_oid); if (!tag) return error(_("bad mergetag in commit '%s'"), ref); if (parse_tag_buffer(tag, extra->value, extra->len)) return error(_("malformed mergetag in commit '%s'"), ref); /* iterate over new parents */ for (i = 1; i < mergetag_data->argc; i++) { struct object_id oid; if (get_oid(mergetag_data->argv[i], &oid) < 0) return error(_("Not a valid object name: '%s'"), mergetag_data->argv[i]); if (!oidcmp(&tag->tagged->oid, &oid)) return 0; /* found */ } return error(_("original commit '%s' contains mergetag '%s' that is " "discarded; use --edit instead of --graft"), ref, oid_to_hex(&tag_oid)); }
void mp_set_codec_from_tag(struct sh_stream *sh) { switch (sh->type) { case STREAM_VIDEO: sh->codec = lookup_tag(mp_video_codec_tags, avformat_get_riff_video_tags(), sh->format); break; case STREAM_AUDIO: sh->codec = lookup_tag(mp_audio_codec_tags, avformat_get_riff_audio_tags(), sh->format); break; default: ; } }
struct object *parse_object(unsigned char *sha1) { unsigned long mapsize; void *map = map_sha1_file(sha1, &mapsize); if (map) { char type[100]; unsigned long size; void *buffer = unpack_sha1_file(map, mapsize, type, &size); if (!buffer) return NULL; if (check_sha1_signature(sha1, buffer, size, type) < 0) printf("sha1 mismatch %s\n", sha1_to_hex(sha1)); munmap(map, mapsize); if (!strcmp(type, "blob")) { struct blob *ret = lookup_blob(sha1); parse_blob(ret); return &ret->object; } else if (!strcmp(type, "tree")) { struct tree *ret = lookup_tree(sha1); parse_tree(ret); return &ret->object; } else if (!strcmp(type, "commit")) { struct commit *ret = lookup_commit(sha1); parse_commit(ret); return &ret->object; } else if (!strcmp(type, "tag")) { struct tag *ret = lookup_tag(sha1); parse_tag(ret); return &ret->object; } else { return NULL; } } return NULL; }
int parse_tag_buffer(struct tag *item, const void *data, unsigned long size) { unsigned char sha1[20]; char type[20]; const char *bufptr = data; const char *tail = bufptr + size; const char *nl; if (item->object.parsed) return 0; item->object.parsed = 1; if (size < 64) return -1; if (memcmp("object ", bufptr, 7) || get_sha1_hex(bufptr + 7, sha1) || bufptr[47] != '\n') return -1; bufptr += 48; /* "object " + sha1 + "\n" */ if (!starts_with(bufptr, "type ")) return -1; bufptr += 5; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl || sizeof(type) <= (nl - bufptr)) return -1; memcpy(type, bufptr, nl - bufptr); type[nl - bufptr] = '\0'; bufptr = nl + 1; if (!strcmp(type, blob_type)) { item->tagged = &lookup_blob(sha1)->object; } else if (!strcmp(type, tree_type)) { item->tagged = &lookup_tree(sha1)->object; } else if (!strcmp(type, commit_type)) { item->tagged = &lookup_commit(sha1)->object; } else if (!strcmp(type, tag_type)) { item->tagged = &lookup_tag(sha1)->object; } else { error("Unknown type %s", type); item->tagged = NULL; } if (bufptr + 4 < tail && starts_with(bufptr, "tag ")) ; /* good */ else return -1; bufptr += 4; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl) return -1; item->tag = xmemdupz(bufptr, nl - bufptr); bufptr = nl + 1; if (bufptr + 7 < tail && starts_with(bufptr, "tagger ")) item->date = parse_tag_date(bufptr, tail); else item->date = 0; return 0; }
int parse_tag_buffer(struct tag *item, const void *data, unsigned long size) { struct object_id oid; char type[20]; const char *bufptr = data; const char *tail = bufptr + size; const char *nl; if (item->object.parsed) return 0; item->object.parsed = 1; if (size < GIT_SHA1_HEXSZ + 24) return -1; if (memcmp("object ", bufptr, 7) || parse_oid_hex(bufptr + 7, &oid, &bufptr) || *bufptr++ != '\n') return -1; if (!starts_with(bufptr, "type ")) return -1; bufptr += 5; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl || sizeof(type) <= (nl - bufptr)) return -1; memcpy(type, bufptr, nl - bufptr); type[nl - bufptr] = '\0'; bufptr = nl + 1; if (!strcmp(type, blob_type)) { item->tagged = (struct object *)lookup_blob(&oid); } else if (!strcmp(type, tree_type)) { item->tagged = (struct object *)lookup_tree(&oid); } else if (!strcmp(type, commit_type)) { item->tagged = (struct object *)lookup_commit(&oid); } else if (!strcmp(type, tag_type)) { item->tagged = (struct object *)lookup_tag(&oid); } else { error("Unknown type %s", type); item->tagged = NULL; } if (bufptr + 4 < tail && starts_with(bufptr, "tag ")) ; /* good */ else return -1; bufptr += 4; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl) return -1; item->tag = xmemdupz(bufptr, nl - bufptr); bufptr = nl + 1; if (bufptr + 7 < tail && starts_with(bufptr, "tagger ")) item->date = parse_tag_date(bufptr, tail); else item->date = 0; return 0; }
void mp_set_codec_from_tag(struct sh_stream *sh) { sh->codec = lookup_tag(sh->type, sh->format); if (sh->audio && sh->audio->bits_per_coded_sample) { const char *codec = map_audio_pcm_tag(sh->format, sh->audio->bits_per_coded_sample); if (codec) sh->codec = codec; } }
/* Return a reference to attribute tag (different from xref_tag because there is no implicit declaration) */ tag_ref lookup_attribute(word tag) { tag_ref tref = newkind_tag_ref(parse_region, kind_attribute_ref, tag->location, tag, NULL, NULL, FALSE); tag_declaration tdecl = lookup_tag(tref, FALSE); if (!tdecl) error_with_location(tag->location, "unknown attribute `%s'", tag->cstring.data); tref->tdecl = tdecl; return tref; }
static void show_one_mergetag(struct rev_info *opt, struct commit_extra_header *extra, struct commit *commit) { unsigned char sha1[20]; struct tag *tag; struct strbuf verify_message; int status, nth; size_t payload_size, gpg_message_offset; hash_sha1_file(extra->value, extra->len, typename(OBJ_TAG), sha1); tag = lookup_tag(sha1); if (!tag) return; /* error message already given */ strbuf_init(&verify_message, 256); if (parse_tag_buffer(tag, extra->value, extra->len)) strbuf_addstr(&verify_message, "malformed mergetag\n"); else if (is_common_merge(commit) && !hashcmp(tag->tagged->sha1, commit->parents->next->item->object.sha1)) strbuf_addf(&verify_message, "merged tag '%s'\n", tag->tag); else if ((nth = which_parent(tag->tagged->sha1, commit)) < 0) strbuf_addf(&verify_message, "tag %s names a non-parent %s\n", tag->tag, tag->tagged->sha1); else strbuf_addf(&verify_message, "parent #%d, tagged '%s'\n", nth + 1, tag->tag); gpg_message_offset = verify_message.len; payload_size = parse_signature(extra->value, extra->len); if ((extra->len <= payload_size) || (verify_signed_buffer(extra->value, payload_size, extra->value + payload_size, extra->len - payload_size, &verify_message) && verify_message.len <= gpg_message_offset)) { strbuf_addstr(&verify_message, "No signature\n"); status = -1; } else if (strstr(verify_message.buf + gpg_message_offset, ": Good signature from ")) status = 0; else status = -1; show_sig_lines(opt, status, verify_message.buf); strbuf_release(&verify_message); }
struct object *parse_object_buffer(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p) { struct object *obj; *eaten_p = 0; obj = NULL; if (type == OBJ_BLOB) { struct blob *blob = lookup_blob(oid); if (blob) { if (parse_blob_buffer(blob, buffer, size)) return NULL; obj = &blob->object; } } else if (type == OBJ_TREE) { struct tree *tree = lookup_tree(oid); if (tree) { obj = &tree->object; if (!tree->buffer) tree->object.parsed = 0; if (!tree->object.parsed) { if (parse_tree_buffer(tree, buffer, size)) return NULL; *eaten_p = 1; } } } else if (type == OBJ_COMMIT) { struct commit *commit = lookup_commit(oid); if (commit) { if (parse_commit_buffer(commit, buffer, size)) return NULL; if (!get_cached_commit_buffer(commit, NULL)) { set_commit_buffer(commit, buffer, size); *eaten_p = 1; } obj = &commit->object; } } else if (type == OBJ_TAG) { struct tag *tag = lookup_tag(oid); if (tag) { if (parse_tag_buffer(tag, buffer, size)) return NULL; obj = &tag->object; } } else { warning("object %s has unknown type id %d", oid_to_hex(oid), type); obj = NULL; } return obj; }
static void show_one_mergetag(struct commit *commit, struct commit_extra_header *extra, void *data) { struct rev_info *opt = (struct rev_info *)data; unsigned char sha1[20]; struct tag *tag; struct strbuf verify_message; int status, nth; size_t payload_size, gpg_message_offset; hash_sha1_file(extra->value, extra->len, typename(OBJ_TAG), sha1); tag = lookup_tag(sha1); if (!tag) return; /* error message already given */ strbuf_init(&verify_message, 256); if (parse_tag_buffer(tag, extra->value, extra->len)) strbuf_addstr(&verify_message, "malformed mergetag\n"); else if (is_common_merge(commit) && !oidcmp(&tag->tagged->oid, &commit->parents->next->item->object.oid)) strbuf_addf(&verify_message, "merged tag '%s'\n", tag->tag); else if ((nth = which_parent(tag->tagged->oid.hash, commit)) < 0) strbuf_addf(&verify_message, "tag %s names a non-parent %s\n", tag->tag, tag->tagged->oid.hash); else strbuf_addf(&verify_message, "parent #%d, tagged '%s'\n", nth + 1, tag->tag); gpg_message_offset = verify_message.len; payload_size = parse_signature(extra->value, extra->len); status = -1; if (extra->len > payload_size) { /* could have a good signature */ if (!verify_signed_buffer(extra->value, payload_size, extra->value + payload_size, extra->len - payload_size, &verify_message, NULL)) status = 0; /* good */ else if (verify_message.len <= gpg_message_offset) strbuf_addstr(&verify_message, "No signature\n"); /* otherwise we couldn't verify, which is shown as bad */ } show_sig_lines(opt, status, verify_message.buf); strbuf_release(&verify_message); }
static void display_name(struct commit_name *n) { if (n->prio == 2 && !n->tag) { n->tag = lookup_tag(n->sha1); if (!n->tag || parse_tag(n->tag) || !n->tag->tag) die("annotated tag %s not available", n->path); if (strcmp(n->tag->tag, n->path)) warning("tag '%s' is really '%s' here", n->tag->tag, n->path); } if (n->tag) printf("%s", n->tag->tag); else printf("%s", n->path); }
void cgit_print_tag(char *revname) { unsigned char sha1[20]; struct object *obj; struct tag *tag; struct taginfo *info; if (get_sha1(revname, sha1)) { cgit_print_error(fmt("Bad tag reference: %s", revname)); return; } obj = parse_object(sha1); if (!obj) { cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1))); return; } if (obj->type == OBJ_TAG) { tag = lookup_tag(sha1); if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) { cgit_print_error(fmt("Bad tag object: %s", revname)); return; } html("<table class='commit-info'>\n"); htmlf("<tr><td>Tag name</td><td>%s (%s)</td></tr>\n", revname, sha1_to_hex(sha1)); if (info->tagger_date > 0) { html("<tr><td>Tag date</td><td>"); cgit_print_date(info->tagger_date, FMT_LONGDATE, ctx.cfg.local_time); html("</td></tr>\n"); } if (info->tagger) { html("<tr><td>Tagged by</td><td>"); html_txt(info->tagger); if (info->tagger_email) { html(" "); html_txt(info->tagger_email); } html("</td></tr>\n"); } html("<tr><td>Tagged object</td><td>"); cgit_object_link(tag->tagged); html("</td></tr>\n"); html("</table>\n"); print_tag_content(info->msg); } return; }
static void display_name(struct commit_name *n) { if (n->prio == 2 && !n->tag) { n->tag = lookup_tag(n->sha1); if (!n->tag || parse_tag(n->tag)) die(_("annotated tag %s not available"), n->path); } if (n->tag && !n->name_checked) { if (!n->tag->tag) die(_("annotated tag %s has no embedded name"), n->path); if (strcmp(n->tag->tag, all ? n->path + 5 : n->path)) warning(_("tag '%s' is really '%s' here"), n->tag->tag, n->path); n->name_checked = 1; } if (n->tag) printf("%s", n->tag->tag); else printf("%s", n->path); }
int callback(RULE* rule, void* data) { TAG* tag; IDENTIFIER* identifier; STRING* string; META* meta; MATCH* match; int rule_match; int string_found; int show = TRUE; if (show_specified_tags) { show = FALSE; tag = specified_tags_list; while (tag != NULL) { if (lookup_tag(rule->tag_list_head, tag->identifier) != NULL) { show = TRUE; break; } tag = tag->next; } } if (show_specified_rules) { show = FALSE; identifier = specified_rules_list; while (identifier != NULL) { if (strcmp(identifier->name, rule->identifier) == 0) { show = TRUE; break; } identifier = identifier->next; } } rule_match = (rule->flags & RULE_FLAGS_MATCH); show = show && ((!negate && rule_match) || (negate && !rule_match)); if (show) { printf("%s ", rule->identifier); if (show_tags) { tag = rule->tag_list_head; printf("["); while(tag != NULL) { if (tag->next == NULL) { printf("%s", tag->identifier); } else { printf("%s,", tag->identifier); } tag = tag->next; } printf("] "); } if (show_meta) { meta = rule->meta_list_head; printf("["); while(meta != NULL) { if (meta->type == META_TYPE_INTEGER) { printf("%s=%lu", meta->identifier, meta->integer); } else if (meta->type == META_TYPE_BOOLEAN) { printf("%s=%s", meta->identifier, (meta->boolean)?("true"):("false")); } else { printf("%s=\"%s\"", meta->identifier, meta->string); } if (meta->next != NULL) printf(","); meta = meta->next; } printf("] "); } printf("%s\n", (char*) data); /* show matched strings */ if (show_strings) { string = rule->string_list_head; while (string != NULL) { string_found = string->flags & STRING_FLAGS_FOUND; if (string_found) { match = string->matches_head; while (match != NULL) { printf("0x%lx:%s: ", match->offset, string->identifier); if (IS_HEX(string)) { print_hex_string(match->data, match->length); } else if (IS_WIDE(string)) { print_string(match->data, match->length, TRUE); } else { print_string(match->data, match->length, FALSE); } match = match->next; } } string = string->next; } } } if (rule_match) count++; if (limit != 0 && count >= limit) return CALLBACK_ABORT; return CALLBACK_CONTINUE; }
void cgit_print_tag(char *revname) { struct strbuf fullref = STRBUF_INIT; unsigned char sha1[20]; struct object *obj; struct tag *tag; struct taginfo *info; if (!revname) revname = ctx.qry.head; strbuf_addf(&fullref, "refs/tags/%s", revname); if (get_sha1(fullref.buf, sha1)) { cgit_print_error_page(404, "Not found", "Bad tag reference: %s", revname); goto cleanup; } obj = parse_object(sha1); if (!obj) { cgit_print_error_page(500, "Internal server error", "Bad object id: %s", sha1_to_hex(sha1)); goto cleanup; } if (obj->type == OBJ_TAG) { tag = lookup_tag(sha1); if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) { cgit_print_error_page(500, "Internal server error", "Bad tag object: %s", revname); goto cleanup; } cgit_print_layout_start(); html("<table class='commit-info'>\n"); htmlf("<tr><td>tag name</td><td>"); html_txt(revname); htmlf(" (%s)</td></tr>\n", sha1_to_hex(sha1)); if (info->tagger_date > 0) { html("<tr><td>tag date</td><td>"); cgit_print_date(info->tagger_date, FMT_LONGDATE, ctx.cfg.local_time); html("</td></tr>\n"); } if (info->tagger) { html("<tr><td>tagged by</td><td>"); cgit_open_filter(ctx.repo->email_filter, info->tagger_email, "tag"); html_txt(info->tagger); if (info->tagger_email && !ctx.cfg.noplainemail) { html(" "); html_txt(info->tagger_email); } cgit_close_filter(ctx.repo->email_filter); html("</td></tr>\n"); } html("<tr><td>tagged object</td><td class='sha1'>"); cgit_object_link(tag->tagged); html("</td></tr>\n"); if (ctx.repo->snapshots) print_download_links(revname); html("</table>\n"); print_tag_content(info->msg); cgit_print_layout_end(); } else { cgit_print_layout_start(); html("<table class='commit-info'>\n"); htmlf("<tr><td>tag name</td><td>"); html_txt(revname); html("</td></tr>\n"); html("<tr><td>Tagged object</td><td class='sha1'>"); cgit_object_link(obj); html("</td></tr>\n"); if (ctx.repo->snapshots) print_download_links(revname); html("</table>\n"); cgit_print_layout_end(); } cleanup: strbuf_release(&fullref); }
void mp_set_audio_codec_from_tag(struct sh_audio *sh) { sh->gsh->codec = lookup_tag(mp_audio_codec_tags, avformat_get_riff_audio_tags(), sh->format); }