func messages(w http.ResponseWriter, r *http.Request) {
key := r.FormValue("key")
messages, err := store.GetUserMessages(key)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
res := &Response{
Success: true,
Data: &messages,
}
d, err := json.Marshal(res)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if r.FormValue("encrypt") == "1" {
// encrypt all response content so that only the owner of the key can see the messages!!
encryptedData, err := crypto.GPGEncrypt(serverKey, key, bytes.NewReader(d))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/octet-stream")
_, err = w.Write(encryptedData)
} else {
w.Header().Set("Content-Type", "application/json")
_, err = w.Write(d)
}
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func (this *App) send(c *cli.Context) {
if err := this.setup(c); err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
if this.user == nil {
panic(ErrNoUser)
}
var recipient *common.User
if len(c.Args()) == 0 {
fmt.Printf("Sending message to yourself...\n")
recipient = this.user
} else {
to := c.Args()[0]
recipient, _ = this.store.FindUserByKey(to)
if recipient == nil {
keys, err := crypto.GPGListPublicKeys(to)
if err == nil && len(keys) == 1 {
// add to store
recipient = &common.User{
Name: keys[0].Name,
Email: keys[0].Email,
Key: keys[0].PublicKey,
}
this.store.AddUser(recipient)
fmt.Printf("Sending message to %s <%s>...\n", recipient.Name, recipient.Email)
}
}
}
if recipient == nil {
fmt.Printf("No recipient found!\n")
return
}
fmt.Printf("Press any key to start recording...\n")
gopass.GetCh()
// create a temp file
fileName := path.Join(os.TempDir(), fmt.Sprintf("%s.aiff", uuid.NewUUID().String()))
// create a signal
sig := make(chan int)
// create a callback func
cb := func(samples int) {
maxSamples := int(float64(this.maxDuration/time.Second) * audio.DefaultSampleRate)
remain := time.Duration(float64(maxSamples-samples)/audio.DefaultSampleRate) * time.Second
fmt.Printf("\rRecording...%.1f seconds left", remain.Seconds())
}
// record
fmt.Printf("\rRecording...%.1f seconds left", this.maxDuration.Seconds())
options := audio.RecordOptions{
FilePath: fileName,
MaxDuration: this.maxDuration,
StopSignal: sig,
Callback: cb,
}
if err := audio.RecordAIFF(options); err != nil {
fmt.Printf("Error recording message! %s", err.Error())
return
}
// encrypt message
rd, err := os.Open(fileName)
if err != nil {
fmt.Printf("Error: %s", err.Error())
return
}
defer rd.Close()
fmt.Printf("\rRecorded.\nEncrypting message...\n")
content, err := crypto.GPGEncrypt(this.user.Key, recipient.Key, rd)
if err != nil {
fmt.Printf("Error encrypting message! %s", err.Error())
return
}
msg := &common.Message{
From: this.user,
To: recipient,
CreatedAt: time.Now(),
Content: content,
}
this.store.AddMessage(msg) // Store message before send
fmt.Printf("Sending...\n")
err = this.client.Send(msg)
if err != nil {
fmt.Printf("Error sending message! %s\n...will retry later.\n", err.Error())
}
fmt.Println("Done")
}