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

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

Ftp客户端

开发平台：

Unix_Linux

auth.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. /* Authentication front-end for ProFTPD
  21.  * $Id: auth.c,v 1.2 1999/09/17 07:31:44 macgyver Exp $
  22.  */
  24. #include "conf.h"
  26. static cmd_rec *_make_cmd(pool *cp, int argc, ...)
  27. {
  28.   va_list args;
  29.   cmd_rec *c;
  30.   int     i;
  32.   c = pcalloc(cp,sizeof(cmd_rec));
  34.   c->argc = argc;
  35.   c->symtable_index = -1;
  37.   if(argc) {
  38.     c->argv = pcalloc(cp,sizeof(void*)*argc);
  40.     va_start(args,argc);
  42.     for(i = 0; i < argc; i++)
  43.       c->argv[i] = (void*)va_arg(args,char*);
  45.     va_end(args);
  46.   }
  48.   return c;
  49. }
  51. static modret_t *_dispatch_auth(cmd_rec *cmd, char *match)
  52. {
  53.   authtable *m;
  54.   modret_t *mr = NULL;
  56.   m = mod_find_auth_symbol(match,&cmd->symtable_index,NULL);
  57.   while(m) {
  58.     mr = call_module_auth(m->m,m->handler,cmd);
  59.     if(MODRET_ISHANDLED(mr) || MODRET_ISERROR(mr))
  60.       break;
  62.     m = mod_find_auth_symbol(match,&cmd->symtable_index,m);
  63.   }
  64.     
  65.   return mr; 
  66. }
  68. void auth_setpwent(pool *p)
  69. {
  70.   cmd_rec *c;
  71.   modret_t *mr;
  73.   c = _make_cmd(p,0);
  74.   mr = _dispatch_auth(c,"setpwent");
  76.   if(c->tmp_pool) {
  77.     destroy_pool(c->tmp_pool);
  78.     c->tmp_pool = NULL;
  79.   }
  80.   return;  
  81. }
  83. void auth_endpwent(pool *p)
  84. {
  85.   cmd_rec *c;
  86.   modret_t *mr;
  88.   c = _make_cmd(p,0);
  89.   mr = _dispatch_auth(c,"endpwent");
  91.   if(c->tmp_pool) {
  92.     destroy_pool(c->tmp_pool);
  93.     c->tmp_pool = NULL;
  94.   }
  95.   return;  
  96. }
  98. void auth_setgrent(pool *p)
  99. {
  100.   cmd_rec *c;
  101.   modret_t *mr;
  103.   c = _make_cmd(p,0);
  104.   mr = _dispatch_auth(c,"setgrent");
  106.   if(c->tmp_pool) {
  107.     destroy_pool(c->tmp_pool);
  108.     c->tmp_pool = NULL;
  109.   }
  110.   return;  
  111. }
  113. void auth_endgrent(pool *p)
  114. {
  115.   cmd_rec *c;
  116.   modret_t *mr;
  118.   c = _make_cmd(p,0);
  119.   mr = _dispatch_auth(c,"endgrent");
  121.   if(c->tmp_pool) {
  122.     destroy_pool(c->tmp_pool);
  123.     c->tmp_pool = NULL;
  124.   }
  125.   return;  
  126. }
  128. struct passwd *auth_getpwent(pool *p)
  129. {
  130.   cmd_rec *c;
  131.   modret_t *mr;
  132.   struct passwd *ret = NULL;
  134.   c = _make_cmd(p,0);
  135.   mr = _dispatch_auth(c,"getpwent");
  137.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  138.     ret = mr->data;
  140.   if(c->tmp_pool) {
  141.     destroy_pool(c->tmp_pool);
  142.     c->tmp_pool = NULL;
  143.   }
  145.   return ret;
  146. }
  148. struct group *auth_getgrent(pool *p)
  149. {
  150.   cmd_rec *c;
  151.   modret_t *mr;
  152.   struct group *ret = NULL;
  154.   c = _make_cmd(p,0);
  155.   mr = _dispatch_auth(c,"getgrent");
  157.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  158.     ret = mr->data;
  160.   if(c->tmp_pool) {
  161.     destroy_pool(c->tmp_pool);
  162.     c->tmp_pool = NULL;
  163.   }
  165.   return ret;
  166. }
  168. struct passwd *auth_getpwnam(pool *p, const char *name)
  169. {
  170.   cmd_rec *c;
  171.   modret_t *mr;
  172.   struct passwd *ret = NULL;
  174.   c = _make_cmd(p,1,name);
  175.   mr = _dispatch_auth(c,"getpwnam");
  177.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  178.     ret = mr->data;
  180.   if(c->tmp_pool) {
  181.     destroy_pool(c->tmp_pool);
  182.     c->tmp_pool = NULL;
  183.   }
  185.   return ret;
  186. }
  188. struct passwd *auth_getpwuid(pool *p, uid_t uid)
  189. {
  190.   cmd_rec *c;
  191.   modret_t *mr;
  192.   struct passwd *ret = NULL;
  194.   c = _make_cmd(p,1,(void*)uid);
  195.   mr = _dispatch_auth(c,"getpwuid");
  197.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  198.     ret = mr->data;
  200.   if(c->tmp_pool) {
  201.     destroy_pool(c->tmp_pool);
  202.     c->tmp_pool = NULL;
  203.   }
  205.   return ret;
  206. }
  208. struct group *auth_getgrnam(pool *p, const char *name)
  209. {
  210.   cmd_rec *c;
  211.   modret_t *mr;
  212.   struct group *ret = NULL;
  214.   c = _make_cmd(p,1,name);
  215.   mr = _dispatch_auth(c,"getgrnam");
  217.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  218.     ret = mr->data;
  220.   if(c->tmp_pool) {
  221.     destroy_pool(c->tmp_pool);
  222.     c->tmp_pool = NULL;
  223.   }
  225.   return ret;
  226. }
  228. struct group *auth_getgrgid(pool *p, gid_t gid)
  229. {
  230.   cmd_rec *c;
  231.   modret_t *mr;
  232.   struct group *ret = NULL;
  234.   c = _make_cmd(p,1,(void*)gid);
  235.   mr = _dispatch_auth(c,"getgrgid");
  237.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  238.     ret = mr->data;
  240.   if(c->tmp_pool) {
  241.     destroy_pool(c->tmp_pool);
  242.     c->tmp_pool = NULL;
  243.   }
  245.   return ret;
  246. }
  248. int auth_authenticate(pool *p, const char *name, const char *pw)
  249. {
  250.   cmd_rec *c;
  251.   modret_t *mr;
  252.   int ret = AUTH_NOPWD;
  254.   c = _make_cmd(p,2,name,pw);
  255.   mr = _dispatch_auth(c,"auth");
  257.   if(MODRET_ISHANDLED(mr))
  258.     ret = 0;
  259.   else if(MODRET_ISERROR(mr))
  260.     ret = MODRET_ERROR(mr);
  262.   if(c->tmp_pool) {
  263.     destroy_pool(c->tmp_pool);
  264.     c->tmp_pool = NULL;
  265.   }
  267.   return ret;
  268. }
  270. int auth_check(pool *p, const char *cpw, const char *name, const char *pw)
  271. {
  272.   cmd_rec *c;
  273.   modret_t *mr;
  274.   int ret = AUTH_BADPWD;
  276.   c = _make_cmd(p,3,cpw,name,pw);
  277.   mr = _dispatch_auth(c,"check");
  279.   if(MODRET_ISHANDLED(mr))
  280.     ret = 0;
  282.   if(c->tmp_pool) {
  283.     destroy_pool(c->tmp_pool);
  284.     c->tmp_pool = NULL;
  285.   }
  287.   return ret;
  288. }
  290. const char *auth_uid_name(pool *p, uid_t uid)
  291. {
  292.   cmd_rec *c;
  293.   modret_t *mr;
  294.   static char namebuf[64];
  295.   char *ret = NULL;
  297.   c = _make_cmd(p,1,(void*)uid);
  298.   mr = _dispatch_auth(c,"uid_name");
  300.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr)) {
  301.     ret = mr->data;
  302.     sstrncpy(namebuf,ret,sizeof(namebuf));
  303.     ret = namebuf;
  304.   }
  306.   if(c->tmp_pool) {
  307.     destroy_pool(c->tmp_pool);
  308.     c->tmp_pool = NULL;
  309.   }
  311.   return ret;
  312. }
  314. const char *auth_gid_name(pool *p, gid_t gid)
  315. {
  316.   cmd_rec *c;
  317.   modret_t *mr;
  318.   static char namebuf[64];
  319.   char *ret = NULL;
  321.   c = _make_cmd(p,1,(void*)gid);
  322.   mr = _dispatch_auth(c,"gid_name");
  324.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr)) {
  325.     ret = mr->data;
  326.     sstrncpy(namebuf,ret,sizeof(namebuf));
  327.     ret = namebuf;
  328.   }
  330.   if(c->tmp_pool) {
  331.     destroy_pool(c->tmp_pool);
  332.     c->tmp_pool = NULL;
  333.   }
  335.   return ret;
  336. }
  338. uid_t auth_name_uid(pool *p, const char *name)
  339. {
  340.   cmd_rec *c;
  341.   modret_t *mr;
  342.   uid_t ret = -1;
  344.   c = _make_cmd(p,1,name);
  345.   mr = _dispatch_auth(c,"name_uid");
  347.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  348.     ret = (uid_t)mr->data;
  350.   if(c->tmp_pool) {
  351.     destroy_pool(c->tmp_pool);
  352.     c->tmp_pool = NULL;
  353.   }
  355.   return ret;
  356. }
  358. gid_t auth_name_gid(pool *p, const char *name)
  359. {
  360.   cmd_rec *c;
  361.   modret_t *mr;
  362.   gid_t ret = -1;
  364.   c = _make_cmd(p,1,name);
  365.   mr = _dispatch_auth(c,"name_gid");
  367.   if(MODRET_ISHANDLED(mr) && MODRET_HASDATA(mr))
  368.     ret = (gid_t)mr->data;
  370.   if(c->tmp_pool) {
  371.     destroy_pool(c->tmp_pool);
  372.     c->tmp_pool = NULL;
  373.   }
  375.   return ret;
  376. }