/*
This is drupal2fs (Drupal-to-filesystem) program
written by Andrey Vikt. Stolyarov in 2019--2023.

The program extracts the content of a site served with Drupal and
places the content into text files suitable for the Thalassa CMS.
Please see below the explanation of limitations (very serious!) of the
program.

This code is hereby put by its author into public domain; no copyright
is claimed and no restrictions are set here.  For countries where such
copyright disclaim is not legally possible, the permission is given to
any party to use, modify and redistribute this program in any way.
Please note however that so-called moral rights of the author (in
contrast with property rights, which copyright is) remain in effect
(forever, heh), so certain care must be taken.  The author hereby
gives to any interested parties the permission to modify this work in
any way.  Mentioning the author of the original work in any derived
works is encouraged but is not necessary.  However, in no
circumstances a modified work as a whole may be attributed to the
original author, and reasonable measures must be taken to make it
clear that the work has been modified by someone else than the
original author.

You need to install MySQL or MariaDB development files to compile this
program.  E.g., with MariaDB it is compiled like this:

   gcc -Wall -g `mariadb_config --include` drupal2fs.c \
                `mariadb_config --libs` -o drupal2fs

*ANY* gcc version you can find around will do the job; well, this
program compiles with gcc 3.*, just like all programs I write.
It could even be ANSI C as I deliberately avoid all C99-isms, but,
unfortunately, mariadb headers are not ANSI-C-friendly.


Ladies and gentlemen, please don't expect much from this program.  It
was written in order to recover a particular site's content from a EOL
version of Drupal which was running on a EOL version of the PHP
interpreter, using a EOL version of MySQL (not even MariaDB).  The
Drupal in question was of version 5.*, and I'm nearly sure that the
program will require a lot of modifications to make it work with any
later Drupal versions; I'm just too lazy even to try it with later
drupals, primarily because I will never need it for myself.  Well, you
see, I'll never ever again deploy any of my websites using Drupal or
any other CMS written in any interpreted language and/or dependent on
external DBMSes.

So, if your version of Drupal is not 5.* (and this is HIGHLY likely,
as 5.* was declared EOL in 2011), this program perhaps won't serve
your needs right off; you can try to perform its adaptation on your
own.  Well, if you agree to pay me, perhaps I can try doing this for
you, but, well, my time isn't cheap.

Even if your installation of Drupal is of the 5.* version, please note
this program ONLY recovers nodes, comments, aliases (these custom URIs
Drupal allows you to set for nodes) and also some info for user
accounts.  The program does NOT get other things like blocks, themes,
modules, all these site parameters like the whole site's name, slogan,
motto, copyright notice and so on.

Furthermore, perhaps you use custom input formats on your site.  This
program doesn't know how these formats are stored in the database, and
how they are numbered in YOUR particular database.  Please see the
make_format_field function below.  You'll have to change it to reflect
YOUR format numbers; the version found below was built empirically for
the formats used on MY site.

This program served me perfectly, but I only had one site to process,
and that's all: I've got absolutely no reason to try making this
program any better than it now is, because I don't need it any longer.
However, I just as well see no reason to keep this code private.  If
it helps someone around to recover their sites, at least serve as a
start to make their own recovery tools, it's not bad in itself.

                So, well... good luck :-)

Ahh, almost forgot: THERE IS NO WARRANTY FOR THIS PROGRAM, OF ANY
KIND, EXPRESSED, IMPLIED, WHATEVER ELSE.  ACTUALLY, IF YOU CAN NAME A
KIND OF WARRANTY, THAT SOLE FACT MEANS YOU DON'T HAVE THE WARRANTY OF
THAT KIND, AND EVEN IF YOU DON'T KNOW ABOUT WARRANTIES OF A
PARTICULAR KIND, YOU DON'T HAVE THEM AS WELL.

Actually, I'm almost sure the program will NOT work for you, so it
would be somewhat stupid to expect any warranty here.

*/

/*
    The structure of SQL tables this program uses is as follows, may be
    this will help you a bit (I had to pick them manually from all the
    tables I couldn't use in any way)


CREATE TABLE `comments` (
  `cid` int(11) NOT NULL AUTO_INCREMENT,// id (global)
  `pid` int(11) NOT NULL DEFAULT '0',   // parend cmt. id (0 for no parent)
  `nid` int(11) NOT NULL DEFAULT '0',   // node id
  `uid` int(11) NOT NULL DEFAULT '0',   // 0 is for anonymous
  `subject` varchar(64) NOT NULL DEFAULT '',
  `comment` longtext NOT NULL,
  `hostname` varchar(128) NOT NULL DEFAULT '',
  `timestamp` int(11) NOT NULL DEFAULT '0',
  `score` mediumint(9) NOT NULL DEFAULT '0',
  `status` tinyint(3) unsigned NOT NULL DEFAULT '0',
  `format` int(11) NOT NULL DEFAULT '0', // see below
  `thread` varchar(255) NOT NULL,   // ?! '02/'
  `users` longtext,  // ?! something like 'a:1:{i:0;i:0;}', any ideas?
  `name` varchar(60) DEFAULT NULL,
  `mail` varchar(64) DEFAULT NULL,
  `homepage` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`cid`),
  KEY `lid` (`nid`)
) ENGINE=MyISAM AUTO_INCREMENT=2170 DEFAULT CHARSET=utf8;

////////////////////////////////
// input formats as they were in MY database:
//
// 1: "Filtered HTML"    tags, breaks, web
// <a> <em> <strong> <ins> <del> <cite> <code>
// <ul> <ol> <li> <dl> <dt> <dd> <pre>
//
// 2: ?! (unused, perhaps PHP code)
//
// 3: "Full HTML"       breaks, web
//
// 4: "Real HTML"       tags
// <a> <em> <span> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>
// <h1> <h2> <h3> <h4> <h5> <br> <img> <quote> <table> <td> <tr>
//
// 5: "Hardcore HTML"/no filtering


CREATE TABLE `node` (
  `nid` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `vid` int(10) unsigned NOT NULL DEFAULT '0',
  `type` varchar(32) NOT NULL DEFAULT '',
  `title` varchar(128) NOT NULL DEFAULT '',
  `uid` int(11) NOT NULL DEFAULT '0',
  `status` int(11) NOT NULL DEFAULT '1',
  `created` int(11) NOT NULL DEFAULT '0',
  `changed` int(11) NOT NULL DEFAULT '0',
  `comment` int(11) NOT NULL DEFAULT '0',    // 0 - disabled, 2 - rw
  `promote` int(11) NOT NULL DEFAULT '0',
  `moderate` int(11) NOT NULL DEFAULT '0',   // always 0 (?!)
  `sticky` int(11) NOT NULL DEFAULT '0',
  PRIMARY KEY (`nid`,`vid`),
  UNIQUE KEY `vid` (`vid`),
  KEY `node_type` (`type`(4)),
  KEY `node_title_type` (`title`,`type`(4)),
  KEY `status` (`status`),
  KEY `uid` (`uid`),
  KEY `node_moderate` (`moderate`),
  KEY `node_promote_status` (`promote`,`status`),
  KEY `node_created` (`created`),
  KEY `node_changed` (`changed`),
  KEY `node_status_type` (`status`,`type`,`nid`),
  KEY `nid` (`nid`)
) ENGINE=MyISAM AUTO_INCREMENT=262 DEFAULT CHARSET=utf8;

CREATE TABLE `node_revisions` (
  `nid` int(10) unsigned NOT NULL,
  `vid` int(10) unsigned NOT NULL,
  `uid` int(11) NOT NULL DEFAULT '0',
  `title` varchar(128) NOT NULL DEFAULT '',
  `body` longtext NOT NULL,
  `teaser` longtext NOT NULL,
  `log` longtext NOT NULL,
  `timestamp` int(11) NOT NULL DEFAULT '0',
  `format` int(11) NOT NULL DEFAULT '0',
  PRIMARY KEY (`vid`),
  KEY `nid` (`nid`),
  KEY `uid` (`uid`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

CREATE TABLE `url_alias` (
  `pid` int(10) unsigned NOT NULL AUTO_INCREMENT,  // just the seq. num
  `src` varchar(128) NOT NULL DEFAULT '',          // like 'node/6'
  `dst` varchar(128) NOT NULL DEFAULT '',          // localpart
  PRIMARY KEY (`pid`),
  UNIQUE KEY `dst` (`dst`),
  KEY `src` (`src`)
) ENGINE=MyISAM AUTO_INCREMENT=794 DEFAULT CHARSET=utf8;


CREATE TABLE `users` (
  `uid` int(10) unsigned NOT NULL DEFAULT '0',
  `name` varchar(60) NOT NULL DEFAULT '',
  `pass` varchar(32) NOT NULL DEFAULT '',
  `mail` varchar(64) DEFAULT '',
  `mode` tinyint(4) NOT NULL DEFAULT '0',
  `sort` tinyint(4) DEFAULT '0',
  `threshold` tinyint(4) DEFAULT '0',
  `theme` varchar(255) NOT NULL DEFAULT '',
  `signature` varchar(255) NOT NULL DEFAULT '',
  `created` int(11) NOT NULL DEFAULT '0',
  `access` int(11) NOT NULL DEFAULT '0',
  `login` int(11) NOT NULL DEFAULT '0',
  `status` tinyint(4) NOT NULL DEFAULT '0',
  `timezone` varchar(8) DEFAULT NULL,
  `language` varchar(12) NOT NULL DEFAULT '',
  `picture` varchar(255) NOT NULL DEFAULT '',
  `init` varchar(64) DEFAULT '',
  `data` longtext,
  PRIMARY KEY (`uid`),
  UNIQUE KEY `name` (`name`),
  KEY `created` (`created`),
  KEY `access` (`access`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

*/

/* Okay, finally, here the program starts */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <libgen.h>
#include <mysql.h>

static int make_directory_path(const char *path)
{
    char *pc, *dr;
    struct stat st;
    int r;

    r = stat(path, &st);
    if(r != -1) {
        if(S_ISDIR(st.st_mode)) {
            return 0;  /* okay */
        } else {
            errno = ENOTDIR;
            return -1;
        }
    }
    /* stat() failed... why? */
    if(errno != ENOENT)
        return -1;

    /* okay, it really doesn't exist */

    pc = strdup(path);
    dr = dirname(pc);
    /* the check for "." eliminates a stupid call to stat */
    r = (strcmp(".", dr) == 0) ? 0 : make_directory_path(dr);
    free(pc);
    if(r == -1)
        return -1;

    r = mkdir(path, 0777);
    return r;
}

#if 0
static void print_hrule()
{
    int i;
    for(i = 0; i < 75; i++)
        putchar('-');
    putchar('\n');
}
#endif

    /* the result is malloc()'ed! be sure to free() it! */
static char *path_concat(const char *p1, const char *p2)
{
    char *res;
    int len1, len2;
    len1 = strlen(p1);
    len2 = strlen(p2);
    res = malloc(len1+len2+2);  /*  2 is for '/' and the term. zero  */
    strcpy(res, p1);
    res[len1] = '/';
    strcpy(res+len1+1, p2);
    return res;
}

#if 0
static char *make_node_dir_path(const char *dir, const char *vid)
{
    return path_concat(dir, vid);
}
#endif

struct node_info {
    const char *vid;
    const char *rev_timestamp, *time_created, *time_changed;
    const char *type;
    const char *format;
    const char *status;
    const char *promote;
    const char *sticky;
    const char *comment;
    int teaser_len;
    const char *title;
    const char *body;
};

struct comment_info {
    const char *cid;
    const char *pid;
    const char *timestamp;
    const char *status;
    const char *format;
    const char *uid;
    const char *name;
    const char *mail;
    const char *homepage;
    const char *subject;
    const char *comment;
};

/* ------------------------------------------------------------- */
/* comment id conversion */

static int *comment_id_trans;
static int max_comment_id;

static int make_comment_id_trans(MYSQL *con)
{
    MYSQL_RES *res;
    MYSQL_ROW row;
    int i, nid, cid, cur, last_nid;

    if(0 != mysql_query(con, "select max(cid) from comments")) {
        fprintf(stderr, "error getting max comment id: %s\n",
                        mysql_error(con));
        return 0;
    }
    res = mysql_store_result(con);
    row = mysql_fetch_row(res);
    if(!row) {
        fprintf(stderr, "no info about max comment id\n");
        return 0;
    }

    max_comment_id = atoi(row[0]);

    if(max_comment_id < 0 || max_comment_id > 100000) {
        fprintf(stderr, "invalid max comment id\n");
        return 0;
    }

    /* printf("max comment id: %d\n", max_comment_id); */

    comment_id_trans = malloc((max_comment_id + 1) * sizeof(int));
    for(i = 0; i <= max_comment_id; i++)
        comment_id_trans[i] = -1;


    if(0 != mysql_query(con,
                        "select nid, cid from comments order by nid, cid")
    ) {
        fprintf(stderr, "error getting comment id info: %s\n",
                        mysql_error(con));
        return 0;
    }
    res = mysql_store_result(con);

    last_nid = -1;

    while((row = mysql_fetch_row(res))) {
        nid = atoi(row[0]);
        cid = atoi(row[1]);
        if(nid == last_nid) {
            cur++;
        } else {
            cur = 1;
        }
        last_nid = nid;

        if(cid <= 0 || cid > max_comment_id) {
            fprintf(stderr, "error cid out of range: %d, skipped\n", cid);
            continue;
        }
        comment_id_trans[cid] = cur;
        /* printf("%d %d -> %d\n", nid, cid, cur); */
    }
    return 1;
}

/* ------------------------------------------------------------- */

static const char *make_node_flags(const struct node_info *node)
{
    static char retbuf[32];  /* actually, no more than 26 chars is used */
    retbuf[0] = 0;
    if(strcmp(node->status, "0") == 0)
        strcat(retbuf, ", hidden");
#if 0
    if(strcmp(node->promote, "1") == 0)
        strcat(retbuf, ", promote");
#endif
    if(strcmp(node->sticky, "1") == 0)
        strcat(retbuf, ", sticky");
    return *retbuf ? retbuf + 2 : NULL;  /* +2 is to skip the first ", " */
}

static const char *make_format_field(const char *d5code)
{
    if(strcmp(d5code, "1") == 0)
        return "tags, breaks, web";
    if(strcmp(d5code, "3") == 0)
        return "breaks, web";
    if(strcmp(d5code, "4") == 0 || strcmp(d5code, "5") == 0)
        return "verbatim";
    fprintf(stderr, "WARNING: unknown format [%s], using verbatim\n", d5code);
    return "verbatim";
}

static const char *comment_mode(const char *cmt)
{
    if(!*cmt || cmt[1])
        return "unknown";
    switch(*cmt) {
    case '0': return "disabled";
    case '1': return "readonly";
    case '2': return "enabled";
    default: return "unknown";
    }
}

static void
output_field_protected(FILE *f, const char *field, const char *val)
{
    const char *p;
    fputs(field, f);
    fputs(": ", f);
    for(p = val; *p; p++) {
        fputc(*p, f);
        if(*p == '\n')
            fputc('\t', f);
    }
    fputc('\n', f);
}

static void save_node_file(const char *the_node_dir_path,
                           const struct node_info *node)
{
    FILE *f;
    char *fname;
    const char *flags;

    fname = path_concat(the_node_dir_path, "content.txt");
    f = fopen(fname, "w");
    if(!f) {
        perror(fname);
        free(fname);
        return;
    }
    free(fname);

    flags = make_node_flags(node);

    fprintf(f, "id: %s\n", node->vid);
    fprintf(f, "unixtime: %s\n", node->time_created);
    /* fprintf(f, "unixtime: %s\n", node->timestamp); */
    fprintf(f, "type: %s\n", node->type);
    fprintf(f, "encoding: utf8\n");
    fprintf(f, "format: %s\n", make_format_field(node->format));
    if(flags && flags[0])
        fprintf(f, "flags: %s\n", flags);
    if(strcmp(node->promote, "1") == 0)
        fprintf(f, "tags: _news\n");
    fprintf(f, "comments: %s\n", comment_mode(node->comment));
    fprintf(f, "teaser_len: %d\n", node->teaser_len);
    /* fprintf(f, "title: %s\n\n", node->title); */
    output_field_protected(f, "title", node->title);
    fputs("\n", f);
    fputs(node->body, f);
    fclose(f);
}

static const char *make_comment_flags(const struct comment_info *comment)
{
    static char retbuf[32];  /* actually, no more than 15 chars is used */
    retbuf[0] = 0;
    if(strcmp(comment->status, "1") == 0)  /* NB: status is '1' for hidden */
        strcat(retbuf, ", hidden");         /* while in nodes it is '0' */
    if(strcmp(comment->uid, "0") == 0)
        strcat(retbuf, ", anon");
    return *retbuf ? retbuf+2 : NULL; /* +2 hides the first ", " */
}

static void save_single_comment(const char *the_node_dir_path,
                                const struct comment_info *comment,
                                int *max_id)
{
    FILE *f;
    char *fname;
    const char *flags;
    char idbuf[16];

    int cid, par_id = 0;

    cid = atoi(comment->cid);
    if(cid <= 0 || cid > max_comment_id) {
        fprintf(stderr, "invalid comment id %s\n", comment->cid);
        return;
    }
    cid = comment_id_trans[cid];

    par_id = atoi(comment->pid);
    if(par_id < 0 || par_id > max_comment_id) {
        fprintf(stderr, "invalid parent comment id %s\n", comment->pid);
        return;
    }
    if(par_id != 0)
        par_id = comment_id_trans[par_id];

    sprintf(idbuf, "%04d", cid);
    fname = path_concat(the_node_dir_path, idbuf);
    f = fopen(fname, "w");
    if(!f) {
        perror(fname);
        free(fname);
        return;
    }
    free(fname);

    flags = make_comment_flags(comment);

    fprintf(f, "id: %d\n", cid);
    if(par_id > 0)
        fprintf(f, "parent: %d\n", par_id);
    fprintf(f, "unixtime: %s\n", comment->timestamp);
    fprintf(f, "encoding: utf8\n");
    fprintf(f, "format: %s\n", make_format_field(comment->format));
    if(flags)
        fprintf(f, "flags: %s\n", flags);

    if(strcmp(comment->uid, "0") != 0)
        fprintf(f, "user: %s\n", comment->uid);
    if(comment->name && comment->name[0])
        output_field_protected(f, "from", comment->name);
    if(comment->mail && comment->mail[0])
        output_field_protected(f, "mail", comment->mail);
    if(comment->homepage && comment->homepage[0])
        output_field_protected(f, "homepage", comment->homepage);

    fprintf(f, "anchor: comment-%s\n", comment->cid);
    fprintf(f, "orig-par: %s\n", comment->pid);
    output_field_protected(f, "title", comment->subject);
    fputs("\n", f);

    fputs(comment->comment, f);

    fclose(f);

    if(cid > *max_id)
        *max_id = cid;
}

static void save_node_comments(MYSQL *con,
                        const char *the_dir_path, const char *vid)
{
    MYSQL_RES *res;
    MYSQL_ROW row;

    FILE *f;
    char *hintp;

    static char query[256];
    struct comment_info comment;

    int max_cid;

    sprintf(query,
            "select cid, pid, timestamp, status, format,"
            "   uid, name, mail, homepage, "
            "   subject, comment"
            "   from `comments` where nid = %s",
            vid);

    if(0 != mysql_query(con, query)) {
        fprintf(stderr, "error getting comments for node/%s: %s; skipped",
                        vid, mysql_error(con));
        return;
    }

    res = mysql_store_result(con);

#if 0
    nrows = mysql_num_rows(res);
    if(nrows > 0) {
        fprintf(stderr, "* node/%s has %d comments\n", vid, nrows);
    } else {
        return;
    }
#endif

    max_cid = 0;

    while((row = mysql_fetch_row(res))) {
        comment.cid = row[0];
        comment.pid = row[1];
        comment.timestamp = row[2];
        comment.status = row[3];
        comment.format = row[4];
        comment.uid = row[5];
        comment.name = row[6];
        comment.mail = row[7];
        comment.homepage = row[8];
        comment.subject = row[9];
        comment.comment = row[10];
        save_single_comment(the_dir_path, &comment, &max_cid);
    }

    hintp = path_concat(the_dir_path, "_hints");
    f = fopen(hintp, "w");
    fprintf(f, "%d\n", max_cid);
    fclose(f);
    free(hintp);
}

static int process_single_node(MYSQL *con, const char *dir, const char *vid,
                     const char *type, const char *uid,
                     const char *status, const char *promote,
                     const char *sticky,
                     const char *time_created, const char *time_changed,
                     const char *comment)
{
    MYSQL_RES *res;
    MYSQL_ROW row;

    static char query[256];
    const char *teaser;
    struct node_info node;
    char *the_node_dir_path;
    char *comments_dir_path;
    char nodebuf[32];

    node.vid = vid;
    node.time_created = time_created;
    node.time_changed = time_changed;
    node.type = type;
    node.type = type;
    /*node.uid = uid;*/
    node.status = status;
    node.promote = promote;
    node.sticky = sticky;
    node.comment = comment;

    sprintf(query,
            "select title, body, teaser, timestamp, format "
            "   from `node_revisions` where vid = %s",
            vid);

    if(0 != mysql_query(con, query)) {
        fprintf(stderr, "error getting node/%s: %s; skipped",
                        vid, mysql_error(con));
        return 0;
    }

    res = mysql_store_result(con);

    if(!(row = mysql_fetch_row(res))) {
        fprintf(stderr, "error getting the body for node/%s: %s; skipped",
                        vid, mysql_error(con));
        return 0;
    }
    node.title = row[0]; node.body = row[1]; teaser = row[2];
    node.rev_timestamp = row[3]; node.format = row[4];

    node.teaser_len = strlen(teaser);
    if(0 != strncmp(teaser, node.body, node.teaser_len)) {
        fprintf(stderr, "WARNING: strange teaser for %s\n", vid);
    }

    sprintf(nodebuf, "node/%s", vid);
    the_node_dir_path = path_concat(dir, nodebuf);
    make_directory_path(the_node_dir_path);
    save_node_file(the_node_dir_path, &node);
    free(the_node_dir_path);

    sprintf(nodebuf, "comments/node%s", vid);
    comments_dir_path = path_concat(dir, nodebuf);
    make_directory_path(comments_dir_path);
    save_node_comments(con, comments_dir_path, vid);
    free(comments_dir_path);

    return 1;
}

static int process_nodes(MYSQL *con, const char *dir)
{
    MYSQL_RES *res;
    MYSQL_ROW row;

    int count;

    if(0 != mysql_query(con, "select nid, vid, type, uid, "
                             " status, promote, sticky, created, changed,"
                             " comment"  /* NB: 'moderate' is always 0 */
                             " from node order by cast(nid as unsigned)")
    ) {
        fprintf(stderr, "can't get the nodes: %s; aborting\n",
                        mysql_error(con));
        return -1;
    }
    res = mysql_store_result(con);

    /*columns = mysql_num_fields(res);*/

    count = 0;
    while((row = mysql_fetch_row(res))) {
        if(strcmp(row[0], row[1]) != 0) {
            fprintf(stderr, "Warning: nid %s != vid %s\n", row[0], row[1]);
        }
        if(process_single_node(con, dir, row[1] /* vid */, row[2] /* type */,
                               row[3] /* uid */, row[4] /* status */,
                               row[5] /* promote */, row[6] /* sticky */,
                               row[7] /* created */, row[8] /*changed */,
                               row[9] /* comment */)
        ) {
            count++;
        }
    }

    return count;
}

static void print_num_or_empty_column(FILE *f, long n)
{
    fputc(':', f);
    if(n >= 0)
        fprintf(f, "%ld", n);
}

static void make_list_nav_hint(const char *dir, const char *list,
                               long idx, long prev, long cur, long next)
{
    char *fname;
    char nodebuf[32];
    FILE *f;

    sprintf(nodebuf, "node/%ld/_list", cur);
    fname = path_concat(dir, nodebuf);
    f = fopen(fname, "w");
    if(!f) {
        perror(fname);
        free(fname);
        return;
    }
    free(fname);
    /* fprintf(f, "%s:%ld:%ld:%ld:%ld\n", list, idx, prev, cur, next); */
    fputs(list, f);
    print_num_or_empty_column(f, idx);
    print_num_or_empty_column(f, prev);
    print_num_or_empty_column(f, cur);
    print_num_or_empty_column(f, next);
    fputc('\n', f);
    fclose(f);
}

static int build_front_list_nav(MYSQL *con, const char *dir)
{
    MYSQL_RES *res;
    MYSQL_ROW row;
    FILE *f;
    char *fname;
    long count, prev_id, prev_prev_id, cur_id;

    if(0 != mysql_query(con, "select nid from node"
                             "  where status = 1 and promote = 1"
                             "  order by cast(nid as unsigned)")
    ) {
        fprintf(stderr, "can't get IDs for the <front>: %s; aborting\n",
                        mysql_error(con));
        return -1;
    }
    res = mysql_store_result(con);

    fname = path_concat(dir, "node/_news");
    f = fopen(fname, "w");
    if(!f) {
        perror(fname);
        free(fname);
        return -1;
    }
    free(fname);

    prev_id = prev_prev_id = -1;
    count = 0;
    while((row = mysql_fetch_row(res))) {
        /* row[0] is the nid as const char* */
        char *endptr;
        if(!*(row[0])) {
            fprintf(stderr, "warning: empty ID\n");
            continue;
        }
        cur_id = strtol(row[0], &endptr, 10);
        if(*endptr != 0) {
            fprintf(stderr, "non-num id: [%s]\n", row[0]);
            continue;
        }
        fprintf(f, "%ld:%s\n", count+1, row[0]);
        if(prev_id != -1)
            make_list_nav_hint(dir, "_news",
                               count, prev_prev_id, prev_id, cur_id);
        prev_prev_id = prev_id;
        prev_id = cur_id;
        count++;
    }
    if(prev_id != -1)
        make_list_nav_hint(dir, "_news", count, prev_prev_id, prev_id, -1);

    fclose(f);
    return count;
}

/* ----------------- processing aliases (urls) -- --------------------- */

static int has_prefix(const char *prefix, const char *str)
{
    int i;
    for(i = 0; prefix[i]; i++)
        if(prefix[i] != str[i])
            return 0;
    return 1;
}

static int has_suffix(const char *suffix, const char *str)
{
    int i, lensfx, lens, d;
    lensfx = strlen(suffix);
    lens = strlen(str);
    if(lens < lensfx)
        return 0;
    d = lens - lensfx;
    for(i = 0; i < lensfx; i++)
        if(suffix[i] != str[i+d])
            return 0;
    return 1;
}

static int process_aliases(MYSQL *con, const char *dir)
{
    MYSQL_RES *res;
    MYSQL_ROW row;
    int count;
    FILE *f;
    char *fname;

    if(0 != mysql_query(con, "select dst, src from url_alias order by dst")) {
        fprintf(stderr, "can't get the url_alias table: %s\n",
                        mysql_error(con));
        return -1;
    }
    res = mysql_store_result(con);

    fname = path_concat(dir, "url_alias");
    f = fopen(fname, "w");
    if(!f) {
        perror(fname);
        free(fname);
        return -1;
    }
    free(fname);

    count = 0;
    while((row = mysql_fetch_row(res))) {
        /* row[0], row[1]!!! */
        if(has_prefix("admin/", row[1]) ||
            has_suffix("/edit", row[1]) ||
            has_prefix("node/", row[0]) ||
            0 == strcmp(row[1], "node") ||
            0 == strcmp(row[1], "node/")
        ) {
            continue;
        }
        fprintf(f, "%s:%s\n", row[0], row[1]);
        count++;
    }
    fclose(f);

    return count;
}

static int process_users(MYSQL *con, const char *dir)
{
    MYSQL_RES *res;
    MYSQL_ROW row;
    FILE *f;
    char *dirname;
    char *fname;
    int count;

    if(0 != mysql_query(con, "select uid,name,mail,created,login,access"
                             "   from users"
                             "   where status = '1' and exists "
                             "     (select uid from comments where"
                             "      users.uid = comments.uid"
                             /*"      and comments.status <> '0'"*/
                             ")")
    ) {
        fprintf(stderr, "can't get users: %s; aborting\n",
                        mysql_error(con));
        return -1;
    }
    res = mysql_store_result(con);
    dirname = path_concat(dir, "_users");
    make_directory_path(dirname);
    count = 0;
    while((row = mysql_fetch_row(res))) {
        fname = path_concat(dirname, row[0]);
        f = fopen(fname, "w");
        if(!f) {
            perror(fname);
            free(fname);
            continue;
        }
        free(fname);
        fprintf(f, "realname = %s\n"
                   "email = %s\n"
                   "created = %s\n"
                   "last_login = %s\n"
                   "last_seen = %s\n"
                   "status = active\n"
                   "comment = imported from drupal\n",
                   row[1], row[2], row[3], row[4], row[5]);
        fclose(f);
        count++;
    }
    free(dirname);
    return count;
}

/* ----------------- main funciton infrastructure --------------------- */

/* options passed from command line */
struct cl_options {
    const char *database;
    const char *user;
    const char *password;
    const char *host;
    int port;
    const char *resdir;
};

static void help()
{
    static const char * const htext[] = {
        "usage: drupal2fs <options>",
        "    options: -D <database>  set the database name ['drupal']",
        "             -h <hostname>  host name ['localhost']",
        "             -u <user>      user name for mysql [login name]",
        "             -p <password>  password [none]",
        "             -P <port>      port to connect to [default for mysql]",
        "             -o <dir>       output directory ['./_drupal/']",
        "             -? / -H        display this text and quit",
        "    The program refuses to work with no options at all.  If all the",
        "    defaults are Ok for you, please specify ``--'' as the only",
        "    option, just to tell the program everything goes well.",
        NULL
    };
    int i;

    for(i = 0; htext[i]; i++)
        printf("%s\n", htext[i]);
}

static int cmdline_parse(int argc, char *const*argv, struct cl_options *opt)
{
    int c;

    if(argc < 2) {
        fprintf(stderr, "Can't run with no parameters, try -H\n");
        return 0;
    }

    opt->database = "drupal";
    opt->user = NULL;
    opt->password = NULL;
    opt->host = "localhost";
    opt->port = 0;
    opt->resdir = "./_drupal";

    while(-1 != (c = getopt(argc, argv, ":D:h:u:p:P:o:H?"))) {
        switch(c) {
        case 'D':
            opt->database = optarg;
            break;
        case 'h':
            opt->host = optarg;
            break;
        case 'u':
            opt->user = optarg;
            break;
        case 'p':
            opt->password = optarg;
            break;
        case 'P': {
            char *err;
            int i = strtol(optarg, &err, 16);
            if(*optarg != '\0' && *err == '\0') {
                opt->port = i;
            } else {
                fprintf(stderr, "invalid port number\n");
                return 0;
            }
            break;
        }
        case 'o':
            opt->resdir = optarg;
            break;
        case 'H':
        case '?':
            help();
            return 0;
        case ':':
            fprintf(stderr, "option '%c' needs argument, try -H\n", optopt);
            return 0;
        default:
            fprintf(stderr, "unknown option '%c', try -H\n", optopt);
            return 0;
        }
    }
    if(optind < argc) {
        fprintf(stderr, "extra arguments found\n");
        return 0;
    }
    if(!opt->user) {
        opt->user = getenv("USER");
        if(!opt->user) {
            fprintf(stderr, "can't determine the user name, use -u\n");
            return 0;
        }
    }
    return 1;
}

int main(int argc, char **argv)
{
    int exitcode = 0;
    MYSQL *con, *conres;
    int count;

    struct cl_options options;

    if(!cmdline_parse(argc, argv, &options)) {
        return 1;
    }

    con = mysql_init(NULL);
    if(!con) {
        fprintf(stderr, "%s\n", mysql_error(con));
        return 1;
    }

    conres = mysql_real_connect(con, options.host,
                                options.user, options.password,
                                options.database, options.port,
                                NULL /* unix_socket */, 0 /* flags */);
    if(!conres) {
        fprintf(stderr, "%s\n", mysql_error(con));
        exitcode = 1;
        goto quit;
    }

    mysql_set_character_set(con, "utf8");

    if(!make_comment_id_trans(con))
        fprintf(stderr, "warning: will not convert comments\n");

    count = process_nodes(con, options.resdir);
    if(count == -1) {
        fprintf(stderr, "no nodes processed\n");
        exitcode = 1;
        goto quit;
    }
    fprintf(stderr, "Processed %d nodes\n", count);

    count = build_front_list_nav(con, options.resdir);
    fprintf(stderr, "%d nodes make the ``frontpage'' list\n", count);

    count = process_aliases(con, options.resdir);
    if(count == -1)
        fprintf(stderr, "no aliases processed\n");
    else
        fprintf(stderr, "processed %d aliases\n", count);

    count = process_users(con, options.resdir);
    if(count == -1)
        fprintf(stderr, "no users processed\n");
    else
        fprintf(stderr, "processed %d users\n", count);

quit:
    mysql_close(con);
    return exitcode;
}