func sendMessageLoop(to, message string, group bool, att io.Reader, flags int) uint64 {
var err error
var ts uint64
for {
err = nil
if flags == msgFlagResetSession {
ts, err = textsecure.EndSession(to, "TERMINATE")
} else if flags == msgFlagGroupLeave {
err = textsecure.LeaveGroup(to)
} else if flags == msgFlagGroupUpdate {
_, err = textsecure.UpdateGroup(to, groups[to].Name, strings.Split(groups[to].Members, ","))
} else if att == nil {
if group {
ts, err = textsecure.SendGroupMessage(to, message)
} else {
ts, err = textsecure.SendMessage(to, message)
}
} else {
if group {
ts, err = textsecure.SendGroupAttachment(to, message, att)
} else {
ts, err = textsecure.SendAttachment(to, message, att)
}
}
if err == nil {
break
}
log.Println(err)
//If sending failed, try again after a while
time.Sleep(3 * time.Second)
}
return ts
}
func sendMessage(w http.ResponseWriter, r *http.Request) (res jsonObject) {
var attachmentPath string
var attachment *os.File
req, err := parseRequest(r)
if err != nil {
return errorResponse(err, "")
}
err = validateRequest(req, []string{"contact:s", "msg:s"})
if err != nil {
return errorResponse(err, "")
}
msg := req["msg"].(string)
contactPath, err := absolutePath(req["contact"].(string))
if err != nil {
return errorResponse(err, "")
}
contact, err := parseContact(contactPath)
if err != nil {
return errorResponse(err, "")
}
if a, ok := req["attachment"]; ok {
attachmentPath, err = absolutePath(a.(string))
if err != nil {
return errorResponse(err, "")
}
inKeyPath, private := detectKeyPath(attachmentPath)
if inKeyPath && private {
return errorResponse(errors.New("attaching private key(s) is not allowed"), "")
}
attachment, err = os.Open(attachmentPath)
if err != nil {
return errorResponse(err, "")
}
defer attachment.Close()
// append attachment name with INTERLOCK specific metadata format
msg = msg + " [" + attachmentMsg + path.Base(attachmentPath) + "]"
err = textsecure.SendAttachment(contact.Number, msg, attachment)
if err != nil {
return errorResponse(err, "")
}
err = updateHistory(contact, msg, ">", time.Now())
} else {
err = textsecure.SendMessage(contact.Number, msg)
if err != nil {
return errorResponse(err, "")
}
err = updateHistory(contact, msg, ">", time.Now())
}
if err != nil {
return errorResponse(err, "")
}
res = jsonObject{
"status": "OK",
"response": nil,
}
return
}
func main() {
flag.Parse()
log.SetFlags(0)
client := &textsecure.Client{
GetConfig: getConfig,
GetLocalContacts: getLocalContacts,
GetVerificationCode: getVerificationCode,
GetStoragePassword: getStoragePassword,
MessageHandler: messageHandler,
RegistrationDone: registrationDone,
}
err := textsecure.Setup(client)
if err != nil {
log.Fatal(err)
}
if !echo {
contacts, err := textsecure.GetRegisteredContacts()
if err != nil {
log.Printf("Could not get contacts: %s\n", err)
}
telToName = make(map[string]string)
for _, c := range contacts {
telToName[c.Tel] = c.Name
}
if newgroup != "" {
s := strings.Split(newgroup, ":")
textsecure.NewGroup(s[0], s[1:])
return
}
if leavegroup != "" {
textsecure.LeaveGroup(leavegroup)
return
}
// If "to" matches a contact name then get its phone number, otherwise assume "to" is a phone number
for _, c := range contacts {
if strings.EqualFold(c.Name, to) {
to = c.Tel
break
}
}
if to != "" {
// Terminate the session with the peer
if endsession {
textsecure.EndSession(to, "TERMINATE")
return
}
// Send attachment with optional message then exit
if attachment != "" {
f, err := os.Open(attachment)
if err != nil {
log.Fatal(err)
}
_, err = textsecure.SendAttachment(to, message, f)
if err != nil {
log.Fatal(err)
}
return
}
if stress > 0 {
c := make(chan int, stress)
for i := 0; i < stress; i++ {
go func(i int) {
sendMessage(false, to, fmt.Sprintf("Stress %d\n", i))
c <- i
}(i)
}
for i := 0; i < stress; i++ {
<-c
}
return
}
// Send a message then exit
if message != "" {
err := sendMessage(group, to, message)
if err != nil {
log.Fatal(err)
}
return
}
// Enter conversation mode
go conversationLoop(group)
}
}
err = textsecure.StartListening()
if err != nil {
log.Println(err)
}
}