Vendor RPC (#13943)

Use rpc.DefaultMaxFrameLength everywhere.

go/chat/server_test.go

@@ -70,7 +70,7 @@ func (g *gregorTestConnection) Connect(ctx context.Context) (err error) {
 		TagsFunc:      logger.LogTagsFromContextRPC,
 		WrapErrorFunc: libkb.MakeWrapError(g.G().ExternalG()),
 	}
-	trans := rpc.NewConnectionTransport(uri, libkb.NewRPCLogFactory(g.G().ExternalG()), libkb.MakeWrapError(g.G().ExternalG()))
+	trans := rpc.NewConnectionTransport(uri, libkb.NewRPCLogFactory(g.G().ExternalG()), libkb.MakeWrapError(g.G().ExternalG()), rpc.DefaultMaxFrameLength)
 	conn := rpc.NewConnectionWithTransport(g, trans,
 		libkb.NewContextifiedErrorUnwrapper(g.G().ExternalG()),
 		logger.LogOutputWithDepthAdder{Logger: g.G().Log}, opts)

go/chat/utils/utils.go

@@ -1553,9 +1553,10 @@ func GetGregorConn(ctx context.Context, g *globals.Context, log DebugLabeler,
 		conn = rpc.NewTLSConnection(rpc.NewFixedRemote(uri.HostPort),
 			[]byte(rawCA), libkb.NewContextifiedErrorUnwrapper(g.ExternalG()),
 			handler(nist), libkb.NewRPCLogFactory(g.ExternalG()),
-			logger.LogOutputWithDepthAdder{Logger: g.Log}, rpc.ConnectionOpts{})
+			logger.LogOutputWithDepthAdder{Logger: g.Log},
+			rpc.DefaultMaxFrameLength, rpc.ConnectionOpts{})
 	} else {
-		t := rpc.NewConnectionTransport(uri, nil, libkb.MakeWrapError(g.ExternalG()))
+		t := rpc.NewConnectionTransport(uri, nil, libkb.MakeWrapError(g.ExternalG()), rpc.DefaultMaxFrameLength)
 		conn = rpc.NewConnectionWithTransport(handler(nist), t,
 			libkb.NewContextifiedErrorUnwrapper(g.ExternalG()),
 			logger.LogOutputWithDepthAdder{Logger: g.Log}, rpc.ConnectionOpts{})

go/client/cmd_ping.go

@@ -94,7 +94,7 @@ func (t *pingGregorTransport) Dial(context.Context) (rpc.Transporter, error) {
 	if err != nil {
 		return nil, err
 	}
-	t.stagedTransport = rpc.NewTransport(t.conn, nil, nil)
+	t.stagedTransport = rpc.NewTransport(t.conn, nil, nil, rpc.DefaultMaxFrameLength)
 	return t.stagedTransport, nil
 }
 

go/kex2/provisionee.go

@@ -155,7 +155,7 @@ func (p *provisionee) startServer(s Secret) (err error) {
 		keybase1.Kex2ProvisioneeProtocol(p),
 	}
 	prots = append(prots, keybase1.Kex2Provisionee2Protocol(p))
-	p.xp = rpc.NewTransport(p.conn, p.arg.Provisionee.GetLogFactory(), nil)
+	p.xp = rpc.NewTransport(p.conn, p.arg.Provisionee.GetLogFactory(), nil, rpc.DefaultMaxFrameLength)
 	srv := rpc.NewServer(p.xp, nil)
 	for _, prot := range prots {
 		if err = srv.Register(prot); err != nil {

go/kex2/provisioner.go

@@ -119,7 +119,7 @@ func (p *provisioner) pickFirstConnection() (err error) {
 			return err
 		}
 		prot := keybase1.Kex2ProvisionerProtocol(p)
-		xp = rpc.NewTransport(conn, p.arg.Provisioner.GetLogFactory(), nil)
+		xp = rpc.NewTransport(conn, p.arg.Provisioner.GetLogFactory(), nil, rpc.DefaultMaxFrameLength)
 		srv := rpc.NewServer(xp, nil)
 		if err = srv.Register(prot); err != nil {
 			return err
@@ -141,7 +141,7 @@ func (p *provisioner) pickFirstConnection() (err error) {
 		if p.conn, err = NewConn(p.arg.Ctx, p.arg.LogCtx, p.arg.Mr, sec, p.deviceID, p.arg.Timeout); err != nil {
 			return err
 		}
-		p.xp = rpc.NewTransport(p.conn, p.arg.Provisioner.GetLogFactory(), nil)
+		p.xp = rpc.NewTransport(p.conn, p.arg.Provisioner.GetLogFactory(), nil, rpc.DefaultMaxFrameLength)
 	case <-p.arg.Ctx.Done():
 		err = ErrCanceled
 	case <-time.After(p.arg.Timeout):

go/libkb/socket.go

@@ -51,7 +51,7 @@ func (g *GlobalContext) BindToSocket() (net.Listener, error) {
 }
 
 func NewTransportFromSocket(g *GlobalContext, s net.Conn) rpc.Transporter {
-	return rpc.NewTransport(s, NewRPCLogFactory(g), MakeWrapError(g))
+	return rpc.NewTransport(s, NewRPCLogFactory(g), MakeWrapError(g), rpc.DefaultMaxFrameLength)
 }
 
 // ResetSocket clears and returns a new socket

go/service/gregor.go

@@ -1563,7 +1563,8 @@ func (g *gregorHandler) connectTLS() error {
 	g.conn = rpc.NewTLSConnection(rpc.NewFixedRemote(uri.HostPort),
 		[]byte(rawCA), libkb.NewContextifiedErrorUnwrapper(g.G().ExternalG()),
 		g, libkb.NewRPCLogFactory(g.G().ExternalG()),
-		logger.LogOutputWithDepthAdder{Logger: g.G().Log}, opts)
+		logger.LogOutputWithDepthAdder{Logger: g.G().Log},
+		rpc.DefaultMaxFrameLength, opts)
 
 	// The client we get here will reconnect to gregord on disconnect if necessary.
 	// We should grab it here instead of in OnConnect, since the connection is not

go/service/main.go

@@ -158,7 +158,7 @@ func (d *Service) RegisterProtocols(srv *rpc.Server, xp rpc.Transporter, connID
 }
 
 func (d *Service) Handle(c net.Conn) {
-	xp := rpc.NewTransport(c, libkb.NewRPCLogFactory(d.G()), libkb.MakeWrapError(d.G()))
+	xp := rpc.NewTransport(c, libkb.NewRPCLogFactory(d.G()), libkb.MakeWrapError(d.G()), rpc.DefaultMaxFrameLength)
 
 	server := rpc.NewServer(xp, libkb.MakeWrapError(d.G()))
 

go/service/rpc.go

@@ -1,10 +1,11 @@
 package service
 
 import (
+	"net"
+
 	"github.com/keybase/client/go/libkb"
 	"github.com/keybase/go-framed-msgpack-rpc/rpc"
 	"golang.org/x/net/context"
-	"net"
 )
 
 // connTransport implements rpc.ConnectionTransport
@@ -31,7 +32,7 @@ func (t *connTransport) Dial(context.Context) (rpc.Transporter, error) {
 	if err != nil {
 		return nil, err
 	}
-	t.stagedTransport = rpc.NewTransport(t.conn, libkb.NewRPCLogFactory(t.G()), libkb.MakeWrapError(t.G()))
+	t.stagedTransport = rpc.NewTransport(t.conn, libkb.NewRPCLogFactory(t.G()), libkb.MakeWrapError(t.G()), rpc.DefaultMaxFrameLength)
 	return t.stagedTransport, nil
 }