2021-11-10 13:46:52 -05:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2021-12-16 17:41:17 -05:00
|
|
|
"aim-oscar/models"
|
2021-12-16 19:45:32 -05:00
|
|
|
"aim-oscar/oscar"
|
2021-12-17 19:01:22 -05:00
|
|
|
"aim-oscar/util"
|
|
|
|
"bytes"
|
2021-12-16 17:41:17 -05:00
|
|
|
"context"
|
|
|
|
"database/sql"
|
2021-11-10 13:46:52 -05:00
|
|
|
"fmt"
|
|
|
|
"log"
|
|
|
|
"net"
|
|
|
|
"os"
|
|
|
|
"os/signal"
|
|
|
|
"syscall"
|
2021-12-16 19:45:32 -05:00
|
|
|
"time"
|
2021-11-24 11:59:53 -05:00
|
|
|
|
2021-12-18 17:10:00 -05:00
|
|
|
"github.com/pkg/errors"
|
2021-12-16 17:41:17 -05:00
|
|
|
"github.com/uptrace/bun"
|
|
|
|
"github.com/uptrace/bun/dbfixture"
|
|
|
|
"github.com/uptrace/bun/dialect/sqlitedialect"
|
|
|
|
"github.com/uptrace/bun/driver/sqliteshim"
|
|
|
|
"github.com/uptrace/bun/extra/bundebug"
|
2021-11-10 13:46:52 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2021-12-18 16:48:13 -05:00
|
|
|
SRV_HOST = "10.0.1.2"
|
2021-11-10 13:46:52 -05:00
|
|
|
SRV_PORT = "5190"
|
|
|
|
SRV_ADDRESS = SRV_HOST + ":" + SRV_PORT
|
|
|
|
)
|
|
|
|
|
2021-12-17 19:01:22 -05:00
|
|
|
var services map[uint16]Service
|
|
|
|
|
2021-12-18 22:25:05 -05:00
|
|
|
// Map username to session
|
|
|
|
var sessions map[string]*oscar.Session
|
|
|
|
|
2021-12-17 19:01:22 -05:00
|
|
|
func init() {
|
|
|
|
services = make(map[uint16]Service)
|
2021-12-18 22:25:05 -05:00
|
|
|
sessions = make(map[string]*oscar.Session)
|
2021-12-17 19:01:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func RegisterService(family uint16, service Service) {
|
|
|
|
services[family] = service
|
|
|
|
}
|
|
|
|
|
2021-11-10 13:46:52 -05:00
|
|
|
func main() {
|
2021-12-16 17:41:17 -05:00
|
|
|
// Set up the DB
|
2021-12-18 22:47:57 -05:00
|
|
|
sqldb, err := sql.Open(sqliteshim.ShimName, "file:aim.db")
|
2021-12-16 17:41:17 -05:00
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
db := bun.NewDB(sqldb, sqlitedialect.New())
|
2021-12-16 19:45:32 -05:00
|
|
|
db.SetConnMaxIdleTime(15 * time.Second)
|
|
|
|
db.SetConnMaxLifetime(1 * time.Minute)
|
2021-12-16 17:41:17 -05:00
|
|
|
|
|
|
|
// Print all queries to stdout.
|
|
|
|
db.AddQueryHook(bundebug.NewQueryHook(bundebug.WithVerbose(true)))
|
|
|
|
|
2021-12-16 19:45:32 -05:00
|
|
|
// Register our DB models
|
2021-12-18 21:02:47 -05:00
|
|
|
db.RegisterModel((*models.User)(nil), (*models.Message)(nil))
|
2021-12-16 17:41:17 -05:00
|
|
|
|
2021-12-16 19:45:32 -05:00
|
|
|
// dev: load in fixtures to test against
|
2021-12-16 17:41:17 -05:00
|
|
|
fixture := dbfixture.New(db, dbfixture.WithRecreateTables())
|
|
|
|
err = fixture.Load(context.Background(), os.DirFS("models"), "fixtures.yml")
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
2021-11-10 13:46:52 -05:00
|
|
|
listener, err := net.Listen("tcp", SRV_ADDRESS)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println("Error listening: ", err.Error())
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
defer listener.Close()
|
|
|
|
|
2021-12-18 22:25:05 -05:00
|
|
|
// Goroutine that listens for messages to deliver and tries to find a user socket to push them to
|
2021-12-18 22:54:50 -05:00
|
|
|
commCh, messageRoutine := MessageDelivery()
|
|
|
|
go messageRoutine(db)
|
2021-12-18 22:25:05 -05:00
|
|
|
|
2021-12-18 17:10:00 -05:00
|
|
|
handleCloseFn := func(ctx context.Context, session *oscar.Session) {
|
|
|
|
log.Printf("%v disconnected", session.RemoteAddr())
|
|
|
|
|
|
|
|
user := models.UserFromContext(ctx)
|
|
|
|
if user != nil {
|
|
|
|
user.Status = "offline"
|
|
|
|
if err := user.Update(ctx, db); err != nil {
|
|
|
|
log.Print(errors.Wrap(err, "could not set user as active"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
handleFn := func(ctx context.Context, flap *oscar.FLAP) context.Context {
|
2021-12-18 16:48:13 -05:00
|
|
|
session, err := oscar.SessionFromContext(ctx)
|
|
|
|
if err != nil {
|
|
|
|
util.PanicIfError(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if user := models.UserFromContext(ctx); user != nil {
|
|
|
|
fmt.Printf("%s (%v) ->\n%+v\n", user.Username, session.RemoteAddr(), flap)
|
2021-12-18 17:10:00 -05:00
|
|
|
user.LastActivityAt = time.Now()
|
|
|
|
ctx = models.NewContextWithUser(ctx, user)
|
2021-12-18 22:25:05 -05:00
|
|
|
sessions[user.Username] = session
|
2021-12-18 16:48:13 -05:00
|
|
|
} else {
|
|
|
|
fmt.Printf("%v ->\n%+v\n", session.RemoteAddr(), flap)
|
|
|
|
}
|
|
|
|
|
2021-12-17 19:01:22 -05:00
|
|
|
if flap.Header.Channel == 1 {
|
|
|
|
// Is this a hello?
|
|
|
|
if bytes.Equal(flap.Data.Bytes(), []byte{0, 0, 0, 1}) {
|
2021-12-18 16:48:13 -05:00
|
|
|
return ctx
|
2021-12-17 19:01:22 -05:00
|
|
|
}
|
2021-12-18 16:48:13 -05:00
|
|
|
|
|
|
|
user, err := AuthenticateFLAPCookie(ctx, db, flap)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("Could not authenticate cookie: %s", err)
|
|
|
|
return ctx
|
|
|
|
}
|
|
|
|
ctx = models.NewContextWithUser(ctx, user)
|
|
|
|
|
|
|
|
// Send available services
|
|
|
|
servicesSnac := oscar.NewSNAC(1, 3)
|
|
|
|
servicesSnac.Data.WriteUint16(0x1)
|
|
|
|
servicesSnac.Data.WriteUint16(0x4)
|
|
|
|
servicesFlap := oscar.NewFLAP(2)
|
|
|
|
servicesFlap.Data.WriteBinary(servicesSnac)
|
|
|
|
session.Send(servicesFlap)
|
|
|
|
|
|
|
|
return ctx
|
2021-12-17 19:01:22 -05:00
|
|
|
} else if flap.Header.Channel == 2 {
|
|
|
|
snac := &oscar.SNAC{}
|
|
|
|
err := snac.UnmarshalBinary(flap.Data.Bytes())
|
|
|
|
util.PanicIfError(err)
|
|
|
|
|
|
|
|
fmt.Printf("%+v\n", snac)
|
|
|
|
if tlvs, err := oscar.UnmarshalTLVs(snac.Data.Bytes()); err == nil {
|
|
|
|
for _, tlv := range tlvs {
|
|
|
|
fmt.Printf("%+v\n", tlv)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fmt.Printf("%s\n\n", util.PrettyBytes(snac.Data.Bytes()))
|
|
|
|
}
|
|
|
|
|
|
|
|
if service, ok := services[snac.Header.Family]; ok {
|
2021-12-18 22:25:05 -05:00
|
|
|
newCtx, err := service.HandleSNAC(ctx, db, snac, commCh)
|
2021-12-17 19:01:22 -05:00
|
|
|
util.PanicIfError(err)
|
2021-12-18 16:48:13 -05:00
|
|
|
return newCtx
|
2021-12-17 19:01:22 -05:00
|
|
|
}
|
2021-12-18 16:48:13 -05:00
|
|
|
} else if flap.Header.Channel == 4 {
|
|
|
|
session.Disconnect()
|
2021-12-18 17:10:00 -05:00
|
|
|
handleCloseFn(ctx, session)
|
2021-12-17 19:01:22 -05:00
|
|
|
}
|
2021-12-18 16:48:13 -05:00
|
|
|
|
|
|
|
return ctx
|
2021-12-18 17:10:00 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
handler := oscar.NewHandler(handleFn, handleCloseFn)
|
2021-12-17 19:01:22 -05:00
|
|
|
|
|
|
|
RegisterService(0x17, &AuthorizationRegistrationService{})
|
2021-12-18 16:48:13 -05:00
|
|
|
RegisterService(0x01, &GenericServiceControls{})
|
|
|
|
RegisterService(0x04, &ICBM{})
|
2021-12-16 19:45:32 -05:00
|
|
|
|
2021-11-10 13:46:52 -05:00
|
|
|
exitChan := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(exitChan, os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGABRT)
|
|
|
|
go func() {
|
|
|
|
<-exitChan
|
2021-12-18 22:25:05 -05:00
|
|
|
close(commCh)
|
2021-11-10 13:46:52 -05:00
|
|
|
fmt.Println("Shutting down")
|
|
|
|
os.Exit(1)
|
|
|
|
}()
|
|
|
|
|
|
|
|
fmt.Println("OSCAR listening on " + SRV_ADDRESS)
|
|
|
|
for {
|
|
|
|
conn, err := listener.Accept()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println("Error accepting connection: ", err.Error())
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("Connection from %v", conn.RemoteAddr())
|
2021-12-16 19:45:32 -05:00
|
|
|
go handler.Handle(conn)
|
2021-11-16 16:44:29 -05:00
|
|
|
}
|
2021-11-10 13:46:52 -05:00
|
|
|
}
|