diff --git a/client.go b/client.go index 701cc45..cb504da 100644 --- a/client.go +++ b/client.go @@ -20,7 +20,7 @@ import ( type Auth struct { Nick string - Key rsa.PublicKey + Key *rsa.PublicKey } func (a *Auth) Kind() string { @@ -85,6 +85,7 @@ func (c *Client) handleMessages() { // handle a message received from the server func (c *Client) handleMessage(m Envelope) error { + c.info("received response for message %d", m.Id) res, ok := c.outstanding[m.Id] if !ok { c.info("%v", m) @@ -160,9 +161,27 @@ func (c *Client) handleListNotes(raw json.RawMessage) error { } func (c *Client) handshake() error { - r := &Auth{Nick: c.nick, Key: c.key.PublicKey} + r := &Auth{Nick: c.nick, Key: &c.key.PublicKey} c.info("authenticating as %s", c.nick) - _, err := c.sendRequest(r) + promise, err := c.sendRequest(r) + if err != nil { + return err + } + res := <-promise + switch res.Kind { + case "error": + var e ErrorDoc + if err := json.Unmarshal(res.Body, &e); err != nil { + return fmt.Errorf("cannot read server error: %v", err) + } + c.err("server error: %v", e.Error()) + close(c.done) + case "bool": + c.info(string(res.Body)) + default: + c.err("i dunno what to do with this") + close(c.done) + } return err } diff --git a/db.go b/db.go index cda1e3f..a0ed997 100644 --- a/db.go +++ b/db.go @@ -91,7 +91,7 @@ func getUserDB(nick string, create bool) (*userdb, error) { } opts := &opt.Options{ - ErrorIfMissing: create, + ErrorIfMissing: !create, } path := fmt.Sprintf("./%s.db", nick) conn, err := leveldb.OpenFile(path, opts) diff --git a/error.go b/error.go new file mode 100644 index 0000000..7f4be1b --- /dev/null +++ b/error.go @@ -0,0 +1,13 @@ +package main + +import () + +type ErrorDoc string + +func (e ErrorDoc) Kind() string { + return "error" +} + +func (e ErrorDoc) Error() string { + return string(e) +} diff --git a/request.go b/request.go index 0e5f675..56554c2 100644 --- a/request.go +++ b/request.go @@ -8,9 +8,9 @@ import ( ) type Envelope struct { - Id int - Kind string - Body json.RawMessage + Id int `json:"id"` + Kind string `json:"kind"` + Body json.RawMessage `json:"body"` } type Bool bool diff --git a/server.go b/server.go index 4d5fe80..b230e8c 100644 --- a/server.go +++ b/server.go @@ -31,7 +31,7 @@ func stream(r io.Reader, c chan Envelope, e chan error, done chan interface{}) { type serverConnection struct { conn net.Conn nick string - key rsa.PublicKey + key *rsa.PublicKey db *userdb } @@ -68,9 +68,14 @@ func (s *serverConnection) handleAuthRequest(requestId int, body json.RawMessage if err := json.Unmarshal(body, &auth); err != nil { return fmt.Errorf("bad auth request: %v", err) } + if auth.Nick == "" { + return fmt.Errorf("empty username") + } s.nick = auth.Nick + if auth.Key == nil { + return fmt.Errorf("empty key") + } s.key = auth.Key - // s.sendMeta("hello, %s", auth.Nick) if err := s.openDB(); err != nil { return fmt.Errorf("failed to open user database: %v", err) } @@ -79,36 +84,29 @@ func (s *serverConnection) handleAuthRequest(requestId int, body json.RawMessage case leveldb.ErrNotFound: keybytes, err := json.Marshal(auth.Key) if err != nil { - error_log.Printf("motherfucking bullshit fuck shit fuck: %v", err) - break + return fmt.Errorf("cannot marshal auth key: %v", err) } if err := s.db.Put([]byte("public_key"), keybytes, nil); err != nil { - error_log.Printf("man fuck all this stupid key bullshit i hate it: %v", err) - break + return fmt.Errorf("cannot write public key to database: %v", err) } info_log.Printf("saved key for user %s", auth.Nick) case nil: var key rsa.PublicKey if err := json.Unmarshal(b, &key); err != nil { - error_log.Printf("ok no i can't even do this key unmarshal shit: %v", err) - break + return fmt.Errorf("cannot unmarshal auth key from request: %v", err) } if auth.Key.E != key.E { - error_log.Printf("that's totally the wrong key! hang up. just hang up.") - // todo: make there be a way to hang up lol - break + return fmt.Errorf("client presented wrong auth key") } if auth.Key.N.Cmp(key.N) != 0 { - error_log.Printf("that's totally the wrong key! hang up. just hang up.") - // todo: make there be a way to hang up lol - break + return fmt.Errorf("client presented wrong auth key") } - info_log.Printf("ok the key checks out.") default: - error_log.Printf("unable to get public key for user %s: %v", auth.Nick, err) + return fmt.Errorf("unable to read public key: %v", err) } info_log.Printf("%s", b) info_log.Printf("authenticated user %s", auth.Nick) + s.sendResponse(requestId, Bool(true)) return nil } @@ -145,14 +143,11 @@ func (s *serverConnection) handleGetNoteRequest(requestId int, body json.RawMess if err != nil { return fmt.Errorf("couldn't retrieve note: %v", err) } - raw, err := json.Marshal(&Envelope{Kind: "note", Body: b}) - if err != nil { - return fmt.Errorf("couldn't send note back to client: %v", err) + var note EncryptedNote + if err := json.Unmarshal(b, ¬e); err != nil { + return fmt.Errorf("couldn't unmarshal note: %v", err) } - if _, err := s.conn.Write(raw); err != nil { - return fmt.Errorf("couldn't send note back to client: %v", err) - } - return nil + return s.sendResponse(requestId, note) } func (s *serverConnection) handleListNotesRequest(requestId int, body json.RawMessage) error { @@ -307,6 +302,7 @@ func (s *serverConnection) run() { case request := <-requests: if err := s.handleRequest(request); err != nil { error_log.Printf("client error: %v", err) + s.sendResponse(request.Id, ErrorDoc(err.Error())) } case err := <-errors: error_log.Printf("connection error: %v", err)