gs: Ignore Class B&C downlink when gateway time is not set

pkg/gatewayserver/io/io.go

@@ -307,16 +307,21 @@ func (c *Connection) HandleUp(up *ttnpb.UplinkMessage, frontendSync *FrontendClo
 			"server_time", frontendSync.ServerTime,
 			"gateway_time", frontendSync.GatewayTime,
 		)).Debug("Gateway clocks have been synchronized by the frontend")
+
 	case gpsTime != nil:
 		gatewayTime := *ttnpb.StdTime(gpsTime)
+		// Bryan: up.Settings.Timestamp is tmst, check udp/translation.go v1Metadata and v2Metadata.
 		ct = c.scheduler.SyncWithGatewayAbsolute(up.Settings.Timestamp, receivedAt, gatewayTime)
 		log.FromContext(c.ctx).WithFields(log.Fields(
 			"timestamp", up.Settings.Timestamp,
 			"concentrator_time", ct,
 			"server_time", receivedAt,
 			"gateway_time", gatewayTime,
 		)).Debug("Synchronized server and gateway absolute time")
+
+	// Bryan: gpsTime will be nil when tmms is not provided, or tmms is invalid (check where gpsTimeDelta is used).
 	case gpsTime == nil:
+		// Bryan: up.Settings.Timestamp is tmst, check udp/translation.go v1Metadata and v2Metadata.
 		ct = c.scheduler.Sync(up.Settings.Timestamp, receivedAt)
 		log.FromContext(c.ctx).WithFields(log.Fields(
 			"timestamp", up.Settings.Timestamp,

pkg/gatewayserver/scheduling/clock.go

@@ -72,13 +72,15 @@ func (c *RolloverClock) Sync(timestamp uint32, server time.Time) ConcentratorTim
 	c.absolute = (ConcentratorTime(rollovers<<32) + ConcentratorTime(timestamp)) * ConcentratorTime(time.Microsecond)
 	c.relative = timestamp
 	c.server = &server
+	// Bryan: when gateway gps time is not set or invalid, this sync function will clear gateway gps time.
 	c.gateway = nil
 	c.synced = true
 	return c.absolute
 }
 
 // SyncWithGatewayAbsolute synchronizes the clock with the given concentrator timestamp, the server time and the
 // absolute gateway time that corresponds to the given timestamp.
+// Bryan: this function still syncs with tmst but caching gateway gps time.
 func (c *RolloverClock) SyncWithGatewayAbsolute(timestamp uint32, server, gateway time.Time) ConcentratorTime {
 	ct := c.Sync(timestamp, server)
 	c.gateway = &gateway

pkg/gatewayserver/scheduling/scheduler.go

@@ -316,18 +316,14 @@ func (s *Scheduler) ScheduleAt(ctx context.Context, opts Options) (res Emission,
 	if !ok {
 		panic("clock is synced without server time")
 	}
+	// Bryan: opts.time is absolute time and only set for Class B and C, check gatewayserver/io ScheduleDown.
 	if opts.Time != nil {
 		var ok bool
 		starts, ok = s.clock.FromGatewayTime(*ttnpb.StdTime(opts.Time))
 		if !ok {
-			if medianRTT == nil {
-				return Emission{}, 0, errNoAbsoluteGatewayTime.New()
-			}
-			serverTime, ok := s.clock.FromServerTime(*ttnpb.StdTime(opts.Time))
-			if !ok {
-				return Emission{}, 0, errNoServerTime.New()
-			}
-			starts = serverTime - ConcentratorTime(*medianRTT/2)
+			// Bryan: we can simply fail here to block all Class B and C transmission
+			// when gateway gps time is nil in clock.go.
+			return Emission{}, 0, errNoAbsoluteGatewayTime.New()
 		}
 	} else {
 		starts = s.clock.FromTimestampTime(opts.Timestamp)
@@ -459,6 +455,7 @@ func (s *Scheduler) Sync(v uint32, server time.Time) ConcentratorTime {
 
 // SyncWithGatewayAbsolute synchronizes the clock with the given concentrator timestamp, the server time and the
 // absolute gateway time that corresponds to the given timestamp.
+// Bryan: this function still syncs with tmst but caching gateway gps time.
 func (s *Scheduler) SyncWithGatewayAbsolute(timestamp uint32, server, gateway time.Time) ConcentratorTime {
 	s.mu.Lock()
 	defer s.mu.Unlock()

pkg/gatewayserver/scheduling/scheduler_test.go

@@ -166,26 +166,6 @@ func TestScheduleAtWithBandDutyCycle(t *testing.T) {
 			// Exceeding dwell time of 2 seconds.
 			ExpectedError: scheduling.ErrDwellTime,
 		},
-		{
-			PayloadSize: 16,
-			Settings: &ttnpb.TxSettings{
-				DataRate: &ttnpb.DataRate{
-					Modulation: &ttnpb.DataRate_Lora{
-						Lora: &ttnpb.LoRaDataRate{
-							Bandwidth:       125000,
-							SpreadingFactor: 7,
-							CodingRate:      band.Cr4_5,
-						},
-					},
-				},
-				Frequency: 868100000,
-				Time:      timestamppb.New(time.Unix(0, int64(1*time.Second))),
-			},
-			Priority:       ttnpb.TxSchedulePriority_HIGHEST,
-			MedianRTT:      durationPtr(200 * time.Millisecond),
-			ExpectedToa:    51456 * time.Microsecond,
-			ExpectedStarts: 1000000000 - 200000000/2,
-		},
 		{
 			SyncWithGatewayAbsolute: true,
 			PayloadSize:             16,