formatting
[citadel] / citadel / modules / migrate / serv_migrate.c
1 // This module dumps and/or loads the Citadel database in XML format.
2 //
3 // Copyright (c) 1987-2021 by the citadel.org team
4 //
5 // This program is open source software; you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License version 3.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 // GNU General Public License for more details.
12 //
13 // Explanation of <progress> tags:
14 //
15 // 0%           started
16 // 2%           finished exporting configuration
17 // 7%           finished exporting users
18 // 12%          finished exporting openids
19 // 17%          finished exporting rooms
20 // 18%          finished exporting floors
21 // 25%          finished exporting visits
22 // 26-99%       exporting messages
23 // 100%         finished exporting messages
24 //
25 // These tags are inserted into the XML stream to give the reader an approximation of its progress.
26
27 #include "sysdep.h"
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <stdio.h>
31 #include <fcntl.h>
32 #include <signal.h>
33 #include <pwd.h>
34 #include <errno.h>
35 #include <sys/types.h>
36 #include <time.h>
37 #include <sys/wait.h>
38 #include <string.h>
39 #include <ctype.h>
40 #include <limits.h>
41 #include <expat.h>
42 #include <libcitadel.h>
43 #include "citadel.h"
44 #include "server.h"
45 #include "citserver.h"
46 #include "support.h"
47 #include "config.h"
48 #include "database.h"
49 #include "msgbase.h"
50 #include "user_ops.h"
51 #include "euidindex.h"
52 #include "ctdl_module.h"
53
54 char migr_tempfilename1[PATH_MAX];
55 char migr_tempfilename2[PATH_MAX];
56 FILE *migr_global_message_list;
57 int total_msgs = 0;
58 char *ikey = NULL;                      // If we're importing a config key we store it here.
59
60 //*****************************************************************************
61 //*       Code which implements the export appears in this section            *
62 //*****************************************************************************
63
64 // Output a string to the client with these characters escaped:  & < > " '
65 void xml_strout(char *str) {
66
67         char *c = str;
68
69         if (str == NULL) {
70                 return;
71         }
72
73         while (*c != 0) {
74                 if (*c == '\"') {
75                         client_write(HKEY("&quot;"));
76                 }
77                 else if (*c == '\'') {
78                         client_write(HKEY("&apos;"));
79                 }
80                 else if (*c == '<') {
81                         client_write(HKEY("&lt;"));
82                 }
83                 else if (*c == '>') {
84                         client_write(HKEY("&gt;"));
85                 }
86                 else if (*c == '&') {
87                         client_write(HKEY("&amp;"));
88                 }
89                 else {
90                         client_write(c, 1);
91                 }
92                 ++c;
93         }
94 }
95
96
97 // Export a user record as XML
98 void migr_export_users_backend(char *username, void *data) {
99
100         struct ctdluser u;
101         if (CtdlGetUser(&u, username) != 0) {
102                 return;
103         }
104
105         client_write(HKEY("<user>\n"));
106         cprintf("<u_version>%d</u_version>\n", u.version);
107         cprintf("<u_uid>%ld</u_uid>\n", (long)u.uid);
108         client_write(HKEY("<u_password>"));     xml_strout(u.password);         client_write(HKEY("</u_password>\n"));
109         cprintf("<u_flags>%u</u_flags>\n", u.flags);
110         cprintf("<u_timescalled>%ld</u_timescalled>\n", u.timescalled);
111         cprintf("<u_posted>%ld</u_posted>\n", u.posted);
112         cprintf("<u_axlevel>%d</u_axlevel>\n", u.axlevel);
113         cprintf("<u_usernum>%ld</u_usernum>\n", u.usernum);
114         cprintf("<u_lastcall>%ld</u_lastcall>\n", (long)u.lastcall);
115         cprintf("<u_USuserpurge>%d</u_USuserpurge>\n", u.USuserpurge);
116         client_write(HKEY("<u_fullname>"));     xml_strout(u.fullname);         client_write(HKEY("</u_fullname>\n"));
117         cprintf("<u_msgnum_bio>%ld</u_msgnum_bio>\n", u.msgnum_bio);
118         cprintf("<u_msgnum_pic>%ld</u_msgnum_pic>\n", u.msgnum_pic);
119         cprintf("<u_emailaddrs>%s</u_emailaddrs>\n", u.emailaddrs);
120         cprintf("<u_msgnum_inboxrules>%ld</u_msgnum_inboxrules>\n", u.msgnum_inboxrules);
121         cprintf("<u_lastproc_inboxrules>%ld</u_lastproc_inboxrules>\n", u.lastproc_inboxrules);
122         client_write(HKEY("</user>\n"));
123 }
124
125
126 void migr_export_users(void) {
127         ForEachUser(migr_export_users_backend, NULL);
128 }
129
130
131 void migr_export_room_msg(long msgnum, void *userdata) {
132         static int count = 0;
133
134         cprintf("%ld,", msgnum);
135         if (++count%10==0) {
136                 cprintf("\n");
137         }
138         fprintf(migr_global_message_list, "%ld\n", msgnum);
139 }
140
141
142 void migr_export_rooms_backend(struct ctdlroom *buf, void *data) {
143         client_write(HKEY("<room>\n"));
144         client_write(HKEY("<QRname>"));
145         xml_strout(buf->QRname);
146         client_write(HKEY("</QRname>\n"));
147         client_write(HKEY("<QRpasswd>"));
148         xml_strout(buf->QRpasswd);
149         client_write(HKEY("</QRpasswd>\n"));
150         cprintf("<QRroomaide>%ld</QRroomaide>\n", buf->QRroomaide);
151         cprintf("<QRhighest>%ld</QRhighest>\n", buf->QRhighest);
152         cprintf("<QRgen>%ld</QRgen>\n", (long)buf->QRgen);
153         cprintf("<QRflags>%u</QRflags>\n", buf->QRflags);
154         if (buf->QRflags & QR_DIRECTORY) {
155                 client_write(HKEY("<QRdirname>"));
156                 xml_strout(buf->QRdirname);
157                 client_write(HKEY("</QRdirname>\n"));
158         }
159         cprintf("<QRfloor>%d</QRfloor>\n", buf->QRfloor);
160         cprintf("<QRmtime>%ld</QRmtime>\n", (long)buf->QRmtime);
161         cprintf("<QRexpire_mode>%d</QRexpire_mode>\n", buf->QRep.expire_mode);
162         cprintf("<QRexpire_value>%d</QRexpire_value>\n", buf->QRep.expire_value);
163         cprintf("<QRnumber>%ld</QRnumber>\n", buf->QRnumber);
164         cprintf("<QRorder>%d</QRorder>\n", buf->QRorder);
165         cprintf("<QRflags2>%u</QRflags2>\n", buf->QRflags2);
166         cprintf("<QRdefaultview>%d</QRdefaultview>\n", buf->QRdefaultview);
167         cprintf("<msgnum_info>%ld</msgnum_info>\n", buf->msgnum_info);
168         cprintf("<msgnum_pic>%ld</msgnum_pic>\n", buf->msgnum_pic);
169         client_write(HKEY("</room>\n"));
170
171         // message list goes inside this tag
172         CtdlGetRoom(&CC->room, buf->QRname);
173         client_write(HKEY("<room_messages>"));
174         client_write(HKEY("<FRname>"));
175         xml_strout(buf->QRname);                        // buf->QRname rather than CC->room.QRname to guarantee consistency
176         client_write(HKEY("</FRname>\n"));
177         client_write(HKEY("<FRmsglist>\n"));
178         CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, migr_export_room_msg, NULL);
179         client_write(HKEY("</FRmsglist>\n"));
180         client_write(HKEY("</room_messages>\n"));
181 }
182
183
184 void migr_export_rooms(void) {
185         char cmd[SIZ];
186         migr_global_message_list = fopen(migr_tempfilename1, "w");
187         if (migr_global_message_list != NULL) {
188                 CtdlForEachRoom(migr_export_rooms_backend, NULL);
189                 fclose(migr_global_message_list);
190         }
191
192         // Process the 'global' message list.  (Sort it and remove dups.
193         // Dups are ok because a message may be in more than one room, but
194         // this will be handled by exporting the reference count, not by
195         // exporting the message multiple times.)
196         snprintf(cmd, sizeof cmd, "sort -n <%s >%s", migr_tempfilename1, migr_tempfilename2);
197         if (system(cmd) != 0) {
198                 syslog(LOG_ERR, "migrate: error %d", errno);
199         }
200         snprintf(cmd, sizeof cmd, "uniq <%s >%s", migr_tempfilename2, migr_tempfilename1);
201         if (system(cmd) != 0) {
202                 syslog(LOG_ERR, "migrate: error %d", errno);
203         }
204
205         snprintf(cmd, sizeof cmd, "wc -l %s", migr_tempfilename1);
206         FILE *fp = popen(cmd, "r");
207         if (fp) {
208                 fgets(cmd, sizeof cmd, fp);
209                 pclose(fp);
210                 total_msgs = atoi(cmd);
211         }
212         else {
213                 total_msgs = 1; // any nonzero just to keep it from barfing
214         }
215         syslog(LOG_DEBUG, "migrate: total messages to be exported: %d", total_msgs);
216 }
217
218
219 void migr_export_floors(void) {
220         struct floor qfbuf, *buf;
221         int i;
222
223         for (i=0; i < MAXFLOORS; ++i) {
224                 client_write(HKEY("<floor>\n"));
225                 cprintf("<f_num>%d</f_num>\n", i);
226                 CtdlGetFloor(&qfbuf, i);
227                 buf = &qfbuf;
228                 cprintf("<f_flags>%u</f_flags>\n", buf->f_flags);
229                 client_write(HKEY("<f_name>")); xml_strout(buf->f_name); client_write(HKEY("</f_name>\n"));
230                 cprintf("<f_ref_count>%d</f_ref_count>\n", buf->f_ref_count);
231                 cprintf("<f_ep_expire_mode>%d</f_ep_expire_mode>\n", buf->f_ep.expire_mode);
232                 cprintf("<f_ep_expire_value>%d</f_ep_expire_value>\n", buf->f_ep.expire_value);
233                 client_write(HKEY("</floor>\n"));
234         }
235 }
236
237
238 // Return nonzero if the supplied string contains only characters which are valid in a sequence set.
239 int is_sequence_set(char *s) {
240         if (!s) return(0);
241
242         char *c = s;
243         char ch;
244         while (ch = *c++, ch) {
245                 if (!strchr("0123456789*,:", ch)) {
246                         return(0);
247                 }
248         }
249         return(1);
250 }
251
252
253 // Traverse the visits file...
254 void migr_export_visits(void) {
255         visit vbuf;
256         struct cdbdata *cdbv;
257
258         cdb_rewind(CDB_VISIT);
259
260         while (cdbv = cdb_next_item(CDB_VISIT), cdbv != NULL) {
261                 memset(&vbuf, 0, sizeof(visit));
262                 memcpy(&vbuf, cdbv->ptr,
263                        ((cdbv->len > sizeof(visit)) ?
264                         sizeof(visit) : cdbv->len));
265                 cdb_free(cdbv);
266
267                 client_write(HKEY("<visit>\n"));
268                 cprintf("<v_roomnum>%ld</v_roomnum>\n", vbuf.v_roomnum);
269                 cprintf("<v_roomgen>%ld</v_roomgen>\n", vbuf.v_roomgen);
270                 cprintf("<v_usernum>%ld</v_usernum>\n", vbuf.v_usernum);
271
272                 client_write(HKEY("<v_seen>"));
273                 if ( (!IsEmptyStr(vbuf.v_seen)) && (is_sequence_set(vbuf.v_seen)) ) {
274                         xml_strout(vbuf.v_seen);
275                 }
276                 else {
277                         cprintf("%ld", vbuf.v_lastseen);
278                 }
279                 client_write(HKEY("</v_seen>"));
280
281                 if ( (!IsEmptyStr(vbuf.v_answered)) && (is_sequence_set(vbuf.v_answered)) ) {
282                         client_write(HKEY("<v_answered>"));
283                         xml_strout(vbuf.v_answered);
284                         client_write(HKEY("</v_answered>\n"));
285                 }
286
287                 cprintf("<v_flags>%u</v_flags>\n", vbuf.v_flags);
288                 cprintf("<v_view>%d</v_view>\n", vbuf.v_view);
289                 client_write(HKEY("</visit>\n"));
290         }
291 }
292
293
294 void migr_export_message(long msgnum) {
295         struct MetaData smi;
296         struct CtdlMessage *msg;
297         struct ser_ret smr;
298         long bytes_written = 0;
299         long this_block = 0;
300
301         // We can use a static buffer here because there will never be more than
302         // one of this operation happening at any given time, and it's really best
303         // to just keep it allocated once instead of torturing malloc/free.
304         // Call this function with msgnum "-1" to free the buffer when finished.
305
306         static int encoded_alloc = 0;
307         static char *encoded_msg = NULL;
308
309         if (msgnum < 0) {
310                 if ((encoded_alloc == 0) && (encoded_msg != NULL)) {
311                         free(encoded_msg);
312                         encoded_alloc = 0;
313                         encoded_msg = NULL;
314                 }
315                 return;
316         }
317
318         // Ok, here we go ...
319
320         msg = CtdlFetchMessage(msgnum, 1);
321         if (msg == NULL) return;                                // fail silently
322
323         client_write(HKEY("<message>\n"));
324         GetMetaData(&smi, msgnum);
325         cprintf("<msg_msgnum>%ld</msg_msgnum>\n", msgnum);
326         cprintf("<msg_meta_refcount>%d</msg_meta_refcount>\n", smi.meta_refcount);
327         cprintf("<msg_meta_rfc822_length>%ld</msg_meta_rfc822_length>\n", smi.meta_rfc822_length);
328         client_write(HKEY("<msg_meta_content_type>")); xml_strout(smi.meta_content_type); client_write(HKEY("</msg_meta_content_type>\n"));
329
330         client_write(HKEY("<msg_text>"));
331         CtdlSerializeMessage(&smr, msg);
332         CM_Free(msg);
333
334         // Predict the buffer size we need.  Expand the buffer if necessary.
335         int encoded_len = smr.len * 15 / 10 ;
336         if (encoded_len > encoded_alloc) {
337                 encoded_alloc = encoded_len;
338                 encoded_msg = realloc(encoded_msg, encoded_alloc);
339         }
340
341         if (encoded_msg == NULL) {
342                 // Questionable hack that hopes it'll work next time and we only lose one message
343                 encoded_alloc = 0;
344         }
345         else {
346                 // Once we do the encoding we know the exact size
347                 encoded_len = CtdlEncodeBase64(encoded_msg, (char *)smr.ser, smr.len, 1);
348
349                 // Careful now.  If the message is gargantuan, trying to write multiple gigamegs in one
350                 // big write operation can make our transport unhappy.  So we'll chunk it up 10 KB at a time.
351                 bytes_written = 0;
352                 while ( (bytes_written < encoded_len) && (!server_shutting_down) ) {
353                         this_block = encoded_len - bytes_written;
354                         if (this_block > 10240) {
355                                 this_block = 10240;
356                         }
357                         client_write(&encoded_msg[bytes_written], this_block);
358                         bytes_written += this_block;
359                 }
360         }
361
362         free(smr.ser);
363
364         client_write(HKEY("</msg_text>\n"));
365         client_write(HKEY("</message>\n"));
366 }
367
368
369 void migr_export_openids(void) {
370         struct cdbdata *cdboi;
371         long usernum;
372         char url[512];
373
374         cdb_rewind(CDB_EXTAUTH);
375         while (cdboi = cdb_next_item(CDB_EXTAUTH), cdboi != NULL) {
376                 if (cdboi->len > sizeof(long)) {
377                         client_write(HKEY("<openid>\n"));
378                         memcpy(&usernum, cdboi->ptr, sizeof(long));
379                         snprintf(url, sizeof url, "%s", (cdboi->ptr)+sizeof(long) );
380                         client_write(HKEY("<oid_url>"));
381                         xml_strout(url);
382                         client_write(HKEY("</oid_url>\n"));
383                         cprintf("<oid_usernum>%ld</oid_usernum>\n", usernum);
384                         client_write(HKEY("</openid>\n"));
385                 }
386                 cdb_free(cdboi);
387         }
388 }
389
390
391 void migr_export_configs(void) {
392         struct cdbdata *cdbcfg;
393         int keylen = 0;
394         char *key = NULL;
395         char *value = NULL;
396
397         cdb_rewind(CDB_CONFIG);
398         while (cdbcfg = cdb_next_item(CDB_CONFIG), cdbcfg != NULL) {
399
400                 keylen = strlen(cdbcfg->ptr);
401                 key = cdbcfg->ptr;
402                 value = cdbcfg->ptr + keylen + 1;
403
404                 client_write("<config key=\"", 13);
405                 xml_strout(key);
406                 client_write("\">", 2);
407                 xml_strout(value);
408                 client_write("</config>\n", 10);
409                 cdb_free(cdbcfg);
410         }
411 }
412
413
414 void migr_export_messages(void) {
415         char buf[SIZ];
416         long msgnum;
417         int count = 0;
418         int progress = 0;
419         int prev_progress = 0;
420         CitContext *Ctx;
421
422         Ctx = CC;
423         migr_global_message_list = fopen(migr_tempfilename1, "r");
424         if (migr_global_message_list != NULL) {
425                 syslog(LOG_INFO, "migrate: opened %s", migr_tempfilename1);
426                 while ((Ctx->kill_me == 0) && 
427                        (fgets(buf, sizeof(buf), migr_global_message_list) != NULL)) {
428                         msgnum = atol(buf);
429                         if (msgnum > 0L) {
430                                 migr_export_message(msgnum);
431                                 ++count;
432                         }
433                         progress = (count * 74 / total_msgs) + 25 ;
434                         if ((progress > prev_progress) && (progress < 100)) {
435                                 cprintf("<progress>%d</progress>\n", progress);
436                         }
437                         prev_progress = progress;
438                 }
439                 fclose(migr_global_message_list);
440         }
441         if (Ctx->kill_me == 0) {
442                 syslog(LOG_INFO, "migrate: exported %d messages.", count);
443         }
444         else {
445                 syslog(LOG_ERR, "migrate: export aborted due to client disconnect!");
446         }
447
448         migr_export_message(-1L);       // This frees the encoding buffer
449 }
450
451
452 void migr_do_export(void) {
453         CitContext *Ctx;
454
455         Ctx = CC;
456         cprintf("%d Exporting all Citadel databases.\n", LISTING_FOLLOWS);
457         Ctx->dont_term = 1;
458
459         client_write(HKEY("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"));
460         client_write(HKEY("<citadel_migrate_data>\n"));
461         cprintf("<version>%d</version>\n", REV_LEVEL);
462         cprintf("<progress>%d</progress>\n", 0);
463
464         // export the configuration database
465         migr_export_configs();
466         cprintf("<progress>%d</progress>\n", 2);
467         
468         if (Ctx->kill_me == 0)  migr_export_users();
469         cprintf("<progress>%d</progress>\n", 7);
470         if (Ctx->kill_me == 0)  migr_export_openids();
471         cprintf("<progress>%d</progress>\n", 12);
472         if (Ctx->kill_me == 0)  migr_export_rooms();
473         cprintf("<progress>%d</progress>\n", 17);
474         if (Ctx->kill_me == 0)  migr_export_floors();
475         cprintf("<progress>%d</progress>\n", 18);
476         if (Ctx->kill_me == 0)  migr_export_visits();
477         cprintf("<progress>%d</progress>\n", 25);
478         if (Ctx->kill_me == 0)  migr_export_messages();
479         cprintf("<progress>%d</progress>\n", 100);
480         client_write(HKEY("</citadel_migrate_data>\n"));
481         client_write(HKEY("000\n"));
482         Ctx->dont_term = 0;
483 }
484
485
486 //                              Import code
487 //   Here's the code that implements the import side.  It's going to end up
488 //       being one big loop with lots of global variables.  I don't care.
489 // You wouldn't run multiple concurrent imports anyway.  If this offends your
490 //  delicate sensibilities  then go rewrite it in Ruby on Rails or something.
491
492
493 int citadel_migrate_data = 0;           // Are we inside a <citadel_migrate_data> tag pair?
494 StrBuf *migr_chardata = NULL;
495 StrBuf *migr_MsgData = NULL;
496 struct ctdluser usbuf;
497 struct ctdlroom qrbuf;
498 char openid_url[512];
499 long openid_usernum = 0;
500 char FRname[ROOMNAMELEN];
501 struct floor flbuf;
502 int floornum = 0;
503 visit vbuf;
504 struct MetaData smi;
505 long import_msgnum = 0;
506
507 // This callback stores up the data which appears in between tags.
508 void migr_xml_chardata(void *data, const XML_Char *s, int len) {
509         StrBufAppendBufPlain(migr_chardata, s, len, 0);
510 }
511
512
513 void migr_xml_start(void *data, const char *el, const char **attr) {
514         int i;
515
516         //  *** GENERAL STUFF ***
517
518         // Reset chardata_len to zero and init buffer
519         FlushStrBuf(migr_chardata);
520         FlushStrBuf(migr_MsgData);
521
522         if (!strcasecmp(el, "citadel_migrate_data")) {
523                 ++citadel_migrate_data;
524
525                 // As soon as it looks like the input data is a genuine Citadel XML export,
526                 // whack the existing database on disk to make room for the new one.
527                 if (citadel_migrate_data == 1) {
528                         syslog(LOG_INFO, "migrate: erasing existing databases so we can receive the incoming import");
529                         for (i = 0; i < MAXCDB; ++i) {
530                                 cdb_trunc(i);
531                         }
532                 }
533                 return;
534         }
535
536         if (citadel_migrate_data != 1) {
537                 syslog(LOG_ERR, "migrate: out-of-sequence tag <%s> detected.  Warning: ODD-DATA!", el);
538                 return;
539         }
540
541         // When we begin receiving XML for one of these record types, clear out the associated
542         // buffer so we don't accidentally carry over any data from a previous record.
543         if (!strcasecmp(el, "user"))                    memset(&usbuf, 0, sizeof (struct ctdluser));
544         else if (!strcasecmp(el, "openid"))             memset(openid_url, 0, sizeof openid_url);
545         else if (!strcasecmp(el, "room"))               memset(&qrbuf, 0, sizeof (struct ctdlroom));
546         else if (!strcasecmp(el, "room_messages"))      memset(FRname, 0, sizeof FRname);
547         else if (!strcasecmp(el, "floor"))              memset(&flbuf, 0, sizeof (struct floor));
548         else if (!strcasecmp(el, "visit"))              memset(&vbuf, 0, sizeof (visit));
549
550         else if (!strcasecmp(el, "message")) {
551                 memset(&smi, 0, sizeof (struct MetaData));
552                 import_msgnum = 0;
553         }
554         else if (!strcasecmp(el, "config")) {
555                 if (ikey != NULL) {
556                         free(ikey);
557                         ikey = NULL;
558                 }
559                 while (*attr) {
560                         if (!strcasecmp(attr[0], "key")) {
561                                 ikey = strdup(attr[1]);
562                         }
563                         attr += 2;
564                 }
565         }
566
567 }
568
569
570 int migr_userrecord(void *data, const char *el) {
571         if (!strcasecmp(el, "u_version"))                       usbuf.version = atoi(ChrPtr(migr_chardata));
572         else if (!strcasecmp(el, "u_uid"))                      usbuf.uid = atol(ChrPtr(migr_chardata));
573         else if (!strcasecmp(el, "u_password"))                 safestrncpy(usbuf.password, ChrPtr(migr_chardata), sizeof usbuf.password);
574         else if (!strcasecmp(el, "u_flags"))                    usbuf.flags = atoi(ChrPtr(migr_chardata));
575         else if (!strcasecmp(el, "u_timescalled"))              usbuf.timescalled = atol(ChrPtr(migr_chardata));
576         else if (!strcasecmp(el, "u_posted"))                   usbuf.posted = atol(ChrPtr(migr_chardata));
577         else if (!strcasecmp(el, "u_axlevel"))                  usbuf.axlevel = atoi(ChrPtr(migr_chardata));
578         else if (!strcasecmp(el, "u_usernum"))                  usbuf.usernum = atol(ChrPtr(migr_chardata));
579         else if (!strcasecmp(el, "u_lastcall"))                 usbuf.lastcall = atol(ChrPtr(migr_chardata));
580         else if (!strcasecmp(el, "u_USuserpurge"))              usbuf.USuserpurge = atoi(ChrPtr(migr_chardata));
581         else if (!strcasecmp(el, "u_fullname"))                 safestrncpy(usbuf.fullname, ChrPtr(migr_chardata), sizeof usbuf.fullname);
582         else if (!strcasecmp(el, "u_msgnum_bio"))               usbuf.msgnum_bio = atol(ChrPtr(migr_chardata));
583         else if (!strcasecmp(el, "u_msgnum_pic"))               usbuf.msgnum_pic = atol(ChrPtr(migr_chardata));
584         else if (!strcasecmp(el, "u_emailaddrs"))               safestrncpy(usbuf.emailaddrs, ChrPtr(migr_chardata), sizeof usbuf.emailaddrs);
585         else if (!strcasecmp(el, "u_msgnum_inboxrules"))        usbuf.msgnum_inboxrules = atol(ChrPtr(migr_chardata));
586         else if (!strcasecmp(el, "u_lastproc_inboxrules"))      usbuf.lastproc_inboxrules = atol(ChrPtr(migr_chardata));
587         else return 0;
588         return 1;
589 }
590
591
592 int migr_roomrecord(void *data, const char *el) {
593         if (!strcasecmp(el, "QRname"))                          safestrncpy(qrbuf.QRname, ChrPtr(migr_chardata), sizeof qrbuf.QRname);
594         else if (!strcasecmp(el, "QRpasswd"))                   safestrncpy(qrbuf.QRpasswd, ChrPtr(migr_chardata), sizeof qrbuf.QRpasswd);
595         else if (!strcasecmp(el, "QRroomaide"))                 qrbuf.QRroomaide = atol(ChrPtr(migr_chardata));
596         else if (!strcasecmp(el, "QRhighest"))                  qrbuf.QRhighest = atol(ChrPtr(migr_chardata));
597         else if (!strcasecmp(el, "QRgen"))                      qrbuf.QRgen = atol(ChrPtr(migr_chardata));
598         else if (!strcasecmp(el, "QRflags"))                    qrbuf.QRflags = atoi(ChrPtr(migr_chardata));
599         else if (!strcasecmp(el, "QRdirname"))                  safestrncpy(qrbuf.QRdirname, ChrPtr(migr_chardata), sizeof qrbuf.QRdirname);
600         else if (!strcasecmp(el, "QRfloor"))                    qrbuf.QRfloor = atoi(ChrPtr(migr_chardata));
601         else if (!strcasecmp(el, "QRmtime"))                    qrbuf.QRmtime = atol(ChrPtr(migr_chardata));
602         else if (!strcasecmp(el, "QRexpire_mode"))              qrbuf.QRep.expire_mode = atoi(ChrPtr(migr_chardata));
603         else if (!strcasecmp(el, "QRexpire_value"))             qrbuf.QRep.expire_value = atoi(ChrPtr(migr_chardata));
604         else if (!strcasecmp(el, "QRnumber"))                   qrbuf.QRnumber = atol(ChrPtr(migr_chardata));
605         else if (!strcasecmp(el, "QRorder"))                    qrbuf.QRorder = atoi(ChrPtr(migr_chardata));
606         else if (!strcasecmp(el, "QRflags2"))                   qrbuf.QRflags2 = atoi(ChrPtr(migr_chardata));
607         else if (!strcasecmp(el, "QRdefaultview"))              qrbuf.QRdefaultview = atoi(ChrPtr(migr_chardata));
608         else if (!strcasecmp(el, "msgnum_info"))                qrbuf.msgnum_info = atol(ChrPtr(migr_chardata));
609         else if (!strcasecmp(el, "msgnum_pic"))                 qrbuf.msgnum_pic = atol(ChrPtr(migr_chardata));
610         else return 0;
611         return 1;
612 }
613
614
615 int migr_floorrecord(void *data, const char *el) {
616         if (!strcasecmp(el, "f_num"))                           floornum = atoi(ChrPtr(migr_chardata));
617         else if (!strcasecmp(el, "f_flags"))                    flbuf.f_flags = atoi(ChrPtr(migr_chardata));
618         else if (!strcasecmp(el, "f_name"))                     safestrncpy(flbuf.f_name, ChrPtr(migr_chardata), sizeof flbuf.f_name);
619         else if (!strcasecmp(el, "f_ref_count"))                flbuf.f_ref_count = atoi(ChrPtr(migr_chardata));
620         else if (!strcasecmp(el, "f_ep_expire_mode"))           flbuf.f_ep.expire_mode = atoi(ChrPtr(migr_chardata));
621         else if (!strcasecmp(el, "f_ep_expire_value"))          flbuf.f_ep.expire_value = atoi(ChrPtr(migr_chardata));
622         else return 0;
623         return 1;
624 }
625
626
627 int migr_visitrecord(void *data, const char *el) {
628         if (!strcasecmp(el, "v_roomnum"))                       vbuf.v_roomnum = atol(ChrPtr(migr_chardata));
629         else if (!strcasecmp(el, "v_roomgen"))                  vbuf.v_roomgen = atol(ChrPtr(migr_chardata));
630         else if (!strcasecmp(el, "v_usernum"))                  vbuf.v_usernum = atol(ChrPtr(migr_chardata));
631
632         else if (!strcasecmp(el, "v_seen")) {
633                 int is_textual_seen = 0;
634                 int i;
635                 int max = StrLength(migr_chardata);
636
637                 vbuf.v_lastseen = atol(ChrPtr(migr_chardata));
638                 is_textual_seen = 0;
639                 for (i=0; i < max; ++i) 
640                         if (!isdigit(ChrPtr(migr_chardata)[i]))
641                                 is_textual_seen = 1;
642                 if (is_textual_seen)
643                         safestrncpy(vbuf.v_seen, ChrPtr(migr_chardata), sizeof vbuf.v_seen);
644         }
645
646         else if (!strcasecmp(el, "v_answered"))                 safestrncpy(vbuf.v_answered, ChrPtr(migr_chardata), sizeof vbuf.v_answered);
647         else if (!strcasecmp(el, "v_flags"))                    vbuf.v_flags = atoi(ChrPtr(migr_chardata));
648         else if (!strcasecmp(el, "v_view"))                     vbuf.v_view = atoi(ChrPtr(migr_chardata));
649         else return 0;
650         return 1;
651 }
652
653
654 void migr_xml_end(void *data, const char *el) {
655         const char *ptr;
656         int msgcount = 0;
657         long msgnum = 0L;
658         long *msglist = NULL;
659         int msglist_alloc = 0;
660         // *** GENERAL STUFF ***
661
662         if (!strcasecmp(el, "citadel_migrate_data")) {
663                 --citadel_migrate_data;
664                 return;
665         }
666
667         if (citadel_migrate_data != 1) {
668                 syslog(LOG_ERR, "migrate: out-of-sequence tag <%s> detected.  Warning: ODD-DATA!", el);
669                 return;
670         }
671
672         // syslog(LOG_DEBUG, "END TAG: <%s> DATA: <%s>\n", el, (migr_chardata_len ? migr_chardata : ""));
673
674         // *** CONFIG ***
675
676         if (!strcasecmp(el, "config")) {
677                 syslog(LOG_DEBUG, "migrate: imported config key=%s", ikey);
678
679                 if (ikey != NULL) {
680                         CtdlSetConfigStr(ikey, (char *)ChrPtr(migr_chardata));
681                         free(ikey);
682                         ikey = NULL;
683                 }
684                 else {
685                         syslog(LOG_INFO, "migrate: closed a <config> tag but no key name was supplied.");
686                 }
687         }
688
689         // *** USER ***
690         else if ((!strncasecmp(el, HKEY("u_"))) && 
691                  migr_userrecord(data, el))
692                 ; /* Nothing to do anymore */
693         else if (!strcasecmp(el, "user")) {
694                 CtdlPutUser(&usbuf);
695                 syslog(LOG_INFO, "migrate: imported user: %s", usbuf.fullname);
696         }
697
698         // *** OPENID ***
699
700         else if (!strcasecmp(el, "oid_url"))                    safestrncpy(openid_url, ChrPtr(migr_chardata), sizeof openid_url);
701         else if (!strcasecmp(el, "oid_usernum"))                openid_usernum = atol(ChrPtr(migr_chardata));
702
703         else if (!strcasecmp(el, "openid")) {                   // see serv_openid_rp.c for a description of the record format
704                 char *oid_data;
705                 int oid_data_len;
706                 oid_data_len = sizeof(long) + strlen(openid_url) + 1;
707                 oid_data = malloc(oid_data_len);
708                 memcpy(oid_data, &openid_usernum, sizeof(long));
709                 memcpy(&oid_data[sizeof(long)], openid_url, strlen(openid_url) + 1);
710                 cdb_store(CDB_EXTAUTH, openid_url, strlen(openid_url), oid_data, oid_data_len);
711                 free(oid_data);
712                 syslog(LOG_INFO, "migrate: imported OpenID: %s (%ld)", openid_url, openid_usernum);
713         }
714
715         // *** ROOM ***
716         else if ((!strncasecmp(el, HKEY("QR"))) && 
717                  migr_roomrecord(data, el))
718                 ; // Nothing to do anymore
719         else if (!strcasecmp(el, "room")) {
720                 CtdlPutRoom(&qrbuf);
721                 syslog(LOG_INFO, "migrate: imported room: %s", qrbuf.QRname);
722         }
723
724         // *** ROOM MESSAGE POINTERS ***
725
726         else if (!strcasecmp(el, "FRname")) {
727                 safestrncpy(FRname, ChrPtr(migr_chardata), sizeof FRname);
728         }
729
730         else if (!strcasecmp(el, "FRmsglist")) {
731                 if (!IsEmptyStr(FRname)) {
732                         msgcount = 0;
733                         msglist_alloc = 1000;
734                         msglist = malloc(sizeof(long) * msglist_alloc);
735
736                         syslog(LOG_DEBUG, "migrate: message list for: %s", FRname);
737
738                         ptr = ChrPtr(migr_chardata);
739                         while (*ptr != 0) {
740                                 while ((*ptr != 0) && (!isdigit(*ptr))) {
741                                         ++ptr;
742                                 }
743                                 if ((*ptr != 0) && (isdigit(*ptr))) {
744                                         msgnum = atol(ptr);
745                                         if (msgnum > 0L) {
746                                                 if (msgcount >= msglist_alloc) {
747                                                         msglist_alloc *= 2;
748                                                         msglist = realloc(msglist, sizeof(long) * msglist_alloc);
749                                                 }
750                                                 msglist[msgcount++] = msgnum;
751                                                 }
752                                         }
753                                         while ((*ptr != 0) && (isdigit(*ptr))) {
754                                                 ++ptr;
755                                         }
756                                 }
757                         }
758                         if (msgcount > 0) {
759                                 CtdlSaveMsgPointersInRoom(FRname, msglist, msgcount, 0, NULL, 1);
760                         }
761                         free(msglist);
762                         msglist = NULL;
763                         msglist_alloc = 0;
764                         syslog(LOG_DEBUG, "migrate: imported %d messages.", msgcount);
765                         if (server_shutting_down) {
766                                 return;
767                 }
768         }
769
770         // *** FLOORS ***
771         else if ((!strncasecmp(el, HKEY("f_"))) && 
772                  migr_floorrecord(data, el))
773                 ; // Nothing to do anymore
774
775         else if (!strcasecmp(el, "floor")) {
776                 CtdlPutFloor(&flbuf, floornum);
777                 syslog(LOG_INFO, "migrate: imported floor #%d (%s)", floornum, flbuf.f_name);
778         }
779
780         // *** VISITS ***
781         else if ((!strncasecmp(el, HKEY("v_"))) && migr_visitrecord(data, el)) {
782                 ; // Nothing to do anymore
783         }
784         else if (!strcasecmp(el, "visit")) {
785                 put_visit(&vbuf);
786                 syslog(LOG_INFO, "migrate: imported visit: %ld/%ld/%ld", vbuf.v_roomnum, vbuf.v_roomgen, vbuf.v_usernum);
787         }
788
789         // *** MESSAGES ***
790         
791         else if (!strcasecmp(el, "msg_msgnum"))                 smi.meta_msgnum = import_msgnum = atol(ChrPtr(migr_chardata));
792         else if (!strcasecmp(el, "msg_meta_refcount"))          smi.meta_refcount = atoi(ChrPtr(migr_chardata));
793         else if (!strcasecmp(el, "msg_meta_rfc822_length"))     smi.meta_rfc822_length = atoi(ChrPtr(migr_chardata));
794         else if (!strcasecmp(el, "msg_meta_content_type"))      safestrncpy(smi.meta_content_type, ChrPtr(migr_chardata), sizeof smi.meta_content_type);
795
796         else if (!strcasecmp(el, "msg_text")) {
797                 long rc;
798                 struct CtdlMessage *msg;
799
800                 FlushStrBuf(migr_MsgData);
801                 StrBufDecodeBase64To(migr_chardata, migr_MsgData);
802
803                 msg = CtdlDeserializeMessage(import_msgnum, -1,
804                                              ChrPtr(migr_MsgData), 
805                                              StrLength(migr_MsgData));
806                 if (msg != NULL) {
807                         rc = CtdlSaveThisMessage(msg, import_msgnum, 0);
808                         if (rc == 0) {
809                                 PutMetaData(&smi);
810                         }
811                         CM_Free(msg);
812                 }
813                 else {
814                         rc = -1;
815                 }
816
817                 syslog(LOG_INFO,
818                        "migrate: %s message #%ld, size=%d, ref=%d, body=%ld, content-type: %s",
819                        (rc!= 0)?"failed to import":"imported",
820                        import_msgnum,
821                        StrLength(migr_MsgData),
822                        smi.meta_refcount,
823                        smi.meta_rfc822_length,
824                        smi.meta_content_type
825                 );
826                 memset(&smi, 0, sizeof(smi));
827         }
828
829         // *** MORE GENERAL STUFF ***
830
831         FlushStrBuf(migr_chardata);
832 }
833
834
835 // Import begins here
836 void migr_do_import(void) {
837         XML_Parser xp;
838         char buf[SIZ];
839         
840         unbuffer_output();
841         migr_chardata = NewStrBufPlain(NULL, SIZ * 20);
842         migr_MsgData = NewStrBufPlain(NULL, SIZ * 20);
843         xp = XML_ParserCreate(NULL);
844         if (!xp) {
845                 cprintf("%d Failed to create XML parser instance\n", ERROR+INTERNAL_ERROR);
846                 return;
847         }
848         XML_SetElementHandler(xp, migr_xml_start, migr_xml_end);
849         XML_SetCharacterDataHandler(xp, migr_xml_chardata);
850
851         CC->dont_term = 1;
852
853         cprintf("%d sock it to me\n", SEND_LISTING);
854         unbuffer_output();
855
856         client_set_inbound_buf(SIZ * 10);
857
858         while (client_getln(buf, sizeof buf) >= 0 && strcmp(buf, "000")) {
859                 XML_Parse(xp, buf, strlen(buf), 0);
860                 if (server_shutting_down)
861                         break;  // Should we break or return?
862         }
863
864         XML_Parse(xp, "", 0, 1);
865         XML_ParserFree(xp);
866         FreeStrBuf(&migr_chardata);
867         FreeStrBuf(&migr_MsgData);
868         rebuild_euid_index();
869         rebuild_usersbynumber();
870         CtdlSetConfigInt("MM_fulltext_wordbreaker", -1);        // Set an invalid wordbreaker to force re-indexing
871         CC->dont_term = 0;
872 }
873
874
875 // ******************************************************************************
876 // *                         Dispatcher, Common code                            *
877 // ******************************************************************************
878
879 // Dump out the pathnames of directories which can be copied "as is"
880 void migr_do_listdirs(void) {
881         cprintf("%d Don't forget these:\n", LISTING_FOLLOWS);
882         cprintf("files|%s\n",           ctdl_file_dir);
883         cprintf("messages|%s\n",        ctdl_message_dir);
884         cprintf("keys|%s\n",            ctdl_key_dir);
885         cprintf("000\n");
886 }
887
888
889 // ******************************************************************************
890 // *                    Repair database integrity                               *
891 // ******************************************************************************
892
893 StrBuf *PlainMessageBuf = NULL;
894 HashList *UsedMessageIDS = NULL;
895
896 int migr_restore_message_metadata(long msgnum, int refcount) {
897         struct MetaData smi;
898         struct CtdlMessage *msg;
899         char *mptr = NULL;
900
901         // We can use a static buffer here because there will never be more than
902         // one of this operation happening at any given time, and it's really best
903         // to just keep it allocated once instead of torturing malloc/free.
904         // Call this function with msgnum "-1" to free the buffer when finished.
905         static int encoded_alloc = 0;
906         static char *encoded_msg = NULL;
907
908         if (msgnum < 0) {
909                 if ((encoded_alloc == 0) && (encoded_msg != NULL)) {
910                         free(encoded_msg);
911                         encoded_alloc = 0;
912                         encoded_msg = NULL;
913                         // todo FreeStrBuf(&PlainMessageBuf); PlainMessageBuf = NULL;
914                 }
915                 return 0;
916         }
917
918         if (PlainMessageBuf == NULL) {
919                 PlainMessageBuf = NewStrBufPlain(NULL, 10*SIZ);
920         }
921
922         // Ok, here we go ...
923
924         msg = CtdlFetchMessage(msgnum, 1);
925         if (msg == NULL) {
926                 return 1;
927         }
928
929         GetMetaData(&smi, msgnum);
930         smi.meta_msgnum = msgnum;
931         smi.meta_refcount = refcount;
932         
933         // restore the content type from the message body:
934         mptr = bmstrcasestr(msg->cm_fields[eMesageText], "Content-type:");
935         if (mptr != NULL) {
936                 char *aptr;
937                 safestrncpy(smi.meta_content_type, &mptr[13], sizeof smi.meta_content_type);
938                 striplt(smi.meta_content_type);
939                 aptr = smi.meta_content_type;
940                 while (!IsEmptyStr(aptr)) {
941                         if ((*aptr == ';')
942                             || (*aptr == ' ')
943                             || (*aptr == 13)
944                             || (*aptr == 10)) {
945                                 memset(aptr, 0, sizeof(smi.meta_content_type) - (aptr - smi.meta_content_type));
946                         }
947                         else aptr++;
948                 }
949         }
950
951         CC->redirect_buffer = PlainMessageBuf;
952         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, QP_EADDR);
953         smi.meta_rfc822_length = StrLength(CC->redirect_buffer);
954         CC->redirect_buffer = NULL;
955
956         syslog(LOG_INFO,
957                "migrate: setting message #%ld meta data to: refcount=%d, bodylength=%ld, content-type: %s",
958                smi.meta_msgnum,
959                smi.meta_refcount,
960                smi.meta_rfc822_length,
961                smi.meta_content_type
962         );
963
964         PutMetaData(&smi);
965         CM_Free(msg);
966         return 0;
967 }
968
969
970 void migr_check_room_msg(long msgnum, void *userdata) {
971         fprintf(migr_global_message_list, "%ld %s\n", msgnum, CC->room.QRname);
972 }
973
974
975 void migr_check_rooms_backend(struct ctdlroom *buf, void *data) {
976         // message list goes inside this tag
977         CtdlGetRoom(&CC->room, buf->QRname);
978         CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, migr_check_room_msg, NULL);
979 }
980
981
982 void RemoveMessagesFromRooms(StrBuf *RoomNameVec, long msgnum) {
983         struct MetaData smi;
984         const char *Pos = NULL;
985         StrBuf *oneRoom = NewStrBuf();
986
987         syslog(LOG_INFO, "migrate: removing message pointer %ld from these rooms: %s", msgnum, ChrPtr(RoomNameVec));
988
989         while (Pos != StrBufNOTNULL){
990                 StrBufExtract_NextToken(oneRoom, RoomNameVec, &Pos, '|');
991                 CtdlDeleteMessages(ChrPtr(oneRoom), &msgnum, 1, "");
992         };
993         GetMetaData(&smi, msgnum);
994         AdjRefCount(msgnum, -smi.meta_refcount);
995 }
996
997
998 void migr_do_restore_meta(void) {
999         char buf[SIZ];
1000         int failGetMessage;
1001         long msgnum = 0;
1002         int lastnum = 0;
1003         int refcount = 0;
1004         CitContext *Ctx;
1005         char *prn;
1006         StrBuf *RoomNames;
1007         char cmd[SIZ];
1008
1009         migr_global_message_list = fopen(migr_tempfilename1, "w");
1010         if (migr_global_message_list != NULL) {
1011                 CtdlForEachRoom(migr_check_rooms_backend, NULL);
1012                 fclose(migr_global_message_list);
1013         }
1014
1015         // Process the 'global' message list.  (Sort it and remove dups.
1016         // Dups are ok because a message may be in more than one room, but
1017         // this will be handled by exporting the reference count, not by
1018         // exporting the message multiple times.)
1019         snprintf(cmd, sizeof cmd, "sort -n <%s >%s", migr_tempfilename1, migr_tempfilename2);
1020         if (system(cmd) != 0) {
1021                 syslog(LOG_ERR, "migrate: error %d", errno);
1022         }
1023
1024         RoomNames = NewStrBuf();
1025         Ctx = CC;
1026         migr_global_message_list = fopen(migr_tempfilename2, "r");
1027         if (migr_global_message_list != NULL) {
1028                 syslog(LOG_INFO, "migrate: opened %s", migr_tempfilename1);
1029                 while ((Ctx->kill_me == 0) && 
1030                        (fgets(buf, sizeof(buf), migr_global_message_list) != NULL)) {
1031                         msgnum = atol(buf);
1032                         if (msgnum == 0L) 
1033                                 continue;
1034                         if (lastnum == 0) {
1035                                 lastnum = msgnum;
1036                         }
1037                         prn = strchr(buf, ' ');
1038                         if (lastnum != msgnum) {
1039                                 failGetMessage = migr_restore_message_metadata(lastnum, refcount);
1040                                 if (failGetMessage) {
1041                                         RemoveMessagesFromRooms(RoomNames, lastnum);
1042                                 }
1043                                 refcount = 1;
1044                                 lastnum = msgnum;
1045                                 if (prn != NULL) {
1046                                         StrBufPlain(RoomNames, prn + 1, -1);
1047                                 }
1048                                 StrBufTrim(RoomNames);
1049                         }
1050                         else {
1051                                 if (prn != NULL) {
1052                                         if (StrLength(RoomNames) > 0) {
1053                                                 StrBufAppendBufPlain(RoomNames, HKEY("|"), 0);
1054                                         }
1055                                         StrBufAppendBufPlain(RoomNames, prn, -1, 1);
1056                                         StrBufTrim(RoomNames);
1057                                 }
1058                                 refcount ++;
1059                         }
1060                         lastnum = msgnum;
1061                 }
1062                 failGetMessage = migr_restore_message_metadata(msgnum, refcount);
1063                 if (failGetMessage) {
1064                         RemoveMessagesFromRooms(RoomNames, lastnum);
1065                 }
1066                 fclose(migr_global_message_list);
1067         }
1068
1069         migr_restore_message_metadata(-1L, -1); // This frees the encoding buffer
1070         cprintf("%d system analysis completed", CIT_OK);
1071         Ctx->kill_me = 1;
1072 }
1073
1074
1075 // ******************************************************************************
1076 // *                         Dispatcher, Common code                            *
1077 // ******************************************************************************
1078 void cmd_migr(char *cmdbuf) {
1079         char cmd[32];
1080         
1081         if (CtdlAccessCheck(ac_aide)) return;
1082         
1083         if (CtdlTrySingleUser()) {
1084                 CtdlDisableHouseKeeping();
1085                 CtdlMakeTempFileName(migr_tempfilename1, sizeof migr_tempfilename1);
1086                 CtdlMakeTempFileName(migr_tempfilename2, sizeof migr_tempfilename2);
1087
1088                 extract_token(cmd, cmdbuf, 0, '|', sizeof cmd);
1089                 if (!strcasecmp(cmd, "export")) {
1090                         migr_do_export();
1091                 }
1092                 else if (!strcasecmp(cmd, "import")) {
1093                         migr_do_import();
1094                 }
1095                 else if (!strcasecmp(cmd, "listdirs")) {
1096                         migr_do_listdirs();
1097                 }
1098                 else if (!strcasecmp(cmd, "restoremeta")) {
1099                         migr_do_restore_meta();
1100                 }
1101                 else {
1102                         cprintf("%d illegal command\n", ERROR + ILLEGAL_VALUE);
1103                 }
1104
1105                 unlink(migr_tempfilename1);
1106                 unlink(migr_tempfilename2);
1107
1108                 CtdlEnableHouseKeeping();
1109                 CtdlEndSingleUser();
1110         }
1111         else {
1112                 cprintf("%d The migrator is already running.\n", ERROR + RESOURCE_BUSY);
1113         }
1114 }
1115
1116
1117 // ******************************************************************************
1118 // *                              Module Hook                                   *
1119 // ******************************************************************************
1120
1121 CTDL_MODULE_INIT(migrate)
1122 {
1123         if (!threading)
1124         {
1125                 CtdlRegisterProtoHook(cmd_migr, "MIGR", "Across-the-wire migration");
1126         }
1127         
1128         // return our module name for the log
1129         return "migrate";
1130 }