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

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

Ftp客户端

开发平台：

Unix_Linux

mod_unixpw.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  4.  *  
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  20. /*
  21.  * unix password lookup module for ProFTPD
  22.  * $Id: mod_unixpw.c,v 1.3 1999/10/01 03:33:47 macgyver Exp $
  23.  */
  25. #include "conf.h"
  27. #ifdef HAVE_CRYPT_H
  28. #include <crypt.h>
  29. #endif
  31. #ifdef USESHADOW
  32. #include <shadow.h>
  33. #endif
  35. #ifdef HAVE_SYS_SECURITY_H
  36. #include <sys/security.h>
  37. #endif
  38. #ifdef HAVE_KRB_H
  39. #include <krb.h>
  40. #endif
  41. #ifdef HAVE_HPSECURITY_H
  42. #include <hpsecurity.h>
  43. #endif
  44. #ifdef HAVE_PROT_H
  45. #include <prot.h>
  46. #endif
  48. #include "privs.h"
  50. const char *pwdfname="/etc/passwd";
  51. const char *grpfname="/etc/group";
  53. #ifdef HAVE__PW_STAYOPEN
  54. extern int _pw_stayopen;
  55. #endif
  57. #define HASH_TABLE_SIZE 10
  59. typedef struct _idmap {
  60.   struct _idmap *next,*prev;
  62.   int id; /* uid or gid */
  63.   char *name; /* user or group name */
  64. } idmap_t;
  66. static xaset_t *uid_table[HASH_TABLE_SIZE];
  67. static xaset_t *gid_table[HASH_TABLE_SIZE];
  69. static FILE *pwdf = NULL;
  70. static FILE *grpf = NULL;
  72. #ifdef NEED_PERSISTENT_PASSWD
  73. int persistent = 1;
  74. #else
  75. int persistent = 0;
  76. #endif
  78. static int persistent_passwd = 0, persistent_group = 0;
  80. #define PERSISTENT_PASSWD (persistent || persistent_passwd)
  81. #define PERSISTENT_GROUP (persistent || persistent_group)
  83. #undef PASSWD
  84. #define PASSWD pwdfname
  85. #undef GROUP
  86. #define GROUP grpfname
  88. #ifdef USESHADOW
  90. /* Shadow password entries are stored as number of days, not seconds
  91.  * and are -1 if unused
  92.  */
  94. #define SP_CVT_DAYS(x) ((x) == (time_t)-1 ? (x) : ((x) * 86400))
  96. #endif /* USESHADOW */
  98. static void p_setpwent()
  99. {
  100.   if(pwdf)
  101.     rewind(pwdf);
  102.   else
  103.     pwdf = fopen(PASSWD,"r");
  104. }
  106. static void p_endpwent()
  107. {
  108.   if(pwdf) {
  109.     fclose(pwdf);
  110.     pwdf = NULL;
  111.   }
  112. }
  114. static void p_setgrent()
  115. {
  116.   if(grpf)
  117.     rewind(grpf);
  118.   else
  119.     grpf = fopen(GROUP,"r");
  120. }
  122. static void p_endgrent()
  123. {   
  124.   if(grpf) {
  125.     fclose(grpf);
  126.     grpf = NULL;
  127.   }
  128. }
  130. static struct passwd *p_getpwent()
  131. {  
  132.   if(!pwdf)
  133.     p_setpwent();
  135.   if(!pwdf)
  136.     return NULL;
  137.   
  138.   return fgetpwent(pwdf);
  139. }
  141. static struct group *p_getgrent()
  142. {   
  143.   struct group *gr;
  144.    
  145.   if(!grpf)
  146.     p_setgrent();
  147.   
  148.   if(!grpf)
  149.     return NULL;
  151.   gr = fgetgrent(grpf);  
  152.  
  153.   return gr;
  154. }
  156. static struct passwd *p_getpwnam(const char *name)
  157. {  
  158.   struct passwd *pw;
  159.     
  160.   p_setpwent();
  161.   while((pw = p_getpwent()) != NULL)
  162.     if(!strcmp(name,pw->pw_name))
  163.       break;
  164.  
  165.   return pw;
  166. }
  168. static struct passwd *p_getpwuid(uid_t uid)
  169. {   
  170.   struct passwd *pw;
  171.   
  172.   p_setpwent();
  173.   while((pw = p_getpwent()) != NULL)
  174.     if(pw->pw_uid == uid)
  175.       break;
  176.  
  177.   return pw;
  178. }
  180. static struct group *p_getgrnam(const char *name)
  181. { 
  182.   struct group *gr;
  183.   
  184.   p_setgrent();
  185.   while((gr = p_getgrent()) != NULL)
  186.     if(!strcmp(name,gr->gr_name))
  187.       break;
  188.  
  189.   return gr;
  190. }
  192. static struct group *p_getgrgid(gid_t gid)
  193. { 
  194.   struct group *gr;
  195.   
  196.   p_setgrent();
  197.   while((gr = p_getgrent()) != NULL)
  198.     if(gr->gr_gid == gid)
  199.       break;
  200.  
  201.   return gr;
  202. }
  204. static int _compare_id(idmap_t *m1, idmap_t *m2)
  205. {
  206.   if(m1->id < m2->id)
  207.     return -1;
  208.   if(m1->id > m2->id)
  209.     return 1;
  210.   return 0;
  211. }
  213. static idmap_t *_auth_lookup_id(xaset_t **id_table, int id)
  214. {
  215.   int hash = id % HASH_TABLE_SIZE;
  216.   idmap_t *m;
  218.   if(!id_table[hash])
  219.     id_table[hash] = xaset_create(permanent_pool,
  220.                      (XASET_COMPARE)_compare_id);
  222.   for(m = (idmap_t*)id_table[hash]->xas_list; m; m=m->next)
  223.     if(m->id == id)
  224.       break;
  226.   if(!m || m->id != id) {
  227.     /* Isn't in the table */
  228.     m = (idmap_t*)pcalloc(id_table[hash]->mempool,sizeof(idmap_t));
  229.     m->id = id;
  230.     xaset_insert_sort(id_table[hash],(xasetmember_t*)m,FALSE);
  231.   }
  233.   return m;
  234. }
  236. MODRET pw_setpwent(cmd_rec *cmd)
  237. {
  238.   if(PERSISTENT_PASSWD)
  239.     p_setpwent();
  240.   else
  241.     setpwent();
  243.   return HANDLED(cmd);
  244. }
  246. MODRET pw_endpwent(cmd_rec *cmd)
  247. {
  248.   if(PERSISTENT_PASSWD)
  249.     p_endpwent();
  250.   else
  251.     endpwent();
  253.   return HANDLED(cmd);
  254. }
  256. MODRET pw_setgrent(cmd_rec *cmd)
  257. {
  258.   if(PERSISTENT_GROUP)
  259.     p_setgrent();
  260.   else
  261.     setgrent();
  263.   return HANDLED(cmd);
  264. }
  266. MODRET pw_endgrent(cmd_rec *cmd)
  267. {
  268.   if(PERSISTENT_GROUP)
  269.     p_endgrent();
  270.   else
  271.     endgrent();
  273.   return HANDLED(cmd);
  274. }
  276. MODRET pw_getgrent(cmd_rec *cmd)
  277. {
  278.   struct group *gr;
  280.   if(PERSISTENT_GROUP)
  281.     gr = p_getgrent();
  282.   else
  283.     gr = getgrent();
  285.   if(gr)
  286.     return mod_create_data(cmd,gr);
  287.   else
  288.     return ERROR(cmd);
  289. }
  291. MODRET pw_getpwent(cmd_rec *cmd)
  292. {
  293.   struct passwd *pw;
  295.   if(PERSISTENT_PASSWD)
  296.     pw = p_getpwent();
  297.   else
  298.     pw = getpwent();
  300.   if(pw)
  301.     return mod_create_data(cmd,pw);
  302.   else
  303.     return ERROR(cmd);
  304. }
  306. MODRET pw_getpwuid(cmd_rec *cmd)
  307. {
  308.   struct passwd *pw;
  309.   uid_t uid;
  311.   uid = (uid_t)cmd->argv[0];
  312.   if(PERSISTENT_PASSWD)
  313.     pw = p_getpwuid(uid);
  314.   else
  315.     pw = getpwuid(uid);
  317.   if(pw)
  318.     return mod_create_data(cmd,pw);
  319.   else
  320.     return ERROR(cmd);
  321. }
  323. MODRET pw_getpwnam(cmd_rec *cmd)
  324. {
  325.   struct passwd *pw;
  326.   const char *name;
  328.   name = cmd->argv[0];
  329.   if(PERSISTENT_PASSWD)
  330.     pw = p_getpwnam(name);
  331.   else
  332.     pw = getpwnam(name);
  334.   if(pw)
  335.     return mod_create_data(cmd,pw);
  336.   else
  337.     return ERROR(cmd);
  338. }
  340. MODRET pw_getgrnam(cmd_rec *cmd)
  341. {
  342.   struct group *gr;
  343.   const char *name;
  345.   name = cmd->argv[0];
  346.   if(PERSISTENT_GROUP)
  347.     gr = p_getgrnam(name);
  348.   else
  349.     gr = getgrnam(name);
  351.   if(gr)
  352.     return mod_create_data(cmd,gr);
  353.   else
  354.     return ERROR(cmd);
  355. }
  357. MODRET pw_getgrgid(cmd_rec *cmd)
  358. {
  359.   struct group *gr;
  360.   gid_t gid;
  362.   gid = (gid_t)cmd->argv[0];
  363.   if(PERSISTENT_GROUP)
  364.     gr = p_getgrgid(gid);
  365.   else
  366.     gr = getgrgid(gid);
  368.   if(gr)
  369.     return mod_create_data(cmd,gr);
  370.   else
  371.     return ERROR(cmd);
  372. }
  374. #ifdef USESHADOW
  375. static char *_get_pw_info(pool *p, const char *u,
  376.                           time_t *lstchg, time_t *min, time_t *max,
  377.                           time_t *warn, time_t *inact, time_t *expire)
  378. {
  379.   struct spwd *sp;
  380.   char *cpw = NULL;
  382.   PRIVS_ROOT
  383.   sp = getspnam(u);
  385.   if(sp) {
  386.     cpw = pstrdup(p,sp->sp_pwdp);
  387.     if(lstchg) *lstchg = SP_CVT_DAYS(sp->sp_lstchg);
  388.     if(min) *min = SP_CVT_DAYS(sp->sp_min);
  389.     if(max) *max = SP_CVT_DAYS(sp->sp_max);
  390.     if(warn) *warn = SP_CVT_DAYS(sp->sp_warn);
  391.     if(inact) *inact = SP_CVT_DAYS(sp->sp_inact);
  392.     if(expire) *expire = SP_CVT_DAYS(sp->sp_expire);
  393.   }
  394. #ifdef AUTOSHADOW
  395.   else {
  396.     struct passwd *pw;
  398.     endspent();
  399.     PRIVS_RELINQUISH
  401.     if((pw = getpwnam(u)) != NULL) {
  402.       cpw = pstrdup(p,pw->pw_passwd);
  403.       if(lstchg) *lstchg = (time_t)-1;
  404.       if(min) *min = (time_t)-1;
  405.       if(max) *max = (time_t)-1;
  406.       if(warn) *warn = (time_t)-1;
  407.       if(inact) *inact = (time_t)-1;
  408.       if(expire) *expire = (time_t)-1;
  409.     }
  410.   }
  411. #else
  412.   endspent();
  413.   PRIVS_RELINQUISH
  414. #endif /* AUTOSHADOW */
  415.   return cpw;
  416. }
  418. #else /* USESHADOW */
  420. static char *_get_pw_info(pool *p, const char *u,
  421.                           time_t *lstchg, time_t *min, time_t *max,
  422.                           time_t *warn, time_t *inact, time_t *expire)
  423. {
  424.   char *cpw = NULL;
  425. #ifdef HAVE_GETPRPWENT
  426.   struct pr_passwd *pw;
  427. #else
  428.   struct passwd *pw;
  429. #endif
  431.  /* some platforms (i.e. bsd) provide "transparent" shadowing, which
  432.   * requires that we are root in order to have the password member
  433.   * filled in.
  434.   */
  436.   PRIVS_ROOT
  437. #ifndef HAVE_GETPRPWENT
  438.   endpwent();
  439. #if defined(BSDI3) || defined(BSDI4)
  440.   /* endpwent() seems to be buggy on BSDI3.1 (is this true for 4.0?)
  441.    * setpassent(0) _seems_ to do the same thing, however this conflicts
  442.    * with the man page documented behavior.  Argh, why do all the bsds
  443.    * have to be different in this area (except OpenBSD, grin).
  444.    */
  445.   setpassent(0);
  446. #else /* BSDI3 || BSDI4 */
  447.   setpwent();
  448. #endif /* BSDI3 || BSDI4 */
  450.   pw = getpwnam(u);
  452.   if(pw) {
  453.     cpw = pstrdup(p,pw->pw_passwd);
  454.     if(lstchg) *lstchg = (time_t)-1;
  455.     if(min) *min = (time_t)-1;
  456.     if(max) *max = (time_t)-1;
  457.     if(warn) *warn = (time_t)-1;
  458.     if(inact) *inact = (time_t)-1;
  459.     if(expire) *expire = (time_t)-1;
  460.   }
  462.   endpwent();
  464. #else /* HAVE_GETPRPWENT */
  465.   endprpwent();
  466.   setprpwent();
  468.   pw = getprpwnam(u);
  470.   if(pw) {
  471.     cpw = pstrdup(p,pw->ufld.fd_encrypt);
  472.     if(lstchg) *lstchg = (time_t)-1;
  473.     if(min) *min = pw->ufld.fd_min; 
  474.     if(max) *max = (time_t)-1;
  475.     if(warn) *warn = (time_t)-1;
  476.     if(inact) *inact = (time_t)-1;
  477.     if(expire) *expire = pw->ufld.fd_expire;
  478.   }
  480.   endprpwent();
  482. #endif /* HAVE_GETPRPWENT */
  484.   PRIVS_RELINQUISH
  485. #if defined(BSDI3) || defined(BSDI4)
  486.   setpassent(1);
  487. #endif
  488.   return cpw;
  489. }
  491. #endif /* USESHADOW */
  493. static char *_get_ppw_info(pool *p, const char *u)
  494. {
  495.   struct passwd *pw;
  496.   char *cpw = NULL;
  498.   pw = p_getpwnam(u);
  499.   if(pw)
  500.     cpw = pstrdup(p,pw->pw_passwd);
  502.   return cpw;
  503. }
  505. /* high-level auth handlers
  506.  */
  508. /* cmd->argv[0] : user name
  509.  * cmd->argv[1] : cleartext password
  510.  */
  512. MODRET pw_auth(cmd_rec *cmd)
  513. {
  514.   time_t now;
  515.   char *cpw;
  516.   time_t lstchg = -1,max = -1,inact = -1,disable = -11;
  517.   const char *name;
  519.   name = cmd->argv[0];
  520.   time(&now);
  522.   if(persistent_passwd)
  523.     cpw = _get_ppw_info(cmd->tmp_pool,name);
  524.   else
  525.     cpw = _get_pw_info(cmd->tmp_pool,name,&lstchg,NULL,&max,NULL,&inact,&disable);
  527.   if(!cpw)
  528.     return ERROR_INT(cmd,AUTH_NOPWD);
  530.   if(auth_check(cmd->tmp_pool,cpw,cmd->argv[0],cmd->argv[1]))
  531.     return ERROR_INT(cmd,AUTH_BADPWD);
  533.   if(lstchg > (time_t)0 && max > (time_t)0 &&
  534.      inact > (time_t)0)
  535.     if(now > lstchg + max + inact)
  536.       return ERROR_INT(cmd,AUTH_AGEPWD);
  538.   if(disable > (time_t)0 && now > disable)
  539.     return ERROR_INT(cmd,AUTH_DISABLEDPWD);
  541.   return HANDLED(cmd);
  542. }
  544. /*
  545.  * cmd->argv[0] = hashed password,
  546.  * cmd->argv[1] = user,
  547.  * cmd->argv[2] = cleartext
  548.  */
  550. MODRET pw_check(cmd_rec *cmd)
  551. {
  552.   static char *pw,*cpw;
  554.   cpw = cmd->argv[0];
  555.   pw = cmd->argv[2];
  557.   if(strcmp(crypt(pw,cpw),cpw) != 0)
  558.     return ERROR(cmd);
  560.   return HANDLED(cmd);
  561. }
  563. MODRET pw_uid_name(cmd_rec *cmd)
  564. {
  565.   idmap_t *m;
  566.   struct passwd *pw;
  567.   uid_t uid;
  569.   uid = (uid_t)cmd->argv[0];
  570.   m = _auth_lookup_id(uid_table,uid);
  572.   if(!m->name) {
  573.     /* wasn't cached, so perform a lookup */
  575.     if(PERSISTENT_PASSWD)
  576.       pw = p_getpwuid(uid);
  577.     else
  578.       pw = getpwuid(uid);
  580.     if(pw)
  581.       m->name = pstrdup(permanent_pool,pw->pw_name);
  582.     else {
  583.       char buf[10];
  585.       snprintf(buf, sizeof(buf), "%lu",(ULONG)uid);
  586.       m->name = pstrdup(permanent_pool,buf);
  587.     }
  588.   }
  590.   return mod_create_data(cmd,m->name);
  591. }
  593. MODRET pw_gid_name(cmd_rec *cmd)
  594. {
  595.   idmap_t *m;
  596.   struct group *gr;
  597.   gid_t gid;
  599.   gid = (gid_t)cmd->argv[0];
  601.   m = _auth_lookup_id(gid_table,gid);
  603.   if(!m->name) {
  604.     if(PERSISTENT_GROUP)
  605.       gr = p_getgrgid(gid);
  606.     else
  607.       gr = getgrgid(gid);
  609.     if(gr)
  610.       m->name = pstrdup(permanent_pool,gr->gr_name);
  611.     else {
  612.       char buf[10];
  614.       snprintf(buf, sizeof(buf), "%lu",(ULONG)gid);
  615.       m->name = pstrdup(permanent_pool,buf);
  616.     }
  617.   }
  619.   return mod_create_data(cmd,m->name);
  620. }
  622. MODRET pw_name_uid(cmd_rec *cmd)
  623. {
  624.   struct passwd *pw;
  625.   const char *name;
  627.   name = cmd->argv[0];
  628.   
  629.   if(PERSISTENT_PASSWD)
  630.     pw = p_getpwnam(name);
  631.   else
  632.     pw = getpwnam(name);
  634.   if(pw)
  635.     return mod_create_data(cmd,(void*)pw->pw_uid);
  636.   return ERROR(cmd);
  637. }
  639. MODRET pw_name_gid(cmd_rec *cmd)
  640. {
  641.   struct group *gr;
  643.   const char *name;
  645.   name = cmd->argv[0];
  646.   
  647.   if(PERSISTENT_GROUP)
  648.     gr = p_getgrnam(name);
  649.   else
  650.     gr = getgrnam(name);
  652.   if(gr)
  653.     return mod_create_data(cmd,(void*)gr->gr_gid);
  654.   return ERROR(cmd);
  655. }
  657. MODRET set_persistentpasswd(cmd_rec *cmd)
  658. {
  659.   int b;
  661.   CHECK_ARGS(cmd,1);
  662.   CHECK_CONF(cmd,CONF_ROOT);
  664.   b = get_boolean(cmd,1);
  665.   if(b != -1)
  666.     persistent = b;
  668.   return HANDLED(cmd);
  669. }
  671. MODRET set_authuserfile(cmd_rec *cmd)
  672. {
  673.   CHECK_ARGS(cmd,1);
  674.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  676.   add_config_param_str("AuthUserFile",1,cmd->argv[1]);
  677.   return HANDLED(cmd);
  678. }
  680. MODRET set_authgroupfile(cmd_rec *cmd)
  681. {
  682.   CHECK_ARGS(cmd,1);
  683.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  685.   add_config_param_str("AuthGroupFile",1,cmd->argv[1]);
  686.   return HANDLED(cmd);
  687. }
  689. static int unixpw_init()
  690. {
  691.   memset(uid_table,0,sizeof(uid_table));
  692.   memset(gid_table,0,sizeof(gid_table));
  694. #ifdef HAVE__PW_STAYOPEN
  695.   _pw_stayopen = 1;
  696. #endif
  698.   return 0;
  699. }
  701. static int unixpw_child()
  702. {
  703.   const char *file;
  705.   file = (const char*)get_param_ptr(main_server->conf,"AuthUserFile",FALSE);
  706.   if(file) {
  707.     endpwent(); 
  708.     persistent_passwd = 1; /* Force persistent mode */
  709.     pwdfname = file;
  710.     p_endpwent();
  711.     p_setpwent();
  712.   }
  714.   file = (const char*)get_param_ptr(main_server->conf,"AuthGroupFile",FALSE);
  715.   if(file) {
  716.     endgrent();
  717.     persistent_group = 1;
  718.     grpfname = file;
  719.     p_endgrent();
  720.     p_setgrent();
  721.   }
  722.   
  723.   return 0;
  724. }
  726. static conftable unixpw_config[] = {
  727.   { "PersistentPasswd", set_persistentpasswd, NULL },
  728.   { "AuthUserFile", set_authuserfile, NULL },
  729.   { "AuthGroupFile", set_authgroupfile, NULL },
  730.   { NULL, NULL, NULL }
  731. };
  733. static authtable unixpw_auth[] = {
  734.   { 0,  "setpwent", pw_setpwent },
  735.   { 0,  "endpwent", pw_endpwent },
  736.   { 0,  "setgrent",     pw_setgrent },
  737.   { 0,  "endgrent", pw_endgrent },
  738.   { 0, "getpwent", pw_getpwent },
  739.   { 0,  "getgrent", pw_getgrent },
  740.   { 0,  "getpwnam", pw_getpwnam },
  741.   { 0, "getpwuid", pw_getpwuid },
  742.   { 0,  "getgrnam",     pw_getgrnam     },
  743.   { 0,  "getgrgid",     pw_getgrgid     },
  744.   { 0,  "auth",         pw_auth },
  745.   { 0,  "check", pw_check },
  746.   { 0,  "uid_name", pw_uid_name },
  747.   { 0,  "gid_name", pw_gid_name },
  748.   { 0,  "name_uid", pw_name_uid },
  749.   { 0,  "name_gid", pw_name_gid },
  750.   { 0,  NULL }
  751. };
  753. module unixpw_module = {
  754.   NULL,NULL, /* Always NULL */
  755.   0x20, /* API Version 2.0 */
  756.   "unixpw",
  757.   unixpw_config, /* Configuration directive table */
  758.   NULL, /* No command handlers */
  759.   unixpw_auth, /* Authentication handlers */
  760.   unixpw_init,unixpw_child /* Initialization functions */
  761. };