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
}