Merge pull request #103 from jhalter/handle_tracker_list_errors

[rbdr/mobius] / hotline / client.go

diff --git a/hotline/client.go b/hotline/client.go
index 35ec7fb488015c2c4ae00179cfea4468d8d53193..ffd0fb3c1cb2c1607848c52278dcfcdf9c9ecd6a 100644 (file)
--- a/hotline/client.go
+++ b/hotline/client.go
@@ -1,29 +1,27 @@
 package hotline
 
 import (
 package hotline
 
 import (

+       "bufio"

        "bytes"
        "embed"
        "encoding/binary"
        "errors"
        "fmt"
        "bytes"
        "embed"
        "encoding/binary"
        "errors"
        "fmt"

-       "github.com/davecgh/go-spew/spew"

        "github.com/gdamore/tcell/v2"
        "github.com/rivo/tview"
        "github.com/gdamore/tcell/v2"
        "github.com/rivo/tview"

-       "github.com/stretchr/testify/mock"

        "go.uber.org/zap"
        "go.uber.org/zap"

-       "gopkg.in/yaml.v2"
-       "io/ioutil"
+       "gopkg.in/yaml.v3"

        "math/big"
        "math/rand"
        "net"
        "os"
        "math/big"
        "math/rand"
        "net"
        "os"

-       "strconv"

        "strings"
        "time"
 )
 
 const (
        trackerListPage = "trackerList"
        "strings"
        "time"
 )
 
 const (
        trackerListPage = "trackerList"

+       serverUIPage    = "serverUI"

 )
 
 //go:embed banners/*.txt
 )
 
 //go:embed banners/*.txt


@@ -37,10 +35,11 @@ type Bookmark struct {
 }
 
 type ClientPrefs struct {
 }
 
 type ClientPrefs struct {

-       Username  string     `yaml:"Username"`
-       IconID    int        `yaml:"IconID"`
-       Bookmarks []Bookmark `yaml:"Bookmarks"`
-       Tracker   string     `yaml:"Tracker"`
+       Username   string     `yaml:"Username"`
+       IconID     int        `yaml:"IconID"`
+       Bookmarks  []Bookmark `yaml:"Bookmarks"`
+       Tracker    string     `yaml:"Tracker"`
+       EnableBell bool       `yaml:"EnableBell"`

 }
 
 func (cp *ClientPrefs) IconBytes() []byte {
 }
 
 func (cp *ClientPrefs) IconBytes() []byte {


@@ -49,6 +48,10 @@ func (cp *ClientPrefs) IconBytes() []byte {
        return iconBytes
 }
 
        return iconBytes
 }
 

+func (cp *ClientPrefs) AddBookmark(name, addr, login, pass string) {
+       cp.Bookmarks = append(cp.Bookmarks, Bookmark{Addr: addr, Login: login, Password: pass})
+}
+

 func readConfig(cfgPath string) (*ClientPrefs, error) {
        fh, err := os.Open(cfgPath)
        if err != nil {
 func readConfig(cfgPath string) (*ClientPrefs, error) {
        fh, err := os.Open(cfgPath)
        if err != nil {


@@ -57,7 +60,6 @@ func readConfig(cfgPath string) (*ClientPrefs, error) {
 
        prefs := ClientPrefs{}
        decoder := yaml.NewDecoder(fh)
 
        prefs := ClientPrefs{}
        decoder := yaml.NewDecoder(fh)

-       decoder.SetStrict(true)

        if err := decoder.Decode(&prefs); err != nil {
                return nil, err
        }
        if err := decoder.Decode(&prefs); err != nil {
                return nil, err
        }


@@ -68,197 +70,55 @@ type Client struct {
        cfgPath     string
        DebugBuf    *DebugBuffer
        Connection  net.Conn
        cfgPath     string
        DebugBuf    *DebugBuffer
        Connection  net.Conn

-       Login       *[]byte
-       Password    *[]byte
-       Flags       *[]byte
-       ID          *[]byte
-       Version     []byte

        UserAccess  []byte
        UserAccess  []byte

-       Agreed      bool
+       filePath    []string

        UserList    []User
        Logger      *zap.SugaredLogger
        activeTasks map[uint32]*Transaction
        UserList    []User
        Logger      *zap.SugaredLogger
        activeTasks map[uint32]*Transaction

+       serverName  string

 
 

-       pref *ClientPrefs
+       Pref *ClientPrefs

 
 

-       Handlers map[uint16]clientTHandler
+       Handlers map[uint16]ClientHandler

 
        UI *UI
 
 
        UI *UI
 

-       outbox chan *Transaction
-       Inbox  chan *Transaction
-}
-
-type UI struct {
-       chatBox      *tview.TextView
-       chatInput    *tview.InputField
-       App          *tview.Application
-       Pages        *tview.Pages
-       userList     *tview.TextView
-       agreeModal   *tview.Modal
-       trackerList  *tview.List
-       settingsPage *tview.Box
-       HLClient     *Client
-}
-
-func NewUI(c *Client) *UI {
-       app := tview.NewApplication()
-       chatBox := tview.NewTextView().
-               SetScrollable(true).
-               SetDynamicColors(true).
-               SetWordWrap(true).
-               SetChangedFunc(func() {
-                       app.Draw() // TODO: docs say this is bad but it's the only way to show content during initial render??
-               })
-       chatBox.Box.SetBorder(true).SetTitle("Chat")
-
-       chatInput := tview.NewInputField()
-       chatInput.
-               SetLabel("> ").
-               SetFieldBackgroundColor(tcell.ColorDimGray).
-               SetDoneFunc(func(key tcell.Key) {
-                       // skip send if user hit enter with no other text
-                       if len(chatInput.GetText()) == 0 {
-                               return
-                       }
-
-                       c.Send(
-                               *NewTransaction(tranChatSend, nil,
-                                       NewField(fieldData, []byte(chatInput.GetText())),
-                               ),
-                       )
-                       chatInput.SetText("") // clear the input field after chat send
-               })
-
-       chatInput.Box.SetBorder(true).SetTitle("Send")
-
-       userList := tview.
-               NewTextView().
-               SetDynamicColors(true).
-               SetChangedFunc(func() {
-                       app.Draw() // TODO: docs say this is bad but it's the only way to show content during initial render??
-               })
-       userList.Box.SetBorder(true).SetTitle("Users")
-
-       return &UI{
-               App:         app,
-               chatBox:     chatBox,
-               Pages:       tview.NewPages(),
-               chatInput:   chatInput,
-               userList:    userList,
-               trackerList: tview.NewList(),
-               agreeModal:  tview.NewModal(),
-               HLClient:    c,
-       }
+       Inbox chan *Transaction

 }
 
 }
 

-func (ui *UI) showBookmarks() *tview.List {
-       list := tview.NewList()
-       list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-               if event.Key() == tcell.KeyEsc {
-                       ui.Pages.SwitchToPage("home")
-               }
-               return event
-       })
-       list.Box.SetBorder(true).SetTitle("| Bookmarks |")
-
-       shortcut := 97 // rune for "a"
-       for i, srv := range ui.HLClient.pref.Bookmarks {
-               addr := srv.Addr
-               login := srv.Login
-               pass := srv.Password
-               list.AddItem(srv.Name, srv.Addr, rune(shortcut+i), func() {
-                       ui.Pages.RemovePage("joinServer")
+type ClientHandler func(*Client, *Transaction) ([]Transaction, error)

 
 

-                       newJS := ui.renderJoinServerForm(addr, login, pass, "bookmarks", true, true)
+func (c *Client) HandleFunc(transactionID uint16, handler ClientHandler) {
+       c.Handlers[transactionID] = handler
+}

 
 

-                       ui.Pages.AddPage("joinServer", newJS, true, true)
-               })
+func NewClient(username string, logger *zap.SugaredLogger) *Client {
+       c := &Client{
+               Logger:      logger,
+               activeTasks: make(map[uint32]*Transaction),
+               Handlers:    make(map[uint16]ClientHandler),

        }
        }

+       c.Pref = &ClientPrefs{Username: username}

 
 

-       return list
+       return c

 }
 
 }
 

-func (ui *UI) getTrackerList() *tview.List {
-       listing, err := GetListing(ui.HLClient.pref.Tracker)
-       if err != nil {
-               spew.Dump(err)
+func NewUIClient(cfgPath string, logger *zap.SugaredLogger) *Client {
+       c := &Client{
+               cfgPath:     cfgPath,
+               Logger:      logger,
+               activeTasks: make(map[uint32]*Transaction),
+               Handlers:    clientHandlers,

        }
        }

+       c.UI = NewUI(c)

 
 

-       list := tview.NewList()
-       list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-               if event.Key() == tcell.KeyEsc {
-                       ui.Pages.SwitchToPage("home")
-               }
-               return event
-       })
-       list.Box.SetBorder(true).SetTitle("| Servers |")
-
-       shortcut := 97 // rune for "a"
-       for i, srv := range listing {
-               addr := srv.Addr()
-               list.AddItem(string(srv.Name), string(srv.Description), rune(shortcut+i), func() {
-                       ui.Pages.RemovePage("joinServer")
-
-                       newJS := ui.renderJoinServerForm(addr, GuestAccount, "", trackerListPage, false, true)
-
-                       ui.Pages.AddPage("joinServer", newJS, true, true)
-                       ui.Pages.ShowPage("joinServer")
-               })
+       prefs, err := readConfig(cfgPath)
+       if err != nil {
+               logger.Fatal(fmt.Sprintf("unable to read config file %s\n", cfgPath))

        }
        }

+       c.Pref = prefs

 
 

-       return list
-}
-
-func (ui *UI) renderSettingsForm() *tview.Flex {
-       iconStr := strconv.Itoa(ui.HLClient.pref.IconID)
-       settingsForm := tview.NewForm()
-       settingsForm.AddInputField("Your Name", ui.HLClient.pref.Username, 0, nil, nil)
-       settingsForm.AddInputField("IconID", iconStr, 0, func(idStr string, _ rune) bool {
-               _, err := strconv.Atoi(idStr)
-               return err == nil
-       }, nil)
-       settingsForm.AddInputField("Tracker", ui.HLClient.pref.Tracker, 0, nil, nil)
-       settingsForm.AddButton("Save", func() {
-               usernameInput := settingsForm.GetFormItem(0).(*tview.InputField).GetText()
-               if len(usernameInput) == 0 {
-                       usernameInput = "unnamed"
-               }
-               ui.HLClient.pref.Username = usernameInput
-               iconStr = settingsForm.GetFormItem(1).(*tview.InputField).GetText()
-               ui.HLClient.pref.IconID, _ = strconv.Atoi(iconStr)
-               ui.HLClient.pref.Tracker = settingsForm.GetFormItem(2).(*tview.InputField).GetText()
-
-               out, err := yaml.Marshal(&ui.HLClient.pref)
-               if err != nil {
-                       // TODO: handle err
-               }
-               // TODO: handle err
-               err = ioutil.WriteFile(ui.HLClient.cfgPath, out, 0666)
-               if err != nil {
-                       println(ui.HLClient.cfgPath)
-                       panic(err)
-               }
-               ui.Pages.RemovePage("settings")
-       })
-       settingsForm.SetBorder(true)
-       settingsForm.SetCancelFunc(func() {
-               ui.Pages.RemovePage("settings")
-       })
-       settingsPage := tview.NewFlex().SetDirection(tview.FlexRow)
-       settingsPage.Box.SetBorder(true).SetTitle("Settings")
-       settingsPage.AddItem(settingsForm, 0, 1, true)
-
-       centerFlex := tview.NewFlex().
-               AddItem(nil, 0, 1, false).
-               AddItem(tview.NewFlex().
-                       SetDirection(tview.FlexRow).
-                       AddItem(nil, 0, 1, false).
-                       AddItem(settingsForm, 15, 1, true).
-                       AddItem(nil, 0, 1, false), 40, 1, true).
-               AddItem(nil, 0, 1, false)
-
-       return centerFlex
+       return c

 }
 
 // DebugBuffer wraps a *tview.TextView and adds a Sync() method to make it available as a Zap logger
 }
 
 // DebugBuffer wraps a *tview.TextView and adds a Sync() method to make it available as a Zap logger


@@ -270,384 +130,213 @@ func (db *DebugBuffer) Write(p []byte) (int, error) {
        return db.TextView.Write(p)
 }
 
        return db.TextView.Write(p)
 }
 

-// Sync is a noop function that exists to satisfy the zapcore.WriteSyncer interface
+// Sync is a noop function that dataFile to satisfy the zapcore.WriteSyncer interface

 func (db *DebugBuffer) Sync() error {
        return nil
 }
 
 func (db *DebugBuffer) Sync() error {
        return nil
 }
 

-func (ui *UI) joinServer(addr, login, password string) error {
-       if err := ui.HLClient.JoinServer(addr, login, password); err != nil {
-               return errors.New(fmt.Sprintf("Error joining server: %v\n", err))
-       }
+func randomBanner() string {
+       rand.Seed(time.Now().UnixNano())

 
 

-       go func() {
-               err := ui.HLClient.ReadLoop()
-               if err != nil {
-                       ui.HLClient.Logger.Errorw("read error", "err", err)
-               }
-       }()
-       return nil
+       bannerFiles, _ := bannerDir.ReadDir("banners")
+       file, _ := bannerDir.ReadFile("banners/" + bannerFiles[rand.Intn(len(bannerFiles))].Name())
+
+       return fmt.Sprintf("\n\n\nWelcome to...\n\n[red::b]%s[-:-:-]\n\n", file)

 }
 
 }
 

-func (ui *UI) renderJoinServerForm(server, login, password, backPage string, save, defaultConnect bool) *tview.Flex {
-       joinServerForm := tview.NewForm()
-       joinServerForm.
-               AddInputField("Server", server, 0, nil, nil).
-               AddInputField("Login", login, 0, nil, nil).
-               AddPasswordField("Password", password, 0, '*', nil).
-               AddCheckbox("Save", save, func(checked bool) {
-                       // TODO: Implement bookmark saving
-               }).
-               AddButton("Cancel", func() {
-                       ui.Pages.SwitchToPage(backPage)
-               }).
-               AddButton("Connect", func() {
-                       err := ui.joinServer(
-                               joinServerForm.GetFormItem(0).(*tview.InputField).GetText(),
-                               joinServerForm.GetFormItem(1).(*tview.InputField).GetText(),
-                               joinServerForm.GetFormItem(2).(*tview.InputField).GetText(),
-                       )
-                       if err != nil {
-                               ui.HLClient.Logger.Errorw("login error", "err", err)
-                               loginErrModal := tview.NewModal().
-                                       AddButtons([]string{"Oh no"}).
-                                       SetText(err.Error()).
-                                       SetDoneFunc(func(buttonIndex int, buttonLabel string) {
-                                               ui.Pages.SwitchToPage(backPage)
-                                       })
-
-                               ui.Pages.AddPage("loginErr", loginErrModal, false, true)
-                       }
+type ClientTransaction struct {
+       Name    string
+       Handler func(*Client, *Transaction) ([]Transaction, error)
+}

 
 

-                       // Save checkbox
-                       if joinServerForm.GetFormItem(3).(*tview.Checkbox).IsChecked() {
-                               // TODO: implement bookmark saving
-                       }
-               })
+func (ch ClientTransaction) Handle(cc *Client, t *Transaction) ([]Transaction, error) {
+       return ch.Handler(cc, t)
+}

 
 

-       joinServerForm.Box.SetBorder(true).SetTitle("| Connect |")
-       joinServerForm.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-               if event.Key() == tcell.KeyEscape {
-                       ui.Pages.SwitchToPage(backPage)
+type ClientTHandler interface {
+       Handle(*Client, *Transaction) ([]Transaction, error)
+}
+
+var clientHandlers = map[uint16]ClientHandler{
+       TranChatMsg:          handleClientChatMsg,
+       TranLogin:            handleClientTranLogin,
+       TranShowAgreement:    handleClientTranShowAgreement,
+       TranUserAccess:       handleClientTranUserAccess,
+       TranGetUserNameList:  handleClientGetUserNameList,
+       TranNotifyChangeUser: handleNotifyChangeUser,
+       TranNotifyDeleteUser: handleNotifyDeleteUser,
+       TranGetMsgs:          handleGetMsgs,
+       TranGetFileNameList:  handleGetFileNameList,
+       TranServerMsg:        handleTranServerMsg,
+       TranKeepAlive: func(client *Client, transaction *Transaction) (t []Transaction, err error) {
+               return t, err
+       },
+}
+
+func handleTranServerMsg(c *Client, t *Transaction) (res []Transaction, err error) {
+       now := time.Now().Format(time.RFC850)
+
+       msg := strings.ReplaceAll(string(t.GetField(FieldData).Data), "\r", "\n")
+       msg += "\n\nAt " + now
+       title := fmt.Sprintf("| Private Message From:   %s |", t.GetField(FieldUserName).Data)
+
+       msgBox := tview.NewTextView().SetScrollable(true)
+       msgBox.SetText(msg).SetBackgroundColor(tcell.ColorDarkSlateBlue)
+       msgBox.SetTitle(title).SetBorder(true)
+       msgBox.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+               switch event.Key() {
+               case tcell.KeyEscape:
+                       c.UI.Pages.RemovePage("serverMsgModal" + now)

                }
                return event
        })
 
                }
                return event
        })
 

-       if defaultConnect {
-               joinServerForm.SetFocus(5)
-       }
-
-       joinServerPage := tview.NewFlex().
+       centeredFlex := tview.NewFlex().

                AddItem(nil, 0, 1, false).
                AddItem(nil, 0, 1, false).

-               AddItem(tview.NewFlex().
-                       SetDirection(tview.FlexRow).
+               AddItem(tview.NewFlex().SetDirection(tview.FlexRow).

                        AddItem(nil, 0, 1, false).
                        AddItem(nil, 0, 1, false).

-                       AddItem(joinServerForm, 14, 1, true).
-                       AddItem(nil, 0, 1, false), 40, 1, true).
+                       AddItem(msgBox, 0, 2, true).
+                       AddItem(nil, 0, 1, false), 0, 2, true).

                AddItem(nil, 0, 1, false)
 
                AddItem(nil, 0, 1, false)
 

-       return joinServerPage
-}
+       c.UI.Pages.AddPage("serverMsgModal"+now, centeredFlex, true, true)
+       c.UI.App.Draw() // TODO: errModal doesn't render without this.  wtf?

 
 

-func randomBanner() string {
-       rand.Seed(time.Now().UnixNano())
-
-       bannerFiles, _ := bannerDir.ReadDir("banners")
-       file, _ := bannerDir.ReadFile("banners/" + bannerFiles[rand.Intn(len(bannerFiles))].Name())
-
-       return fmt.Sprintf("\n\n\nWelcome to...\n\n[red::b]%s[-:-:-]\n\n", file)
+       return res, err

 }
 
 }
 

-func (ui *UI) renderServerUI() *tview.Flex {
-       commandList := tview.NewTextView().SetDynamicColors(true)
-       commandList.
-               SetText("[yellow]^n[-::]: Read News   [yellow]^p[-::]: Post News\n[yellow]^l[-::]: View Logs\n").
-               SetBorder(true).
-               SetTitle("Keyboard Shortcuts")
-
-       modal := tview.NewModal().
-               SetText("Disconnect from the server?").
-               AddButtons([]string{"Cancel", "Exit"}).
-               SetFocus(1)
-       modal.SetDoneFunc(func(buttonIndex int, buttonLabel string) {
-               if buttonIndex == 1 {
-                       _ = ui.HLClient.Disconnect()
-                       ui.Pages.SwitchToPage("home")
-               } else {
-                       ui.Pages.HidePage("modal")
-               }
-       })
+func (c *Client) showErrMsg(msg string) {
+       t := time.Now().Format(time.RFC850)

 
 

-       serverUI := tview.NewFlex().
-               AddItem(tview.NewFlex().
-                       SetDirection(tview.FlexRow).
-                       AddItem(commandList, 4, 0, false).
-                       AddItem(ui.chatBox, 0, 8, false).
-                       AddItem(ui.chatInput, 3, 0, true), 0, 1, true).
-               AddItem(ui.userList, 25, 1, false)
-       serverUI.SetBorder(true).SetTitle("| Mobius - Connected to " + "TODO" + " |").SetTitleAlign(tview.AlignLeft)
-       serverUI.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-               if event.Key() == tcell.KeyEscape {
-                       ui.Pages.AddPage("modal", modal, false, true)
-               }
+       title := "| Error |"

 
 

-               // Show News
-               if event.Key() == tcell.KeyCtrlN {
-                       if err := ui.HLClient.Send(*NewTransaction(tranGetMsgs, nil)); err != nil {
-                               ui.HLClient.Logger.Errorw("err", "err", err)
-                       }
+       msgBox := tview.NewTextView().SetScrollable(true)
+       msgBox.SetText(msg).SetBackgroundColor(tcell.ColorDarkRed)
+       msgBox.SetTitle(title).SetBorder(true)
+       msgBox.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+               switch event.Key() {
+               case tcell.KeyEscape:
+                       c.UI.Pages.RemovePage("serverMsgModal" + t)

                }
                }

+               return event
+       })

 
 

-               // Post news
-               if event.Key() == tcell.KeyCtrlP {
-
-                       newsFlex := tview.NewFlex()
-
-                       newsPostTextArea := tview.NewTextView()
-                       newsPostTextArea.SetBackgroundColor(tcell.ColorDimGray)
-                       newsPostTextArea.SetChangedFunc(func() {
-                               ui.App.Draw() // TODO: docs say this is bad but it's the only way to show content during initial render??
-                       })
-                       //newsPostTextArea.SetBorderPadding(0, 0, 1, 1)
-
-                       newsPostForm := tview.NewForm().
-                               SetButtonsAlign(tview.AlignRight).
-                               AddButton("Post", nil)
-                       newsPostForm.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-                               switch event.Key() {
-                               case tcell.KeyTab:
-                                       ui.App.SetFocus(newsPostTextArea)
-                               case tcell.KeyEnter:
-                                       newsText := strings.ReplaceAll(newsPostTextArea.GetText(true), "\n", "\r")
-                                       err := ui.HLClient.Send(
-                                               *NewTransaction(tranOldPostNews, nil,
-                                                       NewField(fieldData, []byte(newsText)),
-                                               ),
-                                       )
-                                       if err != nil {
-                                               ui.HLClient.Logger.Errorw("Error posting news", "err", err)
-                                               // TODO: display errModal to user
-                                       }
-                                       //newsInput.SetText("") // clear the input field after chat send
-                                       ui.Pages.RemovePage("newsInput")
-                               }
+       centeredFlex := tview.NewFlex().
+               AddItem(nil, 0, 1, false).
+               AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
+                       AddItem(nil, 0, 1, false).
+                       AddItem(msgBox, 0, 2, true).
+                       AddItem(nil, 0, 1, false), 0, 2, true).
+               AddItem(nil, 0, 1, false)

 
 

-                               return event
-                       })
-
-                       newsFlex.
-                               SetDirection(tview.FlexRow).
-                               SetBorder(true).
-                               SetTitle("News Post")
-
-                       newsPostTextArea.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-                               ui.HLClient.Logger.Infow("key", "key", event.Key(), "rune", event.Rune())
-                               switch event.Key() {
-                               case tcell.KeyEscape:
-                                       ui.Pages.RemovePage("newsInput")
-                               case tcell.KeyTab:
-                                       ui.App.SetFocus(newsPostForm)
-                               case tcell.KeyEnter:
-                                       fmt.Fprintf(newsPostTextArea, "\n")
-                               default:
-                                       switch event.Rune() {
-                                       case 127: // backspace
-                                               curTxt := newsPostTextArea.GetText(true)
-                                               if len(curTxt) > 0 {
-                                                       curTxt = curTxt[:len(curTxt)-1]
-                                                       newsPostTextArea.SetText(curTxt)
-                                               }
-                                       default:
-                                               fmt.Fprintf(newsPostTextArea, string(event.Rune()))
-                                       }
-                               }
+       c.UI.Pages.AddPage("serverMsgModal"+t, centeredFlex, true, true)
+       c.UI.App.Draw() // TODO: errModal doesn't render without this.  wtf?
+}

 
 

-                               return event
-                       })
-
-                       newsFlex.AddItem(newsPostTextArea, 10, 0, true)
-                       newsFlex.AddItem(newsPostForm, 3, 0, false)
-
-                       newsPostPage := tview.NewFlex().
-                               AddItem(nil, 0, 1, false).
-                               AddItem(tview.NewFlex().
-                                       SetDirection(tview.FlexRow).
-                                       AddItem(nil, 0, 1, false).
-                                       AddItem(newsFlex, 15, 1, true).
-                                       //AddItem(newsPostForm, 3, 0, false).
-                                       AddItem(nil, 0, 1, false), 40, 1, false).
-                               AddItem(nil, 0, 1, false)
-
-                       ui.Pages.AddPage("newsInput", newsPostPage, true, true)
-                       ui.App.SetFocus(newsPostTextArea)
-               }
+func handleGetFileNameList(c *Client, t *Transaction) (res []Transaction, err error) {
+       if t.IsError() {
+               c.showErrMsg(string(t.GetField(FieldError).Data))
+               c.Logger.Infof("Error: %s", t.GetField(FieldError).Data)
+               return res, err
+       }

 
 

-               return event
-       })
-       return serverUI
-}
+       fTree := tview.NewTreeView().SetTopLevel(1)
+       root := tview.NewTreeNode("Root")
+       fTree.SetRoot(root).SetCurrentNode(root)
+       fTree.SetBorder(true).SetTitle("| Files |")
+       fTree.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+               switch event.Key() {
+               case tcell.KeyEscape:
+                       c.UI.Pages.RemovePage("files")
+                       c.filePath = []string{}
+               case tcell.KeyEnter:
+                       selectedNode := fTree.GetCurrentNode()

 
 

-func (ui *UI) Start() {
-       home := tview.NewFlex().SetDirection(tview.FlexRow)
-       home.Box.SetBorder(true).SetTitle("| Mobius v" + VERSION + " |").SetTitleAlign(tview.AlignLeft)
-       mainMenu := tview.NewList()
+                       if selectedNode.GetText() == "<- Back" {
+                               c.filePath = c.filePath[:len(c.filePath)-1]
+                               f := NewField(FieldFilePath, EncodeFilePath(strings.Join(c.filePath, "/")))

 
 

-       bannerItem := tview.NewTextView().
-               SetText(randomBanner()).
-               SetDynamicColors(true).
-               SetTextAlign(tview.AlignCenter)
+                               if err := c.UI.HLClient.Send(*NewTransaction(TranGetFileNameList, nil, f)); err != nil {
+                                       c.UI.HLClient.Logger.Errorw("err", "err", err)
+                               }
+                               return event
+                       }

 
 

-       home.AddItem(
-               tview.NewFlex().AddItem(bannerItem, 0, 1, false),
-               14, 1, false)
-       home.AddItem(tview.NewFlex().
-               AddItem(nil, 0, 1, false).
-               AddItem(mainMenu, 0, 1, true).
-               AddItem(nil, 0, 1, false),
-               0, 1, true,
-       )
+                       entry := selectedNode.GetReference().(*FileNameWithInfo)

 
 

-       mainMenu.AddItem("Join Server", "", 'j', func() {
-               joinServerPage := ui.renderJoinServerForm("", GuestAccount, "", "home", false, false)
-               ui.Pages.AddPage("joinServer", joinServerPage, true, true)
-       }).
-               AddItem("Bookmarks", "", 'b', func() {
-                       ui.Pages.AddAndSwitchToPage("bookmarks", ui.showBookmarks(), true)
-               }).
-               AddItem("Browse Tracker", "", 't', func() {
-                       ui.trackerList = ui.getTrackerList()
-                       ui.Pages.AddAndSwitchToPage("trackerList", ui.trackerList, true)
-               }).
-               AddItem("Settings", "", 's', func() {
-                       ui.Pages.AddPage("settings", ui.renderSettingsForm(), true, true)
-               }).
-               AddItem("Quit", "", 'q', func() {
-                       ui.App.Stop()
-               })
+                       if bytes.Equal(entry.Type[:], []byte("fldr")) {
+                               c.Logger.Infow("get new directory listing", "name", string(entry.name))

 
 

-       ui.Pages.AddPage("home", home, true, true)
+                               c.filePath = append(c.filePath, string(entry.name))
+                               f := NewField(FieldFilePath, EncodeFilePath(strings.Join(c.filePath, "/")))

 
 

-       // App level input capture
-       ui.App.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
-               if event.Key() == tcell.KeyCtrlC {
-                       ui.HLClient.Logger.Infow("Exiting")
-                       ui.App.Stop()
-                       os.Exit(0)
-               }
-               // Show Logs
-               if event.Key() == tcell.KeyCtrlL {
-                       ui.HLClient.DebugBuf.TextView.ScrollToEnd()
-                       ui.HLClient.DebugBuf.TextView.SetBorder(true).SetTitle("Logs")
-                       ui.HLClient.DebugBuf.TextView.SetDoneFunc(func(key tcell.Key) {
-                               if key == tcell.KeyEscape {
-                                       ui.Pages.RemovePage("logs")
+                               if err := c.UI.HLClient.Send(*NewTransaction(TranGetFileNameList, nil, f)); err != nil {
+                                       c.UI.HLClient.Logger.Errorw("err", "err", err)

                                }
                                }

-                       })
-
-                       ui.Pages.AddAndSwitchToPage("logs", ui.HLClient.DebugBuf.TextView, true)
+                       } else {
+                               // TODO: initiate file download
+                               c.Logger.Infow("download file", "name", string(entry.name))
+                       }

                }
                }

+

                return event
        })
 
                return event
        })
 

-       if err := ui.App.SetRoot(ui.Pages, true).SetFocus(ui.Pages).Run(); err != nil {
-               ui.App.Stop()
-               os.Exit(1)
-       }
-}
-
-func NewClient(cfgPath string, logger *zap.SugaredLogger) *Client {
-       c := &Client{
-               cfgPath:     cfgPath,
-               Logger:      logger,
-               activeTasks: make(map[uint32]*Transaction),
-               Handlers:    clientHandlers,
-       }
-       c.UI = NewUI(c)
-
-       prefs, err := readConfig(cfgPath)
-       if err != nil {
-               fmt.Printf("unable to read config file")
-               logger.Fatal("unable to read config file", "path", cfgPath)
+       if len(c.filePath) > 0 {
+               node := tview.NewTreeNode("<- Back")
+               root.AddChild(node)

        }
        }

-       c.pref = prefs

 
 

-       return c
-}
-
-type clientTransaction struct {
-       Name    string
-       Handler func(*Client, *Transaction) ([]Transaction, error)
-}
+       for _, f := range t.Fields {
+               var fn FileNameWithInfo
+               err = fn.UnmarshalBinary(f.Data)
+               if err != nil {
+                       return nil, nil
+               }

 
 

-func (ch clientTransaction) Handle(cc *Client, t *Transaction) ([]Transaction, error) {
-       return ch.Handler(cc, t)
-}
+               if bytes.Equal(fn.Type[:], []byte("fldr")) {
+                       node := tview.NewTreeNode(fmt.Sprintf("[blue::]📁 %s[-:-:-]", fn.name))
+                       node.SetReference(&fn)
+                       root.AddChild(node)
+               } else {
+                       size := binary.BigEndian.Uint32(fn.FileSize[:]) / 1024

 
 

-type clientTHandler interface {
-       Handle(*Client, *Transaction) ([]Transaction, error)
-}
+                       node := tview.NewTreeNode(fmt.Sprintf("   %-40s %10v KB", fn.name, size))
+                       node.SetReference(&fn)
+                       root.AddChild(node)
+               }
+       }

 
 

-type mockClientHandler struct {
-       mock.Mock
-}
+       centerFlex := tview.NewFlex().
+               AddItem(nil, 0, 1, false).
+               AddItem(tview.NewFlex().
+                       SetDirection(tview.FlexRow).
+                       AddItem(nil, 0, 1, false).
+                       AddItem(fTree, 20, 1, true).
+                       AddItem(nil, 0, 1, false), 60, 1, true).
+               AddItem(nil, 0, 1, false)

 
 

-func (mh *mockClientHandler) Handle(cc *Client, t *Transaction) ([]Transaction, error) {
-       args := mh.Called(cc, t)
-       return args.Get(0).([]Transaction), args.Error(1)
-}
+       c.UI.Pages.AddPage("files", centerFlex, true, true)
+       c.UI.App.Draw()

 
 

-var clientHandlers = map[uint16]clientTHandler{
-       // Server initiated
-       tranChatMsg: clientTransaction{
-               Name:    "tranChatMsg",
-               Handler: handleClientChatMsg,
-       },
-       tranLogin: clientTransaction{
-               Name:    "tranLogin",
-               Handler: handleClientTranLogin,
-       },
-       tranShowAgreement: clientTransaction{
-               Name:    "tranShowAgreement",
-               Handler: handleClientTranShowAgreement,
-       },
-       tranUserAccess: clientTransaction{
-               Name:    "tranUserAccess",
-               Handler: handleClientTranUserAccess,
-       },
-       tranGetUserNameList: clientTransaction{
-               Name:    "tranGetUserNameList",
-               Handler: handleClientGetUserNameList,
-       },
-       tranNotifyChangeUser: clientTransaction{
-               Name:    "tranNotifyChangeUser",
-               Handler: handleNotifyChangeUser,
-       },
-       tranNotifyDeleteUser: clientTransaction{
-               Name:    "tranNotifyDeleteUser",
-               Handler: handleNotifyDeleteUser,
-       },
-       tranGetMsgs: clientTransaction{
-               Name:    "tranNotifyDeleteUser",
-               Handler: handleGetMsgs,
-       },
+       return res, err

 }
 
 func handleGetMsgs(c *Client, t *Transaction) (res []Transaction, err error) {
 }
 
 func handleGetMsgs(c *Client, t *Transaction) (res []Transaction, err error) {

-       newsText := string(t.GetField(fieldData).Data)
+       newsText := string(t.GetField(FieldData).Data)

        newsText = strings.ReplaceAll(newsText, "\r", "\n")
 
        newsTextView := tview.NewTextView().
                SetText(newsText).
                SetDoneFunc(func(key tcell.Key) {
        newsText = strings.ReplaceAll(newsText, "\r", "\n")
 
        newsTextView := tview.NewTextView().
                SetText(newsText).
                SetDoneFunc(func(key tcell.Key) {

-                       c.UI.Pages.SwitchToPage("serverUI")
+                       c.UI.Pages.SwitchToPage(serverUIPage)

                        c.UI.App.SetFocus(c.UI.chatInput)
                })
        newsTextView.SetBorder(true).SetTitle("News")
 
        c.UI.Pages.AddPage("news", newsTextView, true, true)
                        c.UI.App.SetFocus(c.UI.chatInput)
                })
        newsTextView.SetBorder(true).SetTitle("News")
 
        c.UI.Pages.AddPage("news", newsTextView, true, true)

-       c.UI.Pages.SwitchToPage("news")
-       c.UI.App.SetFocus(newsTextView)
-
+       // c.UI.Pages.SwitchToPage("news")
+       // c.UI.App.SetFocus(newsTextView)

        c.UI.App.Draw()
 
        return res, err
        c.UI.App.Draw()
 
        return res, err


@@ -655,10 +344,10 @@ func handleGetMsgs(c *Client, t *Transaction) (res []Transaction, err error) {
 
 func handleNotifyChangeUser(c *Client, t *Transaction) (res []Transaction, err error) {
        newUser := User{
 
 func handleNotifyChangeUser(c *Client, t *Transaction) (res []Transaction, err error) {
        newUser := User{

-               ID:    t.GetField(fieldUserID).Data,
-               Name:  string(t.GetField(fieldUserName).Data),
-               Icon:  t.GetField(fieldUserIconID).Data,
-               Flags: t.GetField(fieldUserFlags).Data,
+               ID:    t.GetField(FieldUserID).Data,
+               Name:  string(t.GetField(FieldUserName).Data),
+               Icon:  t.GetField(FieldUserIconID).Data,
+               Flags: t.GetField(FieldUserFlags).Data,

        }
 
        // Possible cases:
        }
 
        // Possible cases:


@@ -693,7 +382,7 @@ func handleNotifyChangeUser(c *Client, t *Transaction) (res []Transaction, err e
 }
 
 func handleNotifyDeleteUser(c *Client, t *Transaction) (res []Transaction, err error) {
 }
 
 func handleNotifyDeleteUser(c *Client, t *Transaction) (res []Transaction, err error) {

-       exitUser := t.GetField(fieldUserID).Data
+       exitUser := t.GetField(FieldUserID).Data

 
        var newUserList []User
        for _, u := range c.UserList {
 
        var newUserList []User
        for _, u := range c.UserList {


@@ -709,59 +398,11 @@ func handleNotifyDeleteUser(c *Client, t *Transaction) (res []Transaction, err e
        return res, err
 }
 
        return res, err
 }
 

-const readBuffSize = 1024000 // 1KB - TODO: what should this be?
-
-func (c *Client) ReadLoop() error {
-       tranBuff := make([]byte, 0)
-       tReadlen := 0
-       // Infinite loop where take action on incoming client requests until the connection is closed
-       for {
-               buf := make([]byte, readBuffSize)
-               tranBuff = tranBuff[tReadlen:]
-
-               readLen, err := c.Connection.Read(buf)
-               if err != nil {
-                       return err
-               }
-               tranBuff = append(tranBuff, buf[:readLen]...)
-
-               // We may have read multiple requests worth of bytes from Connection.Read.  readTransactions splits them
-               // into a slice of transactions
-               var transactions []Transaction
-               if transactions, tReadlen, err = readTransactions(tranBuff); err != nil {
-                       c.Logger.Errorw("Error handling transaction", "err", err)
-               }
-
-               // iterate over all of the transactions that were parsed from the byte slice and handle them
-               for _, t := range transactions {
-                       if err := c.HandleTransaction(&t); err != nil {
-                               c.Logger.Errorw("Error handling transaction", "err", err)
-                       }
-               }
-       }
-}
-
-func (c *Client) GetTransactions() error {
-       tranBuff := make([]byte, 0)
-       tReadlen := 0
-
-       buf := make([]byte, readBuffSize)
-       tranBuff = tranBuff[tReadlen:]
-
-       readLen, err := c.Connection.Read(buf)
-       if err != nil {
-               return err
-       }
-       tranBuff = append(tranBuff, buf[:readLen]...)
-
-       return nil
-}
-

 func handleClientGetUserNameList(c *Client, t *Transaction) (res []Transaction, err error) {
        var users []User
        for _, field := range t.Fields {
 func handleClientGetUserNameList(c *Client, t *Transaction) (res []Transaction, err error) {
        var users []User
        for _, field := range t.Fields {

-               // The Hotline protocol docs say that ClientGetUserNameList should only return fieldUsernameWithInfo (300)
-               // fields, but shxd sneaks in fieldChatSubject (115) so it's important to filter explicitly for the expected
+               // The Hotline protocol docs say that ClientGetUserNameList should only return FieldUsernameWithInfo (300)
+               // fields, but shxd sneaks in FieldChatSubject (115) so it's important to filter explicitly for the expected

                // field type.  Probably a good idea to do everywhere.
                if bytes.Equal(field.ID, []byte{0x01, 0x2c}) {
                        u, err := ReadUser(field.Data)
                // field type.  Probably a good idea to do everywhere.
                if bytes.Equal(field.ID, []byte{0x01, 0x2c}) {
                        u, err := ReadUser(field.Data)


@@ -782,45 +423,49 @@ func (c *Client) renderUserList() {
        c.UI.userList.Clear()
        for _, u := range c.UserList {
                flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(u.Flags)))
        c.UI.userList.Clear()
        for _, u := range c.UserList {
                flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(u.Flags)))

-               if flagBitmap.Bit(userFlagAdmin) == 1 {
+               if flagBitmap.Bit(UserFlagAdmin) == 1 {

                        _, _ = fmt.Fprintf(c.UI.userList, "[red::b]%s[-:-:-]\n", u.Name)
                } else {
                        _, _ = fmt.Fprintf(c.UI.userList, "%s\n", u.Name)
                }
                        _, _ = fmt.Fprintf(c.UI.userList, "[red::b]%s[-:-:-]\n", u.Name)
                } else {
                        _, _ = fmt.Fprintf(c.UI.userList, "%s\n", u.Name)
                }

+               // TODO: fade if user is away

        }
 }
 
 func handleClientChatMsg(c *Client, t *Transaction) (res []Transaction, err error) {
        }
 }
 
 func handleClientChatMsg(c *Client, t *Transaction) (res []Transaction, err error) {

-       _, _ = fmt.Fprintf(c.UI.chatBox, "%s \n", t.GetField(fieldData).Data)
+       if c.Pref.EnableBell {
+               fmt.Println("\a")
+       }
+
+       _, _ = fmt.Fprintf(c.UI.chatBox, "%s \n", t.GetField(FieldData).Data)

 
        return res, err
 }
 
 func handleClientTranUserAccess(c *Client, t *Transaction) (res []Transaction, err error) {
 
        return res, err
 }
 
 func handleClientTranUserAccess(c *Client, t *Transaction) (res []Transaction, err error) {

-       c.UserAccess = t.GetField(fieldUserAccess).Data
+       c.UserAccess = t.GetField(FieldUserAccess).Data

 
        return res, err
 }
 
 func handleClientTranShowAgreement(c *Client, t *Transaction) (res []Transaction, err error) {
 
        return res, err
 }
 
 func handleClientTranShowAgreement(c *Client, t *Transaction) (res []Transaction, err error) {

-       agreement := string(t.GetField(fieldData).Data)
+       agreement := string(t.GetField(FieldData).Data)

        agreement = strings.ReplaceAll(agreement, "\r", "\n")
 
        agreement = strings.ReplaceAll(agreement, "\r", "\n")
 

-       c.UI.agreeModal = tview.NewModal().
+       agreeModal := tview.NewModal().

                SetText(agreement).
                AddButtons([]string{"Agree", "Disagree"}).
                SetDoneFunc(func(buttonIndex int, buttonLabel string) {
                        if buttonIndex == 0 {
                                res = append(res,
                                        *NewTransaction(
                SetText(agreement).
                AddButtons([]string{"Agree", "Disagree"}).
                SetDoneFunc(func(buttonIndex int, buttonLabel string) {
                        if buttonIndex == 0 {
                                res = append(res,
                                        *NewTransaction(

-                                               tranAgreed, nil,
-                                               NewField(fieldUserName, []byte(c.pref.Username)),
-                                               NewField(fieldUserIconID, c.pref.IconBytes()),
-                                               NewField(fieldUserFlags, []byte{0x00, 0x00}),
-                                               NewField(fieldOptions, []byte{0x00, 0x00}),
+                                               TranAgreed, nil,
+                                               NewField(FieldUserName, []byte(c.Pref.Username)),
+                                               NewField(FieldUserIconID, c.Pref.IconBytes()),
+                                               NewField(FieldUserFlags, []byte{0x00, 0x00}),
+                                               NewField(FieldOptions, []byte{0x00, 0x00}),

                                        ),
                                )
                                        ),
                                )

-                               c.Agreed = true

                                c.UI.Pages.HidePage("agreement")
                                c.UI.App.SetFocus(c.UI.chatInput)
                        } else {
                                c.UI.Pages.HidePage("agreement")
                                c.UI.App.SetFocus(c.UI.chatInput)
                        } else {


@@ -830,18 +475,14 @@ func handleClientTranShowAgreement(c *Client, t *Transaction) (res []Transaction
                },
                )
 
                },
                )
 

-       c.Logger.Debug("show agreement page")
-       c.UI.Pages.AddPage("agreement", c.UI.agreeModal, false, true)
-
-       c.UI.Pages.ShowPage("agreement ")
+       c.UI.Pages.AddPage("agreement", agreeModal, false, true)

 
 

-       c.UI.App.Draw()

        return res, err
 }
 
 func handleClientTranLogin(c *Client, t *Transaction) (res []Transaction, err error) {
        if !bytes.Equal(t.ErrorCode, []byte{0, 0, 0, 0}) {
        return res, err
 }
 
 func handleClientTranLogin(c *Client, t *Transaction) (res []Transaction, err error) {
        if !bytes.Equal(t.ErrorCode, []byte{0, 0, 0, 0}) {

-               errMsg := string(t.GetField(fieldError).Data)
+               errMsg := string(t.GetField(FieldError).Data)

                errModal := tview.NewModal()
                errModal.SetText(errMsg)
                errModal.AddButtons([]string{"Oh no"})
                errModal := tview.NewModal()
                errModal.SetText(errMsg)
                errModal.AddButtons([]string{"Oh no"})


@@ -853,22 +494,23 @@ func handleClientTranLogin(c *Client, t *Transaction) (res []Transaction, err er
 
                c.UI.App.Draw() // TODO: errModal doesn't render without this.  wtf?
 
 
                c.UI.App.Draw() // TODO: errModal doesn't render without this.  wtf?
 

-               c.Logger.Error(string(t.GetField(fieldError).Data))
-               return nil, errors.New("login error: " + string(t.GetField(fieldError).Data))
+               c.Logger.Error(string(t.GetField(FieldError).Data))
+               return nil, errors.New("login error: " + string(t.GetField(FieldError).Data))

        }
        }

-       c.UI.Pages.AddAndSwitchToPage("serverUI", c.UI.renderServerUI(), true)
+       c.UI.Pages.AddAndSwitchToPage(serverUIPage, c.UI.renderServerUI(), true)

        c.UI.App.SetFocus(c.UI.chatInput)
 
        c.UI.App.SetFocus(c.UI.chatInput)
 

-       if err := c.Send(*NewTransaction(tranGetUserNameList, nil)); err != nil {
+       if err := c.Send(*NewTransaction(TranGetUserNameList, nil)); err != nil {

                c.Logger.Errorw("err", "err", err)
        }
        return res, err
 }
 
 // JoinServer connects to a Hotline server and completes the login flow
                c.Logger.Errorw("err", "err", err)
        }
        return res, err
 }
 
 // JoinServer connects to a Hotline server and completes the login flow

-func (c *Client) JoinServer(address, login, passwd string) error {
+func (c *Client) Connect(address, login, passwd string) (err error) {

        // Establish TCP connection to server
        // Establish TCP connection to server

-       if err := c.connect(address); err != nil {
+       c.Connection, err = net.DialTimeout("tcp", address, 5*time.Second)
+       if err != nil {

                return err
        }
 
                return err
        }
 


@@ -877,22 +519,25 @@ func (c *Client) JoinServer(address, login, passwd string) error {
                return err
        }
 
                return err
        }
 

-       // Authenticate (send tranLogin 107)
+       // Authenticate (send TranLogin 107)

        if err := c.LogIn(login, passwd); err != nil {
                return err
        }
 
        if err := c.LogIn(login, passwd); err != nil {
                return err
        }
 

+       // start keepalive go routine
+       go func() { _ = c.keepalive() }()
+

        return nil
 }
 
        return nil
 }
 

-// connect establishes a connection with a Server by sending handshake sequence
-func (c *Client) connect(address string) error {
-       var err error
-       c.Connection, err = net.DialTimeout("tcp", address, 5*time.Second)
-       if err != nil {
-               return err
+const keepaliveInterval = 300 * time.Second
+
+func (c *Client) keepalive() error {
+       for {
+               time.Sleep(keepaliveInterval)
+               _ = c.Send(*NewTransaction(TranKeepAlive, nil))
+               c.Logger.Debugw("Sent keepalive ping")

        }
        }

-       return nil

 }
 
 var ClientHandshake = []byte{
 }
 
 var ClientHandshake = []byte{


@@ -908,10 +553,10 @@ var ServerHandshake = []byte{
 }
 
 func (c *Client) Handshake() error {
 }
 
 func (c *Client) Handshake() error {

-       //Protocol ID   4       ‘TRTP’      0x54 52 54 50
-       //Sub-protocol ID       4               User defined
-       //Version       2       1       Currently 1
-       //Sub-version   2               User defined
+       // Protocol ID  4       ‘TRTP’      0x54 52 54 50
+       // Sub-protocol ID      4               User defined
+       // Version      2       1       Currently 1
+       // Sub-version  2               User defined

        if _, err := c.Connection.Write(ClientHandshake); err != nil {
                return fmt.Errorf("handshake write err: %s", err)
        }
        if _, err := c.Connection.Write(ClientHandshake); err != nil {
                return fmt.Errorf("handshake write err: %s", err)
        }


@@ -922,42 +567,41 @@ func (c *Client) Handshake() error {
                return err
        }
 
                return err
        }
 

-       //spew.Dump(replyBuf)
-       if bytes.Compare(replyBuf, ServerHandshake) == 0 {
+       if bytes.Equal(replyBuf, ServerHandshake) {

                return nil
        }
                return nil
        }

-       // In the case of an error, client and server close the connection.

 
 

+       // In the case of an error, client and server close the connection.

        return fmt.Errorf("handshake response err: %s", err)
 }
 
 func (c *Client) LogIn(login string, password string) error {
        return c.Send(
                *NewTransaction(
        return fmt.Errorf("handshake response err: %s", err)
 }
 
 func (c *Client) LogIn(login string, password string) error {
        return c.Send(
                *NewTransaction(

-                       tranLogin, nil,
-                       NewField(fieldUserName, []byte(c.pref.Username)),
-                       NewField(fieldUserIconID, c.pref.IconBytes()),
-                       NewField(fieldUserLogin, []byte(NegatedUserString([]byte(login)))),
-                       NewField(fieldUserPassword, []byte(NegatedUserString([]byte(password)))),
-                       NewField(fieldVersion, []byte{0, 2}),
+                       TranLogin, nil,
+                       NewField(FieldUserName, []byte(c.Pref.Username)),
+                       NewField(FieldUserIconID, c.Pref.IconBytes()),
+                       NewField(FieldUserLogin, negateString([]byte(login))),
+                       NewField(FieldUserPassword, negateString([]byte(password))),

                ),
        )
 }
 
 func (c *Client) Send(t Transaction) error {
        requestNum := binary.BigEndian.Uint16(t.Type)
                ),
        )
 }
 
 func (c *Client) Send(t Transaction) error {
        requestNum := binary.BigEndian.Uint16(t.Type)

-       tID := binary.BigEndian.Uint32(t.ID)
-
-       //handler := TransactionHandlers[requestNum]

 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {
 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {

-               c.activeTasks[tID] = &t
+               c.activeTasks[binary.BigEndian.Uint32(t.ID)] = &t
+       }
+
+       b, err := t.MarshalBinary()
+       if err != nil {
+               return err

        }
 
        var n int
        }
 
        var n int

-       var err error
-       if n, err = c.Connection.Write(t.Payload()); err != nil {
+       if n, err = c.Connection.Write(b); err != nil {

                return err
        }
        c.Logger.Debugw("Sent Transaction",
                return err
        }
        c.Logger.Debugw("Sent Transaction",


@@ -976,21 +620,17 @@ func (c *Client) HandleTransaction(t *Transaction) error {
                t.Type = origT.Type
        }
 
                t.Type = origT.Type
        }
 

-       requestNum := binary.BigEndian.Uint16(t.Type)
-       c.Logger.Infow(
-               "Received Transaction",
-               "RequestType", requestNum,
-       )
-
-       if handler, ok := c.Handlers[requestNum]; ok {
-               outT, _ := handler.Handle(c, t)
+       if handler, ok := c.Handlers[binary.BigEndian.Uint16(t.Type)]; ok {
+               outT, _ := handler(c, t)

                for _, t := range outT {
                for _, t := range outT {

-                       c.Send(t)
+                       if err := c.Send(t); err != nil {
+                               return err
+                       }

                }
        } else {
                }
        } else {

-               c.Logger.Errorw(
+               c.Logger.Debugw(

                        "Unimplemented transaction type received",
                        "Unimplemented transaction type received",

-                       "RequestID", requestNum,
+                       "RequestID", t.Type,

                        "TransactionID", t.ID,
                )
        }
                        "TransactionID", t.ID,
                )
        }


@@ -998,19 +638,34 @@ func (c *Client) HandleTransaction(t *Transaction) error {
        return nil
 }
 
        return nil
 }
 

-func (c *Client) Connected() bool {
-       fmt.Printf("Agreed: %v UserAccess: %v\n", c.Agreed, c.UserAccess)
-       // c.Agreed == true &&
-       if c.UserAccess != nil {
-               return true
-       }
-       return false
+func (c *Client) Disconnect() error {
+       return c.Connection.Close()

 }
 
 }
 

-func (c *Client) Disconnect() error {
-       err := c.Connection.Close()
-       if err != nil {
-               return err
+func (c *Client) HandleTransactions() error {
+       // Create a new scanner for parsing incoming bytes into transaction tokens
+       scanner := bufio.NewScanner(c.Connection)
+       scanner.Split(transactionScanner)
+
+       // Scan for new transactions and handle them as they come in.
+       for scanner.Scan() {
+               // Make a new []byte slice and copy the scanner bytes to it.  This is critical to avoid a data race as the
+               // scanner re-uses the buffer for subsequent scans.
+               buf := make([]byte, len(scanner.Bytes()))
+               copy(buf, scanner.Bytes())
+
+               var t Transaction
+               _, err := t.Write(buf)
+               if err != nil {
+                       break
+               }
+               if err := c.HandleTransaction(&t); err != nil {
+                       c.Logger.Errorw("Error handling transaction", "err", err)
+               }
+       }
+
+       if scanner.Err() == nil {
+               return scanner.Err()

        }
        return nil
 }
        }
        return nil
 }