开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
mod_sqlpw.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：25k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

mod_sqlpw.c：源码内容
  1. /*
  2.  * ProFTPD: mod_sql -- SQL frontend and user interface.
  3.  * Time-stamp: <1999-10-04 03:58:01 root>
  4.  * Copyright (c) 1998-1999 Johnie Ingram.
  5.  *  
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  21. #define MOD_SQL_VERSION "mod_sqlpw/2.0"
  23. /* This is mod_sqlpw, contrib software for proftpd 1.2.0pre3 and above.
  24.    For more information contact Johnie Ingram <johnie@netgod.net>.
  26.    History Log:
  28.    * 1999-09-19: v2.0: Backend directives split into mod_mysql.
  29.      Runtime API added.  Username/passwords now escaped for SQL.
  31.    * 1999-09-16: v1.0: Added documentation, made directives more
  32.      generic ("MySQL" -> "SQL" except for MySQLInfo).  Dir part of
  33.      SQLLogDirs finally made optional.
  35.    * 1999-06-01: v0.3: fixed segfault, changed 'strncmp' typo which
  36.      should have been copy.  Made uid/gid support optional.
  37.    
  38.    * 1999-05-03: v0.2: Removed dead code, fix bug with interaction
  39.      with anon-user support.  Added MySQLLogHits and MySQLHomedir
  40.      directives.  Fixed atoi() invocation that could segfault.
  41.      Copious debugging code added.
  43.    * 1999-04-09: v0.1: Initial attempt (mod_mysql).
  45. */
  47. #include "conf.h"
  48. #ifdef HAVE_CRYPT_H
  49. #include <crypt.h>
  50. #endif
  52. #include <mysql.h>
  54. /* *INDENT-OFF* */
  56. /* The Debian defintion of nobody/nogroup, minus 1 (used in getgwnam).  */
  57. #define MOD_SQL_MAGIC_USER 65533
  58. #define MOD_SQL_MAGIC_GROUP 65533
  60. /* A uid or gid less than this is mapped to the magic numbers above
  61.    instead of simply rejected (which is arguably better, hmm.) */
  62. #define MOD_SQL_MIN_ID 999
  64. #define MOD_SQL_MAGIC_SHELL "/bin/sh"
  66. /* Maximum username field to expect, etc. */
  67. #define ARBITRARY_MAX                   128
  69. static struct {
  70.   char user [ARBITRARY_MAX];
  71.   struct passwd pw;           /* Scratch space for the getpwnam call. */
  72.   char *pass;                 /* The password from db. */
  74.   char *homedir;              /* Set when getpwnam is called. */
  75.   int pwnamed;                /* Set when getpwnam is called. */
  76.   int sqled;                  /* Set if sql auth was used. */
  78.   char *sql_usertable;        /* CREATE TABLE users ( */
  79.   char *sql_userid;           /* userid varchar(50) NOT NULL, */
  80.   char *sql_passwd;           /* passwd varchar(15), */
  82.   char *sql_uid;              /* uid int(5), */
  83.   char *sql_gid;              /* gid int(5), */
  85.   char *sql_fstor;            /* fstor int(11) NOT NULL DEFAULT '0', */
  86.   char *sql_fretr;            /* fretr int(11) NOT NULL DEFAULT '0', */
  87.   char *sql_bstor;            /* bstor int(11) NOT NULL DEFAULT '0', */
  88.   char *sql_bretr;            /* bretr int(11) NOT NULL DEFAULT '0', */
  90.   char *sql_fhdir;            /* fhdir varchar(255), */
  92.   char *sql_fhost;            /* fhost varchar(50), */
  93.   char *sql_faddr;            /* faddr char(15), */
  94.   char *sql_ftime;            /* ftime timestamp, */
  96.   char *sql_fcdir;            /* fcdir varchar(255), */
  98.   char *sql_frate;            /* frate int(11) NOT NULL DEFAULT '5', */
  99.   char *sql_fcred;            /* fcred int(2) NOT NULL DEFAULT '15', */
  100.   char *sql_brate;            /* brate int(11) NOT NULL DEFAULT '5', */
  101.   char *sql_bcred;            /* bcred int(2) NOT NULL DEFAULT '150000', */
  103.   char *sql_flogs;            /* flogs int(11) NOT NULL DEFAULT '0', */
  105.   char *sql_hittable;
  106.   char *sql_dir;
  107.   char *sql_filename;
  108.   char *sql_hits;
  110.   char *loginmsg;
  111.   int ok;
  113. } g;
  115. /* *INDENT-ON* */
  117. /* **************************************************************** */
  119. /* Functions make_cmd and dispatch liberally stolen from auth.c. */
  121. static cmd_rec *
  122. _make_cmd (pool * cp, int argc, ...)
  123. {
  124.   va_list args;
  125.   cmd_rec *c;
  126.   int i;
  128.   c = pcalloc (cp, sizeof (cmd_rec));
  129.   c->argc = argc;
  130.   c->symtable_index = -1;
  132.   c->argv = pcalloc (cp, sizeof (void *) * (argc + 1));
  133.   c->argv[0] = MOD_SQL_VERSION;
  134.   va_start (args, argc);
  135.   for (i = 0; i < argc; i++)
  136.     c->argv[i + 1] = (void *) va_arg (args, char *);
  137.   va_end (args);
  139.   return c;
  140. }
  142. static modret_t *
  143. _dispatch_sql (cmd_rec * cmd, char *match)
  144. {
  145.   authtable *m;
  146.   modret_t *mr = NULL;
  148.   m = mod_find_auth_symbol (match, &cmd->symtable_index, NULL);
  149.   while (m)
  150.     {
  151.       mr = call_module_auth (m->m, m->handler, cmd);
  152.       if (MODRET_ISHANDLED (mr) || MODRET_ISERROR (mr))
  153. break;
  154.       m = mod_find_auth_symbol (match, &cmd->symtable_index, m);
  155.     }
  156.   if (MODRET_ISERROR (mr))
  157.     log_debug (DEBUG0, "Aiee! sql internal!  %s", MODRET_ERRMSG (mr));
  158.   return mr;
  159. }
  161. MODRET
  162. modsql_open (cmd_rec * cmd)
  163. {
  164.   cmd_rec *c;
  165.   modret_t *mr;
  167.   c = _make_cmd (cmd ? cmd->tmp_pool : permanent_pool, 0);
  168.   mr = _dispatch_sql (c, "dbd_open");
  169.   if (c->tmp_pool)
  170.     destroy_pool (c->tmp_pool);
  171.   return mr;
  172. }
  174. MODRET
  175. modsql_close (cmd_rec * cmd)
  176. {
  177.   cmd_rec *c;
  178.   modret_t *mr;
  180.   c = _make_cmd (cmd ? cmd->tmp_pool : permanent_pool, 0);
  181.   mr = _dispatch_sql (c, "dbd_close");
  182.   if (c->tmp_pool)
  183.     destroy_pool (c->tmp_pool);
  184.   return mr;
  185. }
  187. MODRET
  188. modsql_update (cmd_rec * cmd, const char *query)
  189. {
  190.   cmd_rec *c;
  191.   modret_t *mr;
  193.   c = _make_cmd (cmd->tmp_pool, 1, query);
  194.   mr = _dispatch_sql (c, "dbd_update");
  195.   if (c->tmp_pool)
  196.     destroy_pool (c->tmp_pool);
  197.   return mr;
  198. }
  200. MODRET
  201. modsql_select (cmd_rec * cmd, const char *query)
  202. {
  203.   cmd_rec *c;
  204.   modret_t *mr;
  206.   c = _make_cmd (cmd->tmp_pool, 1, query);
  207.   mr = _dispatch_sql (c, "dbd_select");
  208.   if (c->tmp_pool)
  209.     destroy_pool (c->tmp_pool);
  210.   return mr;
  211. }
  213. MODRET
  214. modsql_queryuser (cmd_rec * cmd, const char *user, const char *query,
  215.   int update)
  216. {
  217.   char *realquery;
  219.   if (update)
  220.     realquery = pstrcat (cmd->tmp_pool, "update ", g.sql_usertable,
  221.  " set ", query, " where ", g.sql_userid, " = '",
  222.  user, "'", NULL);
  223.   else
  224.     realquery = pstrcat (cmd->tmp_pool, "select ", query, " from ",
  225.  g.sql_usertable, " where ", g.sql_userid,
  226.  " = '", user, "'", NULL);
  227.   return (update) ? modsql_update (cmd, realquery)
  228.     : modsql_select (cmd, realquery);
  229. }
  231. /* **************************************************************** */
  233. static char *
  234. _uservar (cmd_rec * cmd, const char *user, const char *var)
  235. {
  236.   cmd_rec *c;
  237.   modret_t *mr;
  238.   char *query;
  239.   char **data;
  241.   query = pstrcat (cmd->tmp_pool, "select ", var, " from ",
  242.    g.sql_usertable, " where ", g.sql_userid,
  243.    " = '", user, "'", NULL);
  244.   c = _make_cmd (cmd->tmp_pool, 1, query);
  246.   mr = _dispatch_sql (c, "dbd_select");
  248.   if (c->tmp_pool)
  249.     destroy_pool (c->tmp_pool);
  250.   if (MODRET_ISHANDLED (mr))
  251.     {
  252.       data = mr->data;
  253.       return (data) ? data[0] : NULL;
  254.     }
  256.   return NULL;
  257. }
  259. /* Note: This function is called once by the master proftpd process
  260.    before it forks, so thankfully the homedir field is only set in the
  261.    child_init(). */
  263. MODRET
  264. auth_cmd_getpwnam (cmd_rec * cmd)
  265. {
  266.   const char *homedir;
  268.   if (!g.sql_fhdir && !g.homedir)
  269.     return DECLINED (cmd);
  271.   /* Only try this for the USER command (is also called twice after
  272.      PASS for some reason.  [update: 1 is dir_realpath/defroot related.] */
  273.   if (!g.homedir && !g.pwnamed++)
  274.     {
  275.       if ((homedir = _uservar (cmd, cmd->argv[0], g.sql_fhdir)))
  276. g.homedir = pstrdup (session.pool, homedir);
  277.     }
  278.   if (!g.homedir)
  279.     return DECLINED (cmd);
  281.   if (!g.pw.pw_name)
  282.     {
  283.       g.pw.pw_name = cmd->argv[0];
  284.       if (g.sql_uid)
  285. g.pw.pw_uid = atoi (_uservar (cmd, cmd->argv[0], g.sql_uid) ? : "0");
  286.       if (g.pw.pw_uid < MOD_SQL_MIN_ID)
  287. g.pw.pw_uid = MOD_SQL_MAGIC_USER;
  288.       if (g.sql_gid)
  289. g.pw.pw_gid = atoi (_uservar (cmd, cmd->argv[0], g.sql_gid) ? : "0");
  290.       if (g.pw.pw_gid < MOD_SQL_MIN_ID)
  291. g.pw.pw_gid = MOD_SQL_MAGIC_GROUP;
  292.       g.pw.pw_shell = MOD_SQL_MAGIC_SHELL;
  293.       g.pw.pw_dir = (char *) g.homedir;
  294.       log_debug (DEBUG3, "sqlpw: user "%s" (%i/%i) for %s",
  295.  cmd->argv[0], g.pw.pw_uid, g.pw.pw_gid, g.pw.pw_dir);
  297.       /* Copy username so proftpd anon handling won't confuse the issue. */
  299.       /* FIXME: unnecessary mysqlism */
  300.       mysql_escape_string (g.user, g.pw.pw_name, strlen (g.pw.pw_name));
  301.       g.user[ARBITRARY_MAX - 1] = 0;
  302.     }
  304.   return mod_create_data (cmd, &g.pw);
  305. }
  307. /* Returns 1 on successful match, 0 unsuccessful match, -1 on error. */
  309. static int
  310. _checkpass (cmd_rec * cmd, const char *user, const char *pass)
  311. {
  312.   int success = 0;
  313.   char *query;
  314.   int emptyok, cplain, ccrypt;
  315.   char **row;
  316.   MODRET mr;
  318.   emptyok = get_param_int (CURRENT_CONF, "SQLEmptyPasswords", FALSE);
  319.   cplain = get_param_int (CURRENT_CONF, "SQLPlaintextPasswords", FALSE);
  320.   ccrypt = get_param_int (CURRENT_CONF, "SQLEncryptedPasswords", FALSE);
  322.   query = pstrcat (cmd->tmp_pool, "select ", g.sql_passwd, " from ",
  323.    g.sql_usertable, " where ", g.sql_userid,
  324.    " = '", user, "'", " limit 2", NULL);
  325.   mr = modsql_select (cmd, query);
  326.   if (!(MODRET_HASDATA (mr)))
  327.     return -1;
  329.   row = mr->data;
  330.   if (row[0] == 0)
  331.     return 0;
  333.   if (!row[0])
  334.     {
  335.       log_debug (DEBUG4, "sqlpw: %s auth declined for NULL pass", user);
  336.       return 0;
  337.     }
  339.   if (row[1])
  340.     {
  341.       log_debug (DEBUG3, "sqlpw: %s pass result was not unique", user);
  342.       return -1;
  343.     }
  345.   if (emptyok == TRUE && !strlen (row[0]))
  346.     {
  347.       log_debug (DEBUG4, "sqlpw: warning: %s has empty password", user);
  348.       success = 1;
  349.     }
  351.   if (!success && cplain == TRUE && !strncasecmp (row[0], pass, 10))
  352.     {
  353.       success = 1;
  354.     }
  356.   /* Deliberate: ccrypt same if TRUE or -1 (unspecified). */
  357.   if (!success && ccrypt)
  358.     {
  359.       if (!strcmp (query = (char *) crypt (pass, row[0]), row[0]))
  360. success = 1;
  361.     }
  363.   if (!success)
  364.     log_debug (DEBUG5, "sqlpw: %s auth failed: '%s' != '%s'",
  365.        user, pass, row ? row[0] : "");
  366.   return success;
  367. }
  369. MODRET
  370. auth_cmd_auth (cmd_rec * cmd)
  371. {
  372.   char *user, *pass;
  373.   int return_type;
  374.   int retval = AUTH_NOPWD;
  376.   if (!g.sql_passwd || !g.homedir)
  377.     return DECLINED (cmd);
  379.   /* Figure out our default return style: Whether or not SQL should
  380.    * allow other auth modules a shot at this user or not is controlled
  381.    * by the parameter "SQLAuthoritative".  Like mod_pam this
  382.    * defaults to no.  */
  383.   return_type = get_param_int (CURRENT_CONF, "SQLAuthoritative", FALSE);
  385.   /* Just in case... */
  386.   if (cmd->argc != 2)
  387.     return return_type ? ERROR (cmd) : DECLINED (cmd);
  388.   if ((user = cmd->argv[0]) == NULL)
  389.     return return_type ? ERROR (cmd) : DECLINED (cmd);
  390.   if ((pass = cmd->argv[1]) == NULL)
  391.     return return_type ? ERROR (cmd) : DECLINED (cmd);
  393.   if (!g.pass
  394.       && get_param_int (CURRENT_CONF, "SQLEmptyPasswords", FALSE) == 2)
  395.     {
  396.       char *query;
  397.       char passbuf[ARBITRARY_MAX];
  399.       /* FIXME: unnecessary mysqlism */
  400.       mysql_escape_string (passbuf, cmd->argv[1], strlen (cmd->argv[1]));
  401.       g.user[ARBITRARY_MAX - 1] = 0;
  403.       query = pstrcat (cmd->tmp_pool, "update ", g.sql_usertable,
  404.        " set ", g.sql_passwd, " = '", passbuf,
  405.        "' where ", g.sql_userid, " = '", g.user, "'", 0);
  406.       log_debug (DEBUG3, "sqlpw: %s NULL pass set to '%s'", user,
  407.  cmd->argv[1], query);
  408.       modsql_update (cmd, query);
  409.     }
  411.   if (_checkpass (cmd, g.user, pass) != 1)
  412.     return return_type ? ERROR_INT (cmd, retval) : DECLINED (cmd);
  414.   g.sqled++;
  415.   return HANDLED (cmd);
  416. }
  418. MODRET
  419. auth_cmd_getstats (cmd_rec * cmd)
  420. {
  421.   MODRET mr;
  422.   char *query;
  424.   if (g.sql_fstor)
  425.     {
  426.       query = pstrcat (cmd->tmp_pool, "select ", g.sql_fstor, ", ",
  427.        g.sql_fretr, ", ", g.sql_bstor, ", ",
  428.        g.sql_bretr, " from ", g.sql_usertable, " where ",
  429.        g.sql_userid, " = '", g.user, "'", NULL);
  430.       mr = modsql_select (cmd, query);
  431.       if (MODRET_HASDATA (mr))
  432. return mr;
  433.     }
  434.   return DECLINED (cmd);
  435. }
  437. MODRET
  438. auth_cmd_getratio (cmd_rec * cmd)
  439. {
  440.   MODRET mr;
  441.   char *query;
  443.   if (g.sql_frate)
  444.     {
  445.       query = pstrcat (cmd->tmp_pool, "select ", g.sql_frate, ", ",
  446.        g.sql_fcred, ", ", g.sql_brate, ", ",
  447.        g.sql_bcred, " from ", g.sql_usertable, " where ",
  448.        g.sql_userid, " = '", g.user, "'", NULL);
  449.       mr = modsql_select (cmd, query);
  450.       if (MODRET_HASDATA (mr))
  451. return mr;
  452.     }
  453.   return DECLINED (cmd);
  454. }
  456. static authtable sqlpw_authtab[] = {
  458.   {0, "auth", auth_cmd_auth},
  459.   {0, "getpwnam", auth_cmd_getpwnam},
  460.   {0, "getstats", auth_cmd_getstats},
  461.   {0, "getratio", auth_cmd_getratio},
  462.   {0, NULL, NULL}
  463. };
  465. /* **************************************************************** */
  467. static void
  468. _setstats (cmd_rec * cmd, int fstor, int fretr, int bstor, int bretr)
  469. {
  470.   char query[ARBITRARY_MAX];
  471.   snprintf (query, sizeof (query),
  472.     "%s = %s + %i, %s = %s + %i, %s = %s + %i, %s = %s + %i",
  473.     g.sql_fstor, g.sql_fstor, fstor,
  474.     g.sql_fretr, g.sql_fretr, fretr,
  475.     g.sql_bstor, g.sql_bstor, bstor, g.sql_bretr, g.sql_bretr, bretr);
  476.   modsql_queryuser (cmd, g.user, query, TRUE);
  477. }
  479. MODRET
  480. pre_cmd_quit (cmd_rec * cmd)
  481. {
  482.   if (g.ok)
  483.     modsql_close (cmd);
  484.   return DECLINED (cmd);
  485. }
  487. MODRET
  488. cmd_user (cmd_rec * cmd)
  489. {
  490.   if (!g.user[0])
  491.     sstrncpy (g.user, cmd->argv[1], ARBITRARY_MAX);
  493.   if (g.sql_passwd)
  494.     {
  495.       g.pass = (char *) _uservar (cmd, cmd->argv[1], g.sql_passwd);
  496.       if (!g.pass
  497.   && get_param_int (CURRENT_CONF, "SQLEmptyPasswords", FALSE) == 2)
  498. if (_uservar (cmd, cmd->argv[1], "1"))
  499.   add_response (R_331, "Changing password for %s -- "
  500. "this password will be saved.", cmd->argv[1]);
  501.     }
  502.   return DECLINED (cmd);
  503. }
  505. MODRET
  506. cmd_pass (cmd_rec * cmd)
  507. {
  508.   if (g.sql_passwd && !g.pass
  509.       && get_param_int (CURRENT_CONF, "SQLEmptyPasswords", FALSE) == 2)
  510.     add_response (R_230, ""%s" is the new user "%s" password.",
  511.   cmd->argv[1], g.user);
  513.   /* This is called before the disconnect() in log_cmd_pass. */
  514.   if (g.sql_fcdir)
  515.     {
  516.       const char *d = _uservar (cmd, g.user, g.sql_fcdir);
  517.       if (d)
  518. add_response (R_230, ""%s" was last directory.", d);
  519.     }
  521.   return DECLINED (cmd);
  522. }
  524. MODRET
  525. post_cmd_pass (cmd_rec * cmd)
  526. {
  527.   if (g.sql_passwd && g.sqled)
  528.     session.anon_user = session.user = (char *) g.user;
  529.   return DECLINED (cmd);
  530. }
  532. MODRET
  533. post_cmd_stor (cmd_rec * cmd)
  534. {
  535.   if (g.sql_fstor)
  536.     _setstats (cmd, 1, 0, session.xfer.total_bytes, 0);
  537.   return DECLINED (cmd);
  538. }
  540. MODRET
  541. cmd_retr (cmd_rec * cmd)
  542. {
  543.   int i;
  544.   char *path, *filename, *query;
  545.   if (g.sql_hittable)
  546.     {
  547.       path = dir_realpath (cmd->tmp_pool, cmd->argv[1]);
  548.       if (g.sql_dir && g.sql_dir[0])
  549. {
  550.   for (i = strlen (path), filename = path + i;
  551.        *filename != '/' && i > 1; i--)
  552.     filename--;
  553.   *filename++ = 0;
  554.   query = pstrcat (cmd->tmp_pool, "update ", g.sql_hittable,
  555.    " set ", g.sql_hits, " = ", g.sql_hits,
  556.    " + 1 where ", g.sql_dir, " = '", ++path,
  557.    "' and ", g.sql_filename, " = '", filename,
  558.    "'", 0);
  559. }
  560.       else
  561. query = pstrcat (cmd->tmp_pool, "update ", g.sql_hittable,
  562.  " set ", g.sql_hits, " = ", g.sql_hits,
  563.  " + 1 where ", g.sql_filename, " = '", path, "'", 0);
  564.       modsql_update (cmd, query);
  565.     }
  566.   return DECLINED (cmd);
  567. }
  569. MODRET
  570. post_cmd_retr (cmd_rec * cmd)
  571. {
  572.   if (g.sql_fretr)
  573.     _setstats (cmd, 0, 1, 0, session.xfer.total_bytes);
  574.   return DECLINED (cmd);
  575. }
  577. MODRET
  578. log_cmd_pass (cmd_rec * cmd)
  579. {
  580.   char *query;
  582.   if (g.sql_fhost)
  583.     {
  584.       query = pstrcat (cmd->tmp_pool, g.sql_fhost, " = '",
  585.        session.c->remote_name, "', ", g.sql_faddr,
  586.        " = '", inet_ntoa (*session.c->remote_ipaddr),
  587.        "', ", g.sql_ftime, " = now()", NULL);
  588.       modsql_queryuser (cmd, g.user, query, TRUE);
  589.     }
  590.   if (g.sql_flogs)
  591.     {
  592.       query = pstrcat (cmd->tmp_pool, g.sql_flogs, " = ", g.sql_flogs,
  593.        " + 1", NULL);
  594.       modsql_queryuser (cmd, g.user, query, TRUE);
  595.     }
  597.   /* Autononpersistence: disconnect now if no other feature is being used. */
  598.   if (!g.sql_fstor && !g.sql_fcdir && !g.sql_hittable)
  599.     modsql_close (cmd);
  600.   return DECLINED (cmd);
  601. }
  603. MODRET
  604. log_cmd_cwd (cmd_rec * cmd)
  605. {
  606.   if (g.sql_fcdir)
  607.     {
  608.       char *query = pstrcat (cmd->tmp_pool, g.sql_fcdir, " = '",
  609.      session.cwd, "'", NULL);
  610.       modsql_queryuser (cmd, g.user, query, TRUE);
  611.     }
  612.   return DECLINED (cmd);
  613. }
  615. cmdtable sqlpw_cmdtab[] = {
  616. /* *INDENT-OFF* */
  618.   { PRE_CMD,  C_QUIT, G_NONE, pre_cmd_quit,  FALSE, FALSE },
  619.   { CMD,      C_USER, G_NONE, cmd_user,  FALSE, FALSE },
  620.   { CMD,      C_PASS, G_NONE, cmd_pass,  FALSE, FALSE },
  621.   { POST_CMD, C_PASS, G_NONE, post_cmd_pass,  FALSE, FALSE },
  622.   { POST_CMD, C_STOR, G_NONE, post_cmd_stor,  FALSE, FALSE },
  623.   { POST_CMD, C_RETR, G_NONE, post_cmd_retr,  FALSE, FALSE },
  624.   { CMD,      C_RETR, G_NONE, cmd_retr,  FALSE, FALSE },
  625.   { LOG_CMD,  C_PASS, G_NONE, log_cmd_pass,  FALSE, FALSE },
  626.   { LOG_CMD,  C_CWD, G_NONE, log_cmd_cwd,  FALSE, FALSE },
  627.   { LOG_CMD,  C_CDUP, G_NONE, log_cmd_cwd,  FALSE, FALSE },
  629.   { 0,       NULL }
  631. /* *INDENT-ON* */
  632. };
  634. /* **************************************************************** */
  636. MODRET
  637. set_sqlloghosts (cmd_rec * cmd)
  638. {
  639.   int b;
  641.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  642.   switch (cmd->argc - 1)
  643.     {
  644.     default:
  645.       CONF_ERROR (cmd, "requires a boolean or 3 field names: "
  646.   "fhost faddr ftime");
  647.     case 1:
  648.       if ((b = get_boolean (cmd, 1)) == -1)
  649. CONF_ERROR (cmd, "requires a boolean or 3 field names: "
  650.     "fhost faddr ftime");
  651.       if (b)
  652. add_config_param_str ("SQLLogHosts", 3, "fhost", "faddr", "ftime");
  653.       break;
  655.     case 3:
  656.       add_config_param_str ("SQLLogHosts", 3,
  657.     (void *) cmd->argv[1], (void *) cmd->argv[2],
  658.     (void *) cmd->argv[3]);
  659.     }
  660.   return HANDLED (cmd);
  661. }
  663. MODRET
  664. set_sqllogstats (cmd_rec * cmd)
  665. {
  666.   int b;
  668.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  669.   switch (cmd->argc - 1)
  670.     {
  671.     default:
  672.       CONF_ERROR (cmd, "requires a boolean or 4 field names: "
  673.   "fstor fretr bstor bretr");
  674.     case 1:
  675.       if ((b = get_boolean (cmd, 1)) == -1)
  676. CONF_ERROR (cmd, "requires a boolean or 4 field names: "
  677.     "fstor fretr bstor bretr");
  678.       if (b)
  679. add_config_param_str ("SQLLogStats", 4,
  680.       "fstor", "fretr", "bstor", "bretr");
  681.       break;
  683.     case 4:
  684.       add_config_param_str ("SQLLogStats", 4,
  685.     (void *) cmd->argv[1], (void *) cmd->argv[2],
  686.     (void *) cmd->argv[3], (void *) cmd->argv[4]);
  687.     }
  688.   return HANDLED (cmd);
  689. }
  691. MODRET
  692. set_sqlloghits (cmd_rec * cmd)
  693. {
  694.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  695.   switch (cmd->argc - 1)
  696.     {
  697.     default:
  698.       CONF_ERROR (cmd, "requires a table or table plus 3 fields: "
  699.   "[table] filename count dir");
  700.     case 1:
  701.       add_config_param_str ("SQLLogHits", 4, (void *) cmd->argv[1],
  702.     "filename", "count", "");
  703.       break;
  704.     case 3:
  705.       add_config_param_str ("SQLLogHits", 4,
  706.     (void *) cmd->argv[1], (void *) cmd->argv[2],
  707.     (void *) cmd->argv[3], "");
  709.     case 4:
  710.       add_config_param_str ("SQLLogHits", 4,
  711.     (void *) cmd->argv[1], (void *) cmd->argv[2],
  712.     (void *) cmd->argv[3], (void *) cmd->argv[4]);
  713.     }
  714.   return HANDLED (cmd);
  715. }
  717. MODRET
  718. set_sqllogdirs (cmd_rec * cmd)
  719. {
  720.   int b;
  722.   CHECK_ARGS (cmd, 1);
  723.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  724.   if ((b = get_boolean (cmd, 1)) == -1)
  725.     add_config_param_str ("SQLLogDirs", 1, (void *) cmd->argv[1]);
  726.   else if (b)
  727.     add_config_param_str ("SQLLogDirs", 1, "fcdir");
  728.   return HANDLED (cmd);
  729. }
  731. MODRET
  732. set_sqlratios (cmd_rec * cmd)
  733. {
  734.   int b;
  736.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  737.   switch (cmd->argc - 1)
  738.     {
  739.     default:
  740.       CONF_ERROR (cmd, "requires a boolean or 4 field names: "
  741.   "frate fcred brate bcred");
  742.     case 1:
  743.       if ((b = get_boolean (cmd, 1)) == -1)
  744. CONF_ERROR (cmd, "requires a boolean or 4 field names: "
  745.     "frate fcred brate bcred");
  746.       if (b)
  747. add_config_param_str ("SQLRatios", 4,
  748.       "frate", "fcred", "brate", "bcred");
  749.       break;
  751.     case 4:
  752.       add_config_param_str ("SQLRatios", 4,
  753.     (void *) cmd->argv[1], (void *) cmd->argv[2],
  754.     (void *) cmd->argv[3], (void *) cmd->argv[4]);
  755.     }
  756.   return HANDLED (cmd);
  757. }
  759. MODRET
  760. set_sqlempty (cmd_rec * cmd)
  761. {
  762.   int b;
  763.   config_rec *c;
  765.   CHECK_ARGS (cmd, 1);
  766.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  768.   if ((b = get_boolean (cmd, 1)) == -1)
  769.     {
  770.       if (!strcasecmp (cmd->argv[1], "set"))
  771. b = 2;
  772.       else
  773. CONF_ERROR (cmd, "requires 'set' or a boolean value");
  774.     }
  775.   c = add_config_param (cmd->argv[0], 1, (void *) b);
  776.   c->flags |= CF_MERGEDOWN;
  777.   return HANDLED (cmd);
  778. }
  780. MODRET
  781. add_globalstr (cmd_rec * cmd)
  782. {
  783.   CHECK_ARGS (cmd, 1);
  784.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  785.   add_config_param_str (cmd->argv[0], 1, (void *) cmd->argv[1]);
  786.   return HANDLED (cmd);
  787. }
  789. MODRET
  790. add_globalbool (cmd_rec * cmd)
  791. {
  792.   int b;
  793.   config_rec *c;
  795.   CHECK_ARGS (cmd, 1);
  796.   CHECK_CONF (cmd, CONF_ROOT | CONF_GLOBAL);
  798.   b = get_boolean (cmd, 1);
  799.   if (b == -1)
  800.     CONF_ERROR (cmd, "requires a boolean value");
  801.   c = add_config_param (cmd->argv[0], 1, (void *) b);
  802.   c->flags |= CF_MERGEDOWN;
  803.   return HANDLED (cmd);
  804. }
  806. static conftable sqlpw_conftab[] = {
  807. /* *INDENT-OFF* */
  809.   { "SQLLogHosts",            set_sqlloghosts,   NULL },
  810.   { "SQLLogStats",            set_sqllogstats,   NULL },
  811.   { "SQLLogHits",             set_sqlloghits,    NULL },
  812.   { "SQLLogDirs",             set_sqllogdirs,    NULL },
  813.   { "SQLRatios",              set_sqlratios,     NULL },
  814.   { "SQLEmptyPasswords",      set_sqlempty,      NULL },
  816.   { "SQLUserTable",           add_globalstr,     NULL },
  817.   { "SQLUsernameField",       add_globalstr,     NULL },
  818.   { "SQLUidField",            add_globalstr,     NULL },
  819.   { "SQLGidField",            add_globalstr,     NULL },
  820.   { "SQLPasswordField",       add_globalstr,     NULL },
  821.   { "SQLHomedirField",        add_globalstr,     NULL },
  822.   { "SQLLoginCountField",     add_globalstr,     NULL },
  823.   { "SQLHomedir",             add_globalstr,     NULL },
  825.   { "SQLAuthoritative",       add_globalbool,    NULL },
  826.   { "SQLEncryptedPasswords",  add_globalbool,    NULL },
  827.   { "SQLPlaintextPasswords",  add_globalbool,    NULL },
  829.   { NULL, NULL, NULL }
  831. /* *INDENT-ON* */
  832. };
  834. /* **************************************************************** */
  836. static int
  837. sqlpw_child_init ()
  838. {
  839.   config_rec *c;
  840.   MODRET mr;
  842.   memset (&g, 0, sizeof (g));
  843.   g.ok = TRUE;
  845.   g.sql_passwd = get_param_ptr (CURRENT_CONF, "SQLPasswordField", FALSE);
  846.   g.sql_flogs = get_param_ptr (CURRENT_CONF, "SQLLoginCountField", FALSE);
  847.   g.sql_uid = get_param_ptr (CURRENT_CONF, "SQLUidField", FALSE);
  848.   g.sql_gid = get_param_ptr (CURRENT_CONF, "SQLGidField", FALSE);
  850.   if (!(g.homedir = get_param_ptr (CURRENT_CONF, "SQLHomedir", FALSE)))
  851.     {
  852.       g.sql_fhdir = get_param_ptr (CURRENT_CONF, "SQLHomedirField", FALSE);
  853.     }
  854.   if ((c = find_config (CURRENT_CONF, CONF_PARAM, "SQLLogHosts", FALSE)))
  855.     {
  856.       g.sql_fhost = c->argv[0];
  857.       g.sql_faddr = c->argv[1];
  858.       g.sql_ftime = c->argv[2];
  859.     }
  860.   if ((c = find_config (CURRENT_CONF, CONF_PARAM, "SQLLogStats", FALSE)))
  861.     {
  862.       g.sql_fstor = c->argv[0];
  863.       g.sql_fretr = c->argv[1];
  864.       g.sql_bstor = c->argv[2];
  865.       g.sql_bretr = c->argv[3];
  866.     }
  867.   if ((c = find_config (CURRENT_CONF, CONF_PARAM, "SQLRatios", FALSE)))
  868.     {
  869.       if (!g.sql_fstor)
  870. log_pri (LOG_WARNING, "sqlpw: warning: SQLRatios directive "
  871.  "ineffective without SQLLogStats on");
  872.       g.sql_frate = c->argv[0];
  873.       g.sql_fcred = c->argv[1];
  874.       g.sql_brate = c->argv[2];
  875.       g.sql_bcred = c->argv[3];
  876.     }
  877.   if ((c = find_config (CURRENT_CONF, CONF_PARAM, "SQLLogHits", FALSE)))
  878.     {
  879.       g.sql_hittable = c->argv[0];
  880.       g.sql_filename = c->argv[1];
  881.       g.sql_hits = c->argv[2];
  882.       g.sql_dir = c->argv[3];
  883.     }
  884.   g.sql_fcdir = get_param_ptr (CURRENT_CONF, "SQLLogDirs", FALSE);
  886.   g.sql_usertable = get_param_ptr (CURRENT_CONF, "SQLUserTable",
  887.    FALSE) ? : "users";
  888.   g.sql_userid = get_param_ptr (CURRENT_CONF, "SQLUsernameField",
  889. FALSE) ? : "userid";
  891.   if (!(g.homedir || g.sql_fhdir) && !g.sql_fhost
  892.       && !g.sql_fstor && !g.sql_fcdir)
  893.     return 0;
  895.   mr = modsql_open (NULL);
  896.   if (MODRET_ISHANDLED (mr))
  897.     {
  898.       log_debug (DEBUG3, "%s: configured: %s%s%s%s%s%s%s%s",
  899.  MOD_SQL_VERSION,
  900.  (g.sql_passwd && (g.homedir || g.sql_fhdir))
  901.  ? "auth " : "",
  902.  g.homedir ? "homedir " : "",
  903.  g.sql_fhdir ? "homedirfield " : "",
  904.  g.sql_fhost ? "loghosts " : "",
  905.  g.sql_fstor ? "logstats " : "",
  906.  g.sql_frate ? "ratios " : "",
  907.  g.sql_hittable ? "loghits " : "",
  908.  g.sql_fcdir ? "logdirs " : "");
  909.     }
  910.   else
  911.     {
  912.       memset (&g, 0, sizeof (g));
  913.       log_debug (DEBUG3, "%s: unconfigured: no backend could connect"
  914.  MOD_SQL_VERSION);
  915.     }
  916.   return 0;
  917. }
  919. static int
  920. sqlpw_parent_init (void)
  921. {
  922.   /* FIXME: add db init stuff once parent_init() actually works. */
  923.   return 0;
  924. }
  926. module sqlpw_module = {
  927.   NULL, NULL, /* Always NULL */
  928.   0x20, /* API Version 2.0 */
  929.   "sql",
  930.   sqlpw_conftab, /* SQL configuration handler table */
  931.   sqlpw_cmdtab, /* SQL command handler table */
  932.   sqlpw_authtab, /* SQL authentication handler table */
  933.   sqlpw_parent_init, /* Pre-fork "parent mode" init */
  934.   sqlpw_child_init /* Post-fork "child mode" init */
  935. };