func (overlayWhiteoutConverter) ConvertWrite(hdr *tar.Header, path string, fi os.FileInfo) error {
// convert whiteouts to AUFS format
if fi.Mode()&os.ModeCharDevice != 0 && hdr.Devmajor == 0 && hdr.Devminor == 0 {
// we just rename the file and make it normal
hdr.Name = WhiteoutPrefix + hdr.Name
hdr.Mode = 0600
hdr.Typeflag = tar.TypeReg
}
if fi.Mode()&os.ModeDir != 0 {
// convert opaque dirs to AUFS format by writing an empty file with the prefix
opaque, err := system.Lgetxattr(path, "trusted.overlay.opaque")
if err != nil {
return err
}
if opaque != nil && len(opaque) == 1 && opaque[0] == 'y' {
// create a header for the whiteout file
// it should inherit some properties from the parent, but be a regular file
*hdr = tar.Header{
Typeflag: tar.TypeReg,
Mode: hdr.Mode & int64(os.ModePerm),
Name: filepath.Join(hdr.Name, WhiteoutOpaqueDir),
Size: 0,
Uid: hdr.Uid,
Uname: hdr.Uname,
Gid: hdr.Gid,
Gname: hdr.Gname,
AccessTime: hdr.AccessTime,
ChangeTime: hdr.ChangeTime,
}
}
}
return nil
}
// Process impl
func (p *ArchiveExtract) Process(hdr *tar.Header, r io.Reader) (*tar.Header, io.Reader, error) {
// make sure we have our tempdir
if p.workingDir == "" {
t, err := ioutil.TempDir(p.tempDir, "tar-")
if err != nil {
return hdr, r, err
}
p.workingDir = t
}
// If a directory make it and continue
fpath := filepath.Join(p.workingDir, hdr.Name)
if hdr.FileInfo().IsDir() {
err := os.MkdirAll(fpath, 0755)
return hdr, r, err
}
// Extract the file!
file, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE, hdr.FileInfo().Mode())
if err != nil {
return hdr, r, err
}
defer file.Close()
_, err = io.Copy(file, r)
if err != nil {
return hdr, r, err
}
return hdr, r, nil
}
// Writes the given file into tarfn
func writeItem(tarfn string, fn string) (pos uint64, err error) {
pos = 0
sfh, err := os.Open(fn)
defer sfh.Close()
if sfi, err := sfh.Stat(); err == nil {
hdr := new(tar.Header)
hdr.Name = sfi.Name()
hdr.Size = sfi.Size()
hdr.Mode = int64(sfi.Mode().Perm())
hdr.ModTime = sfi.ModTime()
var (
tw *tar.Writer
f ReadWriteSeekCloser
)
if tw, f, pos, err = OpenForAppend(tarfn); err == nil {
defer f.Close()
defer tw.Close() //LIFO
if err := tw.WriteHeader(hdr); err == nil {
if zw, err := gzip.NewWriterLevel(tw, flate.BestCompression); err == nil {
defer zw.Close()
_, err = io.Copy(zw, sfh)
}
}
}
}
return
}
func writeTarGz(filePath, baseDir string, tarGzWriter *tar.Writer, fileInfo os.FileInfo) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
relativePath, err := filepath.Rel(baseDir, filePath)
if err != nil {
return err
}
header := new(tar.Header)
header.Name = relativePath
header.Size = fileInfo.Size()
header.Mode = int64(fileInfo.Mode())
header.ModTime = fileInfo.ModTime()
err = tarGzWriter.WriteHeader(header)
if err != nil {
return err
}
_, err = io.Copy(tarGzWriter, file)
if err != nil {
return err
}
return nil
}
// file name filelist is like this: './source/file'
func TarFilelist(filelist []string, case_dir string, object_name string) (tar_url string) {
tar_url = path.Join(case_dir, object_name) + ".tar.gz"
fw, err := os.Create(tar_url)
if err != nil {
fmt.Println("Failed in create tar file ", err)
return tar_url
}
defer fw.Close()
gw := gzip.NewWriter(fw)
defer gw.Close()
tw := tar.NewWriter(gw)
defer tw.Close()
for index := 0; index < len(filelist); index++ {
source_file := filelist[index]
fi, err := os.Stat(path.Join(case_dir, source_file))
if err != nil {
fmt.Println(err)
continue
}
fr, err := os.Open(path.Join(case_dir, source_file))
if err != nil {
fmt.Println(err)
continue
}
h := new(tar.Header)
h.Name = source_file
h.Size = fi.Size()
h.Mode = int64(fi.Mode())
h.ModTime = fi.ModTime()
err = tw.WriteHeader(h)
_, err = io.Copy(tw, fr)
}
return tar_url
}
func (t *Tarball) addFile(file *File) error {
// grab a handle on the file to read it into the buffer
fr, err := os.Open(file.path)
if err != nil {
return err
}
defer fr.Close()
if stat, err := fr.Stat(); err == nil {
// create the tarball header for this file
header := new(tar.Header)
header.Name = file.path
header.Size = stat.Size()
header.Mode = int64(stat.Mode())
header.ModTime = stat.ModTime()
// write the header to the current tarball
if err := t.tw.WriteHeader(header); err != nil {
return err
}
// copy the file data over now that the header is set
if _, err := io.Copy(t.tw, fr); err == nil {
t.size += stat.Size()
} else {
return err
}
} else {
return err
}
return nil
}
func addFile(path string, fileInfo os.FileInfo, tarFileWriter *tar.Writer) error {
if fileInfo.IsDir() {
return nil
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
header := new(tar.Header)
header.Name = file.Name()
header.Size = fileInfo.Size()
header.Mode = int64(fileInfo.Mode())
header.ModTime = fileInfo.ModTime()
err = tarFileWriter.WriteHeader(header)
if err != nil {
return err
}
_, err = io.Copy(tarFileWriter, file)
if err != nil {
return err
}
return nil
}
func extractFile(dir string, header *tar.Header, tarReader io.Reader) error {
path := filepath.Join(dir, header.Name)
glog.V(3).Infof("Creating %s", path)
file, err := os.Create(path)
// The file times need to be modified after it's been closed thus this function
// is deferred after the file close (LIFO order for defer)
defer os.Chtimes(path, time.Now(), header.FileInfo().ModTime())
defer file.Close()
if err != nil {
return err
}
glog.V(3).Infof("Extracting/writing %s", path)
written, err := io.Copy(file, tarReader)
if err != nil {
return err
}
if written != header.Size {
return fmt.Errorf("Wrote %d bytes, expected to write %d", written, header.Size)
}
if runtime.GOOS != "windows" { // Skip chmod if on windows OS
return file.Chmod(header.FileInfo().Mode())
}
return nil
}
func compress() {
err := os.Mkdir("non_sparse", 0777)
tarfile, err := os.Create("non_sparse/non_sparse.tar")
if err != nil {
log.Fatalln(err)
}
defer tarfile.Close()
var fileWriter io.WriteCloser = tarfile
tfw := tar.NewWriter(fileWriter)
defer tfw.Close()
file, err := os.Open("sparse.img")
defer file.Close()
fileInfo, err := file.Stat()
header := new(tar.Header)
header.Name = file.Name()
header.Size = fileInfo.Size()
header.Mode = int64(fileInfo.Mode())
header.ModTime = fileInfo.ModTime()
err = tfw.WriteHeader(header)
if err != nil {
log.Fatalln(err)
}
_, err = io.Copy(tfw, file)
if err != nil {
log.Fatalln(err)
}
}
// We have a dummy version of this call in posix.go.
// Windows does not implement the syscall.Stat_t type we
// need, but the *nixes do. We use this in util.AddToArchive
// to set owner/group on files being added to a tar archive.
func GetOwnerAndGroup(finfo os.FileInfo, header *tar.Header) {
systat := finfo.Sys().(*syscall.Stat_t)
if systat != nil {
header.Uid = int(systat.Uid)
header.Gid = int(systat.Gid)
}
}
func (t *TarArchiveProvider) ExtractReader(dst string, src io.Reader) error {
tr := tar.NewReader(src)
for {
var h *tar.Header
h, err := tr.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
fp := filepath.Join(dst, h.Name)
if h.FileInfo().IsDir() {
os.MkdirAll(fp, 0755)
continue
}
os.MkdirAll(filepath.Dir(fp), 0755)
f, err := os.Create(fp)
if err != nil {
return err
}
_, err = io.Copy(f, tr)
f.Close()
if err != nil {
return err
}
os.Chmod(fp, os.FileMode(h.Mode))
}
return nil
}
// Write the files into the tar dir
func writeTar(path string, tw *tar.Writer, fi os.FileInfo) error {
fr, err := os.Open(path)
if err != nil {
return err
}
defer fr.Close()
h := new(tar.Header)
h.Name = fi.Name()
h.Size = fi.Size()
h.Mode = int64(fi.Mode())
h.ModTime = fi.ModTime()
err = tw.WriteHeader(h)
if err != nil {
return err
}
_, err = io.Copy(tw, fr)
if err != nil {
return err
}
return err
}
func addFileToArchive(filePath string, addPath string, tarWriter *tar.Writer, fileInfo os.FileInfo) error {
addPath = filepath.ToSlash(addPath)
if isSymlink(fileInfo) {
link, err := filepath.EvalSymlinks(filePath)
if err != nil {
return err
}
filePath = link
fileInfo, err = os.Lstat(filePath)
if err != nil {
return err
}
}
header := new(tar.Header)
header.Name = addPath
header.Size = fileInfo.Size()
header.Mode = int64(fileInfo.Mode())
header.ModTime = fileInfo.ModTime()
fileReader, err := os.Open(filePath)
if err != nil {
return err
}
defer fileReader.Close()
err = tarWriter.WriteHeader(header)
fail.Handle(err)
_, err = io.Copy(tarWriter, fileReader)
return err
}
func extractTarArchiveFile(header *tar.Header, dest string, input io.Reader) error {
filePath := filepath.Join(dest, header.Name)
fileInfo := header.FileInfo()
if fileInfo.IsDir() {
err := os.MkdirAll(filePath, fileInfo.Mode())
if err != nil {
return err
}
} else {
err := os.MkdirAll(filepath.Dir(filePath), 0755)
if err != nil {
return err
}
if fileInfo.Mode()&os.ModeSymlink != 0 {
return os.Symlink(header.Linkname, filePath)
}
fileCopy, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, fileInfo.Mode())
if err != nil {
return err
}
defer fileCopy.Close()
_, err = io.Copy(fileCopy, input)
if err != nil {
return err
}
}
return nil
}
func (c AdminData) Download(createdTime string) revel.Result {
backup, ok := configService.GetBackup(createdTime)
if !ok {
return c.RenderText("")
}
dbname, _ := revel.Config.String("db.dbname")
path := backup["path"] + "/" + dbname
allFiles := ListDir(path)
filename := "backup_" + dbname + "_" + backup["createdTime"] + ".tar.gz"
// file write
fw, err := os.Create(revel.BasePath + "/files/" + filename)
if err != nil {
return c.RenderText("")
}
// defer fw.Close() // 不需要关闭, 还要读取给用户下载
// gzip write
gw := gzip.NewWriter(fw)
defer gw.Close()
// tar write
tw := tar.NewWriter(gw)
defer tw.Close()
// 遍历文件列表
for _, file := range allFiles {
fn := path + "/" + file
fr, err := os.Open(fn)
fileInfo, _ := fr.Stat()
if err != nil {
return c.RenderText("")
}
defer fr.Close()
// 信息头
h := new(tar.Header)
h.Name = file
h.Size = fileInfo.Size()
h.Mode = int64(fileInfo.Mode())
h.ModTime = fileInfo.ModTime()
// 写信息头
err = tw.WriteHeader(h)
if err != nil {
panic(err)
}
// 写文件
_, err = io.Copy(tw, fr)
if err != nil {
panic(err)
}
} // for
return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachm
}
func extractFile(archive *tar.Reader, hdr *tar.Header, path string) error {
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, hdr.FileInfo().Mode())
if err != nil {
return err
}
defer file.Close()
_, err = io.Copy(file, archive)
return err
}
// WriteHeader renames files and directories inline as a tarfile is being
// written
func (a RenameAdapter) WriteHeader(hdr *tar.Header) error {
if hdr.Name == a.Old {
hdr.Name = a.New
} else if strings.HasPrefix(hdr.Name, a.Old+"/") {
hdr.Name = a.New + hdr.Name[len(a.Old):]
}
return a.Writer.WriteHeader(hdr)
}
func MakeTarball(tarname string, fnames []string) error {
log.Printf("tarring %d entrires to %s ...", len(fnames), tarname)
tarfile, err := os.Create(tarname)
if err != nil {
return err
}
defer tarfile.Close()
var tarwriter *tar.Writer
if strings.HasSuffix(tarname, ".gz") {
zipper := gzip.NewWriter(tarfile)
defer zipper.Close()
tarwriter = tar.NewWriter(zipper)
/*
} else if strings.HasSuffix(tarname, ".xz") {
p := xz.WriterDefaults
p.DictCap = 1 << 24
zipper, err := xz.NewWriterParams(tarfile, &p) //xz.NewWriter(tarfile)
if err != nil {
return err
}
defer zipper.Close()
tarwriter = tar.NewWriter(zipper)
*/
} else {
tarwriter = tar.NewWriter(tarfile)
}
defer tarwriter.Close()
for _, fname := range fnames {
realm, ts, good := util.Parse_FName(fname)
if !good {
log.Printf("warning: skip ill-named file '%s'", fname)
continue // skip
}
data, err := util.Load(fname)
if err != nil {
return err
}
hdr := new(tar.Header)
hdr.Name = util.Make_FName(realm, ts, false)
hdr.Size = int64(len(data))
hdr.ModTime = ts
hdr.Mode = 0644
err = tarwriter.WriteHeader(hdr)
if err != nil {
return err
}
log.Printf("tar %d bytes for file %s", hdr.Size, hdr.Name)
_, err = tarwriter.Write(data)
if err != nil {
return err
}
}
log.Printf("%s tarred without errors", tarname)
return nil
}
// Process impl
func (p *ArchiveCheckEmpty) Process(hdr *tar.Header, r io.Reader) (*tar.Header, io.Reader, error) {
if p.hasFiles {
return hdr, r, nil
}
if !hdr.FileInfo().IsDir() {
p.hasFiles = true
}
return hdr, r, nil
}
func TarCompress(source, target string) error {
fw, err := os.Create(target)
if err != nil {
return err
}
defer fw.Close()
// gzip write
gw := gzip.NewWriter(fw)
defer gw.Close()
// tar write
tw := tar.NewWriter(gw)
defer tw.Close()
dir, err := os.Open(source)
if err != nil {
return err
}
defer dir.Close()
fis, err := dir.Readdir(0)
if err != nil {
return err
}
for _, fi := range fis {
if fi.IsDir() {
continue
}
fmt.Println(fi.Name())
fr, err := os.Open(dir.Name() + "/" + fi.Name())
if err != nil {
return err
}
defer fr.Close()
h := new(tar.Header)
h.Name = fi.Name()
h.Size = fi.Size()
h.Mode = int64(fi.Mode())
h.ModTime = fi.ModTime()
err = tw.WriteHeader(h)
if err != nil {
return err
}
_, err = io.Copy(tw, fr)
if err != nil {
return err
}
}
return nil
}
func (t *Tar) ChanTar() {
defer sendBoolChan(t.CloseDone, true)
fw, err := os.Create(t.Dest)
if err != nil {
return
}
defer fw.Close()
// if t.Gz {
t.Gw = gzip.NewWriter(fw)
defer t.Gw.Close()
t.Tw = tar.NewWriter(t.Gw)
// }
defer t.Tw.Close()
dir, err := os.Open(t.OriPath)
if err != nil {
return
}
defer dir.Close()
t.Prepare.Done()
for {
var done bool = false
select {
case content := <-t.Ch:
header := new(tar.Header)
header.Name = content.FileName
header.Size = int64(len(content.Text))
header.Mode = content.Mode
if year, _, _ := content.ModTime.Date(); year == 1 {
header.ModTime = time.Now()
}
if err := t.Tw.WriteHeader(header); err != nil {
// todo error
fmt.Println(err.Error())
return
// break
}
if _, err := t.Tw.Write(content.Text); err != nil {
fmt.Println(err.Error())
return
// break
}
t.Job.Done()
case <-t.JobDone:
done = true
break
}
if done {
break
}
}
return
}
func (m *SymlinkWebotsManager) extractFile(v WebotsVersion, h *tar.Header, r io.Reader) error {
dest := strings.TrimPrefix(h.Name, "webots/")
dest = path.Join(m.workpath, v.String(), dest)
if dest == path.Join(m.workpath, v.String()) {
return nil
}
switch h.Typeflag {
case tar.TypeReg, tar.TypeRegA:
destDir := path.Dir(dest)
err := os.MkdirAll(destDir, 0775)
if err != nil {
return err
}
f, err := os.Create(dest)
if err != nil {
return err
}
_, err = io.Copy(f, r)
if err != nil {
return err
}
case tar.TypeDir:
err := os.MkdirAll(dest, 0775)
if err != nil {
return err
}
case tar.TypeSymlink:
destDir := path.Dir(dest)
err := os.MkdirAll(destDir, 0775)
if err != nil {
return err
}
err = os.Symlink(h.Linkname, dest)
if err != nil {
return err
}
return nil
default:
return fmt.Errorf("Internal error, cannot handle file %s", h.Name)
}
err := os.Chtimes(dest, time.Now(), h.FileInfo().ModTime())
if err != nil {
return err
}
err = os.Chmod(dest, h.FileInfo().Mode())
if err != nil {
return err
}
return nil
}
// Write a single file to TarGz
func TarGzWrite(item ArchiveItem, tw *tar.Writer, fi os.FileInfo) (err error) {
if item.FileSystemPath != "" {
fr, err := os.Open(item.FileSystemPath)
if err == nil {
defer fr.Close()
h := new(tar.Header)
h.Name = item.ArchivePath
h.Size = fi.Size()
h.Mode = int64(fi.Mode())
h.ModTime = fi.ModTime()
err = tw.WriteHeader(h)
if err == nil {
_, err = io.Copy(tw, fr)
}
}
} else {
h := new(tar.Header)
//backslash-only paths
h.Name = strings.Replace(item.ArchivePath, "\\", "/", -1)
h.Size = int64(len(item.Data))
h.Mode = int64(0644) //? is this ok?
h.ModTime = time.Now()
err = tw.WriteHeader(h)
if err == nil {
_, err = tw.Write(item.Data)
}
}
return err
}
func untar(tr *tar.Reader, header *tar.Header, dir string) error {
switch header.Typeflag {
case tar.TypeDir:
return os.MkdirAll(filepath.Join(dir, header.Name), 0700)
case tar.TypeReg, tar.TypeRegA:
return writeFile(filepath.Join(dir, header.Name), tr, header.FileInfo().Mode())
case tar.TypeSymlink:
return writeSymlink(filepath.Join(dir, header.Name), header.Linkname)
default:
return fmt.Errorf("%s has unknown type %v", header.Name, header.Typeflag)
}
}
func extractTarArchiveFile(header *tar.Header, dest string, input io.Reader) error {
home := os.Getenv("HOME")
// check if dir has a leading hash
maybeHash := filepath.Dir(header.Name)
_, err := hex.DecodeString(maybeHash)
isHash := err == nil
filePath := filepath.Join(dest, header.Name)
if isHash {
filePath = filepath.Join(home, ".dpm", "workspace", header.Name)
}
fileInfo := header.FileInfo()
if fileInfo.IsDir() {
err := os.MkdirAll(filePath, fileInfo.Mode())
if err != nil {
return err
}
} else {
// already exist
if isHash {
if _, err := os.Stat(filePath); err == nil {
return nil
}
}
err := os.MkdirAll(filepath.Dir(filePath), 0755)
if err != nil {
return err
}
if fileInfo.Mode()&os.ModeSymlink != 0 {
return os.Symlink(header.Linkname, filePath)
}
fileCopy, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, fileInfo.Mode())
if err != nil {
return err
}
defer fileCopy.Close()
_, err = io.Copy(fileCopy, input)
if err != nil {
return err
}
}
return nil
}
func (f *File) WriteTo(w io.Writer) error {
tw := tar.NewWriter(w)
hdr := new(tar.Header)
hdr.Name = "file.qvm"
hdr.Size = 32
if f.QvmFile.Header.Magic == qvm.VM_MAGIC_VER2 {
hdr.Size += 4
}
hdr.Size += int64(f.QvmFile.Header.CodeLength + f.QvmFile.Header.DataLength + f.QvmFile.Header.LitLength)
if err := tw.WriteHeader(hdr); err != nil {
return err
}
buf := new(Rab)
binary.Write(buf, binary.LittleEndian, &f.QvmFile.Header)
if _, err := tw.Write([]byte(*buf)[0:32]); err != nil {
return err
}
if f.QvmFile.Header.Magic == qvm.VM_MAGIC_VER2 {
if _, err := tw.Write([]byte(*buf)[32:]); err != nil {
return err
}
}
if _, err := tw.Write(f.QvmFile.Code); err != nil {
return err
}
if _, err := tw.Write(f.QvmFile.Data); err != nil {
return err
}
if _, err := tw.Write(f.QvmFile.Lit); err != nil {
return err
}
hdr.Name = "comments.csv"
hdr.Size = int64(len(f.CommentsFile.Data))
if err := tw.WriteHeader(hdr); err != nil {
return err
}
if _, err := tw.Write(f.CommentsFile.Data); err != nil {
return err
}
hdr.Name = "syscalls.asm"
hdr.Size = int64(len(f.SyscallsFile.Data))
if err := tw.WriteHeader(hdr); err != nil {
return err
}
if _, err := tw.Write(f.SyscallsFile.Data); err != nil {
return err
}
if err := tw.Flush(); err != nil {
return err
}
return nil
}
func addAllFile(dirPath string, tw *tar.Writer) {
//打开文件夹
dir, err := os.Open(dirPath)
if err != nil {
panic(err)
}
defer dir.Close()
//读取文件列表
fis, err := dir.Readdir(0) //n<=0 读取所有 n>0 读取n个
if err != nil {
panic(err)
}
//遍历文件列表
for _, fi := range fis {
if fi.IsDir() {
addAllFile(dirPath+fi.Name()+"/", tw)
continue
}
//打印文件名称
fmt.Println(dirPath + fi.Name())
//打开文件
fr, err := os.Open(dir.Name() + "/" + fi.Name())
if err != nil {
panic(err)
}
defer fr.Close()
//信息头
h := new(tar.Header)
h.Name = dirPath + fi.Name()
h.Size = fi.Size()
h.Mode = int64(fi.Mode())
h.ModTime = fi.ModTime()
//写信息头
err = tw.WriteHeader(h)
if err != nil {
panic(err)
}
//写文件
_, err = io.Copy(tw, fr)
if err != nil {
panic(err)
}
}
}
// Pack tar and gzip files
func Pack(gzPath, dirPath string, pathMap map[string]int) error {
fw, err := os.Create(gzPath)
if err != nil {
return err
}
defer fw.Close()
gw := gzip.NewWriter(fw)
defer gw.Close()
tw := tar.NewWriter(gw)
defer tw.Close()
for path, val := range pathMap {
if val < 0 {
continue
}
f, err := os.Stat(filepath.Join(dirPath, path))
if err != nil {
continue
}
if f.IsDir() {
continue
}
fr, err := os.Open(filepath.Join(dirPath, path))
if err != nil {
return err
}
defer fr.Close()
h := new(tar.Header)
h.Name = path
h.Size = f.Size()
h.Mode = int64(f.Mode())
h.ModTime = f.ModTime()
err = tw.WriteHeader(h)
if err != nil {
return err
}
_, err = io.Copy(tw, fr)
if err != nil {
return err
}
}
return nil
}
// FIXME: this is duplicated from graph_test.go in the docker package.
func fakeTar() (io.Reader, error) {
content := []byte("Hello world!\n")
buf := new(bytes.Buffer)
tw := tar.NewWriter(buf)
for _, name := range []string{"/etc/postgres/postgres.conf", "/etc/passwd", "/var/log/postgres/postgres.conf"} {
hdr := new(tar.Header)
hdr.Size = int64(len(content))
hdr.Name = name
if err := tw.WriteHeader(hdr); err != nil {
return nil, err
}
tw.Write([]byte(content))
}
tw.Close()
return buf, nil
}
func populateHeaderUnix(h *tar.Header, fi os.FileInfo, seen map[uint64]string) {
st, ok := fi.Sys().(*syscall.Stat_t)
if !ok {
return
}
h.Uid = int(st.Uid)
h.Gid = int(st.Gid)
// If we have already seen this inode, generate a hardlink
p, ok := seen[uint64(st.Ino)]
if ok {
h.Linkname = p
h.Typeflag = tar.TypeLink
} else {
seen[uint64(st.Ino)] = h.Name
}
}