func()

in ptp/simpleclient/client.go [415:471]

• 55 lines of code
• 17 McCabe index (conditional complexity)

func (c *Client) handleMsg(msg *inPacket) error {
	msgType, err := ptp.ProbeMsgType(msg.data)
	if err != nil {
		return err
	}
	switch msgType {
	case ptp.MessageSignaling:
		signaling := &ptp.Signaling{}
		if err := ptp.FromBytes(msg.data, signaling); err != nil {
			return fmt.Errorf("reading signaling msg: %w", err)
		}

		for _, tlv := range signaling.TLVs {
			switch v := tlv.(type) {
			case *ptp.GrantUnicastTransmissionTLV:
				if err := c.handleGrantUnicast(v); err != nil {
					return err
				}

			case *ptp.CancelUnicastTransmissionTLV:
				if err := c.handleCancelUnicast(v); err != nil {
					return err
				}
			default:
				return fmt.Errorf("got unsupported TLV type %s(%d)", tlv.Type(), tlv.Type())
			}
		}
		return nil
	case ptp.MessageAnnounce:
		announce := &ptp.Announce{}
		if err := ptp.FromBytes(msg.data, announce); err != nil {
			return fmt.Errorf("reading announce msg: %w", err)
		}
		return c.handleAnnounce(announce)
	case ptp.MessageSync:
		b := &ptp.SyncDelayReq{}
		if err := ptp.FromBytes(msg.data, b); err != nil {
			return fmt.Errorf("reading sync msg: %w", err)
		}
		return c.handleSync(b, msg.ts)
	case ptp.MessageDelayResp:
		b := &ptp.DelayResp{}
		if err := ptp.FromBytes(msg.data, b); err != nil {
			return fmt.Errorf("reading delay_resp msg: %w", err)
		}
		return c.handleDelay(b)
	case ptp.MessageFollowUp:
		b := &ptp.FollowUp{}
		if err := ptp.FromBytes(msg.data, b); err != nil {
			return fmt.Errorf("reading follow_up msg: %w", err)
		}
		return c.handleFollowUp(b)
	default:
		c.logReceive(msgType, "unsupported, ignoring")
		return nil
	}
}