ardump

chore/ardump/ardump.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"fmt"
+	"io"
 	"log"
 	"os"
 
@@ -34,14 +35,17 @@ func main() {
 	check(err)
 	defer f.Close()
 
-	r := ar.NewReader(f)
+	r, err := ar.NewReader(f)
+	check(err)
 	for {
 		hdr, err := r.Next()
 		if err != nil {
-			log.Println(err)
+			if err != io.EOF {
+				log.Println(err)
+			}
 			break
 		}
-		fmt.Println("==>", hdr.Name)
+		fmt.Println(hdr.Name)
 	}
 }
 

x/ar/common.go

@@ -17,14 +17,31 @@
 package ar
 
 import (
+	"errors"
 	"time"
 )
 
-const (
+var (
-	headerByteSize = 60
+	errInvalidHeader = errors.New("ar: invalid header")
-	globalHeader   = "!<arch>\n"
+	errWriteTooLong  = errors.New("ar: write too long")
 )
 
+const (
+	globalHeader    = "!<arch>\n"
+	globalHeaderLen = len(globalHeader)
+	headerByteSize  = 60
+)
+
+type recHeader struct {
+	name    [16]byte
+	modTime [12]byte
+	uid     [6]byte
+	gid     [6]byte
+	mode    [8]byte
+	size    [10]byte
+	eol     [2]byte
+}
+
 type Header struct {
 	Name    string
 	ModTime time.Time

x/ar/reader.go

@@ -19,7 +19,8 @@ package ar
 import (
 	"io"
 	"strconv"
-	"time"
+	"strings"
+	"unsafe"
 )
 
 // Provides read access to an ar archive.
@@ -46,41 +47,24 @@ type Reader struct {
 }
 
 // Copies read data to r. Strips the global ar header.
-func NewReader(r io.Reader) *Reader {
+func NewReader(r io.Reader) (*Reader, error) {
-	io.CopyN(io.Discard, r, 8) // Discard global header
+	buf := make([]byte, globalHeaderLen)
-
+	if _, err := io.ReadFull(r, buf); err != nil {
-	return &Reader{r: r}
+		return nil, err
-}
+	}
-
+	if string(buf) != globalHeader {
-func (rd *Reader) string(b []byte) string {
+		return nil, errInvalidHeader
-	i := len(b) - 1
-	for i > 0 && b[i] == 32 {
-		i--
 	}
 
-	return string(b[0 : i+1])
+	return &Reader{r: r}, nil
 }
 
-func (rd *Reader) numeric(b []byte) int64 {
+func stringVal(b []byte) string {
-	i := len(b) - 1
+	return strings.TrimRight(string(b), " ")
-	for i > 0 && b[i] == 32 {
-		i--
-	}
-
-	n, _ := strconv.ParseInt(string(b[0:i+1]), 10, 64)
-
-	return n
 }
 
-func (rd *Reader) octal(b []byte) int64 {
+func intVal(b []byte) (int64, error) {
-	i := len(b) - 1
+	return strconv.ParseInt(stringVal(b), 10, 64)
-	for i > 0 && b[i] == 32 {
-		i--
-	}
-
-	n, _ := strconv.ParseInt(string(b[3:i+1]), 8, 64)
-
-	return n
 }
 
 func (rd *Reader) skipUnread() error {
@@ -95,30 +79,38 @@ func (rd *Reader) skipUnread() error {
 	return err
 }
 
-func (rd *Reader) readHeader() (*Header, error) {
+func (rd *Reader) readHeader() (header *Header, err error) {
-	headerBuf := make([]byte, headerByteSize)
+	var rec recHeader
-	if _, err := io.ReadFull(rd.r, headerBuf); err != nil {
+	var buf = (*[headerByteSize]byte)(unsafe.Pointer(&rec))[:]
-		return nil, err
+	if _, err = io.ReadFull(rd.r, buf); err != nil {
+		return
 	}
 
-	header := new(Header)
+	header = new(Header)
-	s := slicer(headerBuf)
+	header.Name = stringVal(rec.name[:])
+	if header.Size, err = intVal(rec.size[:]); err != nil {
+		return
+	}
 
-	header.Name = rd.string(s.next(16))
-	header.ModTime = time.Unix(rd.numeric(s.next(12)), 0)
-	header.Uid = int(rd.numeric(s.next(6)))
-	header.Gid = int(rd.numeric(s.next(6)))
-	header.Mode = rd.octal(s.next(8))
-	header.Size = rd.numeric(s.next(10))
-
-	rd.nb = int64(header.Size)
 	if header.Size%2 == 1 {
 		rd.pad = 1
 	} else {
 		rd.pad = 0
 	}
 
-	return header, nil
+	if rec.name[0] == '#' {
+		if n, e := strconv.ParseInt(strings.TrimPrefix(header.Name[3:], "#1/"), 10, 64); e == nil {
+			name := make([]byte, n)
+			if _, err = io.ReadFull(rd.r, name); err != nil {
+				return
+			}
+			header.Name = string(name)
+			header.Size -= n
+		}
+	}
+
+	rd.nb = int64(header.Size)
+	return
 }
 
 // Call Next() to skip to the next file in the archive file.

x/ar/writer.go

@@ -17,15 +17,10 @@
 package ar
 
 import (
-	"errors"
 	"io"
 	"strconv"
 )
 
-var (
-	errWriteTooLong = errors.New("ar: write too long")
-)
-
 // Writer provides sequential writing of an ar archive.
 // An ar archive is sequence of header file pairs
 // Call WriteHeader to begin writing a new file, then call Write to supply the file's data