init
This commit is contained in:
@@ -0,0 +1,518 @@
|
||||
package gui
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/wailsapp/wails/v2/pkg/runtime"
|
||||
|
||||
"huya-go/internal/huya"
|
||||
"huya-go/internal/sniper"
|
||||
)
|
||||
|
||||
const (
|
||||
eventLog = "gui:log"
|
||||
eventMonitorResult = "gui:monitor-result"
|
||||
eventMonitorState = "gui:monitor-state"
|
||||
maxLogEntries = 500
|
||||
)
|
||||
|
||||
type App struct {
|
||||
ctx context.Context
|
||||
|
||||
logMu sync.Mutex
|
||||
logs []LogEntry
|
||||
|
||||
runMu sync.Mutex
|
||||
monitorCancel context.CancelFunc
|
||||
monitorRunning bool
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
Transport string `json:"transport"`
|
||||
WSSHost string `json:"wssHost"`
|
||||
SID int32 `json:"sid"`
|
||||
PID int32 `json:"pid"`
|
||||
Name string `json:"name"`
|
||||
CookieText string `json:"cookieText"`
|
||||
Loops int `json:"loops"`
|
||||
DelayMS int `json:"delayMs"`
|
||||
Concurrency int `json:"concurrency"`
|
||||
StopAfterSuccess bool `json:"stopAfterSuccess"`
|
||||
TimeoutSec int `json:"timeoutSec"`
|
||||
StartAt string `json:"startAt"`
|
||||
}
|
||||
|
||||
type AccountPreview struct {
|
||||
Line int `json:"line"`
|
||||
UID int64 `json:"uid"`
|
||||
Valid bool `json:"valid"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type LogEntry struct {
|
||||
Time string `json:"time"`
|
||||
Level string `json:"level"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
type PrizeListResult struct {
|
||||
UID int64 `json:"uid"`
|
||||
Status int32 `json:"status"`
|
||||
Msg string `json:"msg"`
|
||||
Prizes []huya.PrizeInfo `json:"prizes"`
|
||||
Raw *huya.GetActPrizeListResp `json:"raw,omitempty"`
|
||||
}
|
||||
|
||||
type ScoreResult struct {
|
||||
UID int64 `json:"uid"`
|
||||
Score int64 `json:"score"`
|
||||
Resp *huya.GetUserScoreResp `json:"resp,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type RecordResult struct {
|
||||
UID int64 `json:"uid"`
|
||||
Records []huya.UserPrizeInfo `json:"records"`
|
||||
Resp *huya.GetUserPrizeRecordsResp `json:"resp,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type ExchangeResult struct {
|
||||
UID int64 `json:"uid"`
|
||||
Resp *huya.ScoreExchangePrizeResp `json:"resp,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type MonitorState struct {
|
||||
Running bool `json:"running"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
type cookieLine struct {
|
||||
lineNo int
|
||||
text string
|
||||
}
|
||||
|
||||
func NewApp() *App {
|
||||
return &App{}
|
||||
}
|
||||
|
||||
func (a *App) Startup(ctx context.Context) {
|
||||
a.ctx = ctx
|
||||
a.addLog("info", "GUI 已启动")
|
||||
}
|
||||
|
||||
func (a *App) Shutdown(ctx context.Context) {
|
||||
a.StopMonitor()
|
||||
}
|
||||
|
||||
func (a *App) DefaultConfig() Config {
|
||||
return Config{
|
||||
Transport: "wss",
|
||||
WSSHost: huya.DefaultWSSHost,
|
||||
SID: 2203,
|
||||
PID: 12889,
|
||||
Name: "小黄鸭",
|
||||
Loops: 20,
|
||||
DelayMS: 120,
|
||||
Concurrency: 5,
|
||||
StopAfterSuccess: true,
|
||||
TimeoutSec: 15,
|
||||
}
|
||||
}
|
||||
|
||||
func (a *App) PreviewAccounts(cookieText string) []AccountPreview {
|
||||
previews := make([]AccountPreview, 0)
|
||||
for _, line := range splitCookieLines(cookieText) {
|
||||
uid := huya.ResolveUID(line.text)
|
||||
item := AccountPreview{Line: line.lineNo, UID: uid, Valid: uid > 0}
|
||||
if uid <= 0 {
|
||||
item.Error = "无法解析 yyuid/udb_uid"
|
||||
}
|
||||
previews = append(previews, item)
|
||||
}
|
||||
return previews
|
||||
}
|
||||
|
||||
func (a *App) GetLogs() []LogEntry {
|
||||
a.logMu.Lock()
|
||||
defer a.logMu.Unlock()
|
||||
return append([]LogEntry(nil), a.logs...)
|
||||
}
|
||||
|
||||
func (a *App) IsRunning() bool {
|
||||
a.runMu.Lock()
|
||||
defer a.runMu.Unlock()
|
||||
return a.monitorRunning
|
||||
}
|
||||
|
||||
func (a *App) ListPrizes(cfg Config) (PrizeListResult, error) {
|
||||
cfg = normalizeConfig(cfg)
|
||||
accounts, err := parseAccounts(cfg.CookieText)
|
||||
if err != nil {
|
||||
return PrizeListResult{}, err
|
||||
}
|
||||
if cfg.SID <= 0 {
|
||||
return PrizeListResult{}, errors.New("SID 不能为空")
|
||||
}
|
||||
client, closeClient, err := a.newClient(cfg)
|
||||
if err != nil {
|
||||
return PrizeListResult{}, err
|
||||
}
|
||||
defer closeClient()
|
||||
|
||||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||||
defer cancel()
|
||||
resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID)
|
||||
if err != nil {
|
||||
a.addLog("error", "查询奖品失败: %v", err)
|
||||
return PrizeListResult{}, err
|
||||
}
|
||||
a.addLog("info", "查询奖品完成: uid=%d sid=%d count=%d", accounts[0].UID, cfg.SID, len(resp.Prizes))
|
||||
return PrizeListResult{
|
||||
UID: accounts[0].UID,
|
||||
Status: resp.Status,
|
||||
Msg: resp.Msg,
|
||||
Prizes: resp.Prizes,
|
||||
Raw: resp,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (a *App) QueryScores(cfg Config) ([]ScoreResult, error) {
|
||||
cfg = normalizeConfig(cfg)
|
||||
accounts, err := parseAccounts(cfg.CookieText)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if cfg.SID <= 0 {
|
||||
return nil, errors.New("SID 不能为空")
|
||||
}
|
||||
client, closeClient, err := a.newClient(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer closeClient()
|
||||
|
||||
results := make([]ScoreResult, len(accounts))
|
||||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||||
defer cancel()
|
||||
resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID)
|
||||
item := ScoreResult{UID: account.UID, Resp: resp, Error: errorString(err)}
|
||||
if resp != nil {
|
||||
item.Score = resp.AvailableScore()
|
||||
}
|
||||
results[i] = item
|
||||
})
|
||||
a.addLog("info", "查询积分完成: accounts=%d", len(accounts))
|
||||
return results, nil
|
||||
}
|
||||
|
||||
func (a *App) GetRecords(cfg Config) ([]RecordResult, error) {
|
||||
cfg = normalizeConfig(cfg)
|
||||
accounts, err := parseAccounts(cfg.CookieText)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if cfg.SID <= 0 {
|
||||
return nil, errors.New("SID 不能为空")
|
||||
}
|
||||
client, closeClient, err := a.newClient(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer closeClient()
|
||||
|
||||
results := make([]RecordResult, len(accounts))
|
||||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||||
defer cancel()
|
||||
resp, err := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID)
|
||||
item := RecordResult{UID: account.UID, Resp: resp, Error: errorString(err)}
|
||||
if resp != nil {
|
||||
item.Records = resp.Records
|
||||
}
|
||||
results[i] = item
|
||||
})
|
||||
a.addLog("info", "查询兑换记录完成: accounts=%d", len(accounts))
|
||||
return results, nil
|
||||
}
|
||||
|
||||
func (a *App) Exchange(cfg Config) ([]ExchangeResult, error) {
|
||||
cfg = normalizeConfig(cfg)
|
||||
accounts, err := parseAccounts(cfg.CookieText)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if cfg.SID <= 0 || cfg.PID <= 0 {
|
||||
return nil, errors.New("SID 和 PID 都不能为空")
|
||||
}
|
||||
client, closeClient, err := a.newClient(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer closeClient()
|
||||
|
||||
results := make([]ExchangeResult, len(accounts))
|
||||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||||
defer cancel()
|
||||
resp, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, cfg.SID, cfg.PID)
|
||||
results[i] = ExchangeResult{UID: account.UID, Resp: resp, Error: errorString(err)}
|
||||
})
|
||||
a.addLog("info", "直接兑换完成: sid=%d pid=%d accounts=%d", cfg.SID, cfg.PID, len(accounts))
|
||||
return results, nil
|
||||
}
|
||||
|
||||
func (a *App) StartMonitor(cfg Config) error {
|
||||
cfg = normalizeConfig(cfg)
|
||||
accounts, err := parseAccounts(cfg.CookieText)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if cfg.SID <= 0 {
|
||||
return errors.New("SID 不能为空")
|
||||
}
|
||||
if cfg.PID <= 0 && strings.TrimSpace(cfg.Name) == "" {
|
||||
return errors.New("PID 和名称至少填写一个")
|
||||
}
|
||||
startAt, err := parseStartTime(cfg.StartAt)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
a.runMu.Lock()
|
||||
if a.monitorRunning {
|
||||
a.runMu.Unlock()
|
||||
return errors.New("监控已在运行")
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
a.monitorCancel = cancel
|
||||
a.monitorRunning = true
|
||||
a.runMu.Unlock()
|
||||
|
||||
client, closeClient, err := a.newClient(cfg)
|
||||
if err != nil {
|
||||
cancel()
|
||||
a.finishMonitor("启动失败")
|
||||
return err
|
||||
}
|
||||
|
||||
a.emitState(true, "运行中")
|
||||
a.addLog("info", "启动监控: sid=%d pid=%d name=%s accounts=%d", cfg.SID, cfg.PID, cfg.Name, len(accounts))
|
||||
|
||||
go func() {
|
||||
defer closeClient()
|
||||
defer a.finishMonitor("已停止")
|
||||
|
||||
if !startAt.IsZero() {
|
||||
a.addLog("info", "等待定时开始: %s", startAt.Format("2006-01-02 15:04:05"))
|
||||
if err := waitUntil(ctx, startAt); err != nil {
|
||||
a.addLog("info", "定时等待已取消")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
runner := sniper.Runner{Client: client}
|
||||
err := runner.Run(ctx, accounts, sniper.Target{
|
||||
PID: cfg.PID,
|
||||
Name: strings.TrimSpace(cfg.Name),
|
||||
}, sniper.Config{
|
||||
SID: cfg.SID,
|
||||
Loops: cfg.Loops,
|
||||
Delay: time.Duration(cfg.DelayMS) * time.Millisecond,
|
||||
Concurrency: cfg.Concurrency,
|
||||
StopAfterSuccess: cfg.StopAfterSuccess,
|
||||
}, func(result sniper.Result) {
|
||||
a.emit(eventMonitorResult, result)
|
||||
a.addLog("info", "监控结果: loop=%d uid=%d action=%s error=%s", result.Loop, result.UID, result.Action, result.Error)
|
||||
})
|
||||
if err != nil && !errors.Is(err, context.Canceled) {
|
||||
a.addLog("error", "监控结束异常: %v", err)
|
||||
}
|
||||
}()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a *App) StopMonitor() bool {
|
||||
a.runMu.Lock()
|
||||
cancel := a.monitorCancel
|
||||
a.runMu.Unlock()
|
||||
if cancel == nil {
|
||||
return false
|
||||
}
|
||||
cancel()
|
||||
return true
|
||||
}
|
||||
|
||||
func (a *App) newClient(cfg Config) (huya.ActivityClient, func(), error) {
|
||||
return huya.NewActivityClient(cfg.Transport, cfg.WSSHost, time.Duration(cfg.TimeoutSec)*time.Second, func(msg string) {
|
||||
a.addLog("debug", "%s", msg)
|
||||
})
|
||||
}
|
||||
|
||||
func (a *App) runConcurrent(accounts []sniper.Account, concurrency int, fn func(i int, account sniper.Account)) {
|
||||
if concurrency <= 0 {
|
||||
concurrency = 1
|
||||
}
|
||||
sem := make(chan struct{}, concurrency)
|
||||
var wg sync.WaitGroup
|
||||
for i, account := range accounts {
|
||||
i, account := i, account
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
sem <- struct{}{}
|
||||
defer func() { <-sem }()
|
||||
fn(i, account)
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
func (a *App) finishMonitor(message string) {
|
||||
a.runMu.Lock()
|
||||
a.monitorCancel = nil
|
||||
a.monitorRunning = false
|
||||
a.runMu.Unlock()
|
||||
a.emitState(false, message)
|
||||
}
|
||||
|
||||
func (a *App) addLog(level, format string, args ...any) {
|
||||
entry := LogEntry{
|
||||
Time: time.Now().Format("15:04:05.000"),
|
||||
Level: level,
|
||||
Message: fmt.Sprintf(format, args...),
|
||||
}
|
||||
a.logMu.Lock()
|
||||
a.logs = append(a.logs, entry)
|
||||
if len(a.logs) > maxLogEntries {
|
||||
a.logs = append([]LogEntry(nil), a.logs[len(a.logs)-maxLogEntries:]...)
|
||||
}
|
||||
a.logMu.Unlock()
|
||||
a.emit(eventLog, entry)
|
||||
}
|
||||
|
||||
func (a *App) emitState(running bool, message string) {
|
||||
a.emit(eventMonitorState, MonitorState{Running: running, Message: message})
|
||||
}
|
||||
|
||||
func (a *App) emit(event string, data any) {
|
||||
if a.ctx == nil {
|
||||
return
|
||||
}
|
||||
runtime.EventsEmit(a.ctx, event, data)
|
||||
}
|
||||
|
||||
func normalizeConfig(cfg Config) Config {
|
||||
if strings.TrimSpace(cfg.Transport) == "" {
|
||||
cfg.Transport = "wss"
|
||||
}
|
||||
if strings.TrimSpace(cfg.WSSHost) == "" {
|
||||
cfg.WSSHost = huya.DefaultWSSHost
|
||||
}
|
||||
if cfg.Loops <= 0 {
|
||||
cfg.Loops = 1
|
||||
}
|
||||
if cfg.DelayMS <= 0 {
|
||||
cfg.DelayMS = 150
|
||||
}
|
||||
if cfg.Concurrency <= 0 {
|
||||
cfg.Concurrency = 1
|
||||
}
|
||||
if cfg.TimeoutSec <= 0 {
|
||||
cfg.TimeoutSec = 15
|
||||
}
|
||||
cfg.Name = strings.TrimSpace(cfg.Name)
|
||||
cfg.CookieText = strings.TrimSpace(cfg.CookieText)
|
||||
cfg.StartAt = strings.TrimSpace(cfg.StartAt)
|
||||
return cfg
|
||||
}
|
||||
|
||||
func parseAccounts(cookieText string) ([]sniper.Account, error) {
|
||||
lines := splitCookieLines(cookieText)
|
||||
if len(lines) == 0 {
|
||||
return nil, errors.New("Cookie 不能为空")
|
||||
}
|
||||
accounts := make([]sniper.Account, 0, len(lines))
|
||||
for _, cookie := range lines {
|
||||
uid := huya.ResolveUID(cookie.text)
|
||||
if uid <= 0 {
|
||||
return nil, fmt.Errorf("第 %d 行 Cookie 无法解析 yyuid/udb_uid", cookie.lineNo)
|
||||
}
|
||||
accounts = append(accounts, sniper.Account{UID: uid, Cookie: cookie.text})
|
||||
}
|
||||
return accounts, nil
|
||||
}
|
||||
|
||||
func splitCookieLines(cookieText string) []cookieLine {
|
||||
lines := strings.Split(cookieText, "\n")
|
||||
out := make([]cookieLine, 0, len(lines))
|
||||
for i, line := range lines {
|
||||
item := strings.TrimSpace(line)
|
||||
if item == "" || strings.HasPrefix(item, "#") {
|
||||
continue
|
||||
}
|
||||
out = append(out, cookieLine{lineNo: i + 1, text: item})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func requestContext(timeoutSec int) (context.Context, context.CancelFunc) {
|
||||
if timeoutSec <= 0 {
|
||||
timeoutSec = 15
|
||||
}
|
||||
return context.WithTimeout(context.Background(), time.Duration(timeoutSec)*time.Second)
|
||||
}
|
||||
|
||||
func parseStartTime(text string) (time.Time, error) {
|
||||
text = strings.TrimSpace(text)
|
||||
if text == "" {
|
||||
return time.Time{}, nil
|
||||
}
|
||||
if ts, err := strconv.ParseInt(text, 10, 64); err == nil {
|
||||
return time.Unix(ts, 0), nil
|
||||
}
|
||||
for _, layout := range []string{time.RFC3339, "2006-01-02 15:04:05", "2006-01-02 15:04"} {
|
||||
if t, err := time.ParseInLocation(layout, text, time.Local); err == nil {
|
||||
return t, nil
|
||||
}
|
||||
}
|
||||
return time.Time{}, fmt.Errorf("无法解析开始时间: %s", text)
|
||||
}
|
||||
|
||||
func waitUntil(ctx context.Context, when time.Time) error {
|
||||
for {
|
||||
remaining := time.Until(when)
|
||||
if remaining <= 0 {
|
||||
return nil
|
||||
}
|
||||
timer := time.NewTimer(minDuration(remaining, 200*time.Millisecond))
|
||||
select {
|
||||
case <-timer.C:
|
||||
case <-ctx.Done():
|
||||
timer.Stop()
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func minDuration(a, b time.Duration) time.Duration {
|
||||
if a < b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func errorString(err error) string {
|
||||
if err == nil {
|
||||
return ""
|
||||
}
|
||||
return err.Error()
|
||||
}
|
||||
@@ -0,0 +1,581 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"huya-go/internal/taf"
|
||||
)
|
||||
|
||||
const (
|
||||
ActivityWebUA = "web&1.0&huya"
|
||||
ActivityRecordUA = "webh5&1.0.0&huya"
|
||||
ActivityBindUA = "pc&1.0.0&huya"
|
||||
ServantWebActUI = "webActUI"
|
||||
FuncGetUserScore = "getUserScore"
|
||||
FuncPrizeList = "getActPrizeList"
|
||||
FuncPrizeRecords = "getUserPrizeRecords"
|
||||
FuncExchangePrize = "scoreExchangePrize"
|
||||
)
|
||||
|
||||
type ActivityUserID struct {
|
||||
UID int64 `json:"uid"`
|
||||
GUID string `json:"guid,omitempty"`
|
||||
Token string `json:"token,omitempty"`
|
||||
HuyaUA string `json:"huya_ua"`
|
||||
Cookie string `json:"-"`
|
||||
TokenType int32 `json:"token_type"`
|
||||
DeviceInfo string `json:"device_info,omitempty"`
|
||||
}
|
||||
|
||||
func NewActivityUserID(uid int64, cookie, ua string) ActivityUserID {
|
||||
return ActivityUserID{
|
||||
UID: uid,
|
||||
HuyaUA: ua,
|
||||
Cookie: NormalizeCookie(cookie),
|
||||
TokenType: 0,
|
||||
}
|
||||
}
|
||||
|
||||
func (u *ActivityUserID) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteInt64(0, u.UID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, u.GUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(2, u.Token); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(3, u.HuyaUA); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(4, u.Cookie); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(5, int64(u.TokenType)); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteString(6, u.DeviceInfo)
|
||||
}
|
||||
|
||||
func (u *ActivityUserID) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if u.UID, err = r.ReadInt64(0, false, u.UID); err != nil {
|
||||
return err
|
||||
}
|
||||
if u.GUID, err = r.ReadString(1, false, u.GUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if u.Token, err = r.ReadString(2, false, u.Token); err != nil {
|
||||
return err
|
||||
}
|
||||
if u.HuyaUA, err = r.ReadString(3, false, u.HuyaUA); err != nil {
|
||||
return err
|
||||
}
|
||||
if u.Cookie, err = r.ReadString(4, false, u.Cookie); err != nil {
|
||||
return err
|
||||
}
|
||||
if u.TokenType, err = r.ReadInt32(5, false, u.TokenType); err != nil {
|
||||
return err
|
||||
}
|
||||
u.DeviceInfo, err = r.ReadString(6, false, u.DeviceInfo)
|
||||
return err
|
||||
}
|
||||
|
||||
type GetUserScoreReq struct {
|
||||
User ActivityUserID
|
||||
SID int32
|
||||
}
|
||||
|
||||
func (q *GetUserScoreReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteStruct(0, &q.User); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteInt32(1, int64(q.SID))
|
||||
}
|
||||
|
||||
func (q *GetUserScoreReq) ReadFrom(r *taf.Reader) error {
|
||||
_, err := r.ReadStruct(0, false, &q.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
q.SID, err = r.ReadInt32(1, false, q.SID)
|
||||
return err
|
||||
}
|
||||
|
||||
type GetUserScoreResp struct {
|
||||
Status int32 `json:"status"`
|
||||
Msg string `json:"msg"`
|
||||
GainScore int32 `json:"gain_score"`
|
||||
UsedScore int32 `json:"used_score"`
|
||||
NewGainScore int64 `json:"new_gain_score"`
|
||||
NewUsedScore int64 `json:"new_used_score"`
|
||||
Score int64 `json:"score"`
|
||||
IsOpenExchangeTip int32 `json:"is_open_exchange_tip"`
|
||||
}
|
||||
|
||||
func (r *GetUserScoreResp) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (r *GetUserScoreResp) ReadFrom(rd *taf.Reader) error {
|
||||
var err error
|
||||
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.GainScore, err = rd.ReadInt32(2, false, r.GainScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.UsedScore, err = rd.ReadInt32(3, false, r.UsedScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.NewGainScore, err = rd.ReadInt64(4, false, r.NewGainScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.NewUsedScore, err = rd.ReadInt64(5, false, r.NewUsedScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.Score, err = rd.ReadInt64(6, false, r.Score); err != nil {
|
||||
return err
|
||||
}
|
||||
r.IsOpenExchangeTip, err = rd.ReadInt32(7, false, r.IsOpenExchangeTip)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r GetUserScoreResp) AvailableScore() int64 {
|
||||
if r.NewGainScore != 0 || r.NewUsedScore != 0 {
|
||||
score := r.NewGainScore - r.NewUsedScore
|
||||
if score < 0 {
|
||||
return 0
|
||||
}
|
||||
return score
|
||||
}
|
||||
return r.Score
|
||||
}
|
||||
|
||||
type GetActPrizeListReq struct {
|
||||
User ActivityUserID
|
||||
SID int32
|
||||
}
|
||||
|
||||
func (q *GetActPrizeListReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteStruct(0, &q.User); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteInt32(1, int64(q.SID))
|
||||
}
|
||||
|
||||
func (q *GetActPrizeListReq) ReadFrom(r *taf.Reader) error {
|
||||
_, err := r.ReadStruct(0, false, &q.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
q.SID, err = r.ReadInt32(1, false, q.SID)
|
||||
return err
|
||||
}
|
||||
|
||||
type PrizeInfo struct {
|
||||
ID int64 `json:"id"`
|
||||
SID int64 `json:"sid"`
|
||||
Name string `json:"name"`
|
||||
Score int64 `json:"score"`
|
||||
Type int32 `json:"type"`
|
||||
Image string `json:"img,omitempty"`
|
||||
Sort int32 `json:"sort"`
|
||||
Frequency int32 `json:"frequency"`
|
||||
FrequencyLimit int32 `json:"frequency_limit"`
|
||||
CreateTime int64 `json:"create_time"`
|
||||
Num int64 `json:"num"`
|
||||
Status int32 `json:"status"`
|
||||
Percent string `json:"percent"`
|
||||
NewScore int64 `json:"new_score"`
|
||||
Tags string `json:"tags,omitempty"`
|
||||
LeftNum int64 `json:"left_num"`
|
||||
IsShowNum int32 `json:"is_show_num"`
|
||||
}
|
||||
|
||||
func (p *PrizeInfo) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (p *PrizeInfo) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.SID, err = r.ReadInt64(1, false, p.SID); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Name, err = r.ReadString(2, false, p.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Score, err = r.ReadInt64(3, false, p.Score); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Type, err = r.ReadInt32(4, false, p.Type); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Image, err = r.ReadString(5, false, p.Image); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Sort, err = r.ReadInt32(6, false, p.Sort); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Frequency, err = r.ReadInt32(7, false, p.Frequency); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.FrequencyLimit, err = r.ReadInt32(8, false, p.FrequencyLimit); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.CreateTime, err = r.ReadInt64(9, false, p.CreateTime); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Num, err = r.ReadInt64(10, false, p.Num); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Status, err = r.ReadInt32(11, false, p.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Percent, err = r.ReadString(12, false, p.Percent); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.NewScore, err = r.ReadInt64(13, false, p.NewScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Tags, err = r.ReadString(14, false, p.Tags); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.LeftNum, err = r.ReadInt64(15, false, p.LeftNum); err != nil {
|
||||
return err
|
||||
}
|
||||
p.IsShowNum, err = r.ReadInt32(16, false, p.IsShowNum)
|
||||
return err
|
||||
}
|
||||
|
||||
func (p PrizeInfo) Price() int64 {
|
||||
if p.NewScore != 0 {
|
||||
return p.NewScore
|
||||
}
|
||||
return p.Score
|
||||
}
|
||||
|
||||
func (p PrizeInfo) EstimatedLeft() int64 {
|
||||
if p.LeftNum > 0 {
|
||||
return p.LeftNum
|
||||
}
|
||||
text := strings.TrimSuffix(strings.TrimSpace(p.Percent), "%")
|
||||
if text == "" || p.Num <= 0 {
|
||||
return 0
|
||||
}
|
||||
percent, err := strconv.ParseFloat(text, 64)
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return int64(math.Floor(float64(p.Num)*percent/100.0 + 1e-9))
|
||||
}
|
||||
|
||||
type PrizeTag struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Weight int32 `json:"weight"`
|
||||
}
|
||||
|
||||
func (t *PrizeTag) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (t *PrizeTag) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if t.ID, err = r.ReadInt64(0, false, t.ID); err != nil {
|
||||
return err
|
||||
}
|
||||
if t.Name, err = r.ReadString(1, false, t.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
t.Weight, err = r.ReadInt32(2, false, t.Weight)
|
||||
return err
|
||||
}
|
||||
|
||||
type GetActPrizeListResp struct {
|
||||
Status int32 `json:"status"`
|
||||
Msg string `json:"msg"`
|
||||
Prizes []PrizeInfo `json:"prizes"`
|
||||
ModuleID int32 `json:"module_id"`
|
||||
Tags []PrizeTag `json:"tags"`
|
||||
}
|
||||
|
||||
func (r *GetActPrizeListResp) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (r *GetActPrizeListResp) ReadFrom(rd *taf.Reader) error {
|
||||
var err error
|
||||
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
|
||||
return err
|
||||
}
|
||||
items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &PrizeInfo{} })
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.Prizes = make([]PrizeInfo, 0, len(items))
|
||||
for _, item := range items {
|
||||
if prize, ok := item.(*PrizeInfo); ok {
|
||||
r.Prizes = append(r.Prizes, *prize)
|
||||
}
|
||||
}
|
||||
if r.ModuleID, err = rd.ReadInt32(3, false, r.ModuleID); err != nil {
|
||||
return err
|
||||
}
|
||||
tags, err := rd.ReadListStruct(4, false, func() taf.Unmarshaler { return &PrizeTag{} })
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.Tags = make([]PrizeTag, 0, len(tags))
|
||||
for _, item := range tags {
|
||||
if tag, ok := item.(*PrizeTag); ok {
|
||||
r.Tags = append(r.Tags, *tag)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type GetUserPrizeRecordsReq struct {
|
||||
User ActivityUserID
|
||||
SID int32
|
||||
}
|
||||
|
||||
func (q *GetUserPrizeRecordsReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteStruct(0, &q.User); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteInt32(1, int64(q.SID))
|
||||
}
|
||||
|
||||
func (q *GetUserPrizeRecordsReq) ReadFrom(r *taf.Reader) error {
|
||||
_, err := r.ReadStruct(0, false, &q.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
q.SID, err = r.ReadInt32(1, false, q.SID)
|
||||
return err
|
||||
}
|
||||
|
||||
type UserPrizeInfo struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Score int64 `json:"score"`
|
||||
CreateTime int64 `json:"create_time"`
|
||||
Status int32 `json:"status"`
|
||||
Type int32 `json:"type"`
|
||||
IsReal int32 `json:"is_real"`
|
||||
NewScore int64 `json:"new_score"`
|
||||
Account string `json:"account,omitempty"`
|
||||
Code string `json:"code,omitempty"`
|
||||
CommonPrizeType int32 `json:"common_prize_type"`
|
||||
}
|
||||
|
||||
func (p *UserPrizeInfo) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (p *UserPrizeInfo) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Name, err = r.ReadString(1, false, p.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Score, err = r.ReadInt64(2, false, p.Score); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.CreateTime, err = r.ReadInt64(3, false, p.CreateTime); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Status, err = r.ReadInt32(4, false, p.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Type, err = r.ReadInt32(5, false, p.Type); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.IsReal, err = r.ReadInt32(6, false, p.IsReal); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.NewScore, err = r.ReadInt64(7, false, p.NewScore); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Account, err = r.ReadString(8, false, p.Account); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Code, err = r.ReadString(9, false, p.Code); err != nil {
|
||||
return err
|
||||
}
|
||||
p.CommonPrizeType, err = r.ReadInt32(10, false, p.CommonPrizeType)
|
||||
return err
|
||||
}
|
||||
|
||||
type GetUserPrizeRecordsResp struct {
|
||||
Status int32 `json:"status"`
|
||||
Msg string `json:"msg"`
|
||||
Records []UserPrizeInfo `json:"records"`
|
||||
}
|
||||
|
||||
func (r *GetUserPrizeRecordsResp) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (r *GetUserPrizeRecordsResp) ReadFrom(rd *taf.Reader) error {
|
||||
var err error
|
||||
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
|
||||
return err
|
||||
}
|
||||
items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &UserPrizeInfo{} })
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.Records = make([]UserPrizeInfo, 0, len(items))
|
||||
for _, item := range items {
|
||||
if record, ok := item.(*UserPrizeInfo); ok {
|
||||
r.Records = append(r.Records, *record)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type ScoreExchangePrizeReq struct {
|
||||
User ActivityUserID
|
||||
SID int32
|
||||
PID int32
|
||||
IP string
|
||||
ClientEnv map[string]string
|
||||
Source string
|
||||
IsRole int32
|
||||
}
|
||||
|
||||
func (q *ScoreExchangePrizeReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteStruct(0, &q.User); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(1, int64(q.SID)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(2, int64(q.PID)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(3, q.IP); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteMapStringString(4, q.ClientEnv); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(5, q.Source); err != nil {
|
||||
return err
|
||||
}
|
||||
if q.IsRole == 0 {
|
||||
q.IsRole = 1
|
||||
}
|
||||
return w.WriteInt32(6, int64(q.IsRole))
|
||||
}
|
||||
|
||||
func (q *ScoreExchangePrizeReq) ReadFrom(r *taf.Reader) error {
|
||||
_, err := r.ReadStruct(0, false, &q.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if q.SID, err = r.ReadInt32(1, false, q.SID); err != nil {
|
||||
return err
|
||||
}
|
||||
if q.PID, err = r.ReadInt32(2, false, q.PID); err != nil {
|
||||
return err
|
||||
}
|
||||
if q.IP, err = r.ReadString(3, false, q.IP); err != nil {
|
||||
return err
|
||||
}
|
||||
if q.ClientEnv, err = r.ReadMapStringString(4, false); err != nil {
|
||||
return err
|
||||
}
|
||||
if q.Source, err = r.ReadString(5, false, q.Source); err != nil {
|
||||
return err
|
||||
}
|
||||
q.IsRole, err = r.ReadInt32(6, false, q.IsRole)
|
||||
return err
|
||||
}
|
||||
|
||||
type ExchangeInfo struct {
|
||||
PID int32 `json:"pid"`
|
||||
ExchangeScore int64 `json:"exchange_score"`
|
||||
Desc string `json:"desc"`
|
||||
}
|
||||
|
||||
func (e *ExchangeInfo) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (e *ExchangeInfo) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if e.PID, err = r.ReadInt32(1, false, e.PID); err != nil {
|
||||
return err
|
||||
}
|
||||
if e.ExchangeScore, err = r.ReadInt64(2, false, e.ExchangeScore); err != nil {
|
||||
return err
|
||||
}
|
||||
e.Desc, err = r.ReadString(3, false, e.Desc)
|
||||
return err
|
||||
}
|
||||
|
||||
type ActPreCondition struct {
|
||||
ConditionType int32 `json:"condition_type"`
|
||||
ConditionParams map[string]string `json:"condition_params,omitempty"`
|
||||
Tip string `json:"tip,omitempty"`
|
||||
JumpURL string `json:"jump_url,omitempty"`
|
||||
ButtonDesc string `json:"button_desc,omitempty"`
|
||||
}
|
||||
|
||||
func (c *ActPreCondition) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (c *ActPreCondition) ReadFrom(r *taf.Reader) error {
|
||||
var err error
|
||||
if c.ConditionType, err = r.ReadInt32(0, false, c.ConditionType); err != nil {
|
||||
return err
|
||||
}
|
||||
if c.ConditionParams, err = r.ReadMapStringString(1, false); err != nil {
|
||||
return err
|
||||
}
|
||||
if c.Tip, err = r.ReadString(2, false, c.Tip); err != nil {
|
||||
return err
|
||||
}
|
||||
if c.JumpURL, err = r.ReadString(3, false, c.JumpURL); err != nil {
|
||||
return err
|
||||
}
|
||||
c.ButtonDesc, err = r.ReadString(4, false, c.ButtonDesc)
|
||||
return err
|
||||
}
|
||||
|
||||
type ScoreExchangePrizeResp struct {
|
||||
Status int32 `json:"status"`
|
||||
Msg string `json:"msg"`
|
||||
OrderID string `json:"order_id,omitempty"`
|
||||
ExchangeInfo ExchangeInfo `json:"exchange_info"`
|
||||
ActPreCondition ActPreCondition `json:"act_pre_condition"`
|
||||
}
|
||||
|
||||
func (r *ScoreExchangePrizeResp) WriteTo(w *taf.Writer) error { return nil }
|
||||
|
||||
func (r *ScoreExchangePrizeResp) ReadFrom(rd *taf.Reader) error {
|
||||
var err error
|
||||
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
|
||||
return err
|
||||
}
|
||||
if r.OrderID, err = rd.ReadString(3, false, r.OrderID); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err = rd.ReadStruct(4, false, &r.ExchangeInfo); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = rd.ReadStruct(5, false, &r.ActPreCondition)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r ScoreExchangePrizeResp) Success() bool {
|
||||
return r.Status == 200 && (r.Msg == "" || strings.Contains(r.Msg, "成功"))
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"math/rand"
|
||||
"net/url"
|
||||
|
||||
"huya-go/internal/taf"
|
||||
)
|
||||
|
||||
const (
|
||||
HTTPHuyaUA = "webh5&0.0.1&websocket&&diypc_52775"
|
||||
PCUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " +
|
||||
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
|
||||
)
|
||||
|
||||
type WSConnectParaInfo struct {
|
||||
UID int64
|
||||
GUID string
|
||||
UA string
|
||||
AppSrc string
|
||||
MID string
|
||||
Exp string
|
||||
TokenType int32
|
||||
Token string
|
||||
Cookie string
|
||||
TraceID string
|
||||
CustomHeaders map[string]string
|
||||
}
|
||||
|
||||
func NewWSConnectParaInfo(uid int64, guid, cookie string) WSConnectParaInfo {
|
||||
return WSConnectParaInfo{
|
||||
UID: uid,
|
||||
GUID: guid,
|
||||
UA: HTTPHuyaUA,
|
||||
AppSrc: "HUYA&ZH&2052",
|
||||
Cookie: cookie,
|
||||
TraceID: NewTraceID(),
|
||||
CustomHeaders: map[string]string{},
|
||||
}
|
||||
}
|
||||
|
||||
func (i WSConnectParaInfo) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteInt64(0, i.UID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, i.GUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(2, i.UA); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(3, i.AppSrc); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(4, i.MID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(5, i.Exp); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(6, int64(i.TokenType)); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(7, i.Token); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(8, i.Cookie); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(9, i.TraceID); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteMapStringString(10, i.CustomHeaders)
|
||||
}
|
||||
|
||||
func NewTraceID() string {
|
||||
// 与前端 traceId 格式保持一致:hex16:hex16:0:0。
|
||||
v := rand.Uint64()
|
||||
s := lowerHex16(v)
|
||||
return s + ":" + s + ":0:0"
|
||||
}
|
||||
|
||||
func lowerHex16(v uint64) string {
|
||||
const digits = "0123456789abcdef"
|
||||
var b [16]byte
|
||||
for i := 15; i >= 0; i-- {
|
||||
b[i] = digits[v&0xf]
|
||||
v >>= 4
|
||||
}
|
||||
return string(b[:])
|
||||
}
|
||||
|
||||
func GenerateHTTPBaseinfo(uid int64, guid, cookie string) (string, error) {
|
||||
info := NewWSConnectParaInfo(uid, guid, cookie)
|
||||
w := taf.NewWriter()
|
||||
if err := info.WriteTo(w); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return url.QueryEscape(base64.StdEncoding.EncodeToString(w.Bytes())), nil
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ActivityClient 抽象虎牙活动接口,HTTP 与 WSS 传输都实现它。
|
||||
type ActivityClient interface {
|
||||
GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error)
|
||||
QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error)
|
||||
GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error)
|
||||
ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error)
|
||||
}
|
||||
|
||||
// NewActivityClient 按传输层创建活动客户端,供 CLI 和 GUI 共用。
|
||||
func NewActivityClient(transport, wssHost string, timeout time.Duration, logger func(string)) (ActivityClient, func(), error) {
|
||||
switch strings.ToLower(strings.TrimSpace(transport)) {
|
||||
case "", "http":
|
||||
client := NewHTTPClient(logger)
|
||||
if timeout > 0 {
|
||||
client.Client.Timeout = timeout
|
||||
}
|
||||
return client, func() {}, nil
|
||||
case "wss", "ws", "websocket":
|
||||
client := NewWSSClient(logger)
|
||||
if strings.TrimSpace(wssHost) != "" {
|
||||
client.Host = strings.TrimSpace(wssHost)
|
||||
}
|
||||
if timeout > 0 {
|
||||
client.CallTimeout = timeout
|
||||
}
|
||||
return client, func() { _ = client.Close() }, nil
|
||||
default:
|
||||
return nil, func() {}, fmt.Errorf("未知传输层: %s", transport)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type CookiePair struct {
|
||||
Key string
|
||||
Value string
|
||||
}
|
||||
|
||||
func CookiePairs(cookie string) []CookiePair {
|
||||
parts := strings.Split(cookie, ";")
|
||||
pairs := make([]CookiePair, 0, len(parts))
|
||||
for _, part := range parts {
|
||||
item := strings.TrimSpace(part)
|
||||
if item == "" || !strings.Contains(item, "=") {
|
||||
continue
|
||||
}
|
||||
key, value, _ := strings.Cut(item, "=")
|
||||
key = strings.TrimSpace(key)
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
pairs = append(pairs, CookiePair{Key: key, Value: strings.TrimSpace(value)})
|
||||
}
|
||||
return pairs
|
||||
}
|
||||
|
||||
func NormalizeCookie(cookie string) string {
|
||||
pairs := CookiePairs(cookie)
|
||||
order := make([]string, 0, len(pairs))
|
||||
values := map[string]string{}
|
||||
for _, pair := range pairs {
|
||||
if _, ok := values[pair.Key]; !ok {
|
||||
order = append(order, pair.Key)
|
||||
}
|
||||
values[pair.Key] = pair.Value
|
||||
}
|
||||
out := make([]string, 0, len(order))
|
||||
for _, key := range order {
|
||||
out = append(out, key+"="+values[key])
|
||||
}
|
||||
return strings.Join(out, "; ")
|
||||
}
|
||||
|
||||
func CookieValue(cookie, key string) string {
|
||||
value := ""
|
||||
for _, pair := range CookiePairs(cookie) {
|
||||
if pair.Key == key {
|
||||
value = pair.Value
|
||||
}
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
func ResolveUID(cookie string) int64 {
|
||||
for _, key := range []string{"yyuid", "udb_uid", "uid"} {
|
||||
value := CookieValue(cookie, key)
|
||||
if value == "" {
|
||||
continue
|
||||
}
|
||||
uid, err := strconv.ParseInt(value, 10, 64)
|
||||
if err == nil && uid > 0 {
|
||||
return uid
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/gzip"
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"huya-go/internal/taf"
|
||||
"huya-go/internal/wup"
|
||||
)
|
||||
|
||||
const DefaultCDNWSEndpoint = "https://cdnws.api.huya.com/"
|
||||
|
||||
type HTTPClient struct {
|
||||
Endpoint string
|
||||
Client *http.Client
|
||||
Logger func(string)
|
||||
}
|
||||
|
||||
type CallOptions struct {
|
||||
UID int64
|
||||
GUID string
|
||||
Cookie string
|
||||
RequestID int32
|
||||
Timeout time.Duration
|
||||
}
|
||||
|
||||
func NewHTTPClient(logger func(string)) *HTTPClient {
|
||||
return &HTTPClient{
|
||||
Endpoint: DefaultCDNWSEndpoint,
|
||||
Client: &http.Client{
|
||||
Timeout: 15 * time.Second,
|
||||
},
|
||||
Logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HTTPClient) logf(format string, args ...any) {
|
||||
if c.Logger != nil {
|
||||
c.Logger(fmt.Sprintf(format, args...))
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HTTPClient) CallRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler, opt CallOptions) (*wup.Response, error) {
|
||||
if opt.RequestID == 0 {
|
||||
opt.RequestID = 1
|
||||
}
|
||||
reqWup := wup.NewRequest(service, method, opt.RequestID)
|
||||
if err := reqWup.WriteStruct("tReq", reqStruct); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
body, err := reqWup.Encode()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
baseinfo, err := GenerateHTTPBaseinfo(opt.UID, opt.GUID, opt.Cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
endpoint := c.Endpoint
|
||||
if endpoint == "" {
|
||||
endpoint = DefaultCDNWSEndpoint
|
||||
}
|
||||
url := endpoint + "?baseinfo=" + baseinfo
|
||||
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
httpReq.Header.Set("User-Agent", PCUserAgent)
|
||||
httpReq.Header.Set("Origin", "https://zt.huya.com")
|
||||
httpReq.Header.Set("Referer", "https://zt.huya.com/")
|
||||
httpReq.Header.Set("Content-Type", "application/octet-stream")
|
||||
httpReq.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
|
||||
|
||||
client := c.Client
|
||||
if client == nil {
|
||||
client = http.DefaultClient
|
||||
}
|
||||
if opt.Timeout > 0 {
|
||||
var cancel context.CancelFunc
|
||||
ctx, cancel = context.WithTimeout(ctx, opt.Timeout)
|
||||
defer cancel()
|
||||
httpReq = httpReq.WithContext(ctx)
|
||||
}
|
||||
|
||||
c.logf("[HTTP] POST %s.%s body=%dB", service, method, len(body))
|
||||
httpResp, err := client.Do(httpReq)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer httpResp.Body.Close()
|
||||
respBody, err := io.ReadAll(httpResp.Body)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(respBody) >= 2 && respBody[0] == 0x1f && respBody[1] == 0x8b {
|
||||
gz, err := gzip.NewReader(bytes.NewReader(respBody))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
respBody, err = io.ReadAll(gz)
|
||||
_ = gz.Close()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
||||
return nil, fmt.Errorf("http status %d: %s", httpResp.StatusCode, string(respBody[:min(len(respBody), 200)]))
|
||||
}
|
||||
|
||||
var resp wup.Response
|
||||
if err := resp.Decode(respBody); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if respStruct != nil {
|
||||
ok, err := resp.ReadStruct("tRsp", respStruct)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method)
|
||||
}
|
||||
}
|
||||
return &resp, nil
|
||||
}
|
||||
|
||||
func (c *HTTPClient) buildUser(uid int64, cookie, ua string) ActivityUserID {
|
||||
return NewActivityUserID(uid, cookie, ua)
|
||||
}
|
||||
|
||||
func (c *HTTPClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) {
|
||||
req := &GetUserScoreReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid}
|
||||
var resp GetUserScoreResp
|
||||
_, err := c.CallRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 2})
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *HTTPClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) {
|
||||
req := &GetActPrizeListReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid}
|
||||
var resp GetActPrizeListResp
|
||||
_, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1})
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *HTTPClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) {
|
||||
user := c.buildUser(uid, cookie, ActivityRecordUA)
|
||||
user.GUID = CookieValue(cookie, "guid")
|
||||
req := &GetUserPrizeRecordsReq{User: user, SID: sid}
|
||||
var resp GetUserPrizeRecordsResp
|
||||
_, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 6})
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *HTTPClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) {
|
||||
req := &ScoreExchangePrizeReq{
|
||||
User: c.buildUser(uid, cookie, ActivityWebUA),
|
||||
SID: sid,
|
||||
PID: pid,
|
||||
ClientEnv: map[string]string{},
|
||||
IsRole: 1,
|
||||
}
|
||||
var resp ScoreExchangePrizeResp
|
||||
_, err := c.CallRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1})
|
||||
return &resp, err
|
||||
}
|
||||
@@ -0,0 +1,674 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
|
||||
"huya-go/internal/taf"
|
||||
"huya-go/internal/wup"
|
||||
)
|
||||
|
||||
const (
|
||||
DefaultWSSHost = "77bc035c-ws.va.huya.com"
|
||||
DefaultWSSOrigin = "https://zt.huya.com"
|
||||
|
||||
WSSCookieUA = "webh5&0.0.1&websocket&&diypc_52775"
|
||||
WSSBizUA = "web&1.0.0&huya"
|
||||
WSSInitUA = "webh5&0.0.1&websocket&&h5_/index.html"
|
||||
)
|
||||
|
||||
type WSSClient struct {
|
||||
Host string
|
||||
Origin string
|
||||
UserAgent string
|
||||
Dialer *websocket.Dialer
|
||||
Logger func(string)
|
||||
CallTimeout time.Duration
|
||||
|
||||
mu sync.Mutex
|
||||
sessions map[string]*WSSSession
|
||||
}
|
||||
|
||||
type WSSSession struct {
|
||||
client *WSSClient
|
||||
uid int64
|
||||
cookie string
|
||||
guid string
|
||||
|
||||
conn *websocket.Conn
|
||||
|
||||
writeMu sync.Mutex
|
||||
pendingMu sync.Mutex
|
||||
pending []chan rpcResult
|
||||
closed chan struct{}
|
||||
closeOnce sync.Once
|
||||
closeErr error
|
||||
|
||||
nextWUPRequestID int32
|
||||
launchGUID string
|
||||
launchIP string
|
||||
}
|
||||
|
||||
type rpcResult struct {
|
||||
body []byte
|
||||
err error
|
||||
}
|
||||
|
||||
func NewWSSClient(logger func(string)) *WSSClient {
|
||||
return &WSSClient{
|
||||
Host: DefaultWSSHost,
|
||||
Origin: DefaultWSSOrigin,
|
||||
UserAgent: PCUserAgent,
|
||||
Logger: logger,
|
||||
CallTimeout: 10 * time.Second,
|
||||
sessions: map[string]*WSSSession{},
|
||||
}
|
||||
}
|
||||
|
||||
func (c *WSSClient) logf(format string, args ...any) {
|
||||
if c.Logger != nil {
|
||||
c.Logger(fmt.Sprintf(format, args...))
|
||||
}
|
||||
}
|
||||
|
||||
func (c *WSSClient) Close() error {
|
||||
c.mu.Lock()
|
||||
sessions := make([]*WSSSession, 0, len(c.sessions))
|
||||
for _, session := range c.sessions {
|
||||
sessions = append(sessions, session)
|
||||
}
|
||||
c.sessions = map[string]*WSSSession{}
|
||||
c.mu.Unlock()
|
||||
|
||||
var firstErr error
|
||||
for _, session := range sessions {
|
||||
if err := session.Close(); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
}
|
||||
return firstErr
|
||||
}
|
||||
|
||||
func (c *WSSClient) session(ctx context.Context, uid int64, cookie string) (*WSSSession, error) {
|
||||
key := strconv.FormatInt(uid, 10)
|
||||
c.mu.Lock()
|
||||
if session := c.sessions[key]; session != nil && !session.isClosed() {
|
||||
c.mu.Unlock()
|
||||
return session, nil
|
||||
}
|
||||
c.mu.Unlock()
|
||||
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
if session := c.sessions[key]; session != nil && !session.isClosed() {
|
||||
return session, nil
|
||||
}
|
||||
session, err := c.dialSession(ctx, uid, cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c.sessions[key] = session
|
||||
return session, nil
|
||||
}
|
||||
|
||||
func (c *WSSClient) dialSession(ctx context.Context, uid int64, cookie string) (*WSSSession, error) {
|
||||
host := c.Host
|
||||
if host == "" {
|
||||
host = DefaultWSSHost
|
||||
}
|
||||
origin := c.Origin
|
||||
if origin == "" {
|
||||
origin = DefaultWSSOrigin
|
||||
}
|
||||
userAgent := c.UserAgent
|
||||
if userAgent == "" {
|
||||
userAgent = PCUserAgent
|
||||
}
|
||||
|
||||
guid := CookieValue(cookie, "guid")
|
||||
baseinfo, err := GenerateHTTPBaseinfo(uid, guid, NormalizeWSSCookie(cookie))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
wsURL := url.URL{Scheme: "wss", Host: host, Path: "/"}
|
||||
wsURL.RawQuery = "baseinfo=" + baseinfo
|
||||
|
||||
dialer := c.Dialer
|
||||
if dialer == nil {
|
||||
dialer = &websocket.Dialer{
|
||||
HandshakeTimeout: 10 * time.Second,
|
||||
EnableCompression: true,
|
||||
Proxy: http.ProxyFromEnvironment,
|
||||
}
|
||||
}
|
||||
headers := http.Header{}
|
||||
headers.Set("Origin", origin)
|
||||
headers.Set("User-Agent", userAgent)
|
||||
headers.Set("Accept-Language", "zh-CN,zh;q=0.9")
|
||||
|
||||
c.logf("[WSS] 连接 %s uid=%d", host, uid)
|
||||
conn, resp, err := dialer.DialContext(ctx, wsURL.String(), headers)
|
||||
if err != nil {
|
||||
if resp != nil {
|
||||
return nil, fmt.Errorf("wss dial: %w (status=%s)", err, resp.Status)
|
||||
}
|
||||
return nil, fmt.Errorf("wss dial: %w", err)
|
||||
}
|
||||
conn.EnableWriteCompression(true)
|
||||
conn.SetReadLimit(4 << 20)
|
||||
|
||||
session := &WSSSession{
|
||||
client: c,
|
||||
uid: uid,
|
||||
cookie: cookie,
|
||||
guid: guid,
|
||||
conn: conn,
|
||||
closed: make(chan struct{}),
|
||||
nextWUPRequestID: 8,
|
||||
}
|
||||
go session.readLoop()
|
||||
go session.heartbeatLoop()
|
||||
|
||||
if err := session.initialize(ctx); err != nil {
|
||||
_ = session.Close()
|
||||
return nil, err
|
||||
}
|
||||
return session, nil
|
||||
}
|
||||
|
||||
func (s *WSSSession) isClosed() bool {
|
||||
select {
|
||||
case <-s.closed:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) Close() error {
|
||||
var err error
|
||||
s.closeOnce.Do(func() {
|
||||
close(s.closed)
|
||||
err = s.conn.Close()
|
||||
s.failPending(errors.New("wss closed"))
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *WSSSession) readLoop() {
|
||||
for {
|
||||
messageType, raw, err := s.conn.ReadMessage()
|
||||
if err != nil {
|
||||
s.closeWithError(err)
|
||||
return
|
||||
}
|
||||
if messageType != websocket.BinaryMessage {
|
||||
continue
|
||||
}
|
||||
msg, err := DecodeWSSMessage(raw)
|
||||
if err != nil {
|
||||
s.client.logf("[WSS] 解码消息失败: %v", err)
|
||||
continue
|
||||
}
|
||||
switch msg.Command {
|
||||
case WSSCommandRPCResponse:
|
||||
s.resolveNext(rpcResult{body: msg.Body})
|
||||
case WSSCommandHeartbeatRecv:
|
||||
// 心跳响应无需处理。
|
||||
default:
|
||||
s.client.logf("[WSS] 收到 cmd=0x%02x seq=0x%08x body=%dB", msg.Command, msg.Sequence, len(msg.Body))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) heartbeatLoop() {
|
||||
ticker := time.NewTicker(8 * time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
||||
_ = s.sendHeartbeat(ctx)
|
||||
cancel()
|
||||
case <-s.closed:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) closeWithError(err error) {
|
||||
s.closeOnce.Do(func() {
|
||||
s.closeErr = err
|
||||
close(s.closed)
|
||||
_ = s.conn.Close()
|
||||
s.failPending(err)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *WSSSession) failPending(err error) {
|
||||
s.pendingMu.Lock()
|
||||
pending := s.pending
|
||||
s.pending = nil
|
||||
s.pendingMu.Unlock()
|
||||
for _, ch := range pending {
|
||||
ch <- rpcResult{err: err}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) resolveNext(result rpcResult) {
|
||||
s.pendingMu.Lock()
|
||||
if len(s.pending) == 0 {
|
||||
s.pendingMu.Unlock()
|
||||
return
|
||||
}
|
||||
ch := s.pending[0]
|
||||
copy(s.pending, s.pending[1:])
|
||||
s.pending = s.pending[:len(s.pending)-1]
|
||||
s.pendingMu.Unlock()
|
||||
ch <- result
|
||||
}
|
||||
|
||||
func (s *WSSSession) removePending(target chan rpcResult) {
|
||||
s.pendingMu.Lock()
|
||||
defer s.pendingMu.Unlock()
|
||||
for i, ch := range s.pending {
|
||||
if ch == target {
|
||||
copy(s.pending[i:], s.pending[i+1:])
|
||||
s.pending = s.pending[:len(s.pending)-1]
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) writeMessage(ctx context.Context, msg WSSMessage) error {
|
||||
s.writeMu.Lock()
|
||||
defer s.writeMu.Unlock()
|
||||
if deadline, ok := ctx.Deadline(); ok {
|
||||
_ = s.conn.SetWriteDeadline(deadline)
|
||||
defer s.conn.SetWriteDeadline(time.Time{})
|
||||
}
|
||||
return s.conn.WriteMessage(websocket.BinaryMessage, msg.Encode())
|
||||
}
|
||||
|
||||
func (s *WSSSession) callRaw(ctx context.Context, msg WSSMessage) ([]byte, error) {
|
||||
ch := make(chan rpcResult, 1)
|
||||
s.pendingMu.Lock()
|
||||
s.pending = append(s.pending, ch)
|
||||
s.pendingMu.Unlock()
|
||||
|
||||
if err := s.writeMessage(ctx, msg); err != nil {
|
||||
s.removePending(ch)
|
||||
return nil, err
|
||||
}
|
||||
select {
|
||||
case result := <-ch:
|
||||
return result.body, result.err
|
||||
case <-ctx.Done():
|
||||
s.removePending(ch)
|
||||
return nil, ctx.Err()
|
||||
case <-s.closed:
|
||||
if s.closeErr != nil {
|
||||
return nil, s.closeErr
|
||||
}
|
||||
return nil, errors.New("wss closed")
|
||||
}
|
||||
}
|
||||
|
||||
func (s *WSSSession) initialize(ctx context.Context) error {
|
||||
if err := s.sendHeartbeat(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.callWSLaunch(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.callGetConfig(ctx); err != nil {
|
||||
s.client.logf("[WSS] getConfig 失败但继续: %v", err)
|
||||
}
|
||||
if s.launchGUID != "" {
|
||||
if err := s.sendRegister(ctx, s.launchGUID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return s.sendConfirm(ctx)
|
||||
}
|
||||
|
||||
func (s *WSSSession) withTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
|
||||
if _, ok := ctx.Deadline(); ok || s.client.CallTimeout <= 0 {
|
||||
return ctx, func() {}
|
||||
}
|
||||
return context.WithTimeout(ctx, s.client.CallTimeout)
|
||||
}
|
||||
|
||||
func (s *WSSSession) sendHeartbeat(ctx context.Context) error {
|
||||
w := taf.NewWriter()
|
||||
if err := w.WriteHead(0, taf.TypeList); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(0, 1); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(0, "live:0"); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
|
||||
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandHeartbeatSend, Sequence: wssSeqHeartbeat, Body: body})
|
||||
}
|
||||
|
||||
func (s *WSSSession) callWSLaunch(ctx context.Context) error {
|
||||
req := &wsLaunchReq{}
|
||||
wupReq := wup.NewRequest("launch", "wsLaunch", -1)
|
||||
wupReq.Timeout = 0
|
||||
if err := wupReq.WriteStruct("tReq", req); err != nil {
|
||||
return err
|
||||
}
|
||||
data, err := wupReq.Encode()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx, cancel := s.withTimeout(ctx)
|
||||
defer cancel()
|
||||
body, err := s.callRaw(ctx, WSSMessage{
|
||||
Command: WSSCommandRPCRequest,
|
||||
Sequence: wssSeqWSLaunch,
|
||||
Body: encodeWSSRPCBody(data),
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var resp wup.Response
|
||||
if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil {
|
||||
return err
|
||||
}
|
||||
var launch wsLaunchResp
|
||||
ok, err := resp.ReadStruct("tRsp", &launch)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !ok {
|
||||
return errors.New("wsLaunch 响应缺少 tRsp")
|
||||
}
|
||||
s.launchGUID = launch.GUID
|
||||
s.launchIP = launch.ClientIP
|
||||
s.client.logf("[WSS] wsLaunch guid=%s ip=%s", launch.GUID, launch.ClientIP)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *WSSSession) callGetConfig(ctx context.Context) error {
|
||||
req := &getConfigReq{}
|
||||
wupReq := wup.NewRequest("mobileui", "getConfig", 7)
|
||||
wupReq.Timeout = 0
|
||||
if err := wupReq.WriteStruct("tReq", req); err != nil {
|
||||
return err
|
||||
}
|
||||
data, err := wupReq.Encode()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx, cancel := s.withTimeout(ctx)
|
||||
defer cancel()
|
||||
_, err = s.callRaw(ctx, WSSMessage{
|
||||
Command: WSSCommandRPCRequest,
|
||||
Sequence: wssSeqGetConfig,
|
||||
Body: encodeWSSRPCBody(data),
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *WSSSession) sendRegister(ctx context.Context, launchGUID string) error {
|
||||
w := taf.NewWriter()
|
||||
if err := w.WriteString(0, "HUYA&ZH&2052"); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, launchGUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(2, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(3, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteStructBegin(6); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteMapStringString(0, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteMapStringString(1, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(3, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteStructEnd(); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteMapStringString(7, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(8, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
|
||||
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandRegister, Sequence: wssSeqRegister, Body: body})
|
||||
}
|
||||
|
||||
func (s *WSSSession) sendConfirm(ctx context.Context) error {
|
||||
w := taf.NewWriter()
|
||||
if err := w.WriteMapStringString(0, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
|
||||
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandConfirmSend, Sequence: wssSeqConfirm, Body: body})
|
||||
}
|
||||
|
||||
func (s *WSSSession) nextRequestID() int32 {
|
||||
id := s.nextWUPRequestID
|
||||
s.nextWUPRequestID++
|
||||
return id
|
||||
}
|
||||
|
||||
func (s *WSSSession) callRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler) (*wup.Response, error) {
|
||||
wupReq := wup.NewRequest(service, method, s.nextRequestID())
|
||||
wupReq.Timeout = 0
|
||||
if err := wupReq.WriteStruct("tReq", reqStruct); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
data, err := wupReq.Encode()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ctx, cancel := s.withTimeout(ctx)
|
||||
defer cancel()
|
||||
s.client.logf("[WSS] RPC %s.%s body=%dB", service, method, len(data))
|
||||
body, err := s.callRaw(ctx, WSSMessage{
|
||||
Command: WSSCommandRPCRequest,
|
||||
Sequence: wssSeqBusiness,
|
||||
Body: encodeWSSRPCBody(data),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var resp wup.Response
|
||||
if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if respStruct != nil {
|
||||
ok, err := resp.ReadStruct("tRsp", respStruct)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method)
|
||||
}
|
||||
}
|
||||
return &resp, nil
|
||||
}
|
||||
|
||||
func (c *WSSClient) buildUser(uid int64, cookie string) ActivityUserID {
|
||||
user := NewActivityUserID(uid, NormalizeWSSCookie(cookie), WSSBizUA)
|
||||
user.GUID = ""
|
||||
user.Token = ""
|
||||
user.DeviceInfo = ""
|
||||
return user
|
||||
}
|
||||
|
||||
func (c *WSSClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) {
|
||||
session, err := c.session(ctx, uid, cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req := &GetUserScoreReq{User: c.buildUser(uid, cookie), SID: sid}
|
||||
var resp GetUserScoreResp
|
||||
_, err = session.callRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp)
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *WSSClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) {
|
||||
session, err := c.session(ctx, uid, cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req := &GetActPrizeListReq{User: c.buildUser(uid, cookie), SID: sid}
|
||||
var resp GetActPrizeListResp
|
||||
_, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp)
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *WSSClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) {
|
||||
session, err := c.session(ctx, uid, cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req := &GetUserPrizeRecordsReq{User: c.buildUser(uid, cookie), SID: sid}
|
||||
var resp GetUserPrizeRecordsResp
|
||||
_, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp)
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func (c *WSSClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) {
|
||||
session, err := c.session(ctx, uid, cookie)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req := &ScoreExchangePrizeReq{
|
||||
User: c.buildUser(uid, cookie),
|
||||
SID: sid,
|
||||
PID: pid,
|
||||
ClientEnv: map[string]string{},
|
||||
IsRole: 1,
|
||||
}
|
||||
var resp ScoreExchangePrizeResp
|
||||
_, err = session.callRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp)
|
||||
return &resp, err
|
||||
}
|
||||
|
||||
func NormalizeWSSCookie(cookie string) string {
|
||||
cookie = NormalizeCookie(cookie)
|
||||
pairs := CookiePairs(cookie)
|
||||
out := []string{"huya_ua=" + WSSCookieUA}
|
||||
for _, pair := range pairs {
|
||||
if strings.EqualFold(pair.Key, "huya_ua") {
|
||||
continue
|
||||
}
|
||||
out = append(out, pair.Key+"="+pair.Value)
|
||||
}
|
||||
return strings.Join(out, "; ")
|
||||
}
|
||||
|
||||
type wsLaunchReq struct{}
|
||||
|
||||
func (r *wsLaunchReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteInt64(0, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(2, WSSInitUA); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(3, "HUYA&ZH&2052"); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteStructBegin(4); err != nil {
|
||||
return err
|
||||
}
|
||||
for i := 0; i < 5; i++ {
|
||||
if err := w.WriteString(i, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return w.WriteStructEnd()
|
||||
}
|
||||
|
||||
type wsLaunchResp struct {
|
||||
GUID string
|
||||
ClientIP string
|
||||
}
|
||||
|
||||
func (r *wsLaunchResp) ReadFrom(rd *taf.Reader) error {
|
||||
var err error
|
||||
if r.GUID, err = rd.ReadString(0, false, r.GUID); err != nil {
|
||||
return err
|
||||
}
|
||||
r.ClientIP, err = rd.ReadString(1, false, r.ClientIP)
|
||||
return err
|
||||
}
|
||||
|
||||
type getConfigReq struct{}
|
||||
|
||||
func (r *getConfigReq) WriteTo(w *taf.Writer) error {
|
||||
if err := w.WriteStructBegin(0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt64(0, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(2, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(3, WSSInitUA); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(4, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(5, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(6, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(7, ""); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteStructEnd(); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteMapStringString(1, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(2, "huya"); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteHead(3, taf.TypeList); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteInt32(0, 0)
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
package huya
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
)
|
||||
|
||||
const (
|
||||
WSSCommandRPCRequest byte = 0x03
|
||||
WSSCommandRPCResponse byte = 0x04
|
||||
WSSCommandAuth byte = 0x0a
|
||||
WSSCommandHeartbeatSend byte = 0x10
|
||||
WSSCommandHeartbeatRecv byte = 0x11
|
||||
WSSCommandConfirmSend byte = 0x17
|
||||
WSSCommandRegister byte = 0x21
|
||||
|
||||
wssSeqHeartbeat uint32 = 0x1d00000d
|
||||
wssSeqWSLaunch uint32 = 0x1d000078
|
||||
wssSeqGetConfig uint32 = 0x1d000076
|
||||
wssSeqRegister uint32 = 0x1d00003c
|
||||
wssSeqConfirm uint32 = 0x1d000002
|
||||
wssSeqBusiness uint32 = 0x1d000106
|
||||
)
|
||||
|
||||
var (
|
||||
wssTailBytes = []byte{0x2c, 0x36, 0x00, 0x4c, 0x5c, 0x66, 0x00}
|
||||
wssBigTailSuffix = []byte{0x4c, 0x5c, 0x66, 0x00}
|
||||
)
|
||||
|
||||
// WSSMessage 是虎牙 WebSocketCommand 的 Go 表达。
|
||||
//
|
||||
// 外层格式来自浏览器/参考项目:
|
||||
//
|
||||
// 1B version(0) + 1B command + 4B sequence + body
|
||||
type WSSMessage struct {
|
||||
Command byte
|
||||
Sequence uint32
|
||||
Body []byte
|
||||
}
|
||||
|
||||
func (m WSSMessage) Encode() []byte {
|
||||
out := make([]byte, 6+len(m.Body))
|
||||
out[0] = 0
|
||||
out[1] = m.Command
|
||||
binary.BigEndian.PutUint32(out[2:6], m.Sequence)
|
||||
copy(out[6:], m.Body)
|
||||
return out
|
||||
}
|
||||
|
||||
func DecodeWSSMessage(data []byte) (WSSMessage, error) {
|
||||
if len(data) < 6 {
|
||||
return WSSMessage{}, fmt.Errorf("wss: 消息太短: %d", len(data))
|
||||
}
|
||||
return WSSMessage{
|
||||
Command: data[1],
|
||||
Sequence: binary.BigEndian.Uint32(data[2:6]),
|
||||
Body: append([]byte(nil), data[6:]...),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func encodeWSSRPCBody(wupData []byte) []byte {
|
||||
if len(wupData) < 4 {
|
||||
out := append([]byte{}, wupData...)
|
||||
return append(out, wssTailBytes...)
|
||||
}
|
||||
declaredLen := int(binary.BigEndian.Uint32(wupData[:4]))
|
||||
wupBody := wupData
|
||||
if declaredLen == len(wupData) {
|
||||
wupBody = wupData[4:]
|
||||
}
|
||||
if len(wupBody) <= 0xff {
|
||||
out := append([]byte{}, wupData...)
|
||||
return append(out, wssTailBytes...)
|
||||
}
|
||||
|
||||
trace := NewWSSBigTailTrace()
|
||||
packetLen := len(wupData)
|
||||
out := make([]byte, 0, 1+4+len(wupBody)+len(trace))
|
||||
out = append(out, byte(packetLen&0xff))
|
||||
var lenBuf [4]byte
|
||||
binary.BigEndian.PutUint32(lenBuf[:], uint32(packetLen))
|
||||
out = append(out, lenBuf[:]...)
|
||||
out = append(out, wupBody...)
|
||||
out = append(out, trace...)
|
||||
return out
|
||||
}
|
||||
|
||||
func extractWUPFromWSSBody(body []byte) []byte {
|
||||
if len(body) < 5 {
|
||||
return body
|
||||
}
|
||||
// 大包格式: [1B prefix][4B wup_len][裸 WUP body][tail]
|
||||
wupLen := int(binary.BigEndian.Uint32(body[1:5]))
|
||||
if 5+wupLen <= len(body) && len(body) >= 7 && body[5] == 0x10 && body[6] == 0x03 {
|
||||
return body[5 : 5+wupLen]
|
||||
}
|
||||
// 小包格式: [4B total_len][WUP body][tail]
|
||||
totalLen := int(binary.BigEndian.Uint32(body[:4]))
|
||||
if 8 <= totalLen && totalLen <= len(body) && body[4] == 0x10 && body[5] == 0x03 {
|
||||
return body[:totalLen]
|
||||
}
|
||||
if 5+wupLen <= len(body) {
|
||||
return body[5 : 5+wupLen]
|
||||
}
|
||||
return body
|
||||
}
|
||||
|
||||
func NewWSSBigTailTrace() []byte {
|
||||
trace := lowerHex16(rand.Uint64())
|
||||
out := []byte(",6%" + trace + ":" + trace + ":0:3")
|
||||
return append(out, wssBigTailSuffix...)
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package sniper
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"huya-go/internal/huya"
|
||||
)
|
||||
|
||||
type Account struct {
|
||||
UID int64 `json:"uid"`
|
||||
Cookie string `json:"-"`
|
||||
}
|
||||
|
||||
type Target struct {
|
||||
PID int32 `json:"pid"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
SID int32
|
||||
Loops int
|
||||
Delay time.Duration
|
||||
Concurrency int
|
||||
StopAfterSuccess bool
|
||||
}
|
||||
|
||||
type Result struct {
|
||||
Loop int `json:"loop"`
|
||||
UID int64 `json:"uid"`
|
||||
Action string `json:"action"`
|
||||
Prize *huya.PrizeInfo `json:"prize,omitempty"`
|
||||
Exchange *huya.ScoreExchangePrizeResp `json:"exchange,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type Runner struct {
|
||||
Client huya.ActivityClient
|
||||
}
|
||||
|
||||
func (r *Runner) Run(ctx context.Context, accounts []Account, target Target, cfg Config, emit func(Result)) error {
|
||||
if cfg.Loops <= 0 {
|
||||
cfg.Loops = 1
|
||||
}
|
||||
if cfg.Delay <= 0 {
|
||||
cfg.Delay = 150 * time.Millisecond
|
||||
}
|
||||
if cfg.Concurrency <= 0 {
|
||||
cfg.Concurrency = 1
|
||||
}
|
||||
var client huya.ActivityClient = r.Client
|
||||
if client == nil {
|
||||
client = huya.NewHTTPClient(nil)
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
|
||||
for loop := 1; loop <= cfg.Loops; loop++ {
|
||||
if ctx.Err() != nil {
|
||||
return ctx.Err()
|
||||
}
|
||||
sem := make(chan struct{}, cfg.Concurrency)
|
||||
var wg sync.WaitGroup
|
||||
for _, account := range accounts {
|
||||
account := account
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
select {
|
||||
case sem <- struct{}{}:
|
||||
defer func() { <-sem }()
|
||||
case <-ctx.Done():
|
||||
return
|
||||
}
|
||||
result := r.tryAccount(ctx, client, account, target, cfg.SID, loop)
|
||||
if emit != nil {
|
||||
emit(result)
|
||||
}
|
||||
if cfg.StopAfterSuccess && result.Exchange != nil && result.Exchange.Success() {
|
||||
cancel()
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
if ctx.Err() != nil {
|
||||
return ctx.Err()
|
||||
}
|
||||
if loop < cfg.Loops {
|
||||
timer := time.NewTimer(cfg.Delay)
|
||||
select {
|
||||
case <-timer.C:
|
||||
case <-ctx.Done():
|
||||
timer.Stop()
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Runner) tryAccount(ctx context.Context, client huya.ActivityClient, account Account, target Target, sid int32, loop int) Result {
|
||||
list, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, sid)
|
||||
if err != nil {
|
||||
return Result{Loop: loop, UID: account.UID, Action: "list_error", Error: err.Error()}
|
||||
}
|
||||
prize := matchPrize(list.Prizes, target)
|
||||
if prize == nil {
|
||||
return Result{Loop: loop, UID: account.UID, Action: "not_found"}
|
||||
}
|
||||
exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, int32(prize.ID))
|
||||
if err != nil {
|
||||
return Result{Loop: loop, UID: account.UID, Action: "exchange_error", Prize: prize, Error: err.Error()}
|
||||
}
|
||||
return Result{Loop: loop, UID: account.UID, Action: "exchange", Prize: prize, Exchange: exchange}
|
||||
}
|
||||
|
||||
func matchPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo {
|
||||
for i := range prizes {
|
||||
if target.PID > 0 && int32(prizes[i].ID) == target.PID {
|
||||
return &prizes[i]
|
||||
}
|
||||
if target.PID == 0 && target.Name != "" && strings.Contains(prizes[i].Name, target.Name) {
|
||||
return &prizes[i]
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,420 @@
|
||||
package taf
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
)
|
||||
|
||||
// Reader 负责从 TAF/JCE 字节流中按 tag 顺序读取字段。
|
||||
type Reader struct {
|
||||
buf *bytes.Reader
|
||||
}
|
||||
|
||||
func NewReader(data []byte) *Reader {
|
||||
return &Reader{buf: bytes.NewReader(data)}
|
||||
}
|
||||
|
||||
func (r *Reader) Position() int64 {
|
||||
pos, _ := r.buf.Seek(0, io.SeekCurrent)
|
||||
return pos
|
||||
}
|
||||
|
||||
func (r *Reader) Seek(pos int64) error {
|
||||
_, err := r.buf.Seek(pos, io.SeekStart)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *Reader) ReadHead() (int, Type, error) {
|
||||
b, err := r.buf.ReadByte()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
tag := int((b >> 4) & 0x0f)
|
||||
typ := Type(b & 0x0f)
|
||||
if tag == 15 {
|
||||
ext, err := r.buf.ReadByte()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
tag = int(ext)
|
||||
}
|
||||
return tag, typ, nil
|
||||
}
|
||||
|
||||
func (r *Reader) PeekHead() (int, Type, error) {
|
||||
pos := r.Position()
|
||||
tag, typ, err := r.ReadHead()
|
||||
_ = r.Seek(pos)
|
||||
return tag, typ, err
|
||||
}
|
||||
|
||||
func (r *Reader) ReadIntValue(typ Type) (int64, error) {
|
||||
switch typ {
|
||||
case TypeZero:
|
||||
return 0, nil
|
||||
case TypeInt8:
|
||||
b, err := r.buf.ReadByte()
|
||||
return int64(int8(b)), err
|
||||
case TypeInt16:
|
||||
var b [2]byte
|
||||
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(int16(binary.BigEndian.Uint16(b[:]))), nil
|
||||
case TypeInt32:
|
||||
var b [4]byte
|
||||
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(int32(binary.BigEndian.Uint32(b[:]))), nil
|
||||
case TypeInt64:
|
||||
var b [8]byte
|
||||
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(binary.BigEndian.Uint64(b[:])), nil
|
||||
default:
|
||||
return 0, fmt.Errorf("taf: 期望整数类型,实际 0x%02x", byte(typ))
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Reader) ReadStringValue(typ Type) (string, error) {
|
||||
var n uint32
|
||||
switch typ {
|
||||
case TypeString1:
|
||||
b, err := r.buf.ReadByte()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
n = uint32(b)
|
||||
case TypeString4:
|
||||
var b [4]byte
|
||||
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
|
||||
return "", err
|
||||
}
|
||||
n = binary.BigEndian.Uint32(b[:])
|
||||
default:
|
||||
return "", fmt.Errorf("taf: 期望字符串类型,实际 0x%02x", byte(typ))
|
||||
}
|
||||
raw := make([]byte, n)
|
||||
if _, err := io.ReadFull(r.buf, raw); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(raw), nil
|
||||
}
|
||||
|
||||
func (r *Reader) ReadBytesValue(typ Type) ([]byte, error) {
|
||||
if typ != TypeSimpleList {
|
||||
return nil, fmt.Errorf("taf: 期望 bytes,实际 0x%02x", byte(typ))
|
||||
}
|
||||
_, itemType, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if itemType != TypeInt8 {
|
||||
return nil, fmt.Errorf("taf: bytes 元素类型不是 int8: 0x%02x", byte(itemType))
|
||||
}
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if n < 0 || n > math.MaxInt32 {
|
||||
return nil, fmt.Errorf("taf: bytes 长度异常: %d", n)
|
||||
}
|
||||
raw := make([]byte, int(n))
|
||||
_, err = io.ReadFull(r.buf, raw)
|
||||
return raw, err
|
||||
}
|
||||
|
||||
func (r *Reader) Skip(typ Type) error {
|
||||
switch typ {
|
||||
case TypeZero:
|
||||
return nil
|
||||
case TypeInt8:
|
||||
_, err := r.buf.ReadByte()
|
||||
return err
|
||||
case TypeInt16:
|
||||
_, err := r.buf.Seek(2, io.SeekCurrent)
|
||||
return err
|
||||
case TypeInt32, TypeFloat:
|
||||
_, err := r.buf.Seek(4, io.SeekCurrent)
|
||||
return err
|
||||
case TypeInt64, TypeDouble:
|
||||
_, err := r.buf.Seek(8, io.SeekCurrent)
|
||||
return err
|
||||
case TypeString1:
|
||||
b, err := r.buf.ReadByte()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = r.buf.Seek(int64(b), io.SeekCurrent)
|
||||
return err
|
||||
case TypeString4:
|
||||
var b [4]byte
|
||||
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := r.buf.Seek(int64(binary.BigEndian.Uint32(b[:])), io.SeekCurrent)
|
||||
return err
|
||||
case TypeMap:
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := int64(0); i < n; i++ {
|
||||
if _, kt, err := r.ReadHead(); err != nil {
|
||||
return err
|
||||
} else if err := r.Skip(kt); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, vt, err := r.ReadHead(); err != nil {
|
||||
return err
|
||||
} else if err := r.Skip(vt); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
case TypeList:
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := int64(0); i < n; i++ {
|
||||
if _, it, err := r.ReadHead(); err != nil {
|
||||
return err
|
||||
} else if err := r.Skip(it); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
case TypeStructBegin:
|
||||
return r.SkipToStructEnd()
|
||||
case TypeStructEnd:
|
||||
return nil
|
||||
case TypeSimpleList:
|
||||
_, itemType, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if itemType != TypeInt8 {
|
||||
return fmt.Errorf("taf: simple list 元素类型异常: 0x%02x", byte(itemType))
|
||||
}
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = r.buf.Seek(n, io.SeekCurrent)
|
||||
return err
|
||||
default:
|
||||
return fmt.Errorf("taf: 未知字段类型 0x%02x", byte(typ))
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Reader) readLength() (int64, error) {
|
||||
_, typ, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return r.ReadIntValue(typ)
|
||||
}
|
||||
|
||||
func (r *Reader) findTag(target int, required bool) (Type, bool, error) {
|
||||
for {
|
||||
pos := r.Position()
|
||||
tag, typ, err := r.ReadHead()
|
||||
if err != nil {
|
||||
if errors.Is(err, io.EOF) && !required {
|
||||
return 0, false, nil
|
||||
}
|
||||
return 0, false, err
|
||||
}
|
||||
if typ == TypeStructEnd {
|
||||
_ = r.Seek(pos)
|
||||
if required {
|
||||
return 0, false, fmt.Errorf("taf: 未找到 tag=%d,已到结构尾", target)
|
||||
}
|
||||
return 0, false, nil
|
||||
}
|
||||
if tag == target {
|
||||
return typ, true, nil
|
||||
}
|
||||
if tag > target {
|
||||
_ = r.Seek(pos)
|
||||
if required {
|
||||
return 0, false, fmt.Errorf("taf: 未找到 tag=%d,遇到 tag=%d", target, tag)
|
||||
}
|
||||
return 0, false, nil
|
||||
}
|
||||
if err := r.Skip(typ); err != nil {
|
||||
return 0, false, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Reader) ReadInt64(tag int, required bool, def int64) (int64, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return def, err
|
||||
}
|
||||
return r.ReadIntValue(typ)
|
||||
}
|
||||
|
||||
func (r *Reader) ReadInt32(tag int, required bool, def int32) (int32, error) {
|
||||
value, err := r.ReadInt64(tag, required, int64(def))
|
||||
return int32(value), err
|
||||
}
|
||||
|
||||
func (r *Reader) ReadString(tag int, required bool, def string) (string, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return def, err
|
||||
}
|
||||
return r.ReadStringValue(typ)
|
||||
}
|
||||
|
||||
func (r *Reader) ReadBytes(tag int, required bool, def []byte) ([]byte, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return def, err
|
||||
}
|
||||
return r.ReadBytesValue(typ)
|
||||
}
|
||||
|
||||
func (r *Reader) ReadMapStringString(tag int, required bool) (map[string]string, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return map[string]string{}, err
|
||||
}
|
||||
if typ != TypeMap {
|
||||
return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ))
|
||||
}
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make(map[string]string, n)
|
||||
for i := int64(0); i < n; i++ {
|
||||
_, kt, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
k, err := r.ReadStringValue(kt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_, vt, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := r.ReadStringValue(vt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out[k] = v
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (r *Reader) ReadMapStringBytes(tag int, required bool) (map[string][]byte, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return map[string][]byte{}, err
|
||||
}
|
||||
if typ != TypeMap {
|
||||
return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ))
|
||||
}
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make(map[string][]byte, n)
|
||||
for i := int64(0); i < n; i++ {
|
||||
_, kt, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
k, err := r.ReadStringValue(kt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_, vt, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := r.ReadBytesValue(vt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out[k] = v
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (r *Reader) ReadStruct(tag int, required bool, obj Unmarshaler) (bool, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return false, err
|
||||
}
|
||||
if typ != TypeStructBegin {
|
||||
return false, fmt.Errorf("taf: tag=%d 不是结构体: 0x%02x", tag, byte(typ))
|
||||
}
|
||||
if err := obj.ReadFrom(r); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, r.SkipToStructEnd()
|
||||
}
|
||||
|
||||
func (r *Reader) ReadListStruct(tag int, required bool, factory func() Unmarshaler) ([]Unmarshaler, error) {
|
||||
typ, ok, err := r.findTag(tag, required)
|
||||
if err != nil || !ok {
|
||||
return nil, err
|
||||
}
|
||||
if typ != TypeList {
|
||||
return nil, fmt.Errorf("taf: tag=%d 不是 list: 0x%02x", tag, byte(typ))
|
||||
}
|
||||
n, err := r.readLength()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]Unmarshaler, 0, n)
|
||||
for i := int64(0); i < n; i++ {
|
||||
_, it, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if it != TypeStructBegin {
|
||||
if err := r.Skip(it); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
continue
|
||||
}
|
||||
obj := factory()
|
||||
if err := obj.ReadFrom(r); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := r.SkipToStructEnd(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, obj)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (r *Reader) SkipToStructEnd() error {
|
||||
for {
|
||||
_, typ, err := r.ReadHead()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if typ == TypeStructEnd {
|
||||
return nil
|
||||
}
|
||||
if err := r.Skip(typ); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package taf_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"huya-go/internal/huya"
|
||||
"huya-go/internal/taf"
|
||||
)
|
||||
|
||||
func TestStructRoundTrip(t *testing.T) {
|
||||
user := &huya.ActivityUserID{
|
||||
UID: 123456,
|
||||
GUID: "guid-1",
|
||||
HuyaUA: huya.ActivityWebUA,
|
||||
Cookie: "yyuid=123456;",
|
||||
TokenType: 0,
|
||||
}
|
||||
w := taf.NewWriter()
|
||||
if err := w.WriteStruct(0, user); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var got huya.ActivityUserID
|
||||
r := taf.NewReader(w.Bytes())
|
||||
ok, err := r.ReadStruct(0, true, &got)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !ok || got.UID != user.UID || got.GUID != user.GUID || got.HuyaUA != user.HuyaUA {
|
||||
t.Fatalf("round trip mismatch: %#v", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package taf
|
||||
|
||||
// Type 是虎牙前端使用的 TAF/JCE 字段类型。
|
||||
type Type byte
|
||||
|
||||
const (
|
||||
TypeInt8 Type = 0x00
|
||||
TypeInt16 Type = 0x01
|
||||
TypeInt32 Type = 0x02
|
||||
TypeInt64 Type = 0x03
|
||||
TypeFloat Type = 0x04
|
||||
TypeDouble Type = 0x05
|
||||
TypeString1 Type = 0x06
|
||||
TypeString4 Type = 0x07
|
||||
TypeMap Type = 0x08
|
||||
TypeList Type = 0x09
|
||||
TypeStructBegin Type = 0x0a
|
||||
TypeStructEnd Type = 0x0b
|
||||
TypeZero Type = 0x0c
|
||||
TypeSimpleList Type = 0x0d
|
||||
)
|
||||
|
||||
// Marshaler 表示可编码成 TAF 结构体字段的对象。
|
||||
type Marshaler interface {
|
||||
WriteTo(*Writer) error
|
||||
}
|
||||
|
||||
// Unmarshaler 表示可从 TAF 结构体字段读取自身的对象。
|
||||
type Unmarshaler interface {
|
||||
ReadFrom(*Reader) error
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
package taf
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"math"
|
||||
)
|
||||
|
||||
// Writer 负责按 TAF/JCE 格式编码字段。
|
||||
type Writer struct {
|
||||
buf bytes.Buffer
|
||||
}
|
||||
|
||||
func NewWriter() *Writer {
|
||||
return &Writer{}
|
||||
}
|
||||
|
||||
func (w *Writer) Bytes() []byte {
|
||||
return w.buf.Bytes()
|
||||
}
|
||||
|
||||
func (w *Writer) WriteHead(tag int, typ Type) error {
|
||||
if tag < 0 || tag > 255 {
|
||||
return fmt.Errorf("taf: tag 超出范围: %d", tag)
|
||||
}
|
||||
if tag < 15 {
|
||||
return w.buf.WriteByte(byte(tag<<4) | byte(typ))
|
||||
}
|
||||
if err := w.buf.WriteByte(0xf0 | byte(typ)); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.buf.WriteByte(byte(tag))
|
||||
}
|
||||
|
||||
func (w *Writer) WriteInt8(tag int, value int64) error {
|
||||
if value == 0 {
|
||||
return w.WriteHead(tag, TypeZero)
|
||||
}
|
||||
if value < math.MinInt8 || value > math.MaxInt8 {
|
||||
return fmt.Errorf("taf: int8 溢出: %d", value)
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeInt8); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.buf.WriteByte(byte(int8(value)))
|
||||
}
|
||||
|
||||
func (w *Writer) WriteInt16(tag int, value int64) error {
|
||||
if value >= math.MinInt8 && value <= math.MaxInt8 {
|
||||
return w.WriteInt8(tag, value)
|
||||
}
|
||||
if value < math.MinInt16 || value > math.MaxInt16 {
|
||||
return fmt.Errorf("taf: int16 溢出: %d", value)
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeInt16); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [2]byte
|
||||
binary.BigEndian.PutUint16(b[:], uint16(int16(value)))
|
||||
_, err := w.buf.Write(b[:])
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteInt32(tag int, value int64) error {
|
||||
if value >= math.MinInt16 && value <= math.MaxInt16 {
|
||||
return w.WriteInt16(tag, value)
|
||||
}
|
||||
if value < math.MinInt32 || value > math.MaxInt32 {
|
||||
return fmt.Errorf("taf: int32 溢出: %d", value)
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeInt32); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [4]byte
|
||||
binary.BigEndian.PutUint32(b[:], uint32(int32(value)))
|
||||
_, err := w.buf.Write(b[:])
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteInt64(tag int, value int64) error {
|
||||
if value >= math.MinInt32 && value <= math.MaxInt32 {
|
||||
return w.WriteInt32(tag, value)
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeInt64); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [8]byte
|
||||
binary.BigEndian.PutUint64(b[:], uint64(value))
|
||||
_, err := w.buf.Write(b[:])
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteBool(tag int, value bool) error {
|
||||
if value {
|
||||
return w.WriteInt8(tag, 1)
|
||||
}
|
||||
return w.WriteInt8(tag, 0)
|
||||
}
|
||||
|
||||
func (w *Writer) WriteFloat(tag int, value float32) error {
|
||||
if err := w.WriteHead(tag, TypeFloat); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [4]byte
|
||||
binary.BigEndian.PutUint32(b[:], math.Float32bits(value))
|
||||
_, err := w.buf.Write(b[:])
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteDouble(tag int, value float64) error {
|
||||
if err := w.WriteHead(tag, TypeDouble); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [8]byte
|
||||
binary.BigEndian.PutUint64(b[:], math.Float64bits(value))
|
||||
_, err := w.buf.Write(b[:])
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteString(tag int, value string) error {
|
||||
raw := []byte(value)
|
||||
if len(raw) > math.MaxUint8 {
|
||||
if err := w.WriteHead(tag, TypeString4); err != nil {
|
||||
return err
|
||||
}
|
||||
var b [4]byte
|
||||
binary.BigEndian.PutUint32(b[:], uint32(len(raw)))
|
||||
if _, err := w.buf.Write(b[:]); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := w.buf.Write(raw)
|
||||
return err
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeString1); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.buf.WriteByte(byte(len(raw))); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := w.buf.Write(raw)
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteBytes(tag int, value []byte) error {
|
||||
if err := w.WriteHead(tag, TypeSimpleList); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteHead(0, TypeInt8); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(0, int64(len(value))); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := w.buf.Write(value)
|
||||
return err
|
||||
}
|
||||
|
||||
func (w *Writer) WriteStructBegin(tag int) error {
|
||||
return w.WriteHead(tag, TypeStructBegin)
|
||||
}
|
||||
|
||||
func (w *Writer) WriteStructEnd() error {
|
||||
return w.WriteHead(0, TypeStructEnd)
|
||||
}
|
||||
|
||||
func (w *Writer) WriteStruct(tag int, value Marshaler) error {
|
||||
if err := w.WriteStructBegin(tag); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := value.WriteTo(w); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.WriteStructEnd()
|
||||
}
|
||||
|
||||
func (w *Writer) WriteMapStringString(tag int, value map[string]string) error {
|
||||
if value == nil {
|
||||
value = map[string]string{}
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeMap); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(0, int64(len(value))); err != nil {
|
||||
return err
|
||||
}
|
||||
for k, v := range value {
|
||||
if err := w.WriteString(0, k); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteString(1, v); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *Writer) WriteMapStringBytes(tag int, value map[string][]byte) error {
|
||||
if value == nil {
|
||||
value = map[string][]byte{}
|
||||
}
|
||||
if err := w.WriteHead(tag, TypeMap); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(0, int64(len(value))); err != nil {
|
||||
return err
|
||||
}
|
||||
for k, v := range value {
|
||||
if err := w.WriteString(0, k); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteBytes(1, v); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *Writer) WriteListStruct(tag int, values []Marshaler) error {
|
||||
if err := w.WriteHead(tag, TypeList); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := w.WriteInt32(0, int64(len(values))); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, value := range values {
|
||||
if err := w.WriteStruct(0, value); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,263 @@
|
||||
package wup
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"huya-go/internal/taf"
|
||||
)
|
||||
|
||||
// Request 是 WUP v3 请求封装。
|
||||
type Request struct {
|
||||
Version int16
|
||||
PacketType int8
|
||||
Message int32
|
||||
RequestID int32
|
||||
Servant string
|
||||
Func string
|
||||
Timeout int32
|
||||
Context map[string]string
|
||||
Status map[string]string
|
||||
NewData map[string][]byte
|
||||
}
|
||||
|
||||
func NewRequest(servant, fn string, requestID int32) *Request {
|
||||
return &Request{
|
||||
Version: 3,
|
||||
Servant: servant,
|
||||
Func: fn,
|
||||
RequestID: requestID,
|
||||
Timeout: 3000,
|
||||
Context: map[string]string{},
|
||||
Status: map[string]string{},
|
||||
NewData: map[string][]byte{},
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Request) WriteStruct(key string, value taf.Marshaler) error {
|
||||
w := taf.NewWriter()
|
||||
if err := w.WriteStruct(0, value); err != nil {
|
||||
return err
|
||||
}
|
||||
r.NewData[key] = w.Bytes()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Request) Encode() ([]byte, error) {
|
||||
data := taf.NewWriter()
|
||||
if err := data.WriteMapStringBytes(0, r.NewData); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
body := taf.NewWriter()
|
||||
if err := body.WriteInt16(1, int64(r.Version)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteInt8(2, int64(r.PacketType)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteInt32(3, int64(r.Message)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteInt32(4, int64(r.RequestID)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteString(5, r.Servant); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteString(6, r.Func); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteBytes(7, data.Bytes()); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteInt32(8, int64(r.Timeout)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteMapStringString(9, r.Context); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := body.WriteMapStringString(10, r.Status); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
rawBody := body.Bytes()
|
||||
out := bytes.NewBuffer(make([]byte, 0, len(rawBody)+4))
|
||||
var lenBuf [4]byte
|
||||
binary.BigEndian.PutUint32(lenBuf[:], uint32(len(rawBody)+4))
|
||||
out.Write(lenBuf[:])
|
||||
out.Write(rawBody)
|
||||
return out.Bytes(), nil
|
||||
}
|
||||
|
||||
// Response 是 WUP 响应封装。
|
||||
type Response struct {
|
||||
Version int16
|
||||
PacketType int8
|
||||
Message int32
|
||||
RequestID int32
|
||||
Servant string
|
||||
Func string
|
||||
Buffer []byte
|
||||
Timeout int32
|
||||
Context map[string]string
|
||||
Status map[string]string
|
||||
NewData map[string][]byte
|
||||
}
|
||||
|
||||
func (r *Response) Decode(data []byte) error {
|
||||
body := NormalizePayload(data)
|
||||
reader := taf.NewReader(body)
|
||||
r.Context = map[string]string{}
|
||||
r.Status = map[string]string{}
|
||||
r.NewData = map[string][]byte{}
|
||||
|
||||
for {
|
||||
tag, typ, err := reader.ReadHead()
|
||||
if err != nil {
|
||||
if errors.Is(err, io.EOF) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
if tag > 10 {
|
||||
return nil
|
||||
}
|
||||
switch tag {
|
||||
case 1:
|
||||
v, err := reader.ReadIntValue(typ)
|
||||
r.Version = int16(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 2:
|
||||
v, err := reader.ReadIntValue(typ)
|
||||
r.PacketType = int8(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 3:
|
||||
v, err := reader.ReadIntValue(typ)
|
||||
r.Message = int32(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 4:
|
||||
v, err := reader.ReadIntValue(typ)
|
||||
r.RequestID = int32(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 5:
|
||||
v, err := reader.ReadStringValue(typ)
|
||||
r.Servant = v
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 6:
|
||||
v, err := reader.ReadStringValue(typ)
|
||||
r.Func = v
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 7:
|
||||
v, err := reader.ReadBytesValue(typ)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.Buffer = v
|
||||
if err := r.decodeBuffer(); err != nil {
|
||||
return err
|
||||
}
|
||||
case 8:
|
||||
v, err := reader.ReadIntValue(typ)
|
||||
r.Timeout = int32(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 9:
|
||||
if typ != taf.TypeMap {
|
||||
if err := reader.Skip(typ); err != nil {
|
||||
return err
|
||||
}
|
||||
continue
|
||||
}
|
||||
_ = reader.Seek(reader.Position() - 1)
|
||||
v, err := reader.ReadMapStringString(9, false)
|
||||
r.Context = v
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case 10:
|
||||
if typ != taf.TypeMap {
|
||||
if err := reader.Skip(typ); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
_ = reader.Seek(reader.Position() - 1)
|
||||
v, err := reader.ReadMapStringString(10, false)
|
||||
r.Status = v
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
default:
|
||||
if err := reader.Skip(typ); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Response) decodeBuffer() error {
|
||||
if len(r.Buffer) == 0 {
|
||||
return nil
|
||||
}
|
||||
reader := taf.NewReader(r.Buffer)
|
||||
m, err := reader.ReadMapStringBytes(0, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.NewData = m
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Response) ReadStruct(key string, obj taf.Unmarshaler) (bool, error) {
|
||||
data := r.NewData[key]
|
||||
if len(data) == 0 && key == "tRsp" {
|
||||
data = r.NewData["tResp"]
|
||||
}
|
||||
if len(data) == 0 && key == "tResp" {
|
||||
data = r.NewData["tRsp"]
|
||||
}
|
||||
if len(data) == 0 {
|
||||
return false, nil
|
||||
}
|
||||
reader := taf.NewReader(data)
|
||||
_, typ, err := reader.ReadHead()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if typ != taf.TypeStructBegin {
|
||||
return false, fmt.Errorf("wup: %s 不是结构体响应: 0x%02x", key, byte(typ))
|
||||
}
|
||||
if err := obj.ReadFrom(reader); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, reader.SkipToStructEnd()
|
||||
}
|
||||
|
||||
func NormalizePayload(data []byte) []byte {
|
||||
if len(data) < 4 {
|
||||
return data
|
||||
}
|
||||
n := int(binary.BigEndian.Uint32(data[:4]))
|
||||
if n == len(data) || n+4 == len(data) {
|
||||
return data[4:]
|
||||
}
|
||||
return data
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package wup_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"huya-go/internal/huya"
|
||||
"huya-go/internal/wup"
|
||||
)
|
||||
|
||||
func TestWupEncodeDecodeHeader(t *testing.T) {
|
||||
req := wup.NewRequest(huya.ServantWebActUI, huya.FuncGetUserScore, 2)
|
||||
err := req.WriteStruct("tReq", &huya.GetUserScoreReq{
|
||||
User: huya.NewActivityUserID(123, "yyuid=123;", huya.ActivityWebUA),
|
||||
SID: 456,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, err := req.Encode()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var resp wup.Response
|
||||
if err := resp.Decode(raw); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if resp.Servant != huya.ServantWebActUI || resp.Func != huya.FuncGetUserScore || resp.RequestID != 2 {
|
||||
t.Fatalf("unexpected header: %#v", resp)
|
||||
}
|
||||
if len(resp.NewData["tReq"]) == 0 {
|
||||
t.Fatal("missing tReq")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user