コード例 #1
0
ファイル: caching.go プロジェクト: groob/caching_exporter
func (p *configPlist) parse() error {
	f, err := os.Open(configPlistPath)
	if err != nil {
		return err
	}
	defer f.Close()
	return plist.NewDecoder(f).Decode(p)
}
コード例 #2
0
ファイル: main.go プロジェクト: groob/yo-yo
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)
}
コード例 #3
0
ファイル: ipsw.go プロジェクト: JustaPenguin/fwutils
// 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
}
コード例 #4
0
ファイル: caching.go プロジェクト: groob/caching_exporter
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)
}
コード例 #5
0
ファイル: itunesdata.go プロジェクト: JustaPenguin/fwutils
// 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
}
コード例 #6
0
ファイル: plist.go プロジェクト: kyokomi/sb-checker
// 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
}
コード例 #7
0
ファイル: xattr.go プロジェクト: suffuse/go-suffuse
func BinaryPlistToMap(bs []byte) (result map[string]string) {
	buf := bytes.NewReader(bs)
	decoder := plist.NewDecoder(buf)
	decoder.Decode(&result)
	return
}
コード例 #8
0
ファイル: ply.go プロジェクト: Vorstack/go-plist
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()
}
コード例 #9
0
ファイル: ply.go プロジェクト: Vorstack/go-plist
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
}