2 * git-imap-send - drops patches into an imap Drafts folder
3 * derived from isync/mbsync - mailbox synchronizer
5 * Copyright (C) 2000-2002 Michael R. Elkins <me@mutt.org>
6 * Copyright (C) 2002-2004 Oswald Buddenhagen <ossi@users.sf.net>
7 * Copyright (C) 2004 Theodore Y. Ts'o <tytso@mit.edu>
8 * Copyright (C) 2006 Mike McCormack
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include <netinet/in.h>
29 #include <netinet/tcp.h>
30 #include <arpa/inet.h>
33 typedef struct store_conf
{
35 const char *path
; /* should this be here? its interpretation is driver-specific */
38 unsigned max_size
; /* off_t is overkill */
39 unsigned trash_remote_new
:1, trash_only_new
:1;
42 typedef struct string_list
{
43 struct string_list
*next
;
47 typedef struct channel_conf
{
48 struct channel_conf
*next
;
50 store_conf_t
*master
, *slave
;
51 char *master_name
, *slave_name
;
53 string_list_t
*patterns
;
55 unsigned max_messages
; /* for slave only */
58 typedef struct group_conf
{
59 struct group_conf
*next
;
61 string_list_t
*channels
;
64 /* For message->status */
65 #define M_RECENT (1<<0) /* unsyncable flag; maildir_* depend on this being 1<<0 */
66 #define M_DEAD (1<<1) /* expunged */
67 #define M_FLAGS (1<<2) /* flags fetched */
69 typedef struct message
{
71 /* string_list_t *keywords; */
72 size_t size
; /* zero implies "not fetched" */
74 unsigned char flags
, status
;
77 typedef struct store
{
78 store_conf_t
*conf
; /* foreign */
80 /* currently open mailbox */
81 const char *name
; /* foreign! maybe preset? */
83 message_t
*msgs
; /* own */
85 unsigned char opts
; /* maybe preset? */
86 /* note that the following do _not_ reflect stats from msgs, but mailbox totals */
87 int count
; /* # of messages */
88 int recent
; /* # of recent messages - don't trust this beyond the initial read */
99 #define DRV_MSG_BAD -1
100 #define DRV_BOX_BAD -2
101 #define DRV_STORE_BAD -3
103 static int Verbose
, Quiet
;
105 static void info( const char *, ... );
106 static void warn( const char *, ... );
108 static char *next_arg( char ** );
110 static void free_generic_messages( message_t
* );
112 static int nfvasprintf( char **str
, const char *fmt
, va_list va
);
113 static int nfsnprintf( char *buf
, int blen
, const char *fmt
, ... );
116 static void arc4_init( void );
117 static unsigned char arc4_getbyte( void );
119 typedef struct imap_server_conf
{
126 } imap_server_conf_t
;
128 typedef struct imap_store_conf
{
130 imap_server_conf_t
*server
;
133 #define NIL (void*)0x1
134 #define LIST (void*)0x2
136 typedef struct _list
{
137 struct _list
*next
, *child
;
155 typedef struct imap
{
156 int uidnext
; /* from SELECT responses */
157 list_t
*ns_personal
, *ns_other
, *ns_shared
; /* NAMESPACE info */
158 unsigned caps
, rcaps
; /* CAPABILITY results */
160 int nexttag
, num_in_progress
, literal_pending
;
161 struct imap_cmd
*in_progress
, **in_progress_append
;
162 buffer_t buf
; /* this is BIG, so put it last */
165 typedef struct imap_store
{
170 unsigned /*currentnc:1,*/ trashnc
:1;
174 int (*cont
)( imap_store_t
*ctx
, struct imap_cmd
*cmd
, const char *prompt
);
175 void (*done
)( imap_store_t
*ctx
, struct imap_cmd
*cmd
, int response
);
180 unsigned create
:1, trycreate
:1;
184 struct imap_cmd
*next
;
185 struct imap_cmd_cb cb
;
190 #define CAP(cap) (imap->caps & (1 << (cap)))
199 static const char *cap_list
[] = {
210 static int get_cmd_result( imap_store_t
*ctx
, struct imap_cmd
*tcmd
);
213 static const char *Flags
[] = {
222 socket_perror( const char *func
, Socket_t
*sock
, int ret
)
227 fprintf( stderr
, "%s: unexpected EOF\n", func
);
231 socket_read( Socket_t
*sock
, char *buf
, int len
)
233 int n
= read( sock
->fd
, buf
, len
);
235 socket_perror( "read", sock
, n
);
243 socket_write( Socket_t
*sock
, char *buf
, int len
)
245 int n
= write( sock
->fd
, buf
, len
);
247 socket_perror( "write", sock
, n
);
254 /* simple line buffering */
256 buffer_gets( buffer_t
* b
, char **s
)
259 int start
= b
->offset
;
264 /* make sure we have enough data to read the \r\n sequence */
265 if (b
->offset
+ 1 >= b
->bytes
) {
267 /* shift down used bytes */
270 assert( start
<= b
->bytes
);
271 n
= b
->bytes
- start
;
274 memcpy( b
->buf
, b
->buf
+ start
, n
);
280 n
= socket_read( &b
->sock
, b
->buf
+ b
->bytes
,
281 sizeof(b
->buf
) - b
->bytes
);
289 if (b
->buf
[b
->offset
] == '\r') {
290 assert( b
->offset
+ 1 < b
->bytes
);
291 if (b
->buf
[b
->offset
+ 1] == '\n') {
292 b
->buf
[b
->offset
] = 0; /* terminate the string */
293 b
->offset
+= 2; /* next line */
306 info( const char *msg
, ... )
319 warn( const char *msg
, ... )
325 vfprintf( stderr
, msg
, va
);
337 while (isspace( (unsigned char) **s
))
346 *s
= strchr( *s
, '"' );
349 while (**s
&& !isspace( (unsigned char) **s
))
362 free_generic_messages( message_t
*msgs
)
366 for (; msgs
; msgs
= tmsg
) {
373 vasprintf( char **strp
, const char *fmt
, va_list ap
)
378 if ((len
= vsnprintf( tmp
, sizeof(tmp
), fmt
, ap
)) < 0 || !(*strp
= xmalloc( len
+ 1 )))
380 if (len
>= (int)sizeof(tmp
))
381 vsprintf( *strp
, fmt
, ap
);
383 memcpy( *strp
, tmp
, len
+ 1 );
388 nfsnprintf( char *buf
, int blen
, const char *fmt
, ... )
394 if (blen
<= 0 || (unsigned)(ret
= vsnprintf( buf
, blen
, fmt
, va
)) >= (unsigned)blen
)
395 die( "Fatal: buffer too small. Please report a bug.\n");
401 nfvasprintf( char **str
, const char *fmt
, va_list va
)
403 int ret
= vasprintf( str
, fmt
, va
);
405 die( "Fatal: Out of memory\n");
410 unsigned char i
, j
, s
[256];
417 unsigned char j
, si
, dat
[128];
419 if ((fd
= open( "/dev/urandom", O_RDONLY
)) < 0 && (fd
= open( "/dev/random", O_RDONLY
)) < 0) {
420 fprintf( stderr
, "Fatal: no random number source available.\n" );
423 if (read( fd
, dat
, 128 ) != 128) {
424 fprintf( stderr
, "Fatal: cannot read random number source.\n" );
429 for (i
= 0; i
< 256; i
++)
431 for (i
= j
= 0; i
< 256; i
++) {
433 j
+= si
+ dat
[i
& 127];
439 for (i
= 0; i
< 256; i
++)
446 unsigned char si
, sj
;
454 return rs
.s
[(si
+ sj
) & 0xff];
457 static struct imap_cmd
*
458 v_issue_imap_cmd( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
,
459 const char *fmt
, va_list ap
)
461 imap_t
*imap
= ctx
->imap
;
462 struct imap_cmd
*cmd
;
466 cmd
= xmalloc( sizeof(struct imap_cmd
) );
467 nfvasprintf( &cmd
->cmd
, fmt
, ap
);
468 cmd
->tag
= ++imap
->nexttag
;
473 memset( &cmd
->cb
, 0, sizeof(cmd
->cb
) );
475 while (imap
->literal_pending
)
476 get_cmd_result( ctx
, 0 );
478 bufl
= nfsnprintf( buf
, sizeof(buf
), cmd
->cb
.data
? CAP(LITERALPLUS
) ?
479 "%d %s{%d+}\r\n" : "%d %s{%d}\r\n" : "%d %s\r\n",
480 cmd
->tag
, cmd
->cmd
, cmd
->cb
.dlen
);
482 if (imap
->num_in_progress
)
483 printf( "(%d in progress) ", imap
->num_in_progress
);
484 if (memcmp( cmd
->cmd
, "LOGIN", 5 ))
485 printf( ">>> %s", buf
);
487 printf( ">>> %d LOGIN <user> <pass>\n", cmd
->tag
);
489 if (socket_write( &imap
->buf
.sock
, buf
, bufl
) != bufl
) {
497 if (CAP(LITERALPLUS
)) {
498 n
= socket_write( &imap
->buf
.sock
, cmd
->cb
.data
, cmd
->cb
.dlen
);
499 free( cmd
->cb
.data
);
500 if (n
!= cmd
->cb
.dlen
||
501 (n
= socket_write( &imap
->buf
.sock
, "\r\n", 2 )) != 2)
509 imap
->literal_pending
= 1;
510 } else if (cmd
->cb
.cont
)
511 imap
->literal_pending
= 1;
513 *imap
->in_progress_append
= cmd
;
514 imap
->in_progress_append
= &cmd
->next
;
515 imap
->num_in_progress
++;
519 static struct imap_cmd
*
520 issue_imap_cmd( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
522 struct imap_cmd
*ret
;
526 ret
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
532 imap_exec( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
535 struct imap_cmd
*cmdp
;
538 cmdp
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
543 return get_cmd_result( ctx
, cmdp
);
547 imap_exec_m( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
550 struct imap_cmd
*cmdp
;
553 cmdp
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
556 return DRV_STORE_BAD
;
558 switch (get_cmd_result( ctx
, cmdp
)) {
559 case RESP_BAD
: return DRV_STORE_BAD
;
560 case RESP_NO
: return DRV_MSG_BAD
;
561 default: return DRV_OK
;
566 is_atom( list_t
*list
)
568 return list
&& list
->val
&& list
->val
!= NIL
&& list
->val
!= LIST
;
572 is_list( list_t
*list
)
574 return list
&& list
->val
== LIST
;
578 free_list( list_t
*list
)
582 for (; list
; list
= tmp
) {
585 free_list( list
->child
);
586 else if (is_atom( list
))
593 parse_imap_list_l( imap_t
*imap
, char **sp
, list_t
**curp
, int level
)
600 while (isspace( (unsigned char)*s
))
602 if (level
&& *s
== ')') {
606 *curp
= cur
= xmalloc( sizeof(*cur
) );
608 cur
->val
= 0; /* for clean bail */
613 if (parse_imap_list_l( imap
, &s
, &cur
->child
, level
+ 1 ))
615 } else if (imap
&& *s
== '{') {
617 bytes
= cur
->len
= strtol( s
+ 1, &s
, 10 );
621 s
= cur
->val
= xmalloc( cur
->len
);
623 /* dump whats left over in the input buffer */
624 n
= imap
->buf
.bytes
- imap
->buf
.offset
;
627 /* the entire message fit in the buffer */
630 memcpy( s
, imap
->buf
.buf
+ imap
->buf
.offset
, n
);
634 /* mark that we used part of the buffer */
635 imap
->buf
.offset
+= n
;
637 /* now read the rest of the message */
639 if ((n
= socket_read (&imap
->buf
.sock
, s
, bytes
)) <= 0)
645 if (buffer_gets( &imap
->buf
, &s
))
647 } else if (*s
== '"') {
651 for (; *s
!= '"'; s
++)
656 cur
->val
= xmalloc( cur
->len
+ 1 );
657 memcpy( cur
->val
, p
, cur
->len
);
658 cur
->val
[cur
->len
] = 0;
662 for (; *s
&& !isspace( (unsigned char)*s
); s
++)
663 if (level
&& *s
== ')')
666 if (cur
->len
== 3 && !memcmp ("NIL", p
, 3))
669 cur
->val
= xmalloc( cur
->len
+ 1 );
670 memcpy( cur
->val
, p
, cur
->len
);
671 cur
->val
[cur
->len
] = 0;
690 parse_imap_list( imap_t
*imap
, char **sp
)
694 if (!parse_imap_list_l( imap
, sp
, &head
, 0 ))
701 parse_list( char **sp
)
703 return parse_imap_list( 0, sp
);
707 parse_capability( imap_t
*imap
, char *cmd
)
712 imap
->caps
= 0x80000000;
713 while ((arg
= next_arg( &cmd
)))
714 for (i
= 0; i
< ARRAY_SIZE(cap_list
); i
++)
715 if (!strcmp( cap_list
[i
], arg
))
716 imap
->caps
|= 1 << i
;
717 imap
->rcaps
= imap
->caps
;
721 parse_response_code( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, char *s
)
723 imap_t
*imap
= ctx
->imap
;
727 return RESP_OK
; /* no response code */
729 if (!(p
= strchr( s
, ']' ))) {
730 fprintf( stderr
, "IMAP error: malformed response code\n" );
734 arg
= next_arg( &s
);
735 if (!strcmp( "UIDVALIDITY", arg
)) {
736 if (!(arg
= next_arg( &s
)) || !(ctx
->gen
.uidvalidity
= atoi( arg
))) {
737 fprintf( stderr
, "IMAP error: malformed UIDVALIDITY status\n" );
740 } else if (!strcmp( "UIDNEXT", arg
)) {
741 if (!(arg
= next_arg( &s
)) || !(imap
->uidnext
= atoi( arg
))) {
742 fprintf( stderr
, "IMAP error: malformed NEXTUID status\n" );
745 } else if (!strcmp( "CAPABILITY", arg
)) {
746 parse_capability( imap
, s
);
747 } else if (!strcmp( "ALERT", arg
)) {
748 /* RFC2060 says that these messages MUST be displayed
751 for (; isspace( (unsigned char)*p
); p
++);
752 fprintf( stderr
, "*** IMAP ALERT *** %s\n", p
);
753 } else if (cb
&& cb
->ctx
&& !strcmp( "APPENDUID", arg
)) {
754 if (!(arg
= next_arg( &s
)) || !(ctx
->gen
.uidvalidity
= atoi( arg
)) ||
755 !(arg
= next_arg( &s
)) || !(*(int *)cb
->ctx
= atoi( arg
)))
757 fprintf( stderr
, "IMAP error: malformed APPENDUID status\n" );
765 get_cmd_result( imap_store_t
*ctx
, struct imap_cmd
*tcmd
)
767 imap_t
*imap
= ctx
->imap
;
768 struct imap_cmd
*cmdp
, **pcmdp
, *ncmdp
;
769 char *cmd
, *arg
, *arg1
, *p
;
770 int n
, resp
, resp2
, tag
;
773 if (buffer_gets( &imap
->buf
, &cmd
))
776 arg
= next_arg( &cmd
);
778 arg
= next_arg( &cmd
);
780 fprintf( stderr
, "IMAP error: unable to parse untagged response\n" );
784 if (!strcmp( "NAMESPACE", arg
)) {
785 imap
->ns_personal
= parse_list( &cmd
);
786 imap
->ns_other
= parse_list( &cmd
);
787 imap
->ns_shared
= parse_list( &cmd
);
788 } else if (!strcmp( "OK", arg
) || !strcmp( "BAD", arg
) ||
789 !strcmp( "NO", arg
) || !strcmp( "BYE", arg
)) {
790 if ((resp
= parse_response_code( ctx
, 0, cmd
)) != RESP_OK
)
792 } else if (!strcmp( "CAPABILITY", arg
))
793 parse_capability( imap
, cmd
);
794 else if ((arg1
= next_arg( &cmd
))) {
795 if (!strcmp( "EXISTS", arg1
))
796 ctx
->gen
.count
= atoi( arg
);
797 else if (!strcmp( "RECENT", arg1
))
798 ctx
->gen
.recent
= atoi( arg
);
800 fprintf( stderr
, "IMAP error: unable to parse untagged response\n" );
803 } else if (!imap
->in_progress
) {
804 fprintf( stderr
, "IMAP error: unexpected reply: %s %s\n", arg
, cmd
? cmd
: "" );
806 } else if (*arg
== '+') {
807 /* This can happen only with the last command underway, as
808 it enforces a round-trip. */
809 cmdp
= (struct imap_cmd
*)((char *)imap
->in_progress_append
-
810 offsetof(struct imap_cmd
, next
));
812 n
= socket_write( &imap
->buf
.sock
, cmdp
->cb
.data
, cmdp
->cb
.dlen
);
813 free( cmdp
->cb
.data
);
815 if (n
!= (int)cmdp
->cb
.dlen
)
817 } else if (cmdp
->cb
.cont
) {
818 if (cmdp
->cb
.cont( ctx
, cmdp
, cmd
))
821 fprintf( stderr
, "IMAP error: unexpected command continuation request\n" );
824 if (socket_write( &imap
->buf
.sock
, "\r\n", 2 ) != 2)
827 imap
->literal_pending
= 0;
832 for (pcmdp
= &imap
->in_progress
; (cmdp
= *pcmdp
); pcmdp
= &cmdp
->next
)
833 if (cmdp
->tag
== tag
)
835 fprintf( stderr
, "IMAP error: unexpected tag %s\n", arg
);
838 if (!(*pcmdp
= cmdp
->next
))
839 imap
->in_progress_append
= pcmdp
;
840 imap
->num_in_progress
--;
841 if (cmdp
->cb
.cont
|| cmdp
->cb
.data
)
842 imap
->literal_pending
= 0;
843 arg
= next_arg( &cmd
);
844 if (!strcmp( "OK", arg
))
847 if (!strcmp( "NO", arg
)) {
848 if (cmdp
->cb
.create
&& cmd
&& (cmdp
->cb
.trycreate
|| !memcmp( cmd
, "[TRYCREATE]", 11 ))) { /* SELECT, APPEND or UID COPY */
849 p
= strchr( cmdp
->cmd
, '"' );
850 if (!issue_imap_cmd( ctx
, 0, "CREATE \"%.*s\"", strchr( p
+ 1, '"' ) - p
+ 1, p
)) {
854 /* not waiting here violates the spec, but a server that does not
855 grok this nonetheless violates it too. */
857 if (!(ncmdp
= issue_imap_cmd( ctx
, &cmdp
->cb
, "%s", cmdp
->cmd
))) {
864 return 0; /* ignored */
870 } else /*if (!strcmp( "BAD", arg ))*/
872 fprintf( stderr
, "IMAP command '%s' returned response (%s) - %s\n",
873 memcmp (cmdp
->cmd
, "LOGIN", 5) ?
874 cmdp
->cmd
: "LOGIN <user> <pass>",
875 arg
, cmd
? cmd
: "");
877 if ((resp2
= parse_response_code( ctx
, &cmdp
->cb
, cmd
)) > resp
)
881 cmdp
->cb
.done( ctx
, cmdp
, resp
);
883 free( cmdp
->cb
.data
);
886 if (!tcmd
|| tcmd
== cmdp
)
894 imap_close_server( imap_store_t
*ictx
)
896 imap_t
*imap
= ictx
->imap
;
898 if (imap
->buf
.sock
.fd
!= -1) {
899 imap_exec( ictx
, 0, "LOGOUT" );
900 close( imap
->buf
.sock
.fd
);
902 free_list( imap
->ns_personal
);
903 free_list( imap
->ns_other
);
904 free_list( imap
->ns_shared
);
909 imap_close_store( store_t
*ctx
)
911 imap_close_server( (imap_store_t
*)ctx
);
912 free_generic_messages( ctx
->msgs
);
917 imap_open_store( imap_server_conf_t
*srvc
)
923 struct sockaddr_in addr
;
924 int s
, a
[2], preauth
;
926 ctx
= xcalloc( sizeof(*ctx
), 1 );
928 ctx
->imap
= imap
= xcalloc( sizeof(*imap
), 1 );
929 imap
->buf
.sock
.fd
= -1;
930 imap
->in_progress_append
= &imap
->in_progress
;
932 /* open connection to IMAP server */
935 info( "Starting tunnel '%s'... ", srvc
->tunnel
);
937 if (socketpair( PF_UNIX
, SOCK_STREAM
, 0, a
)) {
938 perror( "socketpair" );
943 if (dup2( a
[0], 0 ) == -1 || dup2( a
[0], 1 ) == -1)
947 execl( "/bin/sh", "sh", "-c", srvc
->tunnel
, 0 );
953 imap
->buf
.sock
.fd
= a
[1];
957 memset( &addr
, 0, sizeof(addr
) );
958 addr
.sin_port
= htons( srvc
->port
);
959 addr
.sin_family
= AF_INET
;
961 info( "Resolving %s... ", srvc
->host
);
962 he
= gethostbyname( srvc
->host
);
964 perror( "gethostbyname" );
969 addr
.sin_addr
.s_addr
= *((int *) he
->h_addr_list
[0]);
971 s
= socket( PF_INET
, SOCK_STREAM
, 0 );
973 info( "Connecting to %s:%hu... ", inet_ntoa( addr
.sin_addr
), ntohs( addr
.sin_port
) );
974 if (connect( s
, (struct sockaddr
*)&addr
, sizeof(addr
) )) {
981 imap
->buf
.sock
.fd
= s
;
985 /* read the greeting string */
986 if (buffer_gets( &imap
->buf
, &rsp
)) {
987 fprintf( stderr
, "IMAP error: no greeting response\n" );
990 arg
= next_arg( &rsp
);
991 if (!arg
|| *arg
!= '*' || (arg
= next_arg( &rsp
)) == NULL
) {
992 fprintf( stderr
, "IMAP error: invalid greeting response\n" );
996 if (!strcmp( "PREAUTH", arg
))
998 else if (strcmp( "OK", arg
) != 0) {
999 fprintf( stderr
, "IMAP error: unknown greeting response\n" );
1002 parse_response_code( ctx
, 0, rsp
);
1003 if (!imap
->caps
&& imap_exec( ctx
, 0, "CAPABILITY" ) != RESP_OK
)
1008 info ("Logging in...\n");
1010 fprintf( stderr
, "Skipping server %s, no user\n", srvc
->host
);
1015 sprintf( prompt
, "Password (%s@%s): ", srvc
->user
, srvc
->host
);
1016 arg
= getpass( prompt
);
1018 perror( "getpass" );
1022 fprintf( stderr
, "Skipping account %s@%s, no password\n", srvc
->user
, srvc
->host
);
1026 * getpass() returns a pointer to a static buffer. make a copy
1027 * for long term storage.
1029 srvc
->pass
= strdup( arg
);
1032 fprintf( stderr
, "Skipping account %s@%s, server forbids LOGIN\n", srvc
->user
, srvc
->host
);
1035 warn( "*** IMAP Warning *** Password is being sent in the clear\n" );
1036 if (imap_exec( ctx
, 0, "LOGIN \"%s\" \"%s\"", srvc
->user
, srvc
->pass
) != RESP_OK
) {
1037 fprintf( stderr
, "IMAP error: LOGIN failed\n" );
1044 return (store_t
*)ctx
;
1047 imap_close_store( &ctx
->gen
);
1052 imap_make_flags( int flags
, char *buf
)
1057 for (i
= d
= 0; i
< ARRAY_SIZE(Flags
); i
++)
1058 if (flags
& (1 << i
)) {
1061 for (s
= Flags
[i
]; *s
; s
++)
1072 imap_store_msg( store_t
*gctx
, msg_data_t
*data
, int *uid
)
1074 imap_store_t
*ctx
= (imap_store_t
*)gctx
;
1075 imap_t
*imap
= ctx
->imap
;
1076 struct imap_cmd_cb cb
;
1078 const char *prefix
, *box
;
1079 int ret
, i
, j
, d
, len
, extra
, nocr
;
1080 int start
, sbreak
= 0, ebreak
= 0;
1081 char flagstr
[128], tuid
[TUIDL
* 2 + 1];
1083 memset( &cb
, 0, sizeof(cb
) );
1089 if (!CAP(UIDPLUS
) && uid
) {
1093 if (fmap
[i
++] == '\n') {
1095 if (i
- 2 + nocr
== start
) {
1096 sbreak
= ebreak
= i
- 2 + nocr
;
1099 if (!memcmp( fmap
+ start
, "X-TUID: ", 8 )) {
1100 extra
-= (ebreak
= i
) - (sbreak
= start
) + nocr
;
1105 /* invalid message */
1109 for (j
= 0; j
< TUIDL
; j
++)
1110 sprintf( tuid
+ j
* 2, "%02x", arc4_getbyte() );
1111 extra
+= 8 + TUIDL
* 2 + 2;
1114 for (; i
< len
; i
++)
1115 if (fmap
[i
] == '\n')
1118 cb
.dlen
= len
+ extra
;
1119 buf
= cb
.data
= xmalloc( cb
.dlen
);
1121 if (!CAP(UIDPLUS
) && uid
) {
1123 for (; i
< sbreak
; i
++)
1124 if (fmap
[i
] == '\n') {
1130 memcpy( buf
, fmap
, sbreak
);
1133 memcpy( buf
, "X-TUID: ", 8 );
1135 memcpy( buf
, tuid
, TUIDL
* 2 );
1142 for (; i
< len
; i
++)
1143 if (fmap
[i
] == '\n') {
1149 memcpy( buf
, fmap
+ i
, len
- i
);
1155 d
= imap_make_flags( data
->flags
, flagstr
);
1161 box
= gctx
->conf
->trash
;
1162 prefix
= ctx
->prefix
;
1165 imap
->caps
= imap
->rcaps
& ~(1 << LITERALPLUS
);
1168 prefix
= !strcmp( box
, "INBOX" ) ? "" : ctx
->prefix
;
1172 ret
= imap_exec_m( ctx
, &cb
, "APPEND \"%s%s\" %s", prefix
, box
, flagstr
);
1173 imap
->caps
= imap
->rcaps
;
1184 #define CHUNKSIZE 0x1000
1187 read_message( FILE *f
, msg_data_t
*msg
)
1191 memset( msg
, 0, sizeof *msg
);
1193 msg
->data
= xmalloc( len
+1 );
1197 if (msg
->len
>= len
) {
1200 p
= xrealloc(msg
->data
, len
+1);
1204 r
= fread( &msg
->data
[msg
->len
], 1, len
- msg
->len
, f
);
1209 msg
->data
[msg
->len
] = 0;
1214 count_messages( msg_data_t
*msg
)
1217 char *p
= msg
->data
;
1220 if (!strncmp( "From ", p
, 5 )) {
1224 p
= strstr( p
+5, "\nFrom ");
1233 split_msg( msg_data_t
*all_msgs
, msg_data_t
*msg
, int *ofs
)
1237 memset( msg
, 0, sizeof *msg
);
1238 if (*ofs
>= all_msgs
->len
)
1241 data
= &all_msgs
->data
[ *ofs
];
1242 msg
->len
= all_msgs
->len
- *ofs
;
1244 if (msg
->len
< 5 || strncmp( data
, "From ", 5 ))
1247 p
= strstr( data
, "\nFrom " );
1249 msg
->len
= &p
[1] - data
;
1251 msg
->data
= xmalloc( msg
->len
+ 1 );
1255 memcpy( msg
->data
, data
, msg
->len
);
1256 msg
->data
[ msg
->len
] = 0;
1262 static imap_server_conf_t server
=
1272 static char *imap_folder
;
1275 git_imap_config(const char *key
, const char *val
)
1277 char imap_key
[] = "imap.";
1279 if (strncmp( key
, imap_key
, sizeof imap_key
- 1 ))
1281 key
+= sizeof imap_key
- 1;
1283 if (!strcmp( "folder", key
)) {
1284 imap_folder
= strdup( val
);
1285 } else if (!strcmp( "host", key
)) {
1287 if (!strncmp( "imap:", val
, 5 ))
1292 if (!strncmp( "//", val
, 2 ))
1294 server
.host
= strdup( val
);
1296 else if (!strcmp( "user", key
))
1297 server
.user
= strdup( val
);
1298 else if (!strcmp( "pass", key
))
1299 server
.pass
= strdup( val
);
1300 else if (!strcmp( "port", key
))
1301 server
.port
= git_config_int( key
, val
);
1302 else if (!strcmp( "tunnel", key
))
1303 server
.tunnel
= strdup( val
);
1308 main(int argc
, char **argv
)
1310 msg_data_t all_msgs
, msg
;
1317 /* init the random number generator */
1320 git_config( git_imap_config
);
1323 fprintf( stderr
, "no imap store specified\n" );
1327 /* read the messages */
1328 if (!read_message( stdin
, &all_msgs
)) {
1329 fprintf(stderr
,"nothing to send\n");
1333 /* write it to the imap server */
1334 ctx
= imap_open_store( &server
);
1336 fprintf( stderr
,"failed to open store\n");
1340 total
= count_messages( &all_msgs
);
1341 fprintf( stderr
, "sending %d message%s\n", total
, (total
!=1)?"s":"" );
1342 ctx
->name
= imap_folder
;
1344 unsigned percent
= n
* 100 / total
;
1345 fprintf( stderr
, "%4u%% (%d/%d) done\r", percent
, n
, total
);
1346 if (!split_msg( &all_msgs
, &msg
, &ofs
))
1348 r
= imap_store_msg( ctx
, &msg
, &uid
);
1349 if (r
!= DRV_OK
) break;
1352 fprintf( stderr
,"\n" );
1354 imap_close_store( ctx
);