func (omxHandler) Display(ctx *context.T, mimetype string, r io.ReadCloser) (func(), error) { defer r.Close() tmp, err := ioutil.TempFile("", "") if err != nil { return nil, err } if _, err := io.Copy(tmp, r); err != nil { os.Remove(tmp.Name()) return nil, err } tmp.Close() args := []string{ "-b", tmp.Name(), } vlog.Infof("Running: omxplayer %s", strings.Join(args, " ")) cmd := exec.Command("omxplayer", args...) cmd.Stdin = r cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Start(); err != nil { return nil, err } return func() { if err := cmd.Process.Kill(); err != nil { vlog.Errorf("Could not kill omx: %v", err) } cmd.Wait() os.Remove(tmp.Name()) }, nil }
func (eogHandler) Display(ctx *context.T, mimetype string, r io.ReadCloser) (func(), error) { // eog cannot read from a pipe, so we have to write the file to // the filesystem before displaying it. defer r.Close() tmp, err := ioutil.TempFile("", "") if err != nil { return nil, err } if _, err := io.Copy(tmp, r); err != nil { os.Remove(tmp.Name()) return nil, err } tmp.Close() cmd := exec.Command("eog", "--display", ":0", "-f", tmp.Name()) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr stop := func() { if err := cmd.Process.Kill(); err != nil { vlog.Errorf("Could not kill eog: %v", err) } cmd.Wait() os.Remove(tmp.Name()) } if err := cmd.Start(); err != nil { return stop, err } return stop, nil }
//export swift_io_v_swift_impl_util_type_nativeBase64UrlDecode func swift_io_v_swift_impl_util_type_nativeBase64UrlDecode(base64UrlEncoded *C.char) C.SwiftByteArray { // Decode the base64 url encoded string to bytes in a way that prevents extra copies along the CGO boundary. urlEncoded := C.GoString(base64UrlEncoded) maxLength := base64.URLEncoding.DecodedLen(len(urlEncoded)) bytesBacking := C.malloc(C.size_t(maxLength)) if bytesBacking == nil { vlog.Errorf("Unable allocate %v bytes", maxLength) return EmptySwiftByteArray() } var bytes []byte = (*[1 << 30]byte)(unsafe.Pointer(bytesBacking))[:maxLength:maxLength] n, err := base64.URLEncoding.Decode(bytes, []byte(urlEncoded)) if err != nil { vlog.Errorf("Unable to base64 decode string: %v\n", err) C.free(bytesBacking) return EmptySwiftByteArray() } var swiftArray C.SwiftByteArray swiftArray.length = C._GoUint64(n) swiftArray.data = bytesBacking return swiftArray }
func waitToBeClaimedAndStartLockServer(ctx *context.T, configDir string, stopUnclaimedLock func(), claimed, stop <-chan struct{}, stopped chan<- struct{}) { defer close(stopped) select { case <-claimed: stopUnclaimedLock() case <-stop: stopUnclaimedLock() return } stopLock, err := startLockServer(ctx, configDir) if err != nil { vlog.Errorf("Failed to start lock server after it was claimed: %v", err) return } defer stopLock() <-stop // Wait to be stopped }
// StartMounttable starts a local mounttable server with an authorization // policy that allows all principals to "Resolve" names, but restricts all // other operations to the principal specified by the provided context. // // The mounttable makes itself visible in the local neighborhood under the // name LockNeighborhoodPrefix + <nhName>. // // Returns the endpoint of the mounttable server and a callback to // be invoked to shutdown the mounttable server on success, or an error // on failure. func StartMounttable(ctx *context.T, configDir string, nhName string) (string, func(), error) { if len(configDir) == 0 { return "", nil, errors.New("could not start mounttable, config directory not provided") } permFilePath := filepath.Join(configDir, permsFile) if err := initPermissions(permFilePath); err != nil { return "", nil, fmt.Errorf("could not initialize permissions file (%v) for mounttable: %v", permFilePath, err) } mtName, stopMT, err := mounttablelib.StartServers(ctx, v23.GetListenSpec(ctx), "", nhName, permFilePath, "", "mounttable") if err != nil { vlog.Errorf("mounttablelib.StartServers failed: %v", err) return "", nil, err } vlog.Infof("Started local mounttable at: %v", mtName) return mtName, func() { vlog.Infof("Stopping mounttable...") stopMT() vlog.Infof("Stopped mounttable.") }, nil }
func keyForLock(ctx *context.T, lockName string) (security.Blessings, error) { // We could simply return v23.GetPrincipal(ctx).BlessingStore().ForPeer(lock) // however this would also include any blessings tagged for a peer pattern // is matched by 'lock'. Therefore we iterate over all the blessings // and pick the specific ones that are meant for 'lock'. var ret security.Blessings for _, b := range v23.GetPrincipal(ctx).BlessingStore().PeerBlessings() { if isKeyValidForLock(ctx, b, lockName) { if union, err := security.UnionOfBlessings(ret, b); err != nil { vlog.Errorf("UnionOfBlessings(%v, %v) failed: %v, dropping latter blessing", ret, b, err) } else { ret = union } } } if ret.IsZero() { return security.Blessings{}, fmt.Errorf("no available key for lock %v", lockName) } return ret, nil }
func (vlcHandler) Display(ctx *context.T, mimetype string, r io.ReadCloser) (func(), error) { defer r.Close() tmp, err := ioutil.TempFile("", "") if err != nil { return nil, err } if _, err := io.Copy(tmp, r); err != nil { os.Remove(tmp.Name()) return nil, err } tmp.Close() args := []string{ "--no-video-title-show", "--fullscreen", "--x11-display", ":0", tmp.Name(), "vlc://quit", } if strings.HasPrefix(mimetype, "audio/") { args = append([]string{"--audio-visual=visual"}, args...) } vlog.Infof("Running: vlc %s", strings.Join(args, " ")) cmd := exec.Command("vlc", args...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Start(); err != nil { return nil, err } return func() { if err := cmd.Process.Kill(); err != nil { vlog.Errorf("Could not kill vlc: %v", err) } cmd.Wait() os.Remove(tmp.Name()) }, nil }