649 lines
19 KiB
Go
649 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"time"
|
|
|
|
"fyne.io/fyne/v2"
|
|
"fyne.io/fyne/v2/app"
|
|
"fyne.io/fyne/v2/container"
|
|
"fyne.io/fyne/v2/driver/desktop"
|
|
"fyne.io/fyne/v2/layout"
|
|
"fyne.io/fyne/v2/theme"
|
|
"fyne.io/fyne/v2/widget"
|
|
|
|
com "git.qowevisa.me/Qowevisa/gotell/communication"
|
|
"git.qowevisa.me/Qowevisa/gotell/env"
|
|
"git.qowevisa.me/Qowevisa/gotell/extfyne/widgets"
|
|
)
|
|
|
|
func updateTime(clock *widget.Label) {
|
|
formatted := time.Now().Format("Time: 03:04:05")
|
|
clock.SetText(formatted)
|
|
}
|
|
|
|
var globalApp *MutableApplication
|
|
var globalCfg *FyneConfig
|
|
|
|
var (
|
|
ecdhKeyReceived = false
|
|
ecdhKeySent = false
|
|
)
|
|
|
|
var (
|
|
globalClipboardChannel = make(chan string)
|
|
)
|
|
|
|
func main() {
|
|
tlepCenter.Init()
|
|
userCenter.Init()
|
|
loadingFileName := env.ServerFullchainFileName
|
|
cert, err := os.ReadFile(loadingFileName)
|
|
if err != nil {
|
|
log.Fatalf("client: load root cert: %s", err)
|
|
}
|
|
log.Printf("Certificate %s loaded successfully!\n", loadingFileName)
|
|
//
|
|
roots := x509.NewCertPool()
|
|
if ok := roots.AppendCertsFromPEM(cert); !ok {
|
|
log.Fatalf("client: failed to parse root certificate")
|
|
}
|
|
|
|
config := &tls.Config{
|
|
RootCAs: roots,
|
|
}
|
|
host := "chat.qowevisa.click"
|
|
port := 3232
|
|
service := fmt.Sprintf("%s:%d", host, port)
|
|
log.Printf("client: connecting to %s", service)
|
|
conn, err := tls.Dial("tcp", service, config)
|
|
if err != nil {
|
|
log.Fatalf("client: dial: %s", err)
|
|
}
|
|
defer conn.Close()
|
|
log.Printf("client: connected to %s", service)
|
|
//
|
|
|
|
a := app.New()
|
|
w := a.NewWindow("gotell-fyne")
|
|
// w.Resize(fyne.NewSize(640, 400))
|
|
|
|
// dispatch clipboardChannel
|
|
go func(w fyne.Window) {
|
|
for val := range globalClipboardChannel {
|
|
w.Clipboard().SetContent(val)
|
|
}
|
|
}(w)
|
|
|
|
clock := widget.NewLabel("")
|
|
go func() {
|
|
for range time.Tick(time.Second) {
|
|
updateTime(clock)
|
|
}
|
|
}()
|
|
|
|
btn := widget.NewButtonWithIcon("testBtn", theme.AccountIcon(), func() {
|
|
fmt.Println("I'm pressed!")
|
|
})
|
|
|
|
mainContainer := container.New(layout.NewVBoxLayout(), clock, btn)
|
|
|
|
w.SetContent(mainContainer)
|
|
// w.SetContent(widget.NewLabel("Hello World!"))
|
|
// w2 := a.NewWindow("Larger")
|
|
// w2.SetContent(widget.NewLabel("More content"))
|
|
// w2.Resize(fyne.NewSize(100, 100))
|
|
// w2.Show()
|
|
intercomFromServer := make(chan *com.Message, 16)
|
|
intercomToServer := make(chan *com.Message, 16)
|
|
actionsChannel := make(chan int)
|
|
cfg := FyneConfig{
|
|
App: a,
|
|
Window: w,
|
|
}
|
|
globalCfg = &cfg
|
|
|
|
go readFromServer(conn, intercomFromServer)
|
|
go analyzeMessages(intercomFromServer, actionsChannel)
|
|
go actOnActions(cfg, actionsChannel, intercomToServer)
|
|
go readFromIntercom(intercomToServer, conn)
|
|
w.ShowAndRun()
|
|
}
|
|
|
|
var r com.RegisteredUser
|
|
var tmpLink *com.Link
|
|
var tmpNick string
|
|
|
|
func readFromServer(conn net.Conn, intercom chan *com.Message) {
|
|
buf := make([]byte, 70000)
|
|
for {
|
|
err := conn.SetDeadline(time.Now().Add(1 * time.Minute))
|
|
if err != nil {
|
|
log.Printf("ERROR: conn.SetDeadline: %v", err)
|
|
continue
|
|
}
|
|
n, err := conn.Read(buf)
|
|
if err != nil {
|
|
log.Printf("ERROR: client: read: %s", err)
|
|
if errors.Is(err, net.ErrClosed) {
|
|
log.Printf("caught ErrClosed!")
|
|
}
|
|
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
|
log.Println("caught! Read timeout occurred")
|
|
continue
|
|
}
|
|
return
|
|
}
|
|
msg, err := com.Decode(buf[:n])
|
|
if err != nil {
|
|
log.Printf("ERROR: %#v\n", err)
|
|
continue
|
|
}
|
|
if msg == nil {
|
|
continue
|
|
}
|
|
log.Printf("client: readServer: received message from server: %v", *msg)
|
|
switch msg.ID {
|
|
case com.ID_SERVER_APPROVE_CLIENT_NICKNAME:
|
|
newID := binary.BigEndian.Uint16(msg.Data)
|
|
msg.FromID = newID
|
|
msg.Data = []byte{}
|
|
r.ID = newID
|
|
if tmpNick != "" {
|
|
r.Name = tmpNick
|
|
}
|
|
r.IsRegistered = true
|
|
case com.ID_SERVER_APPROVE_CLIENT_LINK:
|
|
if tmpLink == nil {
|
|
continue
|
|
}
|
|
msg.ToID = tmpLink.UseCount
|
|
msg.Data = tmpLink.Data
|
|
// Crypto stuff
|
|
case com.ID_CLIENT_SEND_CLIENT_ECDH_PUBKEY:
|
|
t, err := tlepCenter.GetTLEP(msg.FromID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
err = t.ECDHApplyOtherKeyBytes(msg.Data)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: ECDHApplyOtherKeyBytes: %v\n", err)
|
|
continue
|
|
}
|
|
fromName, err := userCenter.GetName(msg.FromID)
|
|
if err != nil {
|
|
log.Printf("ERROR: userCenter: GetName: %v\n", err)
|
|
} else {
|
|
msg.Data = []byte(fromName)
|
|
}
|
|
case com.ID_CLIENT_SEND_CLIENT_CBES_SPECS:
|
|
t, err := tlepCenter.GetTLEP(msg.FromID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
cbes, err := t.DecryptMessageEA(msg.Data)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: DecryptMessageEA: %v\n", err)
|
|
continue
|
|
}
|
|
err = t.CBESSetFromBytes(cbes)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: CBESSetFromBytes: %v\n", err)
|
|
continue
|
|
}
|
|
fromName, err := userCenter.GetName(msg.FromID)
|
|
if err != nil {
|
|
log.Printf("ERROR: userCenter: GetName: %v\n", err)
|
|
} else {
|
|
msg.Data = []byte(fromName)
|
|
}
|
|
// message
|
|
case com.ID_CLIENT_SEND_CLIENT_MESSAGE:
|
|
t, err := tlepCenter.GetTLEP(msg.FromID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
decrypedMsg, err := t.DecryptMessageAtMax(msg.Data)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: DecryptMessageAtMax: %v\n", err)
|
|
continue
|
|
}
|
|
msg.Data = decrypedMsg
|
|
// switch
|
|
}
|
|
// user stuff
|
|
switch msg.ID {
|
|
case com.ID_CLIENT_ASK_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE:
|
|
userCenter.AddUser(string(msg.Data), msg.FromID)
|
|
}
|
|
log.Printf("client: readServer: sending message to websocket: %v", *msg)
|
|
intercom <- msg
|
|
}
|
|
}
|
|
|
|
func analyzeMessages(intercomFromServer chan *com.Message, actionsChannel chan int) {
|
|
for msg := range intercomFromServer {
|
|
if msg == nil {
|
|
log.Printf("ERROR: msg is nil")
|
|
continue
|
|
}
|
|
log.Printf("Handling %v from server", *msg)
|
|
switch msg.ID {
|
|
case com.ID_SERVER_ASK_CLIENT_NICKNAME:
|
|
actionsChannel <- ACTION_SET_SCENE_NICKNAME
|
|
case com.ID_SERVER_APPROVE_CLIENT_NICKNAME:
|
|
actionsChannel <- ACTION_SET_SCENE_MAIN
|
|
case com.ID_SERVER_DECLINE_CLIENT_NICKNAME:
|
|
// TODO
|
|
// Link stuff
|
|
case com.ID_SERVER_APPROVE_CLIENT_LINK:
|
|
globalApp.ArrayBundle.LinksMuAr.Add(*tmpLink)
|
|
globalApp.Tabs.LinkTab.Content.Refresh()
|
|
case com.ID_SERVER_SEND_CLIENT_ANOTHER_ID:
|
|
selTab := globalApp.Tabs.AppTabs.Selected()
|
|
id := msg.ToID
|
|
userStr := getStdUserName(id, string(msg.Data))
|
|
globalApp.Widgets.UsersSelect.Options = append(globalApp.Widgets.UsersSelect.Options, userStr)
|
|
globalApp.Tabs.ConnsNoty++
|
|
globalApp.ArrayBundle.UsersOpts[userStr] = &UserOptions{
|
|
Status: USER_STATUS_VISIBLE,
|
|
ToID: id,
|
|
}
|
|
_, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
globalApp.ArrayBundle.UserShortcuts[id] = userStr
|
|
globalApp.ArrayBundle.UserShortcutsRev[userStr] = id
|
|
}
|
|
if selTab != globalApp.Tabs.ConnectionTab {
|
|
updateTabsBasedOnNotyVals(&globalApp.Tabs)
|
|
}
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
case com.ID_CLIENT_ASK_CLIENT_HANDSHAKE:
|
|
selTab := globalApp.Tabs.AppTabs.Selected()
|
|
id := msg.FromID
|
|
userStr := getStdUserName(id, string(msg.Data))
|
|
globalApp.Widgets.UsersSelect.Options = append(globalApp.Widgets.UsersSelect.Options, userStr)
|
|
globalApp.Tabs.ConnsNoty++
|
|
globalApp.ArrayBundle.UsersOpts[userStr] = &UserOptions{
|
|
Status: USER_STATUS_HANDSHAKE_INIT,
|
|
ToID: id,
|
|
}
|
|
_, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
globalApp.ArrayBundle.UserShortcuts[id] = userStr
|
|
globalApp.ArrayBundle.UserShortcutsRev[userStr] = id
|
|
}
|
|
if selTab != globalApp.Tabs.ConnectionTab {
|
|
updateTabsBasedOnNotyVals(&globalApp.Tabs)
|
|
}
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
case com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE:
|
|
id := msg.FromID
|
|
userStr := getStdUserName(id, string(msg.Data))
|
|
var shortcut string
|
|
val, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
globalApp.ArrayBundle.UserShortcuts[id] = userStr
|
|
globalApp.ArrayBundle.UserShortcutsRev[userStr] = id
|
|
shortcut = userStr
|
|
} else {
|
|
shortcut = val
|
|
}
|
|
u, exists := globalApp.ArrayBundle.UsersOpts[shortcut]
|
|
if !exists {
|
|
log.Printf("WARNING!!: UserOpts[%s] NOT exists!", shortcut)
|
|
continue
|
|
}
|
|
u.Status = USER_STATUS_HANDSHAKE_ACCEPTED
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
case com.ID_CLIENT_SEND_CLIENT_ECDH_PUBKEY:
|
|
id := msg.FromID
|
|
if ecdhKeySent {
|
|
val, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
log.Printf("WARNING!!: UserShortcuts[%d] NOT exists!", id)
|
|
continue
|
|
}
|
|
u, exists := globalApp.ArrayBundle.UsersOpts[val]
|
|
if !exists {
|
|
log.Printf("WARNING!!: UserOpts[%s] NOT exists!", val)
|
|
continue
|
|
}
|
|
u.Status = USER_STATUS_ECDH_ESTABLISHED
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
}
|
|
ecdhKeyReceived = true
|
|
case com.ID_CLIENT_SEND_CLIENT_CBES_SPECS:
|
|
id := msg.FromID
|
|
val, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
log.Printf("WARNING!!: UserShortcuts[%d] NOT exists!", id)
|
|
continue
|
|
}
|
|
u, exists := globalApp.ArrayBundle.UsersOpts[val]
|
|
if !exists {
|
|
log.Printf("WARNING!!: UserOpts[%s] NOT exists!", val)
|
|
continue
|
|
}
|
|
u.Status = USER_STATUS_ECDH_CBES_ESTABLISHED
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
//
|
|
log.Printf("Checkin Messages tab")
|
|
userStr := getStdUserName(id, string(msg.Data))
|
|
var shortcut string
|
|
if !exists {
|
|
globalApp.ArrayBundle.UserShortcuts[id] = userStr
|
|
shortcut = userStr
|
|
} else {
|
|
shortcut = val
|
|
}
|
|
//
|
|
haveUser := false
|
|
for _, v := range globalApp.Widgets.MessagesSelect.Options {
|
|
if v == shortcut {
|
|
haveUser = true
|
|
break
|
|
}
|
|
}
|
|
log.Printf("MessagesSelect.Options1 are %v\n", globalApp.Widgets.MessagesSelect.Options)
|
|
log.Printf("have user is : %t\n", haveUser)
|
|
if !haveUser {
|
|
log.Printf("MessagesSelect.Options1.5 shortcut is '%s'\n", shortcut)
|
|
// LOL wtf
|
|
// globalApp.Widgets.MessagesSelect.Options = append(globalApp.Widgets.UsersSelect.Options, shortcut)
|
|
globalApp.Widgets.MessagesSelect.Options = append(globalApp.Widgets.MessagesSelect.Options, shortcut)
|
|
log.Printf("MessagesSelect.Options2 are %v\n", globalApp.Widgets.MessagesSelect.Options)
|
|
globalApp.Tabs.UsersNoty++
|
|
globalApp.Widgets.MessagesSelect.Refresh()
|
|
updateTabsBasedOnNotyVals(&globalApp.Tabs)
|
|
}
|
|
case com.ID_CLIENT_SEND_CLIENT_MESSAGE:
|
|
id := msg.FromID
|
|
shortcut, exists := globalApp.ArrayBundle.UserShortcuts[id]
|
|
if !exists {
|
|
log.Printf("WARNING: UserShortcuts[%d] NOT exists!", id)
|
|
continue
|
|
}
|
|
msgs, exists := globalApp.ArrayBundle.Messages[shortcut]
|
|
mBoardMsg := widgets.MBoardMessage{
|
|
LeftAlign: true,
|
|
Data: widget.NewLabel(string(msg.Data)),
|
|
}
|
|
if !exists {
|
|
tmp := CreateMutexArray[widgets.MBoardMessage]()
|
|
tmp.Add(mBoardMsg)
|
|
globalApp.ArrayBundle.Messages[shortcut] = &tmp
|
|
globalApp.Widgets.MBoardCaretacker.Refresh()
|
|
globalApp.Tabs.UsersTab.Content.Refresh()
|
|
} else {
|
|
msgs.Add(mBoardMsg)
|
|
globalApp.Widgets.MBoardCaretacker.Refresh()
|
|
globalApp.Tabs.UsersTab.Content.Refresh()
|
|
}
|
|
haveUser := false
|
|
for _, v := range globalApp.Widgets.MessagesSelect.Options {
|
|
if v == shortcut {
|
|
haveUser = true
|
|
break
|
|
}
|
|
}
|
|
if !haveUser {
|
|
globalApp.Widgets.MessagesSelect.Options = append(globalApp.Widgets.MessagesSelect.Options, shortcut)
|
|
globalApp.Tabs.UsersNoty++
|
|
updateTabsBasedOnNotyVals(&globalApp.Tabs)
|
|
globalApp.Widgets.MessagesSelect.Refresh()
|
|
}
|
|
//
|
|
mBoard, exists := globalApp.Widgets.MBoardMap[shortcut]
|
|
if exists {
|
|
mBoard.Add(mBoardMsg)
|
|
}
|
|
// TODO
|
|
default:
|
|
log.Printf("Can not handle msg with id %d", msg.ID)
|
|
log.Printf("Msg is different : %v", *msg)
|
|
}
|
|
}
|
|
}
|
|
|
|
func actOnActions(cfg FyneConfig, actionsChannel chan int, intercomToServer chan *com.Message) {
|
|
for action := range actionsChannel {
|
|
log.Printf("Receive action %d", action)
|
|
switch action {
|
|
case ACTION_SET_SCENE_NICKNAME:
|
|
// cfg.Window.Content()
|
|
scene := GetNicknameScene(intercomToServer)
|
|
cfg.Window.Resize(fyne.NewSize(640, 400))
|
|
cfg.Window.SetContent(scene)
|
|
case ACTION_SET_SCENE_MAIN:
|
|
scene, app := GetMainScene(intercomToServer, MainSceneConfig{
|
|
UserNickcname: tmpNick,
|
|
UserNameSet: true,
|
|
UserId: r.ID,
|
|
UserIdSet: true,
|
|
})
|
|
globalApp = app
|
|
globalApp.App.App = cfg.App
|
|
globalApp.App.Window = cfg.Window
|
|
// shortcuts
|
|
ctrl1 := &desktop.CustomShortcut{KeyName: fyne.Key1, Modifier: fyne.KeyModifierControl}
|
|
ctrl2 := &desktop.CustomShortcut{KeyName: fyne.Key2, Modifier: fyne.KeyModifierControl}
|
|
ctrl3 := &desktop.CustomShortcut{KeyName: fyne.Key3, Modifier: fyne.KeyModifierControl}
|
|
cfg.Window.Canvas().AddShortcut(ctrl1, func(shortcut fyne.Shortcut) {
|
|
app.Tabs.AppTabs.Select(app.Tabs.LinkTab)
|
|
})
|
|
cfg.Window.Canvas().AddShortcut(ctrl2, func(shortcut fyne.Shortcut) {
|
|
app.Tabs.AppTabs.Select(app.Tabs.ConnectionTab)
|
|
})
|
|
cfg.Window.Canvas().AddShortcut(ctrl3, func(shortcut fyne.Shortcut) {
|
|
app.Tabs.AppTabs.Select(app.Tabs.UsersTab)
|
|
})
|
|
// cfg.Window.Resize(fyne.NewSize(640, 400))
|
|
cfg.Window.SetContent(scene)
|
|
// ACTION_UPDATE_USER_OPTS_CONTS
|
|
case ACTION_UPDATE_USER_OPTS_CONTS:
|
|
for _, u := range globalApp.ArrayBundle.UsersOpts {
|
|
switch u.Status {
|
|
case USER_STATUS_VISIBLE:
|
|
btn := widget.NewButton("Init Handhake", func() {})
|
|
btn.OnTapped = func() {
|
|
intercomToServer <- &com.Message{
|
|
ID: com.ID_CLIENT_ASK_CLIENT_HANDSHAKE,
|
|
ToID: u.ToID,
|
|
}
|
|
btn.Hide()
|
|
}
|
|
u.OptsContainer = container.NewGridWithRows(1, btn)
|
|
cTaker := globalApp.Widgets.UserOptsCaretaker
|
|
cTaker.RemoveAll()
|
|
cTaker.Add(u.OptsContainer)
|
|
case USER_STATUS_HANDSHAKE_INIT:
|
|
btn := widget.NewButton("Accept Handhake", func() {})
|
|
btn.OnTapped = func() {
|
|
intercomToServer <- &com.Message{
|
|
ID: com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE,
|
|
ToID: u.ToID,
|
|
}
|
|
btn.Hide()
|
|
u.Status = USER_STATUS_HANDSHAKE_ACCEPTED
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
}
|
|
u.OptsContainer = container.NewGridWithRows(1, btn)
|
|
cTaker := globalApp.Widgets.UserOptsCaretaker
|
|
cTaker.RemoveAll()
|
|
cTaker.Add(u.OptsContainer)
|
|
case USER_STATUS_HANDSHAKE_ACCEPTED:
|
|
btn := widget.NewButton("Send ECDH PubKey", func() {})
|
|
btn.OnTapped = func() {
|
|
intercomToServer <- &com.Message{
|
|
ID: com.ID_CLIENT_SEND_CLIENT_ECDH_PUBKEY,
|
|
ToID: u.ToID,
|
|
}
|
|
btn.Hide()
|
|
if ecdhKeyReceived {
|
|
u.Status = USER_STATUS_ECDH_ESTABLISHED
|
|
actionsChannel <- ACTION_UPDATE_USER_OPTS_CONTS
|
|
}
|
|
ecdhKeySent = true
|
|
}
|
|
u.OptsContainer = container.NewGridWithRows(1, btn)
|
|
cTaker := globalApp.Widgets.UserOptsCaretaker
|
|
cTaker.RemoveAll()
|
|
cTaker.Add(u.OptsContainer)
|
|
case USER_STATUS_ECDH_ESTABLISHED:
|
|
btn := widget.NewButton("Send CBES Specs", func() {})
|
|
btn.OnTapped = func() {
|
|
intercomToServer <- &com.Message{
|
|
ID: com.ID_CLIENT_SEND_CLIENT_CBES_SPECS,
|
|
ToID: u.ToID,
|
|
}
|
|
btn.Hide()
|
|
}
|
|
u.OptsContainer = container.NewGridWithRows(1, btn)
|
|
cTaker := globalApp.Widgets.UserOptsCaretaker
|
|
cTaker.RemoveAll()
|
|
cTaker.Add(u.OptsContainer)
|
|
case USER_STATUS_ECDH_CBES_ESTABLISHED:
|
|
btn := widget.NewButton("TBC", func() {})
|
|
btn.OnTapped = func() {
|
|
log.Println("TODO:: 1001")
|
|
}
|
|
u.OptsContainer = container.NewGridWithRows(1, btn)
|
|
cTaker := globalApp.Widgets.UserOptsCaretaker
|
|
cTaker.RemoveAll()
|
|
cTaker.Add(u.OptsContainer)
|
|
default:
|
|
}
|
|
}
|
|
// globalApp.Tabs.ConnectionTab.Content.Refresh()
|
|
// ACTION_UPDATE_USER_OPTS_CONTS
|
|
default:
|
|
}
|
|
}
|
|
}
|
|
|
|
func readFromIntercom(intercom chan *com.Message, conn net.Conn) {
|
|
for msg := range intercom {
|
|
log.Printf("client: received message from Intercom: %v", msg)
|
|
msg.Version = com.V1
|
|
switch msg.ID {
|
|
case com.ID_CLIENT_SEND_SERVER_NICKNAME:
|
|
tmpNick = string(msg.Data)
|
|
case com.ID_CLIENT_SEND_SERVER_LINK:
|
|
if !r.IsRegistered {
|
|
continue
|
|
}
|
|
l, err := r.GenerateLink(msg.ToID)
|
|
if err != nil {
|
|
log.Printf("Error: link: %v", err)
|
|
continue
|
|
}
|
|
tmpLink = &l
|
|
answ, err := com.ClientSendServerLink(r.ID, l)
|
|
if err != nil {
|
|
log.Printf("Error: com: %v", err)
|
|
continue
|
|
}
|
|
log.Printf("client: readWS: sending data to server: %v", answ)
|
|
conn.Write(answ)
|
|
continue
|
|
case com.ID_CLIENT_ASK_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_DECLINE_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_SEND_CLIENT_ECDH_PUBKEY,
|
|
com.ID_CLIENT_SEND_CLIENT_CBES_SPECS,
|
|
com.ID_CLIENT_SEND_CLIENT_MKLG_FINGERPRINT,
|
|
com.ID_CLIENT_DECLINE_CLIENT_MKLG_FINGERPRINT,
|
|
com.ID_CLIENT_SEND_CLIENT_MESSAGE:
|
|
if !r.IsRegistered {
|
|
continue
|
|
}
|
|
msg.FromID = r.ID
|
|
// switch
|
|
}
|
|
// user stuff
|
|
switch msg.ID {
|
|
case com.ID_CLIENT_ASK_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE:
|
|
if r.IsRegistered {
|
|
msg.Data = []byte(r.Name)
|
|
}
|
|
}
|
|
// Crypto stuff
|
|
switch msg.ID {
|
|
case com.ID_CLIENT_ASK_CLIENT_HANDSHAKE,
|
|
com.ID_CLIENT_APPROVE_CLIENT_HANDSHAKE:
|
|
err := tlepCenter.AddTLEP(msg.ToID, fmt.Sprintf("%s-%d", r.Name, msg.ToID))
|
|
if err != nil {
|
|
log.Printf("ERROR: tlepCenter.AddUser: %v\n", err)
|
|
}
|
|
case com.ID_CLIENT_SEND_CLIENT_ECDH_PUBKEY:
|
|
t, err := tlepCenter.GetTLEP(msg.ToID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
key, err := t.ECDHGetPublicKey()
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: ECDHGetPublicKey: %v\n", err)
|
|
continue
|
|
}
|
|
msg.Data = key
|
|
case com.ID_CLIENT_SEND_CLIENT_CBES_SPECS:
|
|
t, err := tlepCenter.GetTLEP(msg.ToID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
err = t.CBESInitRandom()
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: CBESInitRandom: %v\n", err)
|
|
continue
|
|
}
|
|
cbes, err := t.CBESGetBytes()
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: ECDHGetPublicKey: %v\n", err)
|
|
continue
|
|
}
|
|
cbesEAEncr, err := t.EncryptMessageEA(cbes)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: EncryptMessageEA: %v\n", err)
|
|
continue
|
|
}
|
|
msg.Data = cbesEAEncr
|
|
// message
|
|
case com.ID_CLIENT_SEND_CLIENT_MESSAGE:
|
|
t, err := tlepCenter.GetTLEP(msg.ToID)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: GetTLEP: %v\n", err)
|
|
continue
|
|
}
|
|
encrypedMsg, err := t.EncryptMessageAtMax(msg.Data)
|
|
if err != nil {
|
|
log.Printf("ERROR: tlep: EncryptMessageAtMax: %v\n", err)
|
|
continue
|
|
}
|
|
msg.Data = encrypedMsg
|
|
// switch
|
|
}
|
|
encodedMsg, err := msg.Bytes()
|
|
if err != nil {
|
|
log.Printf("Encoding error: %s", err)
|
|
continue
|
|
}
|
|
log.Printf("client: readWS: sending data to server: %v", encodedMsg)
|
|
conn.Write(encodedMsg)
|
|
}
|
|
}
|