b2f58b80afddb245a9bbe60eacd3fc8e1b9631a0
[citadel] / citadel / ctdlmigrate.c
1 /*
2  * Across-the-wire migration utility for Citadel
3  *
4  * Copyright (c) 2009-2021 citadel.org
5  *
6  * This program is open source software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 3.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <ctype.h>
20 #include <fcntl.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <sys/utsname.h>
24 #include <sys/wait.h>
25 #include <signal.h>
26 #include <netdb.h>
27 #include <errno.h>
28 #include <limits.h>
29 #include <pwd.h>
30 #include <time.h>
31 #include <readline/readline.h>
32 #include <sys/socket.h>
33 #include <sys/un.h>
34 #include <libcitadel.h>
35 #include "citadel.h"
36 #include "axdefs.h"
37 #include "sysdep.h"
38 #include "config.h"
39 #include "citadel_dirs.h"
40
41
42
43 // yeah, this wouldn't work in a multithreaded program.
44 static int gmaxlen = 0;
45 static char *gdeftext = NULL;
46
47 static int limit_rl(FILE *dummy) {
48         if (rl_end > gmaxlen) {
49                 return '\b';
50         }
51         return rl_getc(dummy);
52 }
53
54
55 static int getz_deftext(void) {
56         if (gdeftext) {
57                 rl_insert_text(gdeftext);
58                 gdeftext = NULL;
59                 rl_startup_hook = NULL;
60         }
61         return 0;
62 }
63
64
65 /*
66  * Replacement for gets() that doesn't throw a compiler warning.
67  * We're only using it for some simple prompts, so we don't need
68  * to worry about attackers exploiting it.
69  */
70 void getz(char *buf, int maxlen, char *default_value, char *prompt) {
71         rl_startup_hook = getz_deftext;
72         rl_getc_function = limit_rl;
73         gmaxlen = maxlen;
74         gdeftext = default_value;
75         strcpy(buf, readline(prompt));
76 }
77
78
79 void ctdlmigrate_exit(int cmdexit) {
80         printf("\n\n\033[3%dmExit code %d\033[0m\n", (cmdexit ? 1 : 2), cmdexit);
81         exit(cmdexit);
82 }
83
84
85 /*
86  * Connect to a Citadel on a remote host using a TCP/IP socket
87  */
88 static int tcp_connectsock(char *host, char *service) {
89         struct in6_addr serveraddr;
90         struct addrinfo hints;
91         struct addrinfo *res = NULL;
92         struct addrinfo *ai = NULL;
93         int rc = (-1);
94         int sock = (-1);
95
96         if ((host == NULL) || IsEmptyStr(host)) {
97                 return(-1);
98         }
99         if ((service == NULL) || IsEmptyStr(service)) {
100                 return(-1);
101         }
102
103         memset(&hints, 0x00, sizeof(hints));
104         hints.ai_flags = AI_NUMERICSERV;
105         hints.ai_family = AF_UNSPEC;
106         hints.ai_socktype = SOCK_STREAM;
107
108         /*
109          * Handle numeric IPv4 and IPv6 addresses
110          */
111         rc = inet_pton(AF_INET, host, &serveraddr);
112         if (rc == 1) {          /* dotted quad */
113                 hints.ai_family = AF_INET;
114                 hints.ai_flags |= AI_NUMERICHOST;
115         } else {
116                 rc = inet_pton(AF_INET6, host, &serveraddr);
117                 if (rc == 1) {  /* IPv6 address */
118                         hints.ai_family = AF_INET6;
119                         hints.ai_flags |= AI_NUMERICHOST;
120                 }
121         }
122
123         /* Begin the connection process */
124
125         rc = getaddrinfo(host, service, &hints, &res);
126         if (rc != 0) {
127                 fprintf(stderr, "ctdlmigrate: %s\n", strerror(errno));
128                 return (-1);
129         }
130
131         /*
132          * Try all available addresses until we connect to one or until we run out.
133          */
134         for (ai = res; ai != NULL; ai = ai->ai_next) {
135                 sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
136                 if (sock < 0) {
137                         fprintf(stderr, "ctdlmigrate: %s\n", strerror(errno));
138                         return (-1);
139                 }
140
141                 rc = connect(sock, ai->ai_addr, ai->ai_addrlen);
142                 if (rc >= 0) {
143                         return (sock);  /* Connected! */
144                 }
145                 else {
146                         fprintf(stderr, "ctdlmigrate: %s\n", strerror(errno));
147                         close(sock);    /* Failed.  Close the socket to avoid fd leak! */
148                 }
149         }
150         return (-1);
151 }
152
153
154 int uds_connectsock(char *sockpath) {
155         int s;
156         struct sockaddr_un addr;
157
158         memset(&addr, 0, sizeof(addr));
159         addr.sun_family = AF_UNIX;
160         strcpy(addr.sun_path, sockpath);
161
162         s = socket(AF_UNIX, SOCK_STREAM, 0);
163         if (s < 0) {
164                 fprintf(stderr, "ctdlmigrate: Can't create socket: %s\n", strerror(errno));
165                 return(-1);
166         }
167
168         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
169                 fprintf(stderr, "ctdlmigrate: can't connect: %s\n", strerror(errno));
170                 close(s);
171                 return(-1);
172         }
173
174         return s;
175 }
176
177
178 /*
179  * input binary data from socket
180  */
181 void serv_read(int serv_sock, char *buf, int bytes) {
182         int len, rlen;
183
184         len = 0;
185         while (len < bytes) {
186                 rlen = read(serv_sock, &buf[len], bytes - len);
187                 if (rlen < 1) {
188                         return;
189                 }
190                 len = len + rlen;
191         }
192 }
193
194
195 /*
196  * send binary to server
197  */
198 void serv_write(int serv_sock, char *buf, int nbytes) {
199         int bytes_written = 0;
200         int retval;
201         while (bytes_written < nbytes) {
202                 retval = write(serv_sock, &buf[bytes_written], nbytes - bytes_written);
203                 if (retval < 1) {
204                         return;
205                 }
206                 bytes_written = bytes_written + retval;
207         }
208 }
209
210
211 /*
212  * input string from socket - implemented in terms of serv_read()
213  */
214 void serv_gets(int serv_sock, char *buf) {
215         int i;
216
217         /* Read one character at a time.
218          */
219         for (i = 0;; i++) {
220                 serv_read(serv_sock, &buf[i], 1);
221                 if (buf[i] == '\n' || i == (SIZ-1))
222                         break;
223         }
224
225         /* If we got a long line, discard characters until the newline.
226          */
227         if (i == (SIZ-1)) {
228                 while (buf[i] != '\n') {
229                         serv_read(serv_sock, &buf[i], 1);
230                 }
231         }
232
233         /* Strip all trailing nonprintables (crlf)
234          */
235         buf[i] = 0;
236 }
237
238
239 /*
240  * send line to server - implemented in terms of serv_write()
241  */
242 void serv_puts(int serv_sock, char *buf) {
243         serv_write(serv_sock, buf, strlen(buf));
244         serv_write(serv_sock, "\n", 1);
245 }
246
247
248 /*
249  * serv_printf()        Send formatted printable data to the server
250  */
251 void serv_printf(int serv_sock, const char *format, ...) {   
252         va_list arg_ptr;   
253         char buf[1024];
254    
255         va_start(arg_ptr, format);   
256         if (vsnprintf(buf, sizeof buf, format, arg_ptr) == -1)
257                 buf[sizeof buf - 2] = '\n';
258         serv_write(serv_sock, buf, strlen(buf)); 
259         va_end(arg_ptr);
260 }
261
262
263 int main(int argc, char *argv[]) {
264         char ctdldir[PATH_MAX]=CTDLDIR;
265         char yesno[2];
266         int cmdexit = 0;                                // when something fails, set cmdexit to nonzero, and skip to the end
267         char buf[PATH_MAX];
268
269         char remote_user[128];
270         char remote_host[128];
271         char remote_pass[128];
272         char *remote_port = "504";
273
274         int linecount = 0;
275         int a;
276         int remote_server_socket = (-1);
277         int local_admin_socket = (-1);
278         int progress = 0;
279
280         /* Parse command line */
281         while ((a = getopt(argc, argv, "h:")) != EOF) {
282                 switch (a) {
283                 case 'h':
284                         strcpy(ctdldir, optarg);
285                         break;
286                 default:
287                         fprintf(stderr, "ctdlmigrate: usage: ctdlmigrate [-h server_dir]\n");
288                         return(1);
289                 }
290         }
291
292         if (chdir(ctdldir) != 0) {
293                 fprintf(stderr, "ctdlmigrate: %s: %s\n", ctdldir, strerror(errno));
294                 exit(errno);
295         }
296
297         signal(SIGINT, ctdlmigrate_exit);
298         signal(SIGQUIT, ctdlmigrate_exit);
299         signal(SIGTERM, ctdlmigrate_exit);
300         signal(SIGSEGV, ctdlmigrate_exit);
301         signal(SIGHUP, ctdlmigrate_exit);
302         signal(SIGPIPE, ctdlmigrate_exit);
303
304         printf( "\033[2J\033[H\n"
305                 "          \033[32m╔═══════════════════════════════════════════════╗\n"
306                 "          ║                                               ║\n"
307                 "          ║    \033[33mCitadel over-the-wire migration utility    \033[32m║\n"
308                 "          ║                                               ║\n"
309                 "          ╚═══════════════════════════════════════════════╝\033[0m\n"
310                 "\n"
311                 "This utility is designed to migrate your Citadel installation\n"
312                 "to a new host system via a network connection, without disturbing\n"
313                 "the source system.  The target may be a different CPU architecture\n"
314                 "and/or operating system.  The source system should be running\n"
315                 "Citadel version \033[33m%d\033[0m or newer, and the target system should be running\n"
316                 "either the same version or a newer version.  You will also need\n"
317                 "the \033[33mrsync\033[0m utility, and OpenSSH v4 or newer.\n"
318                 "\n"
319                 "You must run this utility on the TARGET SYSTEM.  Any existing data\n"
320                 "on this system will be ERASED.  Your target system will be on this\n"
321                 "host in %s.\n"
322                 "\n",
323                 EXPORT_REV_MIN, ctdldir
324         );
325
326         getz(yesno, 1, NULL, "Do you wish to continue? ");
327         puts(yesno);
328         if (tolower(yesno[0]) != 'y') {
329                 cmdexit = 1;
330         }
331
332         if (!cmdexit) {
333                 printf( "\033[2J\033[H\n"
334                         "          \033[32m╔═══════════════════════════════════════════════╗\n"
335                         "          ║                                               ║\n"
336                         "          ║       \033[33mValidate source and target systems\033[32m      ║\n"
337                         "          ║                                               ║\n"
338                         "          ╚═══════════════════════════════════════════════╝\033[0m\n"
339                         "\n\n");
340         
341                 printf("First we must validate that the local target system is running and ready to receive data.\n");
342                 printf("Checking connectivity to Citadel in %s...\n", ctdldir);
343                 local_admin_socket = uds_connectsock("citadel-admin.socket");
344                 if (local_admin_socket < 0) {
345                         cmdexit = 1;
346                 }
347         }
348
349         if (!cmdexit) {
350                 serv_gets(local_admin_socket, buf);
351                 puts(buf);
352                 if (buf[0] != '2') {
353                         cmdexit = 1;
354                 }
355         }
356
357         if (!cmdexit) {
358                 serv_puts(local_admin_socket, "ECHO Connection to Citadel Server succeeded.");
359                 serv_gets(local_admin_socket, buf);
360                 puts(buf);
361                 if (buf[0] != '2') {
362                         cmdexit = 1;
363                 }
364         }
365
366         if (!cmdexit) {
367                 printf("\n");
368                 printf("OK, this side is ready to go.  Now we must connect to the source system.\n\n");
369
370                 getz(remote_host, sizeof remote_host, NULL,     "Enter the name or IP address of the source system: ");
371                 getz(remote_user, sizeof remote_user, "admin",  "  Enter the user name of an administrator account: ");
372                 getz(remote_pass, sizeof remote_pass, NULL,     "              Enter the password for this account: ");
373
374                 remote_server_socket = tcp_connectsock(remote_host, remote_port);
375                 if (remote_server_socket < 0) {
376                         cmdexit = 1;
377                 }
378         }
379
380         if (!cmdexit) {
381                 serv_gets(remote_server_socket, buf);
382                 puts(buf);
383                 if (buf[0] != '2') {
384                         cmdexit = 1;
385                 }
386         }
387
388         if (!cmdexit) {
389                 serv_printf(remote_server_socket, "USER %s\n", remote_user);
390                 serv_gets(remote_server_socket, buf);
391                 puts(buf);
392                 if (buf[0] != '3') {
393                         cmdexit = 1;
394                 }
395         }
396
397         if (!cmdexit) {
398                 serv_printf(remote_server_socket, "PASS %s\n", remote_pass);
399                 serv_gets(remote_server_socket, buf);
400                 puts(buf);
401                 if (buf[0] != '2') {
402                         cmdexit = 1;
403                 }
404         }
405
406         if (!cmdexit) {
407                 printf( "\033[2J\033[H\n"
408                         "          \033[32m╔═══════════════════════════════════════════════════════════════════╗\n"
409                         "          ║                                                                   ║\n"
410                         "          ║ \033[33mMigrating from: %-50s\033[32m║\n"
411                         "          ║                                                                   ║\n"
412                         "          ╠═══════════════════════════════════════════════════════════════════╣\n"
413                         "          ║                                                                   ║\n"
414                         "          ║ Lines received: 0                           Percent complete: 0   ║\n"
415                         "          ║                                                                   ║\n"
416                         "          ╚═══════════════════════════════════════════════════════════════════╝\033[0m\n"
417                         "\n", remote_host
418                 );
419         }
420
421         if (!cmdexit) {
422                 serv_puts(remote_server_socket, "MIGR export");
423                 serv_gets(remote_server_socket, buf);
424                 if (buf[0] != '1') {
425                         printf("\n\033[31m%s\033[0m\n", buf);
426                         cmdexit = 3;
427                 }
428         }
429
430         if (!cmdexit) {
431                 serv_puts(local_admin_socket, "MIGR import");
432                 serv_gets(local_admin_socket, buf);
433                 if (buf[0] != '4') {
434                         printf("\n\033[31m%s\033[0m\n", buf);
435                         cmdexit = 3;
436                 }
437         }
438
439         if (!cmdexit) {
440                 char *ptr;
441                 time_t last_update = time(NULL);
442
443                 while (serv_gets(remote_server_socket, buf), strcmp(buf, "000")) {
444                         ptr = strchr(buf, '\n');
445                         if (ptr) *ptr = 0;      // remove the newline character
446                         ++linecount;
447                         if (!strncasecmp(buf, "<progress>", 10)) {
448                                 progress = atoi(&buf[10]);
449                                 printf("\033[8;75H\033[33m%d\033[0m\033[20;0H\n", progress);
450                         }
451                         if (time(NULL) != last_update) {
452                                 last_update = time(NULL);
453                                 printf("\033[8;29H\033[33m%d\033[0m\033[20;0H\n", linecount);
454                         }
455                         serv_puts(local_admin_socket, buf);
456                 }
457         
458                 serv_puts(local_admin_socket, "000");
459         }
460
461         if ( (cmdexit == 0) && (progress < 100) ) {
462                 printf("\033[31mERROR: source stream ended before 100 percent of data was received.\033[0m\n");
463                 ctdlmigrate_exit(86);
464         }
465
466         // FIXME restart the local server now
467
468         ctdlmigrate_exit(cmdexit);
469 }