func (p *configPlist) parse() error { f, err := os.Open(configPlistPath) if err != nil { return err } defer f.Close() return plist.NewDecoder(f).Decode(p) }
func fromPlist(path string) (*yoOpts, error) { yo := &yoOpts{} file, err := os.Open(path) if err != nil { return yo, err } defer file.Close() return yo, plist.NewDecoder(file).Decode(yo) }
// Get the restore Plist from the IPSW func (ip *IPSW) GetRestorePlist() (parsed Restore, err error) { url, err := url.Parse(ip.DownloadURL) // retrieve the Restore.plist from the IPSW, possibly need the BuildManifest too? reader, err := ranger.NewReader(&ranger.HTTPRanger{URL: url}) zipreader, err := zip.NewReader(reader, reader.Length()) restorePlist, err := ReadFile(zipreader, "Restore.plist") // decode the plist dec := plist.NewDecoder(bytes.NewReader(restorePlist)) dec.Decode(&parsed) return parsed, err }
func (p *lastStatePlist) parse() error { err := checkCachingStatus() if err != nil { return err } f, err := os.Open(lastStatePlistPath) if os.IsNotExist(err) { // if the server is stopped, the file won't exist return nil } if err != nil { return err } defer f.Close() return plist.NewDecoder(f).Decode(p) }
// creates a new iTunesVersionMaster struct, parsed and ready to use func NewiTunesVersionMaster() *iTunesVersionMaster { resp, err := http.Get(iTunesVersionURL) if err != nil { panic(err) } document, err := ioutil.ReadAll(resp.Body) if err != nil { panic(err) } vm := iTunesVersionMaster{} dec := plist.NewDecoder(bytes.NewReader(document)) dec.Decode(&vm) return &vm }
// plistのファイルをjsonに変換する. func decodeFileJSON(filePath string) ([]byte, error) { f, err := os.Open(filePath) if err != nil { return nil, err } defer f.Close() d := plist.NewDecoder(f) var m = make(decodeCcbRoot) if err := d.Decode(m); err != nil { return nil, err } j, err := json.Marshal(&m) if err != nil { return nil, err } return j, nil }
func BinaryPlistToMap(bs []byte) (result map[string]string) { buf := bytes.NewReader(bs) decoder := plist.NewDecoder(buf) decoder.Decode(&result) return }
func main() { parser := flags.NewParser(&opts, flags.Default) args, err := parser.Parse() if err != nil { parser.WriteHelp(os.Stderr) fmt.Fprintln(os.Stderr, err) return } if opts.Convert == "list" { formats := make([]string, len(nameFormatMap)) i := 0 for k, _ := range nameFormatMap { formats[i] = k i++ } fmt.Fprintln(os.Stderr, "Supported output formats:") fmt.Fprintln(os.Stderr, strings.Join(formats, ", ")) return } if len(args) < 1 { parser.WriteHelp(os.Stderr) return } filename := args[0] keypath := opts.Keypath if len(keypath) == 0 { c := strings.Index(filename, ":") if c > -1 { keypath = filename[c+1:] filename = filename[:c] } } file, err := os.Open(filename) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } var val interface{} switch strings.ToLower(filepath.Ext(filename)) { case ".json", ".yaml", ".yml": buf := &bytes.Buffer{} io.Copy(buf, file) err = yaml.Unmarshal(buf.Bytes(), &val) default: dec := plist.NewDecoder(file) err = dec.Decode(&val) } if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } file.Close() convert := strings.ToLower(opts.Convert) format, ok := nameFormatMap[convert] if !ok { fmt.Fprintf(os.Stderr, "unknown output format %s\n", convert) return } output := opts.Output newline := false var outputStream io.WriteCloser if format < PrettyFormat && output == "" { // Writing a plist, but no output filename. Save to original. output = filename } else if format >= PrettyFormat && output == "" { // Writing a non-plist, but no output filename: Stdout outputStream = os.Stdout newline = true } else if output == "-" { // - means stdout. outputStream = os.Stdout newline = true } if outputStream == nil { outfile, err := os.Create(output) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } outputStream = outfile } keypathContext := &KeypathWalker{} rval, err := keypathContext.WalkKeypath(reflect.ValueOf(val), keypath) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } val = rval.Interface() switch { case format >= 0 && format < PrettyFormat: enc := plist.NewEncoderForFormat(outputStream, format) if opts.Indent { enc.Indent("\t") } err := enc.Encode(val) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } case format == PrettyFormat: PrettyPrint(outputStream, rval.Interface()) case format == JSONFormat: var out []byte var err error if opts.Indent { out, err = json.MarshalIndent(val, "", "\t") } else { out, err = json.Marshal(val) } if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } outputStream.Write(out) case format == YAMLFormat: out, err := yaml.Marshal(val) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) return } outputStream.Write(out) case format == RawFormat: newline = false switch rval.Kind() { case reflect.String: outputStream.Write([]byte(val.(string))) case reflect.Slice: if rval.Elem().Kind() == reflect.Uint8 { outputStream.Write(val.([]byte)) } default: binary.Write(outputStream, binary.LittleEndian, val) } } if newline { fmt.Fprintf(outputStream, "\n") } outputStream.Close() }
func (ctx *KeypathWalker) WalkKeypath(val reflect.Value, keypath string) (reflect.Value, error) { if keypath == "" { return val, nil } if ctx.rootVal == nil { ctx.rootVal = &val } ctx.curVal = val scanner := bufio.NewScanner(strings.NewReader(keypath)) scanner.Split(ctx.Split) for scanner.Scan() { token := scanner.Text() if ctx.curVal.Kind() == reflect.Interface { ctx.curVal = ctx.curVal.Elem() } switch { case len(token) == 0: continue case token[0] == '[': // array s := token[1 : len(token)-1] if ctx.curVal.Kind() != reflect.Slice && ctx.curVal.Kind() != reflect.String { return reflect.ValueOf(nil), errors.New("keypath attempted to index non-indexable with " + s) } colon := strings.Index(s, ":") if colon > -1 { var err error var si, sj int is := s[:colon] js := s[colon+1:] if is != "" { si, err = strconv.Atoi(is) if err != nil { return reflect.ValueOf(nil), err } } if js != "" { sj, err = strconv.Atoi(js) if err != nil { return reflect.ValueOf(nil), err } } if si < 0 || sj > ctx.curVal.Len() { return reflect.ValueOf(nil), errors.New("keypath attempted to index outside of indexable with " + s) } ctx.curVal = ctx.curVal.Slice(si, sj) } else { idx, _ := strconv.Atoi(s) ctx.curVal = ctx.curVal.Index(idx) } case token[0] == '!': // subplist! if ctx.curVal.Kind() != reflect.Slice || ctx.curVal.Type().Elem().Kind() != reflect.Uint8 { return reflect.Value{}, errors.New("Attempted to subplist non-data.") } byt := ctx.curVal.Interface().([]uint8) buf := bytes.NewReader(byt) dec := plist.NewDecoder(buf) var subval interface{} dec.Decode(&subval) ctx.curVal = reflect.ValueOf(subval) default: // just a string if ctx.curVal.Kind() != reflect.Map { return reflect.ValueOf(nil), errors.New("keypath attempted to descend into non-map using key " + token) } if token != "" { ctx.curVal = ctx.curVal.MapIndex(reflect.ValueOf(token)) } } } err := scanner.Err() if err != nil { return reflect.ValueOf(nil), err } return ctx.curVal, nil }