1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
# rpm
[](https://pkg.go.dev/github.com/cavaliergopher/rpm) [](https://app.travis-ci.com/cavaliergopher/rpm) [](https://goreportcard.com/report/github.com/cavaliergopher/rpm)
Package rpm implements the rpm package file format.
$ go get github.com/cavaliergopher/rpm
See the [package documentation](https://pkg.go.dev/github.com/cavaliergopher/rpm)
or the examples programs in `cmd/` to get started.
## Extracting rpm packages
The following working example demonstrates how to extract files from an rpm
package. In this example, only the cpio format and xz compression are supported
which will cover most cases.
Implementations should consider additional formats and compressions algorithms,
as well as support for extracting irregular file types and configuring
permissions, uids and guids, etc.
```go
package main
import (
"io"
"log"
"os"
"path/filepath"
"github.com/cavaliergopher/cpio"
"github.com/cavaliergopher/rpm"
"github.com/ulikunitz/xz"
)
func ExtractRPM(name string) {
// Open a package file for reading
f, err := os.Open(name)
if err != nil {
log.Fatal(err)
}
defer f.Close()
// Read the package headers
pkg, err := rpm.Read(f)
if err != nil {
log.Fatal(err)
}
// Check the compression algorithm of the payload
if compression := pkg.PayloadCompression(); compression != "xz" {
log.Fatalf("Unsupported compression: %s", compression)
}
// Attach a reader to decompress the payload
xzReader, err := xz.NewReader(f)
if err != nil {
log.Fatal(err)
}
// Check the archive format of the payload
if format := pkg.PayloadFormat(); format != "cpio" {
log.Fatalf("Unsupported payload format: %s", format)
}
// Attach a reader to unarchive each file in the payload
cpioReader := cpio.NewReader(xzReader)
for {
// Move to the next file in the archive
hdr, err := cpioReader.Next()
if err == io.EOF {
break // no more files
}
if err != nil {
log.Fatal(err)
}
// Skip directories and other irregular file types in this example
if !hdr.Mode.IsRegular() {
continue
}
// Create the target directory
if dirName := filepath.Dir(hdr.Name); dirName != "" {
if err := os.MkdirAll(dirName, 0o755); err != nil {
log.Fatal(err)
}
}
// Create and write the file
outFile, err := os.Create(hdr.Name)
if err != nil {
log.Fatal(err)
}
if _, err := io.Copy(outFile, cpioReader); err != nil {
outFile.Close()
log.Fatal(err)
}
outFile.Close()
}
}
```
|
