// ./func_handlerequest.go.gen requests.txt
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT

package nslcd_server

import (
	"context"
	"fmt"
	"io"
	"time"

	p "git.lukeshu.com/go/libnslcd/nslcd_proto"
)

const sensitive = "<omitted-from-log>"

func maybePanic(err error) {
	if err != nil {
		panic(err)
	}
}

type Limits struct {
	// What is the maximum total amount of time that we spend
	// handling a single request.  This includes both the time
	// reading the request and the time creating and writing the
	// response.
	Timeout time.Duration

	// How long can we spend reading a request?
	ReadTimeout time.Duration

	// How long can we spend writing a response?
	WriteTimeout time.Duration

	// What is the maximum request length in bytes that we are
	// willing to handle?
	RequestMaxSize int64
}

type Conn interface {
	// This is a subset of net.Conn; semantics are the same.

	Read(b []byte) (n int, err error)
	Write(b []byte) (n int, err error)
	SetDeadline(t time.Time) error
	SetReadDeadline(t time.Time) error
	SetWriteDeadline(t time.Time) error
}

// Handle a request to nslcd.  The caller is responsible for
// initializing the context with PeerCredKey.
func HandleRequest(backend Backend, limits Limits, conn Conn, ctx context.Context) (err error) {
	defer func() {
		if r := recover(); r != nil {
			switch r := r.(type) {
			case p.NslcdError:
				err = r
			default:
				panic(r)
			}
		}
	}()

	now := time.Now()
	deadlineAll := time.Time{}
	deadlineRead := time.Time{}
	if limits.Timeout != 0 {
		deadlineAll = now.Add(limits.Timeout)
	}
	if deadline, ok := ctx.Deadline(); ok {
		if deadlineAll.IsZero() || deadline.Before(deadlineAll) {
			deadlineAll = deadline
		}
	}
	if limits.ReadTimeout != 0 {
		deadlineRead = now.Add(limits.ReadTimeout)
		if !deadlineAll.IsZero() && deadlineAll.Before(deadlineRead) {
			deadlineRead = deadlineAll
		}
	}
	deadlineWrite := deadlineAll
	if !deadlineRead.IsZero() {
		err = conn.SetReadDeadline(deadlineRead)
		if err != nil {
			return err
		}
	}

	log := LoggerFromContext(ctx)

	var in io.Reader = conn
	if limits.RequestMaxSize > 0 {
		in = &io.LimitedReader{R: in, N: limits.RequestMaxSize}
	}
	out := conn

	var version int32
	maybePanic(p.Read(in, &version))
	if version != p.NSLCD_VERSION {
		return p.NslcdError(fmt.Sprintf("Version mismatch: server=%#08x client=%#08x", p.NSLCD_VERSION, version))
	}
	var action int32
	maybePanic(p.Read(in, &action))

	switch action {
	case p.NSLCD_ACTION_CONFIG_GET:
		var req p.Request_Config_Get
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Config_Get(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_ALIAS_BYNAME:
		var req p.Request_Alias_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Alias_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_ALIAS_ALL:
		var req p.Request_Alias_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Alias_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_ETHER_BYNAME:
		var req p.Request_Ether_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Ether_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_ETHER_BYETHER:
		var req p.Request_Ether_ByEther
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Ether_ByEther(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_ETHER_ALL:
		var req p.Request_Ether_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Ether_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_GROUP_BYNAME:
		var req p.Request_Group_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Group_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_GROUP_BYGID:
		var req p.Request_Group_ByGid
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Group_ByGid(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_GROUP_BYMEMBER:
		var req p.Request_Group_ByMember
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Group_ByMember(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_GROUP_ALL:
		var req p.Request_Group_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Group_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_HOST_BYNAME:
		var req p.Request_Host_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Host_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_HOST_BYADDR:
		var req p.Request_Host_ByAddr
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Host_ByAddr(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_HOST_ALL:
		var req p.Request_Host_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Host_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_NETGROUP_BYNAME:
		var req p.Request_Netgroup_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Netgroup_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_NETGROUP_ALL:
		var req p.Request_Netgroup_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Netgroup_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_NETWORK_BYNAME:
		var req p.Request_Network_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Network_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_NETWORK_BYADDR:
		var req p.Request_Network_ByAddr
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Network_ByAddr(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_NETWORK_ALL:
		var req p.Request_Network_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Network_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PASSWD_BYNAME:
		var req p.Request_Passwd_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Passwd_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PASSWD_BYUID:
		var req p.Request_Passwd_ByUID
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Passwd_ByUID(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PASSWD_ALL:
		var req p.Request_Passwd_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Passwd_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PROTOCOL_BYNAME:
		var req p.Request_Protocol_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Protocol_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PROTOCOL_BYNUMBER:
		var req p.Request_Protocol_ByNumber
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Protocol_ByNumber(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PROTOCOL_ALL:
		var req p.Request_Protocol_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Protocol_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_RPC_BYNAME:
		var req p.Request_RPC_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.RPC_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_RPC_BYNUMBER:
		var req p.Request_RPC_ByNumber
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.RPC_ByNumber(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_RPC_ALL:
		var req p.Request_RPC_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.RPC_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_SERVICE_BYNAME:
		var req p.Request_Service_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Service_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_SERVICE_BYNUMBER:
		var req p.Request_Service_ByNumber
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Service_ByNumber(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_SERVICE_ALL:
		var req p.Request_Service_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Service_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_SHADOW_BYNAME:
		var req p.Request_Shadow_ByName
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Shadow_ByName(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_SHADOW_ALL:
		var req p.Request_Shadow_All
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.Shadow_All(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PAM_AUTHENTICATION:
		var req p.Request_PAM_Authentication
		maybePanic(p.Read(in, &req))
		_req := req
		_req.Password = sensitive
		log.Info(fmt.Sprintf("Request: %#v\n", _req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.PAM_Authentication(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PAM_AUTHORIZATION:
		var req p.Request_PAM_Authorization
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.PAM_Authorization(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PAM_SESSIONOPEN:
		var req p.Request_PAM_SessionOpen
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.PAM_SessionOpen(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PAM_SESSIONCLOSE:
		var req p.Request_PAM_SessionClose
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.PAM_SessionClose(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_PAM_PWMOD:
		var req p.Request_PAM_PwMod
		maybePanic(p.Read(in, &req))
		_req := req
		if len(_req.OldPassword) > 0 {
			_req.OldPassword = sensitive
		}
		_req.NewPassword = sensitive
		log.Info(fmt.Sprintf("Request: %#v", _req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.PAM_PwMod(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	case p.NSLCD_ACTION_USERMOD:
		var req p.Request_UserMod
		maybePanic(p.Read(in, &req))
		log.Info(fmt.Sprintf("Request: %#v", req))

		if limits.WriteTimeout != 0 {
			deadlineWrite = time.Now().Add(limits.WriteTimeout)
			if !deadlineAll.IsZero() && deadlineAll.Before(deadlineWrite) {
				deadlineWrite = deadlineAll
			}
		}
		if !deadlineWrite.IsZero() {
			err = out.SetWriteDeadline(deadlineWrite)
			if err != nil {
				return err
			}
		}

		var cancel context.CancelFunc
		if deadline, ok := ctx.Deadline(); !ok || (!deadlineWrite.IsZero() && deadline.After(deadlineWrite)) {
			ctx, cancel = context.WithDeadline(ctx, deadlineWrite)
		} else {
			ctx, cancel = context.WithCancel(ctx)
		}
		defer cancel()

		maybePanic(p.Write(out, p.NSLCD_VERSION))
		maybePanic(p.Write(out, action))
		ch := backend.UserMod(ctx, req)
		n := 0
		for result := range ch {
			if err == nil {
				err = p.Write(out, p.NSLCD_RESULT_BEGIN)
			}
			if err == nil {
				err = p.Write(out, result)
			}
			n++
			log.Info(fmt.Sprintf("Wrote %d results / err = %v", n, err))
		}
		maybePanic(err)
		maybePanic(p.Write(out, p.NSLCD_RESULT_END))
		return ctx.Err() // probably nil
	default:
		return p.NslcdError(fmt.Sprintf("Unknown request action: %#08x", action))
	}
}