func saveAttachment(contact contactInfo, attachment io.Reader, name string, msg *textsecure.Message) (err error) {
var output *os.File
attachmentPath := contact.AttachmentDir
err = os.MkdirAll(attachmentPath, 0700)
if err != nil {
return
}
if name == "" {
output, err = ioutil.TempFile(attachmentPath, "attachment_")
} else {
outputPath := filepath.Join(attachmentPath, name)
output, err = os.OpenFile(outputPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL|os.O_TRUNC, 0600)
}
if err != nil {
return
}
defer output.Close()
io.Copy(output, attachment)
status.Log(syslog.LOG_NOTICE, "saved attachment from %s %s\n", contact.Name, contact.Number)
name = relativePath(output.Name())
updateHistory(contact, "["+name+"]", "<", msg.Timestamp())
return
}
func pretty(msg *textsecure.Message) string {
src := getName(msg.Source())
if msg.Group() != nil {
src = src + "[" + msg.Group().Name + "]"
}
return fmt.Sprintf("%s%s %s%s %s%s", yellow, timestamp(msg), red, src, green, msg.Message())
}
func messageHandler(msg *textsecure.Message) {
status.Log(syslog.LOG_NOTICE, "received message from %s\n", msg.Source())
go func() {
n := status.Notify(syslog.LOG_NOTICE, "received message from %s\n", msg.Source())
time.Sleep(30 * time.Second)
status.Remove(n)
}()
contact, err := getContact(msg.Source())
if err != nil {
status.Error(err)
return
}
if msg.Message() != "" {
updateHistory(contact, msg.Message(), "<", msg.Timestamp())
}
attachments := msg.Attachments()
attachmentPattern := regexp.MustCompile("\\[" + attachmentMsg + "(.*)\\]$")
m := attachmentPattern.FindStringSubmatch(msg.Message())
// assign random name by default, use name embedded in msg for
// attachment sent via INTERLOCK
name := ""
if len(attachments) == 1 && len(m) == 2 {
name = path.Base(m[1])
}
for _, a := range attachments {
err := saveAttachment(contact, a, name, msg)
if err != nil {
status.Error(err)
return
}
}
}
func timestamp(msg *textsecure.Message) string {
t := time.Unix(0, int64(msg.Timestamp())*1000000)
return t.Format(timeFormat)
}
func messageHandler(msg *textsecure.Message) {
if echo {
to := msg.Source()
if msg.Group() != nil {
to = msg.Group().Name
}
err := sendMessage(msg.Group() != nil, to, msg.Message())
if err != nil {
log.Println(err)
}
return
}
if msg.Message() != "" {
fmt.Printf("\r %s%s\n>", pretty(msg), blue)
}
for _, a := range msg.Attachments() {
handleAttachment(msg.Source(), a.R)
}
// if no peer was specified on the command line, start a conversation with the first one contacting us
if to == "" {
to = msg.Source()
isGroup := false
if msg.Group() != nil {
isGroup = true
to = msg.Group().Name
}
go conversationLoop(isGroup)
}
}
func timestamp(msg *textsecure.Message) string {
t := msg.Timestamp()
return t.Format(timeFormat)
}
func messageHandler(msg *textsecure.Message) {
var err error
f := ""
mt := ""
if len(msg.Attachments()) > 0 {
mt = msg.Attachments()[0].MimeType
f, err = saveAttachment(msg.Attachments()[0])
if err != nil {
log.Printf("Error saving %s\n", err.Error())
}
}
msgFlags := 0
text := msg.Message()
if msg.Flags() == textsecure.EndSessionFlag {
text = sessionReset
msgFlags = msgFlagResetSession
}
gr := msg.Group()
if gr != nil && gr.Flags != 0 {
_, ok := groups[gr.Hexid]
members := ""
if ok {
members = groups[gr.Hexid].Members
}
av := []byte{}
if gr.Avatar != nil {
av, err = ioutil.ReadAll(gr.Avatar)
if err != nil {
log.Println(err)
return
}
}
groups[gr.Hexid] = &GroupRecord{
GroupID: gr.Hexid,
Members: strings.Join(gr.Members, ","),
Name: gr.Name,
Avatar: av,
Active: true,
}
if ok {
updateGroup(groups[gr.Hexid])
} else {
saveGroup(groups[gr.Hexid])
}
if gr.Flags == textsecure.GroupUpdateFlag {
dm, _ := membersDiffAndUnion(members, strings.Join(gr.Members, ","))
text = groupUpdateMsg(dm, gr.Name)
msgFlags = msgFlagGroupUpdate
}
if gr.Flags == textsecure.GroupLeaveFlag {
text = telToName(msg.Source()) + " has left the group."
msgFlags = msgFlagGroupLeave
}
}
s := msg.Source()
if gr != nil {
s = gr.Hexid
}
session := sessionsModel.Get(s)
m := session.Add(text, msg.Source(), f, mt, false)
m.ReceivedAt = uint64(time.Now().UnixNano() / 1000000)
m.SentAt = msg.Timestamp()
m.HTime = humanizeTimestamp(m.SentAt)
qml.Changed(m, &m.HTime)
session.Timestamp = m.SentAt
session.When = m.HTime
qml.Changed(session, &session.When)
if gr != nil && gr.Flags == textsecure.GroupUpdateFlag {
session.Name = gr.Name
qml.Changed(session, &session.Name)
}
if msgFlags != 0 {
m.Flags = msgFlags
qml.Changed(m, &m.Flags)
}
saveMessage(m)
updateSession(session)
}
func recieveMessage(msg *ts.Message) {
if msg.Message() != "" {
//fmt.Printf("\r %s%s : %s%s%s\n>", red, getName(msg.Source()), green, msg.Message(), blue)
if msg.Source() == currentContact {
var b bytes.Buffer
t := time.Now()
if t.Hour() < 10 {
b.WriteString("0")
}
b.WriteString(strconv.Itoa(t.Hour()))
b.WriteString(":")
if t.Minute() < 10 {
b.WriteString("0")
}
b.WriteString(strconv.Itoa(t.Minute()))
b.WriteString(": ")
b.WriteString(msg.Message())
printToMsgWindow(b.String(), globalMsgWin, false)
insertMessage(msg.Source(), "You", []byte(msg.Message()), nil)
}
insertMessage(msg.Source(), "You", []byte(msg.Message()), nil)
}
for _, a := range msg.Attachments() {
handleAttachment(msg.Source(), a)
}
}