Merge pull request #2294 from coryb/gateway-exec-extra-hosts

add missing ExtraHosts to gateway exec

client/build_test.go

@@ -23,6 +23,7 @@ import (
 	"github.com/moby/buildkit/solver/pb"
 	"github.com/moby/buildkit/util/entitlements"
 	utilsystem "github.com/moby/buildkit/util/system"
+	"github.com/moby/buildkit/util/testutil/echoserver"
 	"github.com/moby/buildkit/util/testutil/integration"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
@@ -48,6 +49,7 @@ func TestClientGatewayIntegration(t *testing.T) {
 		testClientGatewayExecError,
 		testClientGatewaySlowCacheExecError,
 		testClientGatewayExecFileActionError,
+		testClientGatewayContainerExtraHosts,
 	}, integration.WithMirroredImages(integration.OfficialImages("busybox:latest")))
 
 	integration.Run(t, []integration.Test{
@@ -58,6 +60,16 @@ func TestClientGatewayIntegration(t *testing.T) {
 			"insecure": securityInsecure,
 		}),
 	)
+
+	integration.Run(t, []integration.Test{
+		testClientGatewayContainerHostNetworking,
+	},
+		integration.WithMirroredImages(integration.OfficialImages("busybox:latest")),
+		integration.WithMatrix("netmode", map[string]interface{}{
+			"default": defaultNetwork,
+			"host":    hostNetwork,
+		}),
+	)
 }
 
 func testClientGatewaySolve(t *testing.T, sb integration.Sandbox) {
@@ -1594,6 +1606,173 @@ func testClientGatewayContainerSecurityMode(t *testing.T, sb integration.Sandbox
 	checkAllReleasable(t, c, sb, true)
 }
 
+func testClientGatewayContainerExtraHosts(t *testing.T, sb integration.Sandbox) {
+	requiresLinux(t)
+
+	ctx := sb.Context()
+	product := "buildkit_test"
+
+	c, err := New(ctx, sb.Address())
+	require.NoError(t, err)
+	defer c.Close()
+
+	b := func(ctx context.Context, c client.Client) (*client.Result, error) {
+		st := llb.Image("busybox")
+
+		def, err := st.Marshal(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to marshal state")
+		}
+
+		r, err := c.Solve(ctx, client.SolveRequest{
+			Definition: def.ToPB(),
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to solve")
+		}
+
+		ctr, err := c.NewContainer(ctx, client.NewContainerRequest{
+			Mounts: []client.Mount{{
+				Dest:      "/",
+				MountType: pb.MountType_BIND,
+				Ref:       r.Ref,
+			}},
+			ExtraHosts: []*pb.HostIP{{
+				Host: "some.host",
+				IP:   "169.254.11.22",
+			}},
+		})
+
+		if err != nil {
+			return nil, err
+		}
+
+		stdout := bytes.NewBuffer(nil)
+		stderr := bytes.NewBuffer(nil)
+
+		pid, err := ctr.Start(ctx, client.StartRequest{
+			Args:   []string{"grep", "169.254.11.22\tsome.host", "/etc/hosts"},
+			Stdout: &nopCloser{stdout},
+			Stderr: &nopCloser{stderr},
+		})
+		if err != nil {
+			ctr.Release(ctx)
+			return nil, err
+		}
+		defer ctr.Release(ctx)
+
+		err = pid.Wait()
+
+		t.Logf("Stdout: %q", stdout.String())
+		t.Logf("Stderr: %q", stderr.String())
+
+		require.NoError(t, err)
+
+		return &client.Result{}, nil
+	}
+
+	_, err = c.Build(ctx, SolveOpt{}, product, b, nil)
+	require.NoError(t, err)
+
+	checkAllReleasable(t, c, sb, true)
+}
+
+func testClientGatewayContainerHostNetworking(t *testing.T, sb integration.Sandbox) {
+	if os.Getenv("BUILDKIT_RUN_NETWORK_INTEGRATION_TESTS") == "" {
+		t.SkipNow()
+	}
+
+	if sb.Rootless() && sb.Value("netmode") == defaultNetwork {
+		// skip "default" network test for rootless, it always runs with "host" network
+		// https://github.com/moby/buildkit/blob/v0.9.0/docs/rootless.md#known-limitations
+		t.SkipNow()
+	}
+
+	requiresLinux(t)
+
+	ctx := sb.Context()
+	product := "buildkit_test"
+
+	var allowedEntitlements []entitlements.Entitlement
+	netMode := pb.NetMode_UNSET
+	if sb.Value("netmode") == hostNetwork {
+		netMode = pb.NetMode_HOST
+		allowedEntitlements = []entitlements.Entitlement{entitlements.EntitlementNetworkHost}
+	}
+	c, err := New(sb.Context(), sb.Address())
+	require.NoError(t, err)
+	defer c.Close()
+
+	s, err := echoserver.NewTestServer("foo")
+	require.NoError(t, err)
+	addrParts := strings.Split(s.Addr().String(), ":")
+	port := addrParts[len(addrParts)-1]
+
+	b := func(ctx context.Context, c client.Client) (*client.Result, error) {
+		st := llb.Image("busybox")
+
+		def, err := st.Marshal(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to marshal state")
+		}
+
+		r, err := c.Solve(ctx, client.SolveRequest{
+			Definition: def.ToPB(),
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to solve")
+		}
+
+		ctr, err := c.NewContainer(ctx, client.NewContainerRequest{
+			Mounts: []client.Mount{{
+				Dest:      "/",
+				MountType: pb.MountType_BIND,
+				Ref:       r.Ref,
+			}},
+			NetMode: netMode,
+		})
+
+		if err != nil {
+			return nil, err
+		}
+
+		stdout := bytes.NewBuffer(nil)
+		stderr := bytes.NewBuffer(nil)
+
+		pid, err := ctr.Start(ctx, client.StartRequest{
+			Args:   []string{"/bin/sh", "-c", fmt.Sprintf("nc 127.0.0.1 %s | grep foo", port)},
+			Stdout: &nopCloser{stdout},
+			Stderr: &nopCloser{stderr},
+		})
+		if err != nil {
+			ctr.Release(ctx)
+			return nil, err
+		}
+		defer ctr.Release(ctx)
+
+		err = pid.Wait()
+
+		t.Logf("Stdout: %q", stdout.String())
+		t.Logf("Stderr: %q", stderr.String())
+
+		if netMode == pb.NetMode_HOST {
+			require.NoError(t, err)
+		} else {
+			require.Error(t, err)
+		}
+
+		return &client.Result{}, nil
+	}
+
+	solveOpts := SolveOpt{
+		AllowedEntitlements: allowedEntitlements,
+	}
+	_, err = c.Build(ctx, solveOpts, product, b, nil)
+	require.NoError(t, err)
+
+	checkAllReleasable(t, c, sb, true)
+}
+
 type nopCloser struct {
 	io.Writer
 }

frontend/gateway/client/client.go

@@ -25,6 +25,7 @@ type Client interface {
 type NewContainerRequest struct {
 	Mounts      []Mount
 	NetMode     pb.NetMode
+	ExtraHosts  []*pb.HostIP
 	Platform    *pb.Platform
 	Constraints *pb.WorkerConstraints
 }

frontend/gateway/container.go

@@ -28,6 +28,7 @@ import (
 type NewContainerRequest struct {
 	ContainerID string
 	NetMode     opspb.NetMode
+	ExtraHosts  []executor.HostIP
 	Mounts      []Mount
 	Platform    *opspb.Platform
 	Constraints *opspb.WorkerConstraints
@@ -52,13 +53,14 @@ func NewContainer(ctx context.Context, w worker.Worker, sm *session.Manager, g s
 		platform = *req.Platform
 	}
 	ctr := &gatewayContainer{
-		id:       req.ContainerID,
+		id:         req.ContainerID,
-		netMode:  req.NetMode,
+		netMode:    req.NetMode,
-		platform: platform,
+		extraHosts: req.ExtraHosts,
-		executor: w.Executor(),
+		platform:   platform,
-		errGroup: eg,
+		executor:   w.Executor(),
-		ctx:      ctx,
+		errGroup:   eg,
-		cancel:   cancel,
+		ctx:        ctx,
+		cancel:     cancel,
 	}
 
 	var (
@@ -276,18 +278,19 @@ func PrepareMounts(ctx context.Context, mm *mounts.MountManager, cm cache.Manage
 }
 
 type gatewayContainer struct {
-	id       string
+	id         string
-	netMode  opspb.NetMode
+	netMode    opspb.NetMode
-	platform opspb.Platform
+	extraHosts []executor.HostIP
-	rootFS   executor.Mount
+	platform   opspb.Platform
-	mounts   []executor.Mount
+	rootFS     executor.Mount
-	executor executor.Executor
+	mounts     []executor.Mount
-	started  bool
+	executor   executor.Executor
-	errGroup *errgroup.Group
+	started    bool
-	mu       sync.Mutex
+	errGroup   *errgroup.Group
-	cleanup  []func() error
+	mu         sync.Mutex
-	ctx      context.Context
+	cleanup    []func() error
-	cancel   func()
+	ctx        context.Context
+	cancel     func()
 }
 
 func (gwCtr *gatewayContainer) Start(ctx context.Context, req client.StartRequest) (client.ContainerProcess, error) {
@@ -300,6 +303,7 @@ func (gwCtr *gatewayContainer) Start(ctx context.Context, req client.StartReques
 			Cwd:          req.Cwd,
 			Tty:          req.Tty,
 			NetMode:      gwCtr.netMode,
+			ExtraHosts:   gwCtr.extraHosts,
 			SecurityMode: req.SecurityMode,
 		},
 		Stdin:  req.Stdin,

frontend/gateway/forwarder/forward.go

@@ -272,6 +272,11 @@ func (c *bridgeClient) NewContainer(ctx context.Context, req client.NewContainer
 		return nil, err
 	}
 
+	ctrReq.ExtraHosts, err = gateway.ParseExtraHosts(req.ExtraHosts)
+	if err != nil {
+		return nil, err
+	}
+
 	w, err := c.workers.GetDefault()
 	if err != nil {
 		return nil, err

frontend/gateway/gateway.go

@@ -888,6 +888,11 @@ func (lbf *llbBridgeForwarder) NewContainer(ctx context.Context, in *pb.NewConta
 		return nil, stack.Enable(err)
 	}
 
+	ctrReq.ExtraHosts, err = ParseExtraHosts(in.ExtraHosts)
+	if err != nil {
+		return nil, stack.Enable(err)
+	}
+
 	ctr, err := NewContainer(context.Background(), w, lbf.sm, group, ctrReq)
 	if err != nil {
 		return nil, stack.Enable(err)

frontend/gateway/grpcclient/client.go

@@ -709,6 +709,8 @@ func (c *grpcClient) NewContainer(ctx context.Context, req client.NewContainerRe
 		Mounts:      mounts,
 		Platform:    req.Platform,
 		Constraints: req.Constraints,
+		Network:     req.NetMode,
+		ExtraHosts:  req.ExtraHosts,
 	})
 	if err != nil {
 		return nil, err

frontend/gateway/pb/caps.go

@@ -40,6 +40,10 @@ const (
 	// containers directly through the gateway
 	CapGatewayExec apicaps.CapID = "gateway.exec"
 
+	// CapGatewayExecExtraHosts is the capability to add additional hosts to
+	// /etc/hosts for containers created via gateway exec.
+	CapGatewayExecExtraHosts apicaps.CapID = "gateway.exec.extrahosts"
+
 	// CapFrontendCaps can be used to check that frontends define support for certain capabilities
 	CapFrontendCaps apicaps.CapID = "frontend.caps"
 
@@ -156,6 +160,13 @@ func init() {
 		Status:  apicaps.CapStatusExperimental,
 	})
 
+	Caps.Init(apicaps.Cap{
+		ID:      CapGatewayExecExtraHosts,
+		Name:    "gateway exec extra-hosts",
+		Enabled: true,
+		Status:  apicaps.CapStatusExperimental,
+	})
+
 	Caps.Init(apicaps.Cap{
 		ID:      CapFrontendCaps,
 		Name:    "frontend capabilities",

frontend/gateway/pb/gateway.pb.go

@@ -1337,6 +1337,7 @@ type NewContainerRequest struct {
 	Network              pb.NetMode            `protobuf:"varint,3,opt,name=Network,proto3,enum=pb.NetMode" json:"Network,omitempty"`
 	Platform             *pb.Platform          `protobuf:"bytes,4,opt,name=platform,proto3" json:"platform,omitempty"`
 	Constraints          *pb.WorkerConstraints `protobuf:"bytes,5,opt,name=constraints,proto3" json:"constraints,omitempty"`
+	ExtraHosts           []*pb.HostIP          `protobuf:"bytes,6,rep,name=extraHosts,proto3" json:"extraHosts,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
 	XXX_unrecognized     []byte                `json:"-"`
 	XXX_sizecache        int32                 `json:"-"`
@@ -1410,6 +1411,13 @@ func (m *NewContainerRequest) GetConstraints() *pb.WorkerConstraints {
 	return nil
 }
 
+func (m *NewContainerRequest) GetExtraHosts() []*pb.HostIP {
+	if m != nil {
+		return m.ExtraHosts
+	}
+	return nil
+}
+
 type NewContainerResponse struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -2059,127 +2067,128 @@ func init() {
 func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
 
 var fileDescriptor_f1a937782ebbded5 = []byte{
-	// 1909 bytes of a gzipped FileDescriptorProto
+	// 1932 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x4f, 0x6f, 0x1b, 0xc7,
-	0x15, 0xd7, 0x8a, 0xa4, 0x48, 0x3e, 0xfe, 0x31, 0x33, 0x4e, 0x53, 0x7a, 0x11, 0x38, 0xcc, 0x22,
+	0x15, 0xd7, 0x8a, 0x94, 0x48, 0x3e, 0xfe, 0x31, 0x33, 0x4e, 0x53, 0x7a, 0x11, 0x38, 0xcc, 0x22,
-	0x55, 0x69, 0x47, 0x59, 0xa6, 0x74, 0x02, 0xb9, 0x72, 0x90, 0xd4, 0x94, 0x28, 0x58, 0x8d, 0x24,
+	0x55, 0x69, 0x47, 0x59, 0xa6, 0x74, 0x02, 0xb9, 0x72, 0x90, 0xd4, 0x94, 0x28, 0x48, 0x8d, 0x24,
-	0xab, 0xe3, 0x14, 0x06, 0x82, 0x14, 0xe8, 0x8a, 0x3b, 0xa4, 0x17, 0xa6, 0x76, 0xb7, 0xb3, 0x43,
+	0xb3, 0xe3, 0x14, 0x06, 0x82, 0x14, 0xe8, 0x8a, 0x3b, 0xa4, 0x17, 0xa6, 0x76, 0xb7, 0xb3, 0x43,
-	0xcb, 0x4c, 0x2e, 0xed, 0xad, 0xf7, 0x02, 0xbd, 0x16, 0xe8, 0x27, 0xe8, 0xa5, 0xd7, 0x9e, 0x73,
+	0xcb, 0x4c, 0x2e, 0xed, 0xad, 0xc7, 0x02, 0x05, 0x7a, 0x2d, 0xd0, 0x4f, 0xd0, 0x4b, 0xaf, 0x3d,
-	0xec, 0xb9, 0x07, 0xa3, 0x10, 0xfa, 0x11, 0x7a, 0x6f, 0xf1, 0x66, 0x67, 0xc8, 0x25, 0x45, 0x2d,
+	0xe7, 0xd8, 0x73, 0x0f, 0x46, 0xe1, 0xcf, 0xd0, 0x7b, 0x8b, 0x37, 0x3b, 0x43, 0x2e, 0x29, 0x6a,
-	0x49, 0xe4, 0xc4, 0x99, 0xb7, 0xef, 0xf7, 0xe6, 0xfd, 0x9b, 0xf7, 0xde, 0x10, 0x2a, 0x03, 0x47,
+	0x49, 0x22, 0x27, 0xce, 0xbc, 0x7d, 0xbf, 0x37, 0xef, 0xdf, 0xbc, 0xf7, 0x86, 0x50, 0x1e, 0x38,
-	0xb0, 0x4b, 0x67, 0x6c, 0x87, 0x3c, 0x10, 0x01, 0xb9, 0x73, 0x11, 0x9c, 0x8f, 0xed, 0xf3, 0x91,
+	0x82, 0x5d, 0x39, 0x63, 0x3b, 0xe4, 0x81, 0x08, 0xc8, 0x9d, 0xcb, 0xe0, 0x62, 0x6c, 0x5f, 0x8c,
-	0x37, 0x74, 0x5f, 0x7a, 0xc2, 0x7e, 0xf5, 0x33, 0xbb, 0xcf, 0x03, 0x5f, 0x30, 0xdf, 0x35, 0x3f,
+	0xbc, 0xa1, 0xfb, 0xc2, 0x13, 0xf6, 0xcb, 0x9f, 0xd9, 0x7d, 0x1e, 0xf8, 0x82, 0xf9, 0xae, 0xf9,
-	0x1a, 0x78, 0xe2, 0xc5, 0xe8, 0xdc, 0xee, 0x05, 0x17, 0xad, 0x41, 0x30, 0x08, 0x5a, 0x12, 0x71,
+	0xd1, 0xc0, 0x13, 0xcf, 0x47, 0x17, 0x76, 0x2f, 0xb8, 0x6c, 0x0e, 0x82, 0x41, 0xd0, 0x94, 0x88,
-	0x3e, 0xea, 0xcb, 0x9d, 0xdc, 0xc8, 0x55, 0x2c, 0xc9, 0x6c, 0xcf, 0xb3, 0x0f, 0x82, 0x60, 0x30,
+	0x8b, 0x51, 0x5f, 0xee, 0xe4, 0x46, 0xae, 0x62, 0x49, 0x66, 0x6b, 0x9e, 0x7d, 0x10, 0x04, 0x83,
-	0x64, 0x4e, 0xe8, 0x45, 0x6a, 0xd9, 0xe2, 0x61, 0xaf, 0x15, 0x09, 0x47, 0x8c, 0x22, 0x85, 0xd9,
+	0x21, 0x73, 0x42, 0x2f, 0x52, 0xcb, 0x26, 0x0f, 0x7b, 0xcd, 0x48, 0x38, 0x62, 0x14, 0x29, 0xcc,
-	0x49, 0x60, 0x50, 0x91, 0x96, 0x56, 0xa4, 0x15, 0x05, 0xc3, 0x57, 0x8c, 0xb7, 0xc2, 0xf3, 0x56,
+	0x6e, 0x02, 0x83, 0x8a, 0x34, 0xb5, 0x22, 0xcd, 0x28, 0x18, 0xbe, 0x64, 0xbc, 0x19, 0x5e, 0x34,
-	0x10, 0x6a, 0xee, 0xd6, 0x8d, 0xdc, 0x4e, 0xe8, 0xb5, 0xc4, 0x38, 0x64, 0x51, 0xeb, 0x32, 0xe0,
+	0x83, 0x50, 0x73, 0x37, 0x6f, 0xe4, 0x76, 0x42, 0xaf, 0x29, 0xc6, 0x21, 0x8b, 0x9a, 0x57, 0x01,
-	0x2f, 0x19, 0x57, 0x80, 0x07, 0x37, 0x02, 0x46, 0xc2, 0x1b, 0x22, 0xaa, 0xe7, 0x84, 0x11, 0x1e,
+	0x7f, 0xc1, 0xb8, 0x02, 0x3c, 0xb8, 0x11, 0x30, 0x12, 0xde, 0x10, 0x51, 0x3d, 0x27, 0x8c, 0xf0,
-	0x82, 0xbf, 0x0a, 0x94, 0x34, 0x5b, 0x04, 0xbe, 0x17, 0x09, 0xcf, 0x1b, 0x78, 0xad, 0x7e, 0x24,
+	0x10, 0xfc, 0x55, 0xa0, 0xa4, 0xd9, 0x22, 0xf0, 0xbd, 0x48, 0x78, 0xde, 0xc0, 0x6b, 0xf6, 0x23,
-	0x31, 0xf1, 0x29, 0x68, 0x44, 0xcc, 0x6e, 0xfd, 0x31, 0x03, 0x5b, 0x94, 0x45, 0xa3, 0xa1, 0x20,
+	0x89, 0x89, 0x4f, 0x41, 0x23, 0x62, 0x76, 0xeb, 0x8f, 0x19, 0xd8, 0xa6, 0x2c, 0x1a, 0x0d, 0x05,
-	0xdb, 0x50, 0xe1, 0xac, 0x7f, 0xc0, 0x42, 0xce, 0x7a, 0x8e, 0x60, 0x6e, 0xdd, 0x68, 0x18, 0xcd,
+	0xd9, 0x81, 0x32, 0x67, 0xfd, 0x43, 0x16, 0x72, 0xd6, 0x73, 0x04, 0x73, 0x6b, 0x46, 0xdd, 0x68,
-	0xe2, 0x93, 0x0d, 0x3a, 0x4b, 0x26, 0xbf, 0x86, 0x2a, 0x67, 0xfd, 0x28, 0xc1, 0xb8, 0xd9, 0x30,
+	0x14, 0x8e, 0x37, 0xe8, 0x2c, 0x99, 0xfc, 0x1a, 0x2a, 0x9c, 0xf5, 0xa3, 0x04, 0xe3, 0x66, 0xdd,
-	0x9a, 0xa5, 0xf6, 0x87, 0xf6, 0x8d, 0xc1, 0xb0, 0x29, 0xeb, 0x9f, 0x38, 0xe1, 0x14, 0xf2, 0x64,
+	0x68, 0x14, 0x5b, 0x1f, 0xda, 0x37, 0x06, 0xc3, 0xa6, 0xac, 0x7f, 0xe6, 0x84, 0x53, 0xc8, 0xf1,
-	0x83, 0xce, 0x09, 0x21, 0x6d, 0xc8, 0x70, 0xd6, 0xaf, 0x67, 0xa4, 0xac, 0xbb, 0xe9, 0xb2, 0x9e,
+	0x06, 0x9d, 0x13, 0x42, 0x5a, 0x90, 0xe1, 0xac, 0x5f, 0xcb, 0x48, 0x59, 0x77, 0xd3, 0x65, 0x1d,
-	0x6c, 0x50, 0x64, 0x26, 0xbb, 0x90, 0x45, 0x29, 0xf5, 0xac, 0x04, 0xbd, 0xbf, 0x54, 0x81, 0x27,
+	0x6f, 0x50, 0x64, 0x26, 0x7b, 0x90, 0x45, 0x29, 0xb5, 0xac, 0x04, 0xbd, 0xbf, 0x54, 0x81, 0xe3,
-	0x1b, 0x54, 0x02, 0xc8, 0x97, 0x50, 0xb8, 0x60, 0xc2, 0x71, 0x1d, 0xe1, 0xd4, 0xa1, 0x91, 0x69,
+	0x0d, 0x2a, 0x01, 0xe4, 0x4b, 0xc8, 0x5f, 0x32, 0xe1, 0xb8, 0x8e, 0x70, 0x6a, 0x50, 0xcf, 0x34,
-	0x96, 0xda, 0xad, 0x54, 0x30, 0x3a, 0xc8, 0x3e, 0x51, 0x88, 0xae, 0x2f, 0xf8, 0x98, 0x4e, 0x04,
+	0x8a, 0xad, 0x66, 0x2a, 0x18, 0x1d, 0x64, 0x9f, 0x29, 0x44, 0xc7, 0x17, 0x7c, 0x4c, 0x27, 0x02,
-	0x98, 0x8f, 0xa0, 0x32, 0xf3, 0x89, 0xd4, 0x20, 0xf3, 0x92, 0x8d, 0x63, 0xff, 0x51, 0x5c, 0x92,
+	0xcc, 0x47, 0x50, 0x9e, 0xf9, 0x44, 0xaa, 0x90, 0x79, 0xc1, 0xc6, 0xb1, 0xff, 0x28, 0x2e, 0xc9,
-	0xb7, 0x21, 0xf7, 0xca, 0x19, 0x8e, 0x98, 0x74, 0x55, 0x99, 0xc6, 0x9b, 0xbd, 0xcd, 0x87, 0x46,
+	0xdb, 0xb0, 0xf5, 0xd2, 0x19, 0x8e, 0x98, 0x74, 0x55, 0x89, 0xc6, 0x9b, 0xfd, 0xcd, 0x87, 0x46,
-	0xa7, 0x00, 0x5b, 0x5c, 0x8a, 0xb7, 0xfe, 0x6c, 0x40, 0x6d, 0xde, 0x4f, 0xe4, 0x48, 0x59, 0x68,
+	0x3b, 0x0f, 0xdb, 0x5c, 0x8a, 0xb7, 0xfe, 0x62, 0x40, 0x75, 0xde, 0x4f, 0xe4, 0x44, 0x59, 0x68,
-	0x48, 0x25, 0x3f, 0x5d, 0xc3, 0xc5, 0x48, 0x88, 0x62, 0x55, 0xa5, 0x08, 0x73, 0x17, 0x8a, 0x13,
+	0x48, 0x25, 0x3f, 0x5d, 0xc3, 0xc5, 0x48, 0x88, 0x62, 0x55, 0xa5, 0x08, 0x73, 0x0f, 0x0a, 0x13,
-	0xd2, 0x32, 0x15, 0x8b, 0x09, 0x15, 0xad, 0x5d, 0xc8, 0x50, 0xd6, 0x27, 0x55, 0xd8, 0xf4, 0x54,
+	0xd2, 0x32, 0x15, 0x0b, 0x09, 0x15, 0xad, 0x3d, 0xc8, 0x50, 0xd6, 0x27, 0x15, 0xd8, 0xf4, 0x54,
-	0x52, 0xd0, 0x4d, 0xcf, 0x25, 0x0d, 0xc8, 0xb8, 0xac, 0xaf, 0x82, 0x5f, 0xb5, 0xc3, 0x73, 0xfb,
+	0x52, 0xd0, 0x4d, 0xcf, 0x25, 0x75, 0xc8, 0xb8, 0xac, 0xaf, 0x82, 0x5f, 0xb1, 0xc3, 0x0b, 0xfb,
-	0x80, 0xf5, 0x3d, 0xdf, 0x13, 0x5e, 0xe0, 0x53, 0xfc, 0x64, 0xfd, 0xd5, 0xc0, 0xe4, 0x42, 0xb5,
+	0x90, 0xf5, 0x3d, 0xdf, 0x13, 0x5e, 0xe0, 0x53, 0xfc, 0x64, 0xfd, 0xcd, 0xc0, 0xe4, 0x42, 0xb5,
-	0xc8, 0x17, 0x33, 0x76, 0x2c, 0x4f, 0x95, 0x6b, 0xda, 0x3f, 0x4f, 0xd7, 0xfe, 0x93, 0xa4, 0xf6,
+	0xc8, 0x17, 0x33, 0x76, 0x2c, 0x4f, 0x95, 0x6b, 0xda, 0x3f, 0x4b, 0xd7, 0xfe, 0x93, 0xa4, 0xf6,
-	0x4b, 0xf3, 0x27, 0x69, 0x9d, 0x80, 0x0a, 0x65, 0x62, 0xc4, 0x7d, 0xca, 0x7e, 0x37, 0x62, 0x91,
+	0x4b, 0xf3, 0x27, 0x69, 0x9d, 0x80, 0x32, 0x65, 0x62, 0xc4, 0x7d, 0xca, 0x7e, 0x37, 0x62, 0x91,
-	0x20, 0x3f, 0xd7, 0x11, 0x91, 0xf2, 0x97, 0xa5, 0x15, 0x32, 0x52, 0x05, 0x20, 0x4d, 0xc8, 0x31,
+	0x20, 0x3f, 0xd7, 0x11, 0x91, 0xf2, 0x97, 0xa5, 0x15, 0x32, 0x52, 0x05, 0x20, 0x0d, 0xd8, 0x62,
-	0xce, 0x03, 0xae, 0xb4, 0x20, 0x76, 0x5c, 0x39, 0x6c, 0x1e, 0xf6, 0xec, 0x67, 0xb2, 0x72, 0xd0,
+	0x9c, 0x07, 0x5c, 0x69, 0x41, 0xec, 0xb8, 0x72, 0xd8, 0x3c, 0xec, 0xd9, 0x4f, 0x65, 0xe5, 0xa0,
-	0x98, 0xc1, 0xaa, 0x41, 0x55, 0x9f, 0x1a, 0x85, 0x81, 0x1f, 0x31, 0xeb, 0x16, 0x54, 0x8e, 0xfc,
+	0x31, 0x83, 0x55, 0x85, 0x8a, 0x3e, 0x35, 0x0a, 0x03, 0x3f, 0x62, 0xd6, 0x2d, 0x28, 0x9f, 0xf8,
-	0x70, 0x24, 0x22, 0xa5, 0x87, 0xf5, 0x0f, 0x03, 0xaa, 0x9a, 0x12, 0xf3, 0x90, 0x6f, 0xa0, 0x34,
+	0xe1, 0x48, 0x44, 0x4a, 0x0f, 0xeb, 0x9f, 0x06, 0x54, 0x34, 0x25, 0xe6, 0x21, 0xdf, 0x40, 0x71,
-	0xf5, 0xb1, 0x76, 0xe6, 0x5e, 0x8a, 0x7e, 0xb3, 0xf8, 0x44, 0x80, 0x94, 0x6f, 0x93, 0xe2, 0xcc,
+	0xea, 0x63, 0xed, 0xcc, 0xfd, 0x14, 0xfd, 0x66, 0xf1, 0x89, 0x00, 0x29, 0xdf, 0x26, 0xc5, 0x99,
-	0x53, 0xa8, 0xcd, 0x33, 0x2c, 0xf0, 0xf4, 0x07, 0xb3, 0x9e, 0x9e, 0x0f, 0x7c, 0xc2, 0xb3, 0x7f,
+	0xe7, 0x50, 0x9d, 0x67, 0x58, 0xe0, 0xe9, 0x0f, 0x66, 0x3d, 0x3d, 0x1f, 0xf8, 0x84, 0x67, 0xff,
-	0x32, 0xe0, 0x0e, 0x65, 0xb2, 0x14, 0x1e, 0x5d, 0x38, 0x03, 0xb6, 0x1f, 0xf8, 0x7d, 0x6f, 0xa0,
+	0x6c, 0xc0, 0x1d, 0xca, 0x64, 0x29, 0x3c, 0xb9, 0x74, 0x06, 0xec, 0x20, 0xf0, 0xfb, 0xde, 0x40,
-	0xdd, 0x5c, 0x93, 0x59, 0xa5, 0x25, 0x63, 0x82, 0x35, 0xa1, 0x70, 0x36, 0x74, 0x44, 0x3f, 0xe0,
+	0xbb, 0xb9, 0x2a, 0xb3, 0x4a, 0x4b, 0xc6, 0x04, 0x6b, 0x40, 0xbe, 0x3b, 0x74, 0x44, 0x3f, 0xe0,
-	0x17, 0x4a, 0x78, 0x19, 0x85, 0x6b, 0x1a, 0x9d, 0x7c, 0x25, 0x0d, 0x28, 0x29, 0xc1, 0x27, 0x81,
+	0x97, 0x4a, 0x78, 0x09, 0x85, 0x6b, 0x1a, 0x9d, 0x7c, 0x25, 0x75, 0x28, 0x2a, 0xc1, 0x67, 0x81,
-	0xcb, 0x64, 0xcd, 0x28, 0xd2, 0x24, 0x89, 0xd4, 0x21, 0x7f, 0x1c, 0x0c, 0x4e, 0x9d, 0x0b, 0x26,
+	0xcb, 0x64, 0xcd, 0x28, 0xd0, 0x24, 0x89, 0xd4, 0x20, 0x77, 0x1a, 0x0c, 0xce, 0x9d, 0x4b, 0x26,
-	0x8b, 0x43, 0x91, 0xea, 0xad, 0xf5, 0x7b, 0x03, 0xcc, 0x45, 0x5a, 0x29, 0x17, 0xff, 0x12, 0xb6,
+	0x8b, 0x43, 0x81, 0xea, 0xad, 0xf5, 0x7b, 0x03, 0xcc, 0x45, 0x5a, 0x29, 0x17, 0xff, 0x12, 0xb6,
-	0x0e, 0xbc, 0x01, 0x8b, 0xe2, 0xe8, 0x17, 0x3b, 0xed, 0xef, 0xdf, 0xbc, 0xb7, 0xf1, 0xaf, 0x37,
+	0x0f, 0xbd, 0x01, 0x8b, 0xe2, 0xe8, 0x17, 0xda, 0xad, 0xef, 0x5f, 0xbf, 0xb7, 0xf1, 0xef, 0xd7,
 	0xef, 0xdd, 0x4f, 0xd4, 0xd5, 0x20, 0x64, 0x7e, 0x2f, 0xf0, 0x85, 0xe3, 0xf9, 0x8c, 0x63, 0x7b,
-	0xf8, 0xc8, 0x95, 0x10, 0x3b, 0x46, 0x52, 0x25, 0x81, 0xbc, 0x03, 0x5b, 0xb1, 0x74, 0x75, 0xed,
+	0xf8, 0xc8, 0x95, 0x10, 0x3b, 0x46, 0x52, 0x25, 0x81, 0xbc, 0x03, 0xdb, 0xb1, 0x74, 0x75, 0xed,
-	0xd5, 0xce, 0xfa, 0x6f, 0x0e, 0xca, 0xcf, 0x50, 0x01, 0xed, 0x0b, 0x1b, 0x60, 0xea, 0x42, 0x95,
+	0xd5, 0xce, 0xfa, 0xef, 0x16, 0x94, 0x9e, 0xa2, 0x02, 0xda, 0x17, 0x36, 0xc0, 0xd4, 0x85, 0x2a,
-	0x76, 0xf3, 0x8e, 0x4d, 0x70, 0x10, 0x13, 0x0a, 0x87, 0x2a, 0xc4, 0xea, 0xba, 0x4e, 0xf6, 0xe4,
+	0xed, 0xe6, 0x1d, 0x9b, 0xe0, 0x20, 0x26, 0xe4, 0x8f, 0x54, 0x88, 0xd5, 0x75, 0x9d, 0xec, 0xc9,
-	0x6b, 0x28, 0xe9, 0xf5, 0xd3, 0x50, 0xd4, 0x33, 0x32, 0x47, 0x1e, 0xa6, 0xe4, 0x48, 0x52, 0x13,
+	0xd7, 0x50, 0xd4, 0xeb, 0x27, 0xa1, 0xa8, 0x65, 0x64, 0x8e, 0x3c, 0x4c, 0xc9, 0x91, 0xa4, 0x26,
-	0x3b, 0x01, 0x55, 0x19, 0x92, 0xa0, 0x90, 0xcf, 0xe0, 0xce, 0xd1, 0x45, 0x18, 0x70, 0xb1, 0xef,
+	0x76, 0x02, 0xaa, 0x32, 0x24, 0x41, 0x21, 0x9f, 0xc1, 0x9d, 0x93, 0xcb, 0x30, 0xe0, 0xe2, 0xc0,
-	0xf4, 0x5e, 0x30, 0x3a, 0xdb, 0x05, 0xb2, 0x8d, 0x4c, 0xb3, 0x48, 0x6f, 0x66, 0x20, 0x3b, 0xf0,
+	0xe9, 0x3d, 0x67, 0x74, 0xb6, 0x0b, 0x64, 0xeb, 0x99, 0x46, 0x81, 0xde, 0xcc, 0x40, 0x76, 0xe1,
-	0x96, 0x33, 0x1c, 0x06, 0x97, 0xea, 0xd2, 0xc8, 0xf4, 0xaf, 0xe7, 0x1a, 0x46, 0xb3, 0x40, 0xaf,
+	0x2d, 0x67, 0x38, 0x0c, 0xae, 0xd4, 0xa5, 0x91, 0xe9, 0x5f, 0xdb, 0xaa, 0x1b, 0x8d, 0x3c, 0xbd,
-	0x7f, 0x20, 0x1f, 0xc3, 0xed, 0x04, 0xf1, 0x31, 0xe7, 0xce, 0x18, 0xf3, 0x65, 0x4b, 0xf2, 0x2f,
+	0xfe, 0x81, 0x7c, 0x0c, 0xb7, 0x13, 0xc4, 0xc7, 0x9c, 0x3b, 0x63, 0xcc, 0x97, 0x6d, 0xc9, 0xbf,
-	0xfa, 0x84, 0x15, 0xec, 0xd0, 0xf3, 0x9d, 0x61, 0x1d, 0x24, 0x4f, 0xbc, 0x21, 0x16, 0x94, 0xbb,
+	0xe8, 0x13, 0x56, 0xb0, 0x23, 0xcf, 0x77, 0x86, 0x35, 0x90, 0x3c, 0xf1, 0x86, 0x58, 0x50, 0xea,
-	0xaf, 0x51, 0x25, 0xc6, 0x1f, 0x0b, 0xc1, 0xeb, 0x25, 0x19, 0x8a, 0x19, 0x1a, 0x39, 0x83, 0xb2,
+	0xbc, 0x42, 0x95, 0x18, 0x7f, 0x2c, 0x04, 0xaf, 0x15, 0x65, 0x28, 0x66, 0x68, 0xa4, 0x0b, 0x25,
-	0x54, 0x38, 0xd6, 0x3d, 0xaa, 0x97, 0xa5, 0xd3, 0x76, 0x52, 0x9c, 0x26, 0xd9, 0x9f, 0x86, 0x89,
+	0xa9, 0x70, 0xac, 0x7b, 0x54, 0x2b, 0x49, 0xa7, 0xed, 0xa6, 0x38, 0x4d, 0xb2, 0x3f, 0x09, 0x13,
-	0xab, 0x34, 0x23, 0x81, 0xf4, 0xa0, 0xaa, 0x1d, 0x17, 0xdf, 0xc1, 0x7a, 0x45, 0xca, 0x7c, 0xb4,
+	0x57, 0x69, 0x46, 0x02, 0xe9, 0x41, 0x45, 0x3b, 0x2e, 0xbe, 0x83, 0xb5, 0xb2, 0x94, 0xf9, 0x68,
-	0x6e, 0x20, 0x62, 0x74, 0x7c, 0xc4, 0x9c, 0x48, 0x4c, 0x83, 0x2e, 0x5e, 0x37, 0x47, 0xb0, 0x7a,
+	0xdd, 0x40, 0xc4, 0xe8, 0xf8, 0x88, 0x39, 0x91, 0x98, 0x06, 0x1d, 0xbc, 0x6e, 0x8e, 0x60, 0xb5,
-	0x55, 0xda, 0x3c, 0xd9, 0x9b, 0x9f, 0x43, 0x6d, 0x3e, 0x96, 0xeb, 0x14, 0x7d, 0xf3, 0x57, 0x70,
+	0x8a, 0xb4, 0x79, 0xb2, 0x37, 0x3f, 0x87, 0xea, 0x7c, 0x2c, 0xd7, 0x29, 0xfa, 0xe6, 0xaf, 0xe0,
-	0x7b, 0x81, 0x0a, 0x3f, 0xa8, 0x1e, 0xfc, 0xcd, 0x80, 0xb7, 0xae, 0xf9, 0x8d, 0x10, 0xc8, 0x7e,
+	0xf6, 0x02, 0x15, 0x7e, 0x50, 0x3d, 0xf8, 0xbb, 0x01, 0x6f, 0x5d, 0xf3, 0x1b, 0x21, 0x90, 0xfd,
-	0x35, 0x0e, 0x99, 0x12, 0x29, 0xd7, 0xe4, 0x04, 0x72, 0x18, 0x97, 0xa8, 0xbe, 0x29, 0x9d, 0xb6,
+	0x6a, 0x1c, 0x32, 0x25, 0x52, 0xae, 0xc9, 0x19, 0x6c, 0x61, 0x5c, 0xa2, 0xda, 0xa6, 0x74, 0xda,
-	0xbb, 0x4e, 0x20, 0x6c, 0x89, 0x8c, 0x1d, 0x16, 0x4b, 0x31, 0x1f, 0x02, 0x4c, 0x89, 0x6b, 0xb5,
+	0xde, 0x3a, 0x81, 0xb0, 0x25, 0x32, 0x76, 0x58, 0x2c, 0xc5, 0x7c, 0x08, 0x30, 0x25, 0xae, 0xd5,
-	0xbe, 0x6f, 0xa0, 0xa2, 0xa2, 0xa2, 0xca, 0x43, 0x2d, 0x9e, 0x52, 0x14, 0x18, 0x67, 0x90, 0x69,
+	0xfa, 0xbe, 0x81, 0xb2, 0x8a, 0x8a, 0x2a, 0x0f, 0xd5, 0x78, 0x4a, 0x51, 0x60, 0x9c, 0x41, 0xa6,
-	0xbb, 0xc8, 0xac, 0xd9, 0x2e, 0xac, 0xef, 0xe0, 0x16, 0x65, 0x8e, 0x7b, 0xe8, 0x0d, 0xd9, 0xcd,
+	0xed, 0x22, 0xb3, 0x66, 0xbb, 0xb0, 0xbe, 0x83, 0x5b, 0x94, 0x39, 0xee, 0x91, 0x37, 0x64, 0x37,
-	0x55, 0x11, 0xef, 0xba, 0x37, 0x64, 0x67, 0x8e, 0x78, 0x31, 0xb9, 0xeb, 0x6a, 0x4f, 0xf6, 0x20,
+	0x57, 0x45, 0xbc, 0xeb, 0xde, 0x90, 0x75, 0x1d, 0xf1, 0x7c, 0x72, 0xd7, 0xd5, 0x9e, 0xec, 0xc3,
-	0x47, 0x1d, 0x7f, 0xc0, 0xd4, 0xd1, 0x1f, 0xa4, 0x1c, 0x2d, 0x0f, 0x41, 0x5e, 0x1a, 0x43, 0xac,
+	0x16, 0x75, 0xfc, 0x01, 0x53, 0x47, 0x7f, 0x90, 0x72, 0xb4, 0x3c, 0x04, 0x79, 0x69, 0x0c, 0xb1,
-	0x47, 0x50, 0x9c, 0xd0, 0xb0, 0x52, 0x3d, 0xed, 0xf7, 0x23, 0x16, 0x57, 0xbd, 0x0c, 0x55, 0x3b,
+	0x1e, 0x41, 0x61, 0x42, 0xc3, 0x4a, 0xf5, 0xa4, 0xdf, 0x8f, 0x58, 0x5c, 0xf5, 0x32, 0x54, 0xed,
-	0xa4, 0x1f, 0x33, 0x7f, 0xa0, 0x8e, 0xce, 0x50, 0xb5, 0xb3, 0xb6, 0x71, 0x54, 0xd1, 0x9a, 0x2b,
+	0x90, 0x7e, 0xca, 0xfc, 0x81, 0x3a, 0x3a, 0x43, 0xd5, 0xce, 0xda, 0xc1, 0x51, 0x45, 0x6b, 0xae,
-	0xd7, 0x10, 0xc8, 0x1e, 0xe0, 0x3c, 0x65, 0xc8, 0x0b, 0x26, 0xd7, 0x96, 0x8b, 0x6d, 0xce, 0x71,
+	0x5c, 0x43, 0x20, 0x7b, 0x88, 0xf3, 0x94, 0x21, 0x2f, 0x98, 0x5c, 0x5b, 0x2e, 0xb6, 0x39, 0xc7,
-	0x0f, 0x3c, 0x7e, 0xb3, 0x81, 0x75, 0xc8, 0x1f, 0x78, 0x3c, 0x61, 0x9f, 0xde, 0x92, 0x6d, 0x6c,
+	0x3d, 0xf4, 0xf8, 0xcd, 0x06, 0xd6, 0x20, 0x77, 0xe8, 0xf1, 0x84, 0x7d, 0x7a, 0x4b, 0x76, 0xb0,
-	0x80, 0xbd, 0xe1, 0xc8, 0x45, 0x6b, 0x05, 0xe3, 0xbe, 0xaa, 0xf4, 0x73, 0x54, 0xeb, 0x8b, 0xd8,
+	0x01, 0xf6, 0x86, 0x23, 0x17, 0xad, 0x15, 0x8c, 0xfb, 0xaa, 0xd2, 0xcf, 0x51, 0xad, 0x2f, 0x62,
-	0x8f, 0xf2, 0x14, 0xa5, 0xcc, 0x0e, 0xe4, 0x99, 0x2f, 0xb8, 0xc7, 0x74, 0x97, 0x24, 0x76, 0x3c,
+	0x3f, 0xca, 0x53, 0x94, 0x32, 0xbb, 0x90, 0x63, 0xbe, 0xe0, 0x1e, 0xd3, 0x5d, 0x92, 0xd8, 0xf1,
-	0x02, 0xdb, 0x72, 0x04, 0x96, 0xdd, 0x98, 0x6a, 0x16, 0x6b, 0x17, 0x6e, 0x21, 0x21, 0x3d, 0x10,
+	0x08, 0x6c, 0xcb, 0x11, 0x58, 0x76, 0x63, 0xaa, 0x59, 0xac, 0x3d, 0xb8, 0x85, 0x84, 0xf4, 0x40,
-	0x04, 0xb2, 0x09, 0x25, 0xe5, 0xda, 0xda, 0x83, 0xda, 0x14, 0xa8, 0x8e, 0xde, 0x86, 0x2c, 0x0e,
+	0x10, 0xc8, 0x26, 0x94, 0x94, 0x6b, 0x6b, 0x1f, 0xaa, 0x53, 0xa0, 0x3a, 0x7a, 0x07, 0xb2, 0x38,
-	0xd8, 0xaa, 0x8c, 0x2f, 0x3a, 0x57, 0x7e, 0xb7, 0x2a, 0x50, 0x3a, 0xf3, 0x7c, 0xdd, 0x0f, 0xad,
+	0x60, 0xab, 0x32, 0xbe, 0xe8, 0x5c, 0xf9, 0xdd, 0x2a, 0x43, 0xb1, 0xeb, 0xf9, 0xba, 0x1f, 0x5a,
-	0x2b, 0x03, 0xca, 0x67, 0x81, 0x3f, 0xed, 0x44, 0x67, 0x70, 0x4b, 0xdf, 0xc0, 0xc7, 0x67, 0x47,
+	0x6f, 0x0c, 0x28, 0x75, 0x03, 0x7f, 0xda, 0x89, 0xba, 0x70, 0x4b, 0xdf, 0xc0, 0xc7, 0xdd, 0x93,
-	0xfb, 0x4e, 0xa8, 0x4d, 0x69, 0x5c, 0x0f, 0xb3, 0x7a, 0x0b, 0xd8, 0x31, 0x63, 0x27, 0x8b, 0x4d,
+	0x03, 0x27, 0xd4, 0xa6, 0xd4, 0xaf, 0x87, 0x59, 0xbd, 0x05, 0xec, 0x98, 0xb1, 0x9d, 0xc5, 0xa6,
-	0x8b, 0xce, 0xc3, 0xc9, 0x2f, 0x20, 0x7f, 0x7c, 0xdc, 0x91, 0x92, 0x36, 0xd7, 0x92, 0xa4, 0x61,
+	0x45, 0xe7, 0xe1, 0xe4, 0x17, 0x90, 0x3b, 0x3d, 0x6d, 0x4b, 0x49, 0x9b, 0x6b, 0x49, 0xd2, 0x30,
-	0xe4, 0x73, 0xc8, 0x3f, 0x97, 0x4f, 0x94, 0x48, 0x35, 0x96, 0x05, 0x29, 0x17, 0x1b, 0x1a, 0xb3,
+	0xf2, 0x39, 0xe4, 0x9e, 0xc9, 0x27, 0x4a, 0xa4, 0x1a, 0xcb, 0x82, 0x94, 0x8b, 0x0d, 0x8d, 0xd9,
-	0x51, 0xd6, 0x0b, 0xb8, 0x4b, 0x35, 0xc8, 0xfa, 0x8f, 0x01, 0xb7, 0x4f, 0xd9, 0xe5, 0xbe, 0x6e,
+	0x28, 0xeb, 0x05, 0xdc, 0xa5, 0x1a, 0x64, 0xfd, 0x69, 0x13, 0x6e, 0x9f, 0xb3, 0xab, 0x03, 0xdd,
-	0x9e, 0xda, 0xdb, 0x0d, 0x28, 0x4d, 0x68, 0x47, 0x07, 0xca, 0xeb, 0x49, 0x12, 0x79, 0x1f, 0xb6,
+	0x3c, 0xb5, 0xb7, 0xeb, 0x50, 0x9c, 0xd0, 0x4e, 0x0e, 0x95, 0xd7, 0x93, 0x24, 0xf2, 0x3e, 0x6c,
-	0x4e, 0x82, 0x91, 0x2f, 0xb4, 0xea, 0x45, 0xac, 0x33, 0x92, 0x42, 0xd5, 0x07, 0xf2, 0x13, 0xc8,
+	0x9f, 0x05, 0x23, 0x5f, 0x68, 0xd5, 0x0b, 0x58, 0x67, 0x24, 0x85, 0xaa, 0x0f, 0xe4, 0x27, 0x90,
-	0x9f, 0x32, 0x81, 0x4f, 0x28, 0x99, 0x27, 0xd5, 0x76, 0x09, 0x79, 0x4e, 0x99, 0xc0, 0x89, 0x80,
+	0x3b, 0x67, 0x02, 0x9f, 0x50, 0x32, 0x4f, 0x2a, 0xad, 0x22, 0xf2, 0x9c, 0x33, 0x81, 0x13, 0x01,
-	0xea, 0x6f, 0x38, 0x66, 0x84, 0x7a, 0xcc, 0xc8, 0x2e, 0x1a, 0x33, 0xf4, 0x57, 0xb2, 0x0b, 0xa5,
+	0xd5, 0xdf, 0x70, 0xcc, 0x08, 0xf5, 0x98, 0x91, 0x5d, 0x34, 0x66, 0xe8, 0xaf, 0x64, 0x0f, 0x8a,
-	0x5e, 0xe0, 0x47, 0x82, 0x3b, 0x1e, 0x1e, 0x9c, 0x93, 0xcc, 0x3f, 0x42, 0xe6, 0xd8, 0x9e, 0xfd,
+	0xbd, 0xc0, 0x8f, 0x04, 0x77, 0x3c, 0x3c, 0x78, 0x4b, 0x32, 0xff, 0x08, 0x99, 0x63, 0x7b, 0x0e,
-	0xe9, 0x47, 0x9a, 0xe4, 0xb4, 0xde, 0x81, 0xb7, 0x67, 0xad, 0x54, 0x33, 0xde, 0x23, 0xf8, 0x31,
+	0xa6, 0x1f, 0x69, 0x92, 0x93, 0xdc, 0x07, 0x60, 0xaf, 0x04, 0x77, 0x8e, 0x83, 0x48, 0x44, 0xb5,
-	0x65, 0x43, 0xe6, 0x44, 0x6c, 0x7d, 0x0f, 0x58, 0x26, 0xd4, 0xaf, 0x83, 0x95, 0xe0, 0xbf, 0x67,
+	0x6d, 0xa9, 0x30, 0x20, 0x0e, 0x09, 0x27, 0x5d, 0x9a, 0xf8, 0x6a, 0xbd, 0x03, 0x6f, 0xcf, 0x7a,
-	0xa0, 0xd4, 0x7d, 0xcd, 0x7a, 0x27, 0x2c, 0x8a, 0x9c, 0x01, 0x23, 0xef, 0x42, 0xf1, 0x8c, 0x07,
+	0x44, 0xcd, 0x83, 0x8f, 0xe0, 0xc7, 0x94, 0x0d, 0x99, 0x13, 0xb1, 0xf5, 0xbd, 0x65, 0x99, 0x50,
-	0x3d, 0x16, 0x45, 0x13, 0x59, 0x53, 0x02, 0xf9, 0x0c, 0xb2, 0x47, 0xbe, 0x27, 0x54, 0xc5, 0xde,
+	0xbb, 0x0e, 0x56, 0x82, 0xff, 0x91, 0x81, 0x62, 0xe7, 0x15, 0xeb, 0x9d, 0xb1, 0x28, 0x72, 0x06,
-	0x4e, 0x9d, 0x1f, 0x3d, 0xa1, 0x64, 0xe2, 0xdb, 0x09, 0xb7, 0x64, 0x0f, 0xb2, 0x98, 0xef, 0xab,
+	0x8c, 0xbc, 0x0b, 0x85, 0x2e, 0x0f, 0x7a, 0x2c, 0x8a, 0x26, 0xb2, 0xa6, 0x04, 0xf2, 0x19, 0x64,
-	0xd4, 0x1c, 0x37, 0x81, 0x45, 0x0c, 0xe9, 0xc8, 0xd7, 0xa6, 0xf7, 0x2d, 0x53, 0x9e, 0x6f, 0xa6,
+	0x4f, 0x7c, 0x4f, 0xa8, 0xea, 0xbe, 0x93, 0x3a, 0x6b, 0x7a, 0x42, 0xc9, 0xc4, 0x77, 0x16, 0x6e,
-	0x17, 0x4b, 0xef, 0x5b, 0x36, 0x95, 0xa0, 0x90, 0xa4, 0x0b, 0xf9, 0x67, 0xc2, 0xe1, 0x38, 0x72,
+	0xc9, 0x3e, 0x64, 0xf1, 0x6e, 0xac, 0x52, 0x9f, 0xdc, 0x04, 0x16, 0x31, 0xa4, 0x2d, 0x5f, 0xa6,
-	0xc4, 0x11, 0xb9, 0x97, 0xd6, 0x53, 0x63, 0xce, 0xa9, 0x14, 0x8d, 0x45, 0x27, 0x74, 0x5f, 0x7b,
+	0xde, 0xb7, 0x4c, 0x45, 0xa9, 0x91, 0x5e, 0x58, 0xbd, 0x6f, 0xd9, 0x54, 0x82, 0x42, 0x92, 0x0e,
-	0x42, 0x0e, 0x14, 0xe9, 0x4e, 0x40, 0xb6, 0x84, 0x21, 0xb8, 0x45, 0xf4, 0x41, 0xe0, 0xb3, 0x7a,
+	0xe4, 0x9e, 0x0a, 0x87, 0xe3, 0x78, 0x12, 0x47, 0xef, 0x5e, 0x5a, 0xff, 0x8d, 0x39, 0xa7, 0x52,
-	0x7e, 0x29, 0x1a, 0xd9, 0x12, 0x68, 0xdc, 0x76, 0xf2, 0x90, 0x93, 0x4d, 0xd5, 0xfa, 0x8b, 0x01,
+	0x34, 0x16, 0x9d, 0xd0, 0x79, 0xe5, 0x09, 0x39, 0x7c, 0xa4, 0x3b, 0x01, 0xd9, 0x12, 0x86, 0xe0,
-	0xa5, 0x84, 0x8f, 0x57, 0xb8, 0x07, 0xef, 0x42, 0x16, 0x1f, 0x9b, 0x2a, 0x76, 0x05, 0x79, 0x0b,
+	0x16, 0xd1, 0x87, 0x81, 0xcf, 0x6a, 0xb9, 0xa5, 0x68, 0x64, 0x4b, 0xa0, 0x71, 0xdb, 0xce, 0xc1,
-	0x98, 0x70, 0xa8, 0xa4, 0x62, 0xd5, 0x3a, 0x74, 0xe3, 0xbb, 0x59, 0xa1, 0xb8, 0x44, 0xca, 0x57,
+	0x96, 0x6c, 0xc0, 0xd6, 0x5f, 0x0d, 0x28, 0x26, 0x7c, 0xbc, 0xc2, 0x9d, 0x79, 0x17, 0xb2, 0xf8,
-	0x62, 0x2c, 0xdd, 0x5d, 0xa0, 0xb8, 0x24, 0x3b, 0x50, 0x78, 0xc6, 0x7a, 0x23, 0xee, 0x89, 0xb1,
+	0x30, 0x55, 0xb1, 0xcb, 0xcb, 0x1b, 0xc3, 0x84, 0x43, 0x25, 0x15, 0x2b, 0xdc, 0x91, 0x1b, 0xdf,
-	0x74, 0x60, 0xb5, 0x5d, 0x43, 0x29, 0x9a, 0x26, 0x2f, 0xcb, 0x84, 0xc3, 0xfa, 0x12, 0x13, 0x6b,
+	0xe3, 0x32, 0xc5, 0x25, 0x52, 0xbe, 0x12, 0x63, 0xe9, 0xee, 0x3c, 0xc5, 0x25, 0xd9, 0x85, 0xfc,
-	0xaa, 0x20, 0x81, 0xec, 0x3e, 0x8e, 0xdc, 0xa8, 0x59, 0x85, 0xca, 0x35, 0xbe, 0x7a, 0xba, 0xcb,
+	0x53, 0xd6, 0x1b, 0x71, 0x4f, 0x8c, 0xa5, 0x03, 0x2b, 0xad, 0x2a, 0x4a, 0xd1, 0x34, 0x79, 0xb1,
-	0x5e, 0x3d, 0x5d, 0xfd, 0xea, 0x99, 0x0d, 0x08, 0x16, 0xc1, 0x84, 0x83, 0xac, 0xc7, 0x50, 0x9c,
+	0x26, 0x1c, 0xd6, 0x97, 0x98, 0x58, 0x53, 0x05, 0x09, 0x64, 0x0f, 0x70, 0x3c, 0x47, 0xcd, 0xca,
-	0x24, 0x0d, 0x3e, 0x38, 0x0f, 0x5d, 0x75, 0xd2, 0xe6, 0xa1, 0x8b, 0xa6, 0x74, 0x9f, 0x1e, 0xca,
+	0x54, 0xae, 0xf1, 0x85, 0xd4, 0x59, 0xf6, 0x42, 0xea, 0xe8, 0x17, 0xd2, 0x6c, 0x40, 0xb0, 0x60,
-	0x53, 0x0a, 0x14, 0x97, 0x93, 0x96, 0x93, 0x49, 0xb4, 0x9c, 0x5d, 0x7c, 0xcf, 0x25, 0x32, 0x07,
+	0x26, 0x1c, 0x64, 0x3d, 0x86, 0xc2, 0x24, 0x69, 0xf0, 0x71, 0x7a, 0xe4, 0xaa, 0x93, 0x36, 0x8f,
-	0x99, 0x68, 0x70, 0x19, 0x69, 0x95, 0x71, 0x1d, 0x9b, 0x31, 0x8c, 0xa4, 0x2c, 0x69, 0xc6, 0x30,
+	0x5c, 0x34, 0xa5, 0xf3, 0xe4, 0x48, 0x9e, 0x92, 0xa7, 0xb8, 0x9c, 0xb4, 0xa7, 0x4c, 0xa2, 0x3d,
-	0x6a, 0xff, 0xaf, 0x00, 0xc5, 0xe3, 0xe3, 0x4e, 0x87, 0x7b, 0xee, 0x80, 0x91, 0x3f, 0x18, 0x40,
+	0xed, 0xe1, 0xdb, 0x2f, 0x91, 0x39, 0xc8, 0x44, 0x83, 0xab, 0x48, 0xab, 0x8c, 0xeb, 0xd8, 0x8c,
-	0xae, 0x3f, 0x13, 0xc8, 0x27, 0xe9, 0x09, 0xbb, 0xf8, 0xad, 0x63, 0x7e, 0xba, 0x26, 0x4a, 0x75,
+	0x61, 0x24, 0x65, 0x49, 0x33, 0x86, 0x51, 0xeb, 0x7f, 0x79, 0x28, 0x9c, 0x9e, 0xb6, 0xdb, 0xdc,
-	0x80, 0xaf, 0x21, 0x27, 0xa7, 0x0f, 0xf2, 0xd3, 0x15, 0xa7, 0x46, 0xb3, 0xb9, 0x9c, 0x51, 0xc9,
+	0x73, 0x07, 0x8c, 0xfc, 0xc1, 0x00, 0x72, 0xfd, 0x49, 0x41, 0x3e, 0x49, 0x4f, 0xd8, 0xc5, 0xef,
-	0xee, 0x41, 0x41, 0x77, 0x70, 0x72, 0x3f, 0x55, 0xbd, 0x99, 0x01, 0xc5, 0xfc, 0x70, 0x25, 0x5e,
+	0x22, 0xf3, 0xd3, 0x35, 0x51, 0xaa, 0x5b, 0x7c, 0x0d, 0x5b, 0x72, 0x52, 0x21, 0x3f, 0x5d, 0x71,
-	0x75, 0xc8, 0x6f, 0x21, 0xaf, 0x1a, 0x33, 0xb9, 0xb7, 0x04, 0x37, 0x1d, 0x11, 0xcc, 0xfb, 0xab,
+	0xc2, 0x34, 0x1b, 0xcb, 0x19, 0x95, 0xec, 0x1e, 0xe4, 0x75, 0xb7, 0x27, 0xf7, 0x53, 0xd5, 0x9b,
-	0xb0, 0x4e, 0xcd, 0xd0, 0x0d, 0x38, 0xd5, 0x8c, 0xb9, 0xf6, 0x9e, 0x6a, 0xc6, 0xb5, 0x8e, 0xfe,
+	0x19, 0x66, 0xcc, 0x0f, 0x57, 0xe2, 0x55, 0x87, 0xfc, 0x16, 0x72, 0xaa, 0x89, 0x93, 0x7b, 0x4b,
-	0x1c, 0xb2, 0xd8, 0xa9, 0x49, 0xda, 0x35, 0x4f, 0xb4, 0x72, 0x33, 0x2d, 0x5c, 0x33, 0x2d, 0xfe,
+	0x70, 0xd3, 0x71, 0xc2, 0xbc, 0xbf, 0x0a, 0xeb, 0xd4, 0x0c, 0xdd, 0xac, 0x53, 0xcd, 0x98, 0x1b,
-	0x37, 0x58, 0x0e, 0xe5, 0x6b, 0x27, 0xbd, 0x10, 0x26, 0xfe, 0x9e, 0x30, 0xef, 0xad, 0xc0, 0x39,
+	0x05, 0x52, 0xcd, 0xb8, 0xd6, 0xfd, 0x9f, 0x41, 0x16, 0xbb, 0x3a, 0x49, 0xbb, 0xe6, 0x89, 0xb6,
-	0x15, 0xaf, 0x5e, 0x0a, 0xcd, 0x15, 0xfe, 0x23, 0x58, 0x2e, 0x7e, 0xee, 0xdf, 0x88, 0x00, 0xca,
+	0x6f, 0xa6, 0x85, 0x6b, 0x66, 0x1c, 0xf8, 0x0d, 0x96, 0x43, 0xf9, 0x32, 0x4a, 0x2f, 0x84, 0x89,
-	0xc9, 0x2e, 0x47, 0xec, 0x14, 0xe8, 0x82, 0xa6, 0x6f, 0xb6, 0x56, 0xe6, 0x57, 0x07, 0x7e, 0x87,
+	0xbf, 0x32, 0xcc, 0x7b, 0x2b, 0x70, 0x4e, 0xc5, 0xab, 0x57, 0x45, 0x63, 0x85, 0xff, 0x13, 0x96,
-	0x53, 0xe7, 0x6c, 0x07, 0x24, 0xed, 0x54, 0x77, 0x2c, 0xec, 0xb5, 0xe6, 0x83, 0xb5, 0x30, 0xea,
+	0x8b, 0x9f, 0xfb, 0xe7, 0x22, 0x80, 0x52, 0xb2, 0xcb, 0x11, 0x3b, 0x05, 0xba, 0x60, 0x40, 0x30,
-	0x70, 0x27, 0xee, 0xb0, 0xaa, 0x8b, 0x92, 0xf4, 0x86, 0x31, 0xe9, 0xc4, 0xe6, 0x8a, 0x7c, 0x4d,
+	0x9b, 0x2b, 0xf3, 0xab, 0x03, 0xbf, 0xc3, 0x09, 0x75, 0xb6, 0x03, 0x92, 0x56, 0xaa, 0x3b, 0x16,
-	0xe3, 0x63, 0xa3, 0x53, 0xfe, 0xfe, 0xea, 0xae, 0xf1, 0xcf, 0xab, 0xbb, 0xc6, 0xbf, 0xaf, 0xee,
+	0xf6, 0x5a, 0xf3, 0xc1, 0x5a, 0x18, 0x75, 0xb8, 0x13, 0x77, 0x58, 0xd5, 0x45, 0x49, 0x7a, 0xc3,
-	0x1a, 0xe7, 0x5b, 0xf2, 0x1f, 0xda, 0x07, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x9d, 0x1a,
+	0x98, 0x74, 0x62, 0x73, 0x45, 0xbe, 0x86, 0xf1, 0xb1, 0xd1, 0x2e, 0x7d, 0xff, 0xe6, 0xae, 0xf1,
-	0x7c, 0xf3, 0x16, 0x00, 0x00,
+	0xaf, 0x37, 0x77, 0x8d, 0xff, 0xbc, 0xb9, 0x6b, 0x5c, 0x6c, 0xcb, 0x7f, 0x73, 0x1f, 0xfc, 0x3f,
+	0x00, 0x00, 0xff, 0xff, 0xf5, 0x6a, 0xee, 0x8e, 0x1f, 0x17, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3878,6 +3887,20 @@ func (m *NewContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if len(m.ExtraHosts) > 0 {
+		for iNdEx := len(m.ExtraHosts) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ExtraHosts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGateway(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x32
+		}
+	}
 	if m.Constraints != nil {
 		{
 			size, err := m.Constraints.MarshalToSizedBuffer(dAtA[:i])
@@ -5035,6 +5058,12 @@ func (m *NewContainerRequest) Size() (n int) {
 		l = m.Constraints.Size()
 		n += 1 + l + sovGateway(uint64(l))
 	}
+	if len(m.ExtraHosts) > 0 {
+		for _, e := range m.ExtraHosts {
+			l = e.Size()
+			n += 1 + l + sovGateway(uint64(l))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -8825,6 +8854,40 @@ func (m *NewContainerRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExtraHosts", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGateway
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGateway
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGateway
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ExtraHosts = append(m.ExtraHosts, &pb.HostIP{})
+			if err := m.ExtraHosts[len(m.ExtraHosts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGateway(dAtA[iNdEx:])

frontend/gateway/pb/gateway.proto

@@ -176,6 +176,7 @@ message NewContainerRequest {
 	pb.NetMode Network = 3;
 	pb.Platform platform = 4;
 	pb.WorkerConstraints constraints = 5;
+	repeated pb.HostIP extraHosts = 6;
 }
 
 message NewContainerResponse{}

frontend/gateway/util.go

@@ -0,0 +1,24 @@
+package gateway
+
+import (
+	"net"
+
+	"github.com/moby/buildkit/executor"
+	"github.com/moby/buildkit/solver/pb"
+	"github.com/pkg/errors"
+)
+
+func ParseExtraHosts(ips []*pb.HostIP) ([]executor.HostIP, error) {
+	out := make([]executor.HostIP, len(ips))
+	for i, hip := range ips {
+		ip := net.ParseIP(hip.IP)
+		if ip == nil {
+			return nil, errors.Errorf("failed to parse IP %s", hip.IP)
+		}
+		out[i] = executor.HostIP{
+			IP:   ip,
+			Host: hip.Host,
+		}
+	}
+	return out, nil
+}

hack/update-generated-files

@@ -16,5 +16,5 @@ buildxCmd build \
 
 # --build-arg "PROTOBUF_VERSION=$protobuf_version" \
 
-cp -R "$output/generated-files/" .
+cp -R "$output/generated-files/." .
 rm -rf $output

solver/llbsolver/ops/exec.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"net"
 	"os"
 	"path"
 	"sort"
@@ -290,7 +289,7 @@ func (e *execOp) Exec(ctx context.Context, g session.Group, inputs []solver.Resu
 		return nil, err
 	}
 
-	extraHosts, err := parseExtraHosts(e.op.Meta.ExtraHosts)
+	extraHosts, err := gateway.ParseExtraHosts(e.op.Meta.ExtraHosts)
 	if err != nil {
 		return nil, err
 	}
@@ -377,21 +376,6 @@ func proxyEnvList(p *pb.ProxyEnv) []string {
 	return out
 }
 
-func parseExtraHosts(ips []*pb.HostIP) ([]executor.HostIP, error) {
-	out := make([]executor.HostIP, len(ips))
-	for i, hip := range ips {
-		ip := net.ParseIP(hip.IP)
-		if ip == nil {
-			return nil, errors.Errorf("failed to parse IP %s", hip.IP)
-		}
-		out[i] = executor.HostIP{
-			IP:   ip,
-			Host: hip.Host,
-		}
-	}
-	return out, nil
-}
-
 func (e *execOp) Acquire(ctx context.Context) (solver.ReleaseFunc, error) {
 	if e.parallelism == nil {
 		return func() {}, nil