// echoOn turns back on the terminal echo.
174931
func echoOn(fd []uintptr) {
	// Turn on the terminal echo.
	pid, e := syscall.ForkExec(sttyArg0, sttyArgvEOn, &syscall.ProcAttr{Dir: execCWDir, Files: fd})

	if e == nil {
		_, _ = syscall.Wait4(pid, &ws, 0, nil)
	}
}
212127
func sudo(sudo bool, command string, args ...string) *exec.Cmd {
	if sudo {
		return execCommand("sudo", append([]string{"-n", command}, args...)...)
	}

	return execCommand(command, args...)
}
1095890
func TurnOn(ctx context.Context, hubAddress, zoneAddress, token string) error {
	return SetLevel(ctx, hubAddress, zoneAddress, token, 1)
}
504262
func (hook *InfluxDBHook) handleBatch() {
	if hook.batchInterval == 0 || hook.batchCount == 0 {
		// we don't need to process this if the interval is 0
		return
	}
	for {
		time.Sleep(hook.batchInterval)
		hook.Lock()
		hook.writePoints()
		hook.Unlock()
	}
}
354643
func (p *protoHandler) Echo(ctx context.Context, token *crossdockpb.Token) error {
	callBackAddr := yarpc.CallFromContext(ctx).Header(callBackAddrHeader)
	p.callHome(ctx, callBackAddr, []byte(token.Value), protobuf.Encoding)
	return nil
}
982466
func (self *Commands) Back() error {
	if _, err := self.browser.Tab().RPC(`Page`, `getNavigationHistory`, nil); err == nil {
		return nil
	} else {
		return err
	}
}
729979
func (o *TextOutput) colorOn(num1 int, num2 int) string {
	if o.color {
		return fmt.Sprintf("\033[%d;%dm", num1, num2)
	}
	return ""
}
690938
func (d *Device) TurnOn(timeout time.Duration) error {
	location := parseLocation(d.Scan.Location)
	_, err := sendSOAP(
		timeout,
		location,
		"urn:Belkin:service:basicevent:1",
		"/upnp/control/basicevent1",
		"SetBinaryState",
		"<BinaryState>1</BinaryState>",
	)
	return err
}
1090349
func (bf *HtpasswdFile) ReloadOn(when os.Signal, onbad BadLineHandler) {
	// this is rather common with code in digest, but I don't have a common area...
	c := make(chan os.Signal, 1)
	signal.Notify(c, when)

	go func() {
		for {
			_ = <-c
			bf.Reload(onbad)
		}
	}()
}
189365
func restore() (err error) {
	if _, err = stty("echo"); err != nil {
		return
	}

	if _, err = stty(originalState); err != nil {
		return
	}

	return
}
881386
func (conn *I2CConnection) BacklightOn() error {
	conn.Backlight = true
	return conn.Write(false, 0x00)
}
365591
func (h *Hub) Batch(f func(), shouldLock bool) {
	if pdebug.Enabled {
		g := pdebug.Marker("Batch %t", shouldLock)
		defer g.End()
	}
	if shouldLock {
		// lock during this operation
		h.mutex.Lock()
		defer h.mutex.Unlock()
	}

	// temporarily set isSync = true
	o := h.isSync
	h.isSync = true
	defer func() { h.isSync = o }()

	// ignore panics
	defer func() { recover() }()

	f()
}
1244306
func (c *Client) Echo(m interface{}, msgHandler func(msg *models.Message) error) error {
	_, err := c.conn.SendRequest("echo", m, func(ctx *neptulon.ResCtx) error {
		var msg models.Message
		if err := ctx.Result(&msg); err != nil {
			return fmt.Errorf("client: echo: error reading response: %v", err)
		}
		return msgHandler(&msg)
	})

	if err != nil {
		return fmt.Errorf("client: echo: error sending request: %v", err)
	}

	return nil
}
222404
func (term *Terminal) Reopen() error {
	in := os.Stdin

	t, err := newTerminal(in)
	if err != nil {
		return err
	}

	term.t = t
	return nil
}
714791
func (bp *Bypass) Reversed() bool {
	bp.mux.RLock()
	defer bp.mux.RUnlock()

	return bp.reversed
}
457533
func CmdlineHandler() echo.HandlerFunc {
	return func(ctx echo.Context) error {
		Cmdline(ctx)
		return nil
	}
}
1084415
func echo(socket *zmq.Socket) (err error) {
	msg, err := socket.RecvMessage(0)
	if err != nil {
		return
	}
	_, err = socket.SendMessage(msg)
	return
}