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
;
131 unsigned use_namespace
:1;
134 #define NIL (void*)0x1
135 #define LIST (void*)0x2
137 typedef struct _list
{
138 struct _list
*next
, *child
;
156 typedef struct imap
{
157 int uidnext
; /* from SELECT responses */
158 list_t
*ns_personal
, *ns_other
, *ns_shared
; /* NAMESPACE info */
159 unsigned caps
, rcaps
; /* CAPABILITY results */
161 int nexttag
, num_in_progress
, literal_pending
;
162 struct imap_cmd
*in_progress
, **in_progress_append
;
163 buffer_t buf
; /* this is BIG, so put it last */
166 typedef struct imap_store
{
171 unsigned /*currentnc:1,*/ trashnc
:1;
175 int (*cont
)( imap_store_t
*ctx
, struct imap_cmd
*cmd
, const char *prompt
);
176 void (*done
)( imap_store_t
*ctx
, struct imap_cmd
*cmd
, int response
);
181 unsigned create
:1, trycreate
:1;
185 struct imap_cmd
*next
;
186 struct imap_cmd_cb cb
;
191 #define CAP(cap) (imap->caps & (1 << (cap)))
200 static const char *cap_list
[] = {
211 static int get_cmd_result( imap_store_t
*ctx
, struct imap_cmd
*tcmd
);
214 static const char *Flags
[] = {
223 socket_perror( const char *func
, Socket_t
*sock
, int ret
)
228 fprintf( stderr
, "%s: unexpected EOF\n", func
);
232 socket_read( Socket_t
*sock
, char *buf
, int len
)
234 int n
= read( sock
->fd
, buf
, len
);
236 socket_perror( "read", sock
, n
);
244 socket_write( Socket_t
*sock
, char *buf
, int len
)
246 int n
= write( sock
->fd
, buf
, len
);
248 socket_perror( "write", sock
, n
);
255 /* simple line buffering */
257 buffer_gets( buffer_t
* b
, char **s
)
260 int start
= b
->offset
;
265 /* make sure we have enough data to read the \r\n sequence */
266 if (b
->offset
+ 1 >= b
->bytes
) {
268 /* shift down used bytes */
271 assert( start
<= b
->bytes
);
272 n
= b
->bytes
- start
;
275 memcpy( b
->buf
, b
->buf
+ start
, n
);
281 n
= socket_read( &b
->sock
, b
->buf
+ b
->bytes
,
282 sizeof(b
->buf
) - b
->bytes
);
290 if (b
->buf
[b
->offset
] == '\r') {
291 assert( b
->offset
+ 1 < b
->bytes
);
292 if (b
->buf
[b
->offset
+ 1] == '\n') {
293 b
->buf
[b
->offset
] = 0; /* terminate the string */
294 b
->offset
+= 2; /* next line */
307 info( const char *msg
, ... )
320 warn( const char *msg
, ... )
326 vfprintf( stderr
, msg
, va
);
338 while (isspace( (unsigned char) **s
))
347 *s
= strchr( *s
, '"' );
350 while (**s
&& !isspace( (unsigned char) **s
))
363 free_generic_messages( message_t
*msgs
)
367 for (; msgs
; msgs
= tmsg
) {
374 vasprintf( char **strp
, const char *fmt
, va_list ap
)
379 if ((len
= vsnprintf( tmp
, sizeof(tmp
), fmt
, ap
)) < 0 || !(*strp
= xmalloc( len
+ 1 )))
381 if (len
>= (int)sizeof(tmp
))
382 vsprintf( *strp
, fmt
, ap
);
384 memcpy( *strp
, tmp
, len
+ 1 );
389 nfsnprintf( char *buf
, int blen
, const char *fmt
, ... )
395 if (blen
<= 0 || (unsigned)(ret
= vsnprintf( buf
, blen
, fmt
, va
)) >= (unsigned)blen
)
396 die( "Fatal: buffer too small. Please report a bug.\n");
402 nfvasprintf( char **str
, const char *fmt
, va_list va
)
404 int ret
= vasprintf( str
, fmt
, va
);
406 die( "Fatal: Out of memory\n");
411 unsigned char i
, j
, s
[256];
418 unsigned char j
, si
, dat
[128];
420 if ((fd
= open( "/dev/urandom", O_RDONLY
)) < 0 && (fd
= open( "/dev/random", O_RDONLY
)) < 0) {
421 fprintf( stderr
, "Fatal: no random number source available.\n" );
424 if (read( fd
, dat
, 128 ) != 128) {
425 fprintf( stderr
, "Fatal: cannot read random number source.\n" );
430 for (i
= 0; i
< 256; i
++)
432 for (i
= j
= 0; i
< 256; i
++) {
434 j
+= si
+ dat
[i
& 127];
440 for (i
= 0; i
< 256; i
++)
447 unsigned char si
, sj
;
455 return rs
.s
[(si
+ sj
) & 0xff];
458 static struct imap_cmd
*
459 v_issue_imap_cmd( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
,
460 const char *fmt
, va_list ap
)
462 imap_t
*imap
= ctx
->imap
;
463 struct imap_cmd
*cmd
;
467 cmd
= xmalloc( sizeof(struct imap_cmd
) );
468 nfvasprintf( &cmd
->cmd
, fmt
, ap
);
469 cmd
->tag
= ++imap
->nexttag
;
474 memset( &cmd
->cb
, 0, sizeof(cmd
->cb
) );
476 while (imap
->literal_pending
)
477 get_cmd_result( ctx
, 0 );
479 bufl
= nfsnprintf( buf
, sizeof(buf
), cmd
->cb
.data
? CAP(LITERALPLUS
) ?
480 "%d %s{%d+}\r\n" : "%d %s{%d}\r\n" : "%d %s\r\n",
481 cmd
->tag
, cmd
->cmd
, cmd
->cb
.dlen
);
483 if (imap
->num_in_progress
)
484 printf( "(%d in progress) ", imap
->num_in_progress
);
485 if (memcmp( cmd
->cmd
, "LOGIN", 5 ))
486 printf( ">>> %s", buf
);
488 printf( ">>> %d LOGIN <user> <pass>\n", cmd
->tag
);
490 if (socket_write( &imap
->buf
.sock
, buf
, bufl
) != bufl
) {
498 if (CAP(LITERALPLUS
)) {
499 n
= socket_write( &imap
->buf
.sock
, cmd
->cb
.data
, cmd
->cb
.dlen
);
500 free( cmd
->cb
.data
);
501 if (n
!= cmd
->cb
.dlen
||
502 (n
= socket_write( &imap
->buf
.sock
, "\r\n", 2 )) != 2)
510 imap
->literal_pending
= 1;
511 } else if (cmd
->cb
.cont
)
512 imap
->literal_pending
= 1;
514 *imap
->in_progress_append
= cmd
;
515 imap
->in_progress_append
= &cmd
->next
;
516 imap
->num_in_progress
++;
520 static struct imap_cmd
*
521 issue_imap_cmd( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
523 struct imap_cmd
*ret
;
527 ret
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
533 imap_exec( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
536 struct imap_cmd
*cmdp
;
539 cmdp
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
544 return get_cmd_result( ctx
, cmdp
);
548 imap_exec_m( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, const char *fmt
, ... )
551 struct imap_cmd
*cmdp
;
554 cmdp
= v_issue_imap_cmd( ctx
, cb
, fmt
, ap
);
557 return DRV_STORE_BAD
;
559 switch (get_cmd_result( ctx
, cmdp
)) {
560 case RESP_BAD
: return DRV_STORE_BAD
;
561 case RESP_NO
: return DRV_MSG_BAD
;
562 default: return DRV_OK
;
567 is_atom( list_t
*list
)
569 return list
&& list
->val
&& list
->val
!= NIL
&& list
->val
!= LIST
;
573 is_list( list_t
*list
)
575 return list
&& list
->val
== LIST
;
579 free_list( list_t
*list
)
583 for (; list
; list
= tmp
) {
586 free_list( list
->child
);
587 else if (is_atom( list
))
594 parse_imap_list_l( imap_t
*imap
, char **sp
, list_t
**curp
, int level
)
601 while (isspace( (unsigned char)*s
))
603 if (level
&& *s
== ')') {
607 *curp
= cur
= xmalloc( sizeof(*cur
) );
609 cur
->val
= 0; /* for clean bail */
614 if (parse_imap_list_l( imap
, &s
, &cur
->child
, level
+ 1 ))
616 } else if (imap
&& *s
== '{') {
618 bytes
= cur
->len
= strtol( s
+ 1, &s
, 10 );
622 s
= cur
->val
= xmalloc( cur
->len
);
624 /* dump whats left over in the input buffer */
625 n
= imap
->buf
.bytes
- imap
->buf
.offset
;
628 /* the entire message fit in the buffer */
631 memcpy( s
, imap
->buf
.buf
+ imap
->buf
.offset
, n
);
635 /* mark that we used part of the buffer */
636 imap
->buf
.offset
+= n
;
638 /* now read the rest of the message */
640 if ((n
= socket_read (&imap
->buf
.sock
, s
, bytes
)) <= 0)
646 if (buffer_gets( &imap
->buf
, &s
))
648 } else if (*s
== '"') {
652 for (; *s
!= '"'; s
++)
657 cur
->val
= xmalloc( cur
->len
+ 1 );
658 memcpy( cur
->val
, p
, cur
->len
);
659 cur
->val
[cur
->len
] = 0;
663 for (; *s
&& !isspace( (unsigned char)*s
); s
++)
664 if (level
&& *s
== ')')
667 if (cur
->len
== 3 && !memcmp ("NIL", p
, 3))
670 cur
->val
= xmalloc( cur
->len
+ 1 );
671 memcpy( cur
->val
, p
, cur
->len
);
672 cur
->val
[cur
->len
] = 0;
691 parse_imap_list( imap_t
*imap
, char **sp
)
695 if (!parse_imap_list_l( imap
, sp
, &head
, 0 ))
702 parse_list( char **sp
)
704 return parse_imap_list( 0, sp
);
708 parse_capability( imap_t
*imap
, char *cmd
)
713 imap
->caps
= 0x80000000;
714 while ((arg
= next_arg( &cmd
)))
715 for (i
= 0; i
< ARRAY_SIZE(cap_list
); i
++)
716 if (!strcmp( cap_list
[i
], arg
))
717 imap
->caps
|= 1 << i
;
718 imap
->rcaps
= imap
->caps
;
722 parse_response_code( imap_store_t
*ctx
, struct imap_cmd_cb
*cb
, char *s
)
724 imap_t
*imap
= ctx
->imap
;
728 return RESP_OK
; /* no response code */
730 if (!(p
= strchr( s
, ']' ))) {
731 fprintf( stderr
, "IMAP error: malformed response code\n" );
735 arg
= next_arg( &s
);
736 if (!strcmp( "UIDVALIDITY", arg
)) {
737 if (!(arg
= next_arg( &s
)) || !(ctx
->gen
.uidvalidity
= atoi( arg
))) {
738 fprintf( stderr
, "IMAP error: malformed UIDVALIDITY status\n" );
741 } else if (!strcmp( "UIDNEXT", arg
)) {
742 if (!(arg
= next_arg( &s
)) || !(imap
->uidnext
= atoi( arg
))) {
743 fprintf( stderr
, "IMAP error: malformed NEXTUID status\n" );
746 } else if (!strcmp( "CAPABILITY", arg
)) {
747 parse_capability( imap
, s
);
748 } else if (!strcmp( "ALERT", arg
)) {
749 /* RFC2060 says that these messages MUST be displayed
752 for (; isspace( (unsigned char)*p
); p
++);
753 fprintf( stderr
, "*** IMAP ALERT *** %s\n", p
);
754 } else if (cb
&& cb
->ctx
&& !strcmp( "APPENDUID", arg
)) {
755 if (!(arg
= next_arg( &s
)) || !(ctx
->gen
.uidvalidity
= atoi( arg
)) ||
756 !(arg
= next_arg( &s
)) || !(*(int *)cb
->ctx
= atoi( arg
)))
758 fprintf( stderr
, "IMAP error: malformed APPENDUID status\n" );
766 get_cmd_result( imap_store_t
*ctx
, struct imap_cmd
*tcmd
)
768 imap_t
*imap
= ctx
->imap
;
769 struct imap_cmd
*cmdp
, **pcmdp
, *ncmdp
;
770 char *cmd
, *arg
, *arg1
, *p
;
771 int n
, resp
, resp2
, tag
;
774 if (buffer_gets( &imap
->buf
, &cmd
))
777 arg
= next_arg( &cmd
);
779 arg
= next_arg( &cmd
);
781 fprintf( stderr
, "IMAP error: unable to parse untagged response\n" );
785 if (!strcmp( "NAMESPACE", arg
)) {
786 imap
->ns_personal
= parse_list( &cmd
);
787 imap
->ns_other
= parse_list( &cmd
);
788 imap
->ns_shared
= parse_list( &cmd
);
789 } else if (!strcmp( "OK", arg
) || !strcmp( "BAD", arg
) ||
790 !strcmp( "NO", arg
) || !strcmp( "BYE", arg
)) {
791 if ((resp
= parse_response_code( ctx
, 0, cmd
)) != RESP_OK
)
793 } else if (!strcmp( "CAPABILITY", arg
))
794 parse_capability( imap
, cmd
);
795 else if ((arg1
= next_arg( &cmd
))) {
796 if (!strcmp( "EXISTS", arg1
))
797 ctx
->gen
.count
= atoi( arg
);
798 else if (!strcmp( "RECENT", arg1
))
799 ctx
->gen
.recent
= atoi( arg
);
801 fprintf( stderr
, "IMAP error: unable to parse untagged response\n" );
804 } else if (!imap
->in_progress
) {
805 fprintf( stderr
, "IMAP error: unexpected reply: %s %s\n", arg
, cmd
? cmd
: "" );
807 } else if (*arg
== '+') {
808 /* This can happen only with the last command underway, as
809 it enforces a round-trip. */
810 cmdp
= (struct imap_cmd
*)((char *)imap
->in_progress_append
-
811 offsetof(struct imap_cmd
, next
));
813 n
= socket_write( &imap
->buf
.sock
, cmdp
->cb
.data
, cmdp
->cb
.dlen
);
814 free( cmdp
->cb
.data
);
816 if (n
!= (int)cmdp
->cb
.dlen
)
818 } else if (cmdp
->cb
.cont
) {
819 if (cmdp
->cb
.cont( ctx
, cmdp
, cmd
))
822 fprintf( stderr
, "IMAP error: unexpected command continuation request\n" );
825 if (socket_write( &imap
->buf
.sock
, "\r\n", 2 ) != 2)
828 imap
->literal_pending
= 0;
833 for (pcmdp
= &imap
->in_progress
; (cmdp
= *pcmdp
); pcmdp
= &cmdp
->next
)
834 if (cmdp
->tag
== tag
)
836 fprintf( stderr
, "IMAP error: unexpected tag %s\n", arg
);
839 if (!(*pcmdp
= cmdp
->next
))
840 imap
->in_progress_append
= pcmdp
;
841 imap
->num_in_progress
--;
842 if (cmdp
->cb
.cont
|| cmdp
->cb
.data
)
843 imap
->literal_pending
= 0;
844 arg
= next_arg( &cmd
);
845 if (!strcmp( "OK", arg
))
848 if (!strcmp( "NO", arg
)) {
849 if (cmdp
->cb
.create
&& cmd
&& (cmdp
->cb
.trycreate
|| !memcmp( cmd
, "[TRYCREATE]", 11 ))) { /* SELECT, APPEND or UID COPY */
850 p
= strchr( cmdp
->cmd
, '"' );
851 if (!issue_imap_cmd( ctx
, 0, "CREATE \"%.*s\"", strchr( p
+ 1, '"' ) - p
+ 1, p
)) {
855 /* not waiting here violates the spec, but a server that does not
856 grok this nonetheless violates it too. */
858 if (!(ncmdp
= issue_imap_cmd( ctx
, &cmdp
->cb
, "%s", cmdp
->cmd
))) {
865 return 0; /* ignored */
871 } else /*if (!strcmp( "BAD", arg ))*/
873 fprintf( stderr
, "IMAP command '%s' returned response (%s) - %s\n",
874 memcmp (cmdp
->cmd
, "LOGIN", 5) ?
875 cmdp
->cmd
: "LOGIN <user> <pass>",
876 arg
, cmd
? cmd
: "");
878 if ((resp2
= parse_response_code( ctx
, &cmdp
->cb
, cmd
)) > resp
)
882 cmdp
->cb
.done( ctx
, cmdp
, resp
);
884 free( cmdp
->cb
.data
);
887 if (!tcmd
|| tcmd
== cmdp
)
895 imap_close_server( imap_store_t
*ictx
)
897 imap_t
*imap
= ictx
->imap
;
899 if (imap
->buf
.sock
.fd
!= -1) {
900 imap_exec( ictx
, 0, "LOGOUT" );
901 close( imap
->buf
.sock
.fd
);
903 free_list( imap
->ns_personal
);
904 free_list( imap
->ns_other
);
905 free_list( imap
->ns_shared
);
910 imap_close_store( store_t
*ctx
)
912 imap_close_server( (imap_store_t
*)ctx
);
913 free_generic_messages( ctx
->msgs
);
918 imap_open_store( imap_server_conf_t
*srvc
)
924 struct sockaddr_in addr
;
925 int s
, a
[2], preauth
;
927 ctx
= xcalloc( sizeof(*ctx
), 1 );
929 ctx
->imap
= imap
= xcalloc( sizeof(*imap
), 1 );
930 imap
->buf
.sock
.fd
= -1;
931 imap
->in_progress_append
= &imap
->in_progress
;
933 /* open connection to IMAP server */
936 info( "Starting tunnel '%s'... ", srvc
->tunnel
);
938 if (socketpair( PF_UNIX
, SOCK_STREAM
, 0, a
)) {
939 perror( "socketpair" );
944 if (dup2( a
[0], 0 ) == -1 || dup2( a
[0], 1 ) == -1)
948 execl( "/bin/sh", "sh", "-c", srvc
->tunnel
, 0 );
954 imap
->buf
.sock
.fd
= a
[1];
958 memset( &addr
, 0, sizeof(addr
) );
959 addr
.sin_port
= htons( srvc
->port
);
960 addr
.sin_family
= AF_INET
;
962 info( "Resolving %s... ", srvc
->host
);
963 he
= gethostbyname( srvc
->host
);
965 perror( "gethostbyname" );
970 addr
.sin_addr
.s_addr
= *((int *) he
->h_addr_list
[0]);
972 s
= socket( PF_INET
, SOCK_STREAM
, 0 );
974 info( "Connecting to %s:%hu... ", inet_ntoa( addr
.sin_addr
), ntohs( addr
.sin_port
) );
975 if (connect( s
, (struct sockaddr
*)&addr
, sizeof(addr
) )) {
982 imap
->buf
.sock
.fd
= s
;
986 /* read the greeting string */
987 if (buffer_gets( &imap
->buf
, &rsp
)) {
988 fprintf( stderr
, "IMAP error: no greeting response\n" );
991 arg
= next_arg( &rsp
);
992 if (!arg
|| *arg
!= '*' || (arg
= next_arg( &rsp
)) == NULL
) {
993 fprintf( stderr
, "IMAP error: invalid greeting response\n" );
997 if (!strcmp( "PREAUTH", arg
))
999 else if (strcmp( "OK", arg
) != 0) {
1000 fprintf( stderr
, "IMAP error: unknown greeting response\n" );
1003 parse_response_code( ctx
, 0, rsp
);
1004 if (!imap
->caps
&& imap_exec( ctx
, 0, "CAPABILITY" ) != RESP_OK
)
1009 info ("Logging in...\n");
1011 fprintf( stderr
, "Skipping server %s, no user\n", srvc
->host
);
1016 sprintf( prompt
, "Password (%s@%s): ", srvc
->user
, srvc
->host
);
1017 arg
= getpass( prompt
);
1019 perror( "getpass" );
1023 fprintf( stderr
, "Skipping account %s@%s, no password\n", srvc
->user
, srvc
->host
);
1027 * getpass() returns a pointer to a static buffer. make a copy
1028 * for long term storage.
1030 srvc
->pass
= strdup( arg
);
1033 fprintf( stderr
, "Skipping account %s@%s, server forbids LOGIN\n", srvc
->user
, srvc
->host
);
1036 warn( "*** IMAP Warning *** Password is being sent in the clear\n" );
1037 if (imap_exec( ctx
, 0, "LOGIN \"%s\" \"%s\"", srvc
->user
, srvc
->pass
) != RESP_OK
) {
1038 fprintf( stderr
, "IMAP error: LOGIN failed\n" );
1045 return (store_t
*)ctx
;
1048 imap_close_store( &ctx
->gen
);
1053 imap_make_flags( int flags
, char *buf
)
1058 for (i
= d
= 0; i
< ARRAY_SIZE(Flags
); i
++)
1059 if (flags
& (1 << i
)) {
1062 for (s
= Flags
[i
]; *s
; s
++)
1073 imap_store_msg( store_t
*gctx
, msg_data_t
*data
, int *uid
)
1075 imap_store_t
*ctx
= (imap_store_t
*)gctx
;
1076 imap_t
*imap
= ctx
->imap
;
1077 struct imap_cmd_cb cb
;
1079 const char *prefix
, *box
;
1080 int ret
, i
, j
, d
, len
, extra
, nocr
;
1081 int start
, sbreak
= 0, ebreak
= 0;
1082 char flagstr
[128], tuid
[TUIDL
* 2 + 1];
1084 memset( &cb
, 0, sizeof(cb
) );
1090 if (!CAP(UIDPLUS
) && uid
) {
1094 if (fmap
[i
++] == '\n') {
1096 if (i
- 2 + nocr
== start
) {
1097 sbreak
= ebreak
= i
- 2 + nocr
;
1100 if (!memcmp( fmap
+ start
, "X-TUID: ", 8 )) {
1101 extra
-= (ebreak
= i
) - (sbreak
= start
) + nocr
;
1106 /* invalid message */
1110 for (j
= 0; j
< TUIDL
; j
++)
1111 sprintf( tuid
+ j
* 2, "%02x", arc4_getbyte() );
1112 extra
+= 8 + TUIDL
* 2 + 2;
1115 for (; i
< len
; i
++)
1116 if (fmap
[i
] == '\n')
1119 cb
.dlen
= len
+ extra
;
1120 buf
= cb
.data
= xmalloc( cb
.dlen
);
1122 if (!CAP(UIDPLUS
) && uid
) {
1124 for (; i
< sbreak
; i
++)
1125 if (fmap
[i
] == '\n') {
1131 memcpy( buf
, fmap
, sbreak
);
1134 memcpy( buf
, "X-TUID: ", 8 );
1136 memcpy( buf
, tuid
, TUIDL
* 2 );
1143 for (; i
< len
; i
++)
1144 if (fmap
[i
] == '\n') {
1150 memcpy( buf
, fmap
+ i
, len
- i
);
1156 d
= imap_make_flags( data
->flags
, flagstr
);
1162 box
= gctx
->conf
->trash
;
1163 prefix
= ctx
->prefix
;
1166 imap
->caps
= imap
->rcaps
& ~(1 << LITERALPLUS
);
1169 prefix
= !strcmp( box
, "INBOX" ) ? "" : ctx
->prefix
;
1173 ret
= imap_exec_m( ctx
, &cb
, "APPEND \"%s%s\" %s", prefix
, box
, flagstr
);
1174 imap
->caps
= imap
->rcaps
;
1185 #define CHUNKSIZE 0x1000
1188 read_message( FILE *f
, msg_data_t
*msg
)
1192 memset( msg
, 0, sizeof *msg
);
1194 msg
->data
= xmalloc( len
+1 );
1198 if (msg
->len
>= len
) {
1201 p
= xrealloc(msg
->data
, len
+1);
1205 r
= fread( &msg
->data
[msg
->len
], 1, len
- msg
->len
, f
);
1210 msg
->data
[msg
->len
] = 0;
1215 count_messages( msg_data_t
*msg
)
1218 char *p
= msg
->data
;
1221 if (!strncmp( "From ", p
, 5 )) {
1225 p
= strstr( p
+5, "\nFrom ");
1234 split_msg( msg_data_t
*all_msgs
, msg_data_t
*msg
, int *ofs
)
1238 memset( msg
, 0, sizeof *msg
);
1239 if (*ofs
>= all_msgs
->len
)
1242 data
= &all_msgs
->data
[ *ofs
];
1243 msg
->len
= all_msgs
->len
- *ofs
;
1245 if (msg
->len
< 5 || strncmp( data
, "From ", 5 ))
1248 p
= strstr( data
, "\nFrom " );
1250 msg
->len
= &p
[1] - data
;
1252 msg
->data
= xmalloc( msg
->len
+ 1 );
1256 memcpy( msg
->data
, data
, msg
->len
);
1257 msg
->data
[ msg
->len
] = 0;
1263 static imap_server_conf_t server
=
1273 static char *imap_folder
;
1276 git_imap_config(const char *key
, const char *val
)
1278 char imap_key
[] = "imap.";
1280 if (strncmp( key
, imap_key
, sizeof imap_key
- 1 ))
1282 key
+= sizeof imap_key
- 1;
1284 if (!strcmp( "folder", key
)) {
1285 imap_folder
= strdup( val
);
1286 } else if (!strcmp( "host", key
)) {
1288 if (!strncmp( "imap:", val
, 5 ))
1293 if (!strncmp( "//", val
, 2 ))
1295 server
.host
= strdup( val
);
1297 else if (!strcmp( "user", key
))
1298 server
.user
= strdup( val
);
1299 else if (!strcmp( "pass", key
))
1300 server
.pass
= strdup( val
);
1301 else if (!strcmp( "port", key
))
1302 server
.port
= git_config_int( key
, val
);
1303 else if (!strcmp( "tunnel", key
))
1304 server
.tunnel
= strdup( val
);
1309 main(int argc
, char **argv
)
1311 msg_data_t all_msgs
, msg
;
1318 /* init the random number generator */
1321 git_config( git_imap_config
);
1324 fprintf( stderr
, "no imap store specified\n" );
1328 /* read the messages */
1329 if (!read_message( stdin
, &all_msgs
)) {
1330 fprintf(stderr
,"nothing to send\n");
1334 /* write it to the imap server */
1335 ctx
= imap_open_store( &server
);
1337 fprintf( stderr
,"failed to open store\n");
1341 total
= count_messages( &all_msgs
);
1342 fprintf( stderr
, "sending %d message%s\n", total
, (total
!=1)?"s":"" );
1343 ctx
->name
= imap_folder
;
1345 unsigned percent
= n
* 100 / total
;
1346 fprintf( stderr
, "%4u%% (%d/%d) done\r", percent
, n
, total
);
1347 if (!split_msg( &all_msgs
, &msg
, &ofs
))
1349 r
= imap_store_msg( ctx
, &msg
, &uid
);
1350 if (r
!= DRV_OK
) break;
1353 fprintf( stderr
,"\n" );
1355 imap_close_store( ctx
);