Esempio n. 1
0
func (e *Email) DeleteMany(uids []uint32) (err error) {
	seqSet := new(imap.SeqSet)
	for i := 0; i < len(uids); i++ {
		seqSet.AddNum(uids[i])
	}

	if err != nil {
		return err
	}
	flags := imap.NewFlagSet(`\Deleted`, `\Seen`)

	cmd, err := imap.Wait(e.conn.UIDStore(seqSet, "+FLAGS", flags))
	fmt.Println(cmd)

	if err != nil {
		return err
	}

	cmd, err = imap.Wait(e.conn.Expunge(nil))
	fmt.Println(cmd)

	if err != nil {
		return err
	}

	cmd, err = imap.Wait(e.conn.Close(true))
	fmt.Println(cmd)

	if err != nil {
		return err
	}

	return nil
}
Esempio n. 2
0
func fetchMessage(c *imap.Client, id uint32) {
	seq_set, err := imap.NewSeqSet(fmt.Sprintf("%d", id))

	if err != nil {
		panic(err)
	}

	cmd, err := imap.Wait(c.Fetch(seq_set, "ALL"))

	if err != nil {
		panic(err)
	}

	res, err := cmd.Result(0)

	if err != nil {
		panic(err)
	}

	//fmt.Println(reflect.TypeOf(cmd.Data[0].Fields[2]))
	fmt.Println(cmd.Data[0].Fields[2])

	fmt.Println(res.MessageInfo())

}
Esempio n. 3
0
func NewEmail(server string, user string, pw string, user_id int) (e *Email) {
	e = new(Email)

	e.User_Id = user_id

	var err error

	e.conn, err = e.login(server, user, pw)
	if err != nil {
		panic(err)
	}

	_, err = imap.Wait(e.conn.Select("INBOX", false))
	if err != nil {
		panic(err)
	}

	return e
}
Esempio n. 4
0
func main() {
	var (
		server string
		user   string
		pw     string
	)

	flag.StringVar(&server, "server", "", "IMAP server hostname")
	flag.StringVar(&user, "user", "", "IMAP username")
	flag.StringVar(&pw, "pw", "", "IMAP pw")
	flag.Parse()

	c, err := login(server, user, pw)

	if err != nil {
		panic(err)
	}

	_, err = imap.Wait(c.Select("INBOX", true))

	if err != nil {
		panic(err)
	}

	ids := fetchIds(c)

	for _, id := range ids {
		fetchMessage(c, id)
	}

	/*
	   res, err := cmd.Result(0)
	   fmt.Println(res.String())
	*/
	/*
	   res, err := cmd.Result(0)
	   fmt.Println(res.String())

	   for row := range(res)
	*/

}
Esempio n. 5
0
func (e *Email) getCountsOneLoop(minUid uint32, edw EmailDataWriter) (lastUid uint32, err error) {
	seqSet, err := imap.NewSeqSet(fmt.Sprintf("%d:*", minUid))

	if err != nil {
		return 0, err
	}

	cmd, err := imap.Wait(e.conn.UIDFetch(seqSet, "ALL"))

	if err != nil {
		return 0, err
	}
	for _, resp := range cmd.Data {
		ed, _ := e.ParseFetchResp(resp)
		edw.WriteEmailData(ed)
		lastUid = ed.Uid
	}

	return lastUid, nil
}
Esempio n. 6
0
func fetchIds(c *imap.Client) (ids []uint32) {
	seq_set, err := imap.NewSeqSet("4500:*")

	if err != nil {
		panic(err)
	}

	cmd, err := imap.Wait(c.Fetch(seq_set, "FLAGS"))

	if err != nil {
		panic(err)
	}

	for _, row := range cmd.Data {

		v, ok := row.Fields[0].(uint32)
		if ok {
			ids = append(ids, v)
		}
	}

	return ids
}
Esempio n. 7
0
func ExampleClient() {
	//
	// Note: most of error handling code is omitted for brevity
	//
	var (
		c   *imap.Client
		cmd *imap.Command
		rsp *imap.Response
	)

	// Connect to the server
	c, _ = imap.Dial("imap.example.com")

	// Remember to log out and close the connection when finished
	defer c.Logout(30 * time.Second)

	// Print server greeting (first response in the unilateral server data queue)
	fmt.Println("Server says hello:", c.Data[0].Info)
	c.Data = nil

	// Enable encryption, if supported by the server
	if c.Caps["STARTTLS"] {
		c.StartTLS(nil)
	}

	// Authenticate
	if c.State() == imap.Login {
		c.Login("*****@*****.**", "mysupersecretpassword")
	}

	// List all top-level mailboxes, wait for the command to finish
	cmd, _ = imap.Wait(c.List("", "%"))

	// Print mailbox information
	fmt.Println("\nTop-level mailboxes:")
	for _, rsp = range cmd.Data {
		fmt.Println("|--", rsp.MailboxInfo())
	}

	// Check for new unilateral server data responses
	for _, rsp = range c.Data {
		fmt.Println("Server data:", rsp)
	}
	c.Data = nil

	// Open a mailbox (synchronous command - no need for imap.Wait)
	c.Select("INBOX", true)
	fmt.Print("\nMailbox status:\n", c.Mailbox)

	// Fetch the headers of the 10 most recent messages
	set, _ := imap.NewSeqSet("")
	if c.Mailbox.Messages >= 10 {
		set.AddRange(c.Mailbox.Messages-9, c.Mailbox.Messages)
	} else {
		set.Add("1:*")
	}
	cmd, _ = c.Fetch(set, "RFC822.HEADER")

	// Process responses while the command is running
	fmt.Println("\nMost recent messages:")
	for cmd.InProgress() {
		// Wait for the next response (no timeout)
		c.Recv(-1)

		// Process command data
		for _, rsp = range cmd.Data {
			header := imap.AsBytes(rsp.MessageInfo().Attrs["RFC822.HEADER"])
			if msg, _ := mail.ReadMessage(bytes.NewReader(header)); msg != nil {
				fmt.Println("|--", msg.Header.Get("Subject"))
			}
		}
		cmd.Data = nil

		// Process unilateral server data
		for _, rsp = range c.Data {
			fmt.Println("Server data:", rsp)
		}
		c.Data = nil
	}

	// Check command completion status
	if rsp, err := cmd.Result(imap.OK); err != nil {
		if err == imap.ErrAborted {
			fmt.Println("Fetch command aborted")
		} else {
			fmt.Println("Fetch error:", rsp.Info)
		}
	}
}