return errors.New("ScanRange: Start cannot be after end")
	}
	return nil
}

// StartLen returns start offset plus length from range.
func (s *ScanRange) StartLen() (start, length int64, err error) {
	if s == nil {
		return 0, -1, nil
	}
	err = s.Validate()
	if err != nil {
		return 0, 0, err
	}

	if s.End == nil && s.Start == nil {
		// Not valid, but should be caught above.
		return 0, -1, nil
	}

			rpt.SetStatus(bucket, fileName, nil)
		}
	}

	enc := func(b []byte) *string {
		if b == nil {
			return nil
		}
		v := base64.StdEncoding.EncodeToString(b)
		return &v
	}

	for bucket, meta := range bucketMap {
		err := globalBucketMetadataSys.save(ctx, *meta)
		if err != nil {
			rpt.SetStatus(bucket, "", err)
			continue
		}

	// write "v"
	err = en.Append(0xa1, 0x76)
	if err != nil {
		return
	}
	err = en.WriteString(z.Volume)
	if err != nil {
		err = msgp.WrapError(err, "Volume")
		return
	}
	// write "fp"
	err = en.Append(0xa2, 0x66, 0x70)
	if err != nil {
		return
	}
	err = en.WriteString(z.FilePath)
	if err != nil {
		err = msgp.WrapError(err, "FilePath")
		return
	}
	// write "fi"

		cancelGlobalContext()

		if httpServer := newHTTPServerFn(); httpServer != nil {
			if err := httpServer.Shutdown(); err != nil && !errors.Is(err, http.ErrServerClosed) {
				shutdownLogIf(context.Background(), err)
			}
		}

		if objAPI := newObjectLayerFn(); objAPI != nil {
			shutdownLogIf(context.Background(), objAPI.Shutdown(context.Background()))
		}

		if globalBrowserEnabled {

	if err != nil {
		return
	}
	err = en.WriteString(z.AccessKey)
	if err != nil {
		err = msgp.WrapError(err, "AccessKey")
		return
	}
	// write "SecretKey"
	err = en.Append(0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
	if err != nil {
		return
	}
	err = en.WriteString(z.SecretKey)
	if err != nil {
		err = msgp.WrapError(err, "SecretKey")
		return
	}

func TestMarshalUnmarshalRStat(t *testing.T) {
	v := RStat{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {

	v := connectReq{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {

	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	eventData, err := getLambdaEventData(bucket, object, cred, r)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	resp, err := target.Send(eventData)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return

		if x509Cert, err = x509.ParseCertificate(pemBlock.Bytes); err != nil {
			return nil, ErrTLSUnexpectedData(nil).Msgf("Failed to parse `%s`: %s", certFile, err.Error())
		}

		x509Certs = append(x509Certs, x509Cert)
	}

	if len(x509Certs) == 0 {
		return nil, ErrTLSUnexpectedData(nil).Msgf("Empty public certificate file %s", certFile)
	}

	return x509Certs, nil
}

	if objectAPI == nil {
		return
	}

	var sites []madmin.PeerSite
	if err := parseJSONBody(ctx, r.Body, &sites, cred.SecretKey); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	opts := getSRAddOptions(r)
	status, err := globalSiteReplicationSys.AddPeerClusters(ctx, sites, opts)
	if err != nil {
		adminLogIf(ctx, err)