| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package patch |
| |
| import ( |
| "bytes"; |
| "compress/zlib"; |
| "crypto/sha1"; |
| "encoding/git85"; |
| "fmt"; |
| "io"; |
| "os"; |
| ) |
| |
| func gitSHA1(data []byte) []byte { |
| if len(data) == 0 { |
| // special case: 0 length is all zeros sum |
| return make([]byte, 20) |
| } |
| h := sha1.New(); |
| fmt.Fprintf(h, "blob %d\x00", len(data)); |
| h.Write(data); |
| return h.Sum(); |
| } |
| |
| // BUG(rsc): The GIT binary delta format is not implemented, only GIT binary literals. |
| |
| // GITBinaryLiteral represents a GIT binary literal diff. |
| type GITBinaryLiteral struct { |
| OldSHA1 []byte; // if non-empty, the SHA1 hash of the original |
| New []byte; // the new contents |
| } |
| |
| // Apply implements the Diff interface's Apply method. |
| func (d *GITBinaryLiteral) Apply(old []byte) ([]byte, os.Error) { |
| if sum := gitSHA1(old); !bytes.HasPrefix(sum, d.OldSHA1) { |
| return nil, ErrPatchFailure |
| } |
| return d.New, nil; |
| } |
| |
| func unhex(c byte) uint8 { |
| switch { |
| case '0' <= c && c <= '9': |
| return c - '0' |
| case 'a' <= c && c <= 'f': |
| return c - 'a' + 10 |
| case 'A' <= c && c <= 'F': |
| return c - 'A' + 10 |
| } |
| return 255; |
| } |
| |
| func getHex(s []byte) (data []byte, rest []byte) { |
| n := 0; |
| for n < len(s) && unhex(s[n]) != 255 { |
| n++ |
| } |
| n &^= 1; // Only take an even number of hex digits. |
| data = make([]byte, n/2); |
| for i := range data { |
| data[i] = unhex(s[2*i])<<4 | unhex(s[2*i+1]) |
| } |
| rest = s[n:len(s)]; |
| return; |
| } |
| |
| // ParseGITBinary parses raw as a GIT binary patch. |
| func ParseGITBinary(raw []byte) (Diff, os.Error) { |
| var oldSHA1, newSHA1 []byte; |
| var sawBinary bool; |
| |
| for { |
| var first []byte; |
| first, raw, _ = getLine(raw, 1); |
| first = bytes.TrimSpace(first); |
| if s, ok := skip(first, "index "); ok { |
| oldSHA1, s = getHex(s); |
| if s, ok = skip(s, ".."); !ok { |
| continue |
| } |
| newSHA1, s = getHex(s); |
| continue; |
| } |
| if _, ok := skip(first, "GIT binary patch"); ok { |
| sawBinary = true; |
| continue; |
| } |
| if n, _, ok := atoi(first, "literal ", 10); ok && sawBinary { |
| data := make([]byte, n); |
| d := git85.NewDecoder(bytes.NewBuffer(raw)); |
| z, err := zlib.NewInflater(d); |
| if err != nil { |
| return nil, err |
| } |
| defer z.Close(); |
| if _, err = io.ReadFull(z, data); err != nil { |
| if err == os.EOF { |
| err = io.ErrUnexpectedEOF |
| } |
| return nil, err; |
| } |
| var buf [1]byte; |
| m, err := z.Read(&buf); |
| if m != 0 || err != os.EOF { |
| return nil, os.NewError("GIT binary literal longer than expected") |
| } |
| |
| if sum := gitSHA1(data); !bytes.HasPrefix(sum, newSHA1) { |
| return nil, os.NewError("GIT binary literal SHA1 mismatch") |
| } |
| return &GITBinaryLiteral{oldSHA1, data}, nil; |
| } |
| if !sawBinary { |
| return nil, os.NewError("unexpected GIT patch header: " + string(first)) |
| } |
| } |
| panic("unreachable"); |
| } |