fix crash with realms selector

handlers/worlds/map_item.go

@@ -75,8 +75,8 @@ type MapUI struct {
 	ticker         *time.Ticker
 	w              *worldsHandler
 
-	l  sync.Mutex
-	wg sync.WaitGroup
+	l          sync.Mutex
+	haveColors chan struct{}
 
 	zoomLevel  int  // pixels per chunk
 	needRedraw bool // when the map has updated this is true
@@ -92,6 +92,7 @@ func NewMapUI(w *worldsHandler) *MapUI {
 		oldRendered:    make(map[protocol.ChunkPos]*image.RGBA),
 		needRedraw:     true,
 		w:              w,
+		haveColors:     make(chan struct{}),
 	}
 	return m
 }
@@ -124,15 +125,14 @@ func (m *MapUI) Start(ctx context.Context) {
 	}
 
 	m.ticker = time.NewTicker(33 * time.Millisecond)
-	m.wg.Add(1)
 	go func() {
 		lookup, _ := utils.ResolveColors(m.w.customBlocks, m.w.serverState.packs, true)
 		messages.Router.Handle(&messages.Message{
 			Source: "mapui",
 			Target: "ui",
 			Data:   messages.MapLookup{Lookup: lookup},
 		})
-		m.wg.Done()
+		close(m.haveColors)
 	}()
 	go func() {
 		var oldPos mgl32.Vec3
@@ -218,7 +218,8 @@ func (m *MapUI) SchedRedraw() {
 var red = image.NewUniform(color.RGBA{R: 0xff, G: 0, B: 0, A: 128})
 
 func (m *MapUI) processQueue() []protocol.ChunkPos {
-	m.wg.Wait()
+	<-m.haveColors
+
 	updatedChunks := make([]protocol.ChunkPos, 0, m.renderQueue.Length())
 	for {
 		r, ok := m.renderQueue.Dequeue().(*renderElem)

handlers/worlds/world.go

@@ -296,7 +296,7 @@ func (w *worldsHandler) preloadReplay() error {
 	}
 
 	for {
-		_, _, err := conn.ReadPacket()
+		_, err := conn.ReadPacket()
 		if err != nil {
 			break
 		}

ui/gui/popups/realmsinput.go

@@ -30,6 +30,7 @@ type RealmsList struct {
 func NewRealmsList(setRealm func(realms.Realm)) Popup {
 	return &RealmsList{
 		setRealm: setRealm,
+		buttons:  make(map[int]*widget.Clickable),
 	}
 }
 
@@ -46,6 +47,7 @@ var _ Popup = &RealmsList{}
 func (r *RealmsList) Load() {
 	var err error
 	r.realms, err = utils.GetRealmsAPI().Realms(context.Background())
+	clear(r.buttons)
 	for _, realm := range r.realms {
 		r.buttons[realm.ID] = &widget.Clickable{}
 	}

utils/proxy/context.go

@@ -52,7 +52,6 @@ type Context struct {
 
 	commands  map[string]ingameCommand
 	handlers  []*Handler
-	transfer  *packet.Transfer
 	rpHandler *rpHandler
 }
 
@@ -147,7 +146,7 @@ func (p *Context) proxyLoop(ctx context.Context, toServer bool) (err error) {
 			return ctx.Err()
 		}
 
-		pk, timeReceived, err := c1.ReadPacket()
+		pk, timeReceived, err := c1.ReadPacketWithTime()
 		if err != nil {
 			if errors.Is(err, net.ErrClosed) {
 				err = nil
@@ -170,9 +169,10 @@ func (p *Context) proxyLoop(ctx context.Context, toServer bool) (err error) {
 			}
 		}
 
+		var transfer *packet.Transfer
 		switch _pk := pk.(type) {
 		case *packet.Transfer:
-			p.transfer = _pk
+			transfer = _pk
 			if p.Client != nil {
 				host, port, err := net.SplitHostPort(p.Client.ClientData().ServerAddress)
 				if err != nil {
@@ -196,8 +196,8 @@ func (p *Context) proxyLoop(ctx context.Context, toServer bool) (err error) {
 			}
 		}
 
-		if p.transfer != nil {
-			return nil
+		if transfer != nil {
+			return errTransfer{transfer: transfer}
 		}
 	}
 }
@@ -476,10 +476,6 @@ func (p *Context) doSession(ctx context.Context, cancel context.CancelCauseFunc)
 				}
 				return
 			}
-			if p.transfer != nil {
-				cancel(errTransfer)
-				return
-			}
 		}
 
 		// server to client
@@ -502,21 +498,26 @@ func (p *Context) doSession(ctx context.Context, cancel context.CancelCauseFunc)
 	return err
 }
 
-var errTransfer = errors.New("err transfer")
+type errTransfer struct {
+	transfer *packet.Transfer
+}
+
+func (e errTransfer) Error() string {
+	return fmt.Sprintf("transfer to %s:%d", e.transfer.Address, e.transfer.Port)
+}
 
 func (p *Context) connect(ctx context.Context) (err error) {
 	p.spawned = false
 	p.clientAddr = nil
-	p.transfer = nil
 	p.Client = nil
 	p.clientConnecting = make(chan struct{})
 	p.haveClientData = make(chan struct{})
 	ctx2, cancel := context.WithCancelCause(ctx)
 	err = p.doSession(ctx2, cancel)
 	cancel(nil)
 
-	if errors.Is(err, errTransfer) && p.transfer != nil {
-		p.serverAddress = fmt.Sprintf("%s:%d", p.transfer.Address, p.transfer.Port)
+	if err, ok := err.(*errTransfer); ok {
+		p.serverAddress = fmt.Sprintf("%s:%d", err.transfer.Address, err.transfer.Port)
 		logrus.Infof("transferring to %s", p.serverAddress)
 		return p.connect(ctx)
 	}
@@ -525,7 +526,6 @@ func (p *Context) connect(ctx context.Context) (err error) {
 }
 
 func (p *Context) Run(ctx context.Context, connectString string) (err error) {
-
 	var serverInput *messages.ServerInput
 	if connectString != "" {
 		serverInput, err = utils.ParseServer(context.Background(), connectString)

utils/proxy/pcap2reader.go

@@ -22,7 +22,6 @@ import (
 
 type Pcap2Reader struct {
 	f                 *os.File
-	packetsOffset     int64
 	Version           uint32
 	packetsReader     io.Reader
 	ResourcePacks     *replayCache
@@ -57,15 +56,14 @@ func NewPcap2Reader(f *os.File, packetFunc PacketFunc, ShieldID *atomic.Int32) (
 		return nil, err
 	}
 
-	var packetsOffset int64
 	var packetReader io.ReadCloser
 	if ver < 4 {
 		return nil, errors.New("version < 4 no longer supported")
 	} else if ver < 5 {
 		f.Seek(int64(zipSize+16), 0)
 		packetReader = flate.NewReader(f)
 	} else {
-		packetsOffset, _ = f.Seek(int64(zipSize+16), 0)
+		f.Seek(int64(zipSize+16), 0)
 		packetReader = f
 	}
 
@@ -74,7 +72,6 @@ func NewPcap2Reader(f *os.File, packetFunc PacketFunc, ShieldID *atomic.Int32) (
 
 	return &Pcap2Reader{
 		f:             f,
-		packetsOffset: packetsOffset,
 		Version:       ver,
 		packetsReader: packetReader,
 		ResourcePacks: cache,
@@ -92,7 +89,7 @@ func (r *Pcap2Reader) ReadPacket(skip bool) (packet packet.Packet, toServer bool
 	receivedTime = time.Now()
 
 	// add where this is to index
-	if len(r.packetOffsetIndex) < r.CurrentPacket && r.Version >= 5 {
+	if len(r.packetOffsetIndex) <= r.CurrentPacket && r.Version >= 5 {
 		off, _ := r.f.Seek(0, 1)
 		r.packetOffsetIndex = append(r.packetOffsetIndex, off)
 	}
@@ -123,46 +120,45 @@ func (r *Pcap2Reader) ReadPacket(skip bool) (packet packet.Packet, toServer bool
 		if err != nil {
 			return nil, toServer, receivedTime, err
 		}
-		return nil, false, receivedTime, nil
-	}
-
-	payload := make([]byte, packetLength)
-	n, err := io.ReadFull(r.packetsReader, payload)
-	if err != nil {
-		return nil, toServer, receivedTime, err
-	}
-	if n != int(packetLength) {
-		return nil, toServer, receivedTime, errors.New("truncated")
-	}
+	} else {
+		payload := make([]byte, packetLength)
+		n, err := io.ReadFull(r.packetsReader, payload)
+		if err != nil {
+			return nil, toServer, receivedTime, err
+		}
+		if n != int(packetLength) {
+			return nil, toServer, receivedTime, errors.New("truncated")
+		}
 
-	binary.Read(r.packetsReader, binary.LittleEndian, &magic2)
-	if magic2 != 0xBBBBBBBB {
-		return nil, toServer, receivedTime, errors.New("wrong Magic2")
-	}
+		// version 5 compresses payloads seperately
+		if r.Version >= 5 {
+			payload, err = s2.Decode(nil, payload)
+			if err != nil {
+				return nil, toServer, receivedTime, err
+			}
+		}
 
-	// version 5 compresses payloads seperately
-	if r.Version >= 5 {
-		payload, err = s2.Decode(nil, payload)
+		var src, dst = replayRemoteAddr, replayLocalAddr
+		if toServer {
+			src, dst = replayLocalAddr, replayRemoteAddr
+		}
+		pkData, err := minecraft.ParseData(payload, r.packetFunc, src, dst)
+		if err != nil {
+			return nil, toServer, receivedTime, err
+		}
+		pks, err := pkData.Decode(r.pool, r.protocol, nil, false, false, r.shieldID.Load())
 		if err != nil {
 			return nil, toServer, receivedTime, err
 		}
+		packet = pks[0]
 	}
 
-	var src, dst = replayRemoteAddr, replayLocalAddr
-	if toServer {
-		src, dst = replayLocalAddr, replayRemoteAddr
-	}
-	pkData, err := minecraft.ParseData(payload, r.packetFunc, src, dst)
-	if err != nil {
-		return nil, toServer, receivedTime, err
-	}
-	pks, err := pkData.Decode(r.pool, r.protocol, nil, false, false, r.shieldID.Load())
-	if err != nil {
-		return nil, toServer, receivedTime, err
+	binary.Read(r.packetsReader, binary.LittleEndian, &magic2)
+	if magic2 != 0xBBBBBBBB {
+		return nil, toServer, receivedTime, errors.New("wrong Magic2")
 	}
-	pk := pks[0]
 
-	return pk, toServer, receivedTime, nil
+	return packet, toServer, receivedTime, nil
 }
 
 func (r *Pcap2Reader) Seek(packet int) error {
@@ -181,7 +177,7 @@ func (r *Pcap2Reader) Seek(packet int) error {
 		}
 	} else if diff < 0 {
 		off := r.packetOffsetIndex[packet]
-		_, err := r.f.Seek(off+r.packetsOffset, 0)
+		_, err := r.f.Seek(off, 0)
 		if err != nil {
 			return err
 		}

utils/proxy/replay_connector.go

@@ -218,7 +218,7 @@ func (r *ReplayConnector) Read(b []byte) (n int, err error) {
 	return 0, errors.New("not Implemented")
 }
 
-func (r *ReplayConnector) ReadPacket() (pk packet.Packet, receivedAt time.Time, err error) {
+func (r *ReplayConnector) ReadPacketWithTime() (pk packet.Packet, receivedAt time.Time, err error) {
 	if r.closed.Load() {
 		return nil, time.Time{}, net.ErrClosed
 	}
@@ -230,6 +230,11 @@ func (r *ReplayConnector) ReadPacket() (pk packet.Packet, receivedAt time.Time,
 	return pk, receivedTime, nil
 }
 
+func (r *ReplayConnector) ReadPacket() (pk packet.Packet, err error) {
+	pk, _, err = r.ReadPacketWithTime()
+	return pk, err
+}
+
 func (r *ReplayConnector) Write(b []byte) (n int, err error) {
 	panic("unimplemented")
 }