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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
authldaplib.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：14k
源码类别：

WEB邮件程序

开发平台：

C/C++

authldaplib.c：源码内容
  1. /*
  2.  * authldap.c - 
  3.  *
  4.  * courier-imap - 
  5.  * 
  6.  * Copyright 1999 Luc Saillard <luc.saillard@alcove.fr>.
  7.  *
  8.  * This module use a server LDAP to authenticate user.
  9.  * See the README.ldap
  10.  *
  11.  * This program is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU General Public License
  13.  * as published by the Free Software Foundation; either version 2
  14.  * of the License, or (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  19.  *
  20.  * See the GNU General Public License for more details.
  21.  * 
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; see the file COPYING. If not, write to
  24.  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
  25.  * Boston, MA  02111-1307, USA.
  26.  */
  28. /*
  29.    Modified 01/21/2000 James Golovich <james@wwnet.net>
  31. 1. If LDAP_AUTHBIND is set in the config file, then the ldap server will
  32. handle passwords via authenticated binds, instead of checking these
  33. internally.
  34. 2. Changed paramaters for authldap_get to include pass.
  35. 3. Added int authbind and int authbind_ok to struct ldap_info to
  36. handle authenticated binds.
  38. */
  40. /*
  41.    Modified 12/31/99 Sam Varshavchik:
  43. 1. read_env reads from a configuration file, instead of the environment
  44. 2. read_config appropriately modified.
  45. 3. If 'user' contains the @ character, domain from config is NOT appended.
  46. 4. added 'homeDir' attribute.  Use 'homeDir' instead of mailDir, and put
  47.    mailDir into MAILDIR=
  48. 5. read_config renamed to authldap_read_config
  49. 6. get_user_info renamed to authldap_get
  50. 7. Added authldap_free_config, to clean up all the allocated memory
  51.    (required for preauthldap).
  52. 8. Output LDAP attributes are defined in the configuration file as well.
  53. 9. Allow both plaintext and crypted passwords to be read from LDAP.
  54. 10. Added GLOB_UID GLOB_GID, as well as UID and GID params.
  56. 2/19/2000 Sam.
  58. Rewrite to allow this code to be used in a long-running authentication daemon
  59. (for Courier).  authldap_get renamed to authldapcommon, will initialize and
  60. maintain a persistent connection.  Password checking moved entirely to
  61. authldap.c.  authldapclose() will unbind and close the connection.
  63. connection gets closed and reopened automatically after a protocol error.
  65. error return from authldapcommon will indicate whether this is a transient,
  66. or a permanent failure.
  68. authldap_free_config removed - no longer required.
  70. */
  72. #if HAVE_CONFIG_H
  73. #include "config.h"
  74. #endif
  75. #include <stdio.h>
  76. #include <stdlib.h>
  77. #include <ctype.h>
  78. #include <string.h>
  79. #include <errno.h>
  80. #include <pwd.h>
  81. #include <grp.h>
  82. #if HAVE_UNISTD_H
  83. #include <unistd.h>
  84. #endif
  85. #if HAVE_LBER_H
  86. #include <lber.h>
  87. #endif
  88. #if HAVE_LDAP_H
  89. #include <ldap.h>
  90. #endif
  91. #if HAVE_SYS_TIME_H
  92. #include <sys/time.h>
  93. #endif
  94. #if HAVE_SYS_STAT_H
  95. #include <sys/stat.h>
  96. #endif
  97. #if HAVE_SYSLOG_H
  98. #include <syslog.h>
  99. #else
  100. #define syslog(a,b)
  101. #endif
  104. #include "authldap.h"
  105. #include "auth.h"
  106. #include "authldaprc.h"
  108. #define DEBUG_LDAP 0
  110. struct ldap_info
  111. {
  112. const char *hostname;
  113. int   port;
  114. const char *binddn;
  115. const char *bindpw;
  116. const char *basedn;
  117. const char *mail;
  118. const char *domain;
  119. uid_t uid;
  120. gid_t gid;
  121. int   timeout;
  122. int   authbind;
  124. int authbind_ok;
  125. };
  127. static int read_env(const char *env, const char **copy,
  128. const char *err, int needit, const char *value_default);
  129. static void copy_value(LDAP *ld, LDAPMessage *entry, const char *attribut,
  130. char **copy);
  132. /*
  133.  * Function: read_env
  134.  * Copy the environnement $env and copy to $copy if not null
  135.  * if needit is false, and env doesn't exist, copy $value_default to $copy
  136.  * INPUT:
  137.  *   $env: pointer to the environnement name
  138.  *   $copy: where the value go
  139.  *   $err: print a nice message when $env not_found and $needit is true
  140.  *   $needit: if $needit is true and $value not found, return a error
  141.  *   $value_default: the default value when $needit is false and $env doesn't exists
  142.  * OUTPUT:
  143.  *   boolean
  144.  */
  145. static int read_env(const char *env, const char **copy,
  146. const char *err, int needit, const char *value_default)
  147. {
  148. static char *ldapauth=0;
  149. static size_t ldapauth_size;
  150. size_t i;
  151. char *p;
  152. int l=strlen(env);
  154. if (!ldapauth)
  155. {
  156. FILE *f=fopen(AUTHLDAPRC, "r");
  157. struct stat buf;
  159. if (!f) return (0);
  160. if (fstat(fileno(f), &buf) ||
  161. (ldapauth=malloc(buf.st_size+2)) == 0)
  162. {
  163. fclose(f);
  164. return (0);
  165. }
  166. if (fread(ldapauth, buf.st_size, 1, f) != 1)
  167. {
  168. free(ldapauth);
  169. ldapauth=0;
  170. fclose(f);
  171. return (0);
  172. }
  173. ldapauth[ldapauth_size=buf.st_size]=0;
  175. for (i=0; i<ldapauth_size; i++)
  176. if (ldapauth[i] == 'n')
  177. ldapauth[i]=0;
  178. }
  180. for (i=0; i<ldapauth_size; )
  181. {
  182. p=ldapauth+i;
  183. if (memcmp(p, env, l) == 0 &&
  184. isspace((int)(unsigned char)p[l]))
  185. {
  186. p += l;
  187. while (*p && *p != 'n' &&
  188. isspace((int)(unsigned char)*p))
  189. ++p;
  190. break;
  191. }
  193. while (i < ldapauth_size)
  194. if (ldapauth[i++] == 0) break;
  195. }
  197. if (i < ldapauth_size)
  198. {
  199. *copy= p;
  200. return (1);
  201. }
  203. if (needit)
  204. {
  205. fprintf(stderr, "ERR: %sn",err);
  206. fflush(stderr);
  207. return 0;
  208. }
  210. *copy=0;
  211. if (value_default)
  212. *copy=value_default;
  214. return 1;
  215. }
  217. /*
  218.  * Function: authldap_read_config
  219.  *   Read Configuration from the environnement table
  220.  * INPUT:
  221.  *   $ldap: a structure where we place information
  222.  * OUTPUT:
  223.  *   boolean
  224.  */
  225. static int authldap_read_config(struct ldap_info *ldap)
  226. {
  227.   struct passwd *pwent;
  228.   struct group  *grent;
  229.   const char *p;
  231.   memset(ldap,0,sizeof(struct ldap_info));
  233.   if (!read_env("LDAP_SERVER",&ldap->hostname,"You need to specify a ldap server in config file",1,NULL))
  234.     return 0;
  236.   if (!read_env("LDAP_AUTHBIND", &p, "", 0, ""))
  237. return (0);
  239.   if (p)
  240.     sscanf(p,"%d",&ldap->authbind);
  242.   ldap->port=LDAP_PORT;
  244.   if (!read_env("LDAP_PORT", &p, "", 0, ""))
  245. return (0);
  247.   if (p)
  248.     sscanf(p,"%d",&ldap->port);
  250.   if (!read_env("LDAP_BASEDN",&ldap->basedn,"You need to specify a basedn in config file",1,NULL))
  251.     return 0;
  252.   if (!read_env("LDAP_BINDDN",&ldap->binddn,"You need to specify a BINDDN in config file",0,NULL))
  253.     return 0;
  254.   if (!read_env("LDAP_BINDPW",&ldap->bindpw,"You need to specify a password for the BINDDN in config file",0,NULL))
  255.     return 0;
  256.   if (!read_env("LDAP_MAIL",&ldap->mail,"You need to specify a attribute for mail in config file",0,"mail"))
  257.     return 0;
  258.   if (!read_env("LDAP_DOMAIN",&ldap->domain,"You need to specify a domain for mail in config file",0,"*"))
  259.     return 0;
  261.   p=0;
  262.   ldap->uid=0;
  263.   if (!read_env("LDAP_GLOB_UID", &p, "", 0, ""))
  264. return (0);
  266.   if (p && *p)
  267.   {
  268.   unsigned long n;
  270. if (sscanf(p, "%lu", &n) == 1)
  271. ldap->uid=(uid_t)n;
  272. else
  273. {
  274. pwent=getpwnam(p);
  275. if (!pwent)
  276. {
  277. syslog(LOG_DAEMON|LOG_CRIT,
  278. "authldap: INVALID LDAP_GLOB_UIDn");
  279. return (0);
  280. }
  281. ldap->uid=pwent->pw_uid;
  282. }
  283.   }
  285.   ldap->gid=0;
  286.   p=0;
  287.   if (!read_env("LDAP_GLOB_GID", &p, "", 0, ""))
  288. return (0);
  290.   if (p && *p)
  291.   {
  292.   unsigned long n;
  294. if (sscanf(p, "%lu", &n) == 1)
  295. ldap->gid=(gid_t)n;
  296. else
  297. {
  298. grent=getgrnam(p);
  299. if (!grent)
  300. {
  301. syslog(LOG_DAEMON|LOG_CRIT,
  302. "authldap: INVALID LDAP_GLOB_GIDn");
  303. return (0);
  304. }
  305. ldap->gid=grent->gr_gid;
  306. }
  307.   }
  309.   ldap->timeout=5;
  310.   p=0;
  311.   if (!read_env("LDAP_TIMEOUT", &p, "", 0, ""))
  312. return (0);
  313.   if (p)
  314.   {
  315.     sscanf(p,"%d",&ldap->timeout);
  316.   }
  318.   return 1;
  319. }
  321. /*
  322.  * Function: copy_value
  323.  *   Copy value from a LDAP attribute to $copy
  324.  * INPUT:
  325.  *   $ld:       the connection with the LDAP server
  326.  *   $entry:    the entry who contains attributes
  327.  *   $attribut: this attribut
  328.  *   $copy:     where data can go
  329.  * OUTPUT:
  330.  *   void
  331.  */
  332. static void copy_value(LDAP *ld, LDAPMessage *entry, const char *attribut,
  333. char **copy)
  334. {
  335.   char ** values;
  336.   values=ldap_get_values(ld,entry, (char *)attribut);
  338. if (values==NULL)
  339. {
  340. if (ld->ld_errno != LDAP_DECODING_ERROR)
  341. /* We didn't ask for this attribute */
  342. ldap_perror(ld,"ldap_get_values");
  343. *copy=NULL;
  344. return;
  345. }
  346.   /* We accept only attribute with one value */
  347. else if (ldap_count_values(values)!=1)
  348.  {
  349.  *copy=NULL;
  350.  }
  351.   else
  352.  {
  353.  *copy=strdup(values[0]);
  354.  }
  355.   ldap_value_free(values);
  356. }
  358. static struct ldap_info my_ldap;
  359. static LDAP *my_ldap_fp=0;
  361. void authldapclose()
  362. {
  363. if (my_ldap_fp)
  364. {
  365. ldap_unbind(my_ldap_fp);
  366. my_ldap_fp=0;
  367. }
  368. }
  370. static int ldaperror(int rc)
  371. {
  372. if (rc && !NAME_ERROR(rc))
  373. /* If there was a protocol error, close the connection */
  374. authldapclose();
  375. return (rc);
  376. }
  378. static LDAP *ldapconnect()
  379. {
  380. LDAP *p;
  382. #if DEBUG_LDAP
  383. printf("Hostname: %s:%dn",my_ldap.hostname,my_ldap.port);
  384. printf("UID:      %dn",my_ldap.uid);
  385. printf("GID:      %dn",my_ldap.gid);
  386. #endif
  388. p=ldap_open((char *)my_ldap.hostname,my_ldap.port);
  390. if (p==NULL)
  391. {
  392. #if HAVE_SYSLOG_H
  393. syslog(LOG_DAEMON|LOG_CRIT,
  394. "Cannot connect to LDAP server (%s:%d): %s",
  395. my_ldap.hostname, my_ldap.port, strerror(errno));
  396. #else
  397. fprintf(stderr,
  398. "Cannot connect to LDAP server (%s:%d): %s",
  399. my_ldap.hostname, my_ldap.port, strerror(errno));
  400. #endif
  401. }
  402. return (p);
  403. }
  405. static int ldapopen()
  406. {
  407. if (my_ldap_fp) return (0);
  409. if (authldap_read_config(&my_ldap) == 0)
  410. return (1);
  412. my_ldap_fp=ldapconnect();
  414. if (!my_ldap_fp)
  415. {
  416. return (1);
  417. }
  421.   /* Bind to server */
  422. #if DEBUG_LDAP
  423.   printf("BindDn:   %snBindPw:   %sn",my_ldap.binddn,my_ldap.bindpw);
  424. #endif
  426.   if (ldaperror(ldap_simple_bind_s(my_ldap_fp,
  427. (char *)my_ldap.binddn,
  428. (char *)my_ldap.bindpw)) != LDAP_SUCCESS)
  429.     {
  430.     const char *s=ldap_err2string(my_ldap_fp->ld_errno);
  432. #if HAVE_SYSLOG_H
  433. syslog(LOG_DAEMON|LOG_CRIT, "ldap_simple_bind_s failed: %s", s);
  434. #endif
  435. authldapclose();
  436. return (-1);
  437.     }
  438. return (0);
  439. }
  441. /*
  442.  * Function: authldapcommon
  443.  *   Get information from the LDAP server ($ldap) for this $user
  444.  * INPUT:
  445.  *   $user: the login name
  446.  *   $pass: the login password (NULL if we don't want to check the pw)
  447.  *   callback - callback function with filled in authentication info
  448.  *   arg - extra argument for the callback function.
  449.  * OUTPUT:
  450.  *   < 0 - authentication failure
  451.  *   > 0 - temporary failure
  452.  *   else return code from the callback function.
  453.  */
  455. int authldapcommon(const char *user, const char *pass,
  456.         int (*callback)(struct authinfo *, void *),
  457.                         void *arg)
  458. {
  459.   const char *attributes[10], *ldap_attributes[10];
  460.   
  461.   struct timeval timeout;
  463.   LDAPMessage *result;
  464.   LDAPMessage *entry;
  465.   char *filter, *dn;
  466.   int i, j;
  468. struct authinfo auth;
  469. char *homeDir=0;
  470. char *mailDir=0;
  471. char *userPassword=0;
  472. char *cryptPassword=0;
  473. char *cn=0;
  474. uid_t au;
  475. gid_t ag;
  476. int rc;
  477. char *quota=0;
  479. memset(&auth, 0, sizeof(auth));
  481.   if (ldapopen()) return (1);
  483.   if ((filter=malloc(strlen(my_ldap.mail)+strlen(user)+
  484. (my_ldap.domain ? strlen(my_ldap.domain):0)+
  485. sizeof ("(=@)"))) == 0)
  486.   {
  487.       perror("malloc");
  488.       return 1;
  489.   }
  491.   strcat(strcat(strcat(strcpy(filter, "("), my_ldap.mail), "="), user);
  492.   if ( strchr(user, '@') == 0)
  493.      strcat(strcat(filter, "@"), my_ldap.domain);
  494.   strcat(filter, ")");
  496.   timeout.tv_sec=my_ldap.timeout;
  497.   timeout.tv_usec=0;
  499. read_env("LDAP_HOMEDIR", &attributes[0], "", 0, "homeDir");
  500. read_env("LDAP_MAILDIR", &attributes[1], "", 0, 0);
  501. read_env("LDAP_FULLNAME", &attributes[2], "", 0, "cn");
  502. read_env("LDAP_CLEARPW", &attributes[3], "", 0, 0);
  503. read_env("LDAP_CRYPTPW", &attributes[4], "", 0, 0);
  504. read_env("LDAP_UID", &attributes[5], "", 0, 0);
  505. read_env("LDAP_GID", &attributes[6], "", 0, 0);
  506. attributes[7]=my_ldap.mail;
  507. read_env("LDAP_MAILDIRQUOTA", &attributes[8], "", 0, 0);
  509. j=0;
  510. for (i=0; i<9; i++)
  511. {
  512. if (attributes[i])
  513. ldap_attributes[j++]=attributes[i];
  514. }
  516. ldap_attributes[j]=0;
  518.   if (ldaperror(ldap_search_st(my_ldap_fp, (char *)my_ldap.basedn,LDAP_SCOPE_SUBTREE,
  519. filter, (char **)ldap_attributes, 0, &timeout, &result)
  520. != LDAP_SUCCESS))
  521.     {
  522.       free(filter);
  524. if (my_ldap_fp) return (1);
  525. return (-1);
  526.     }
  528.    free(filter);
  530.   /* If we are more than one result, reject */
  531.   if (ldap_count_entries(my_ldap_fp,result)!=1)
  532.     {
  533.       ldap_msgfree(result);
  534.       return -1;
  535.     }
  536. #if DEBUG_LDAP
  537.   printf("Nombre de r閟ulat:    %dn",ldap_count_entries(ld,result));
  538. #endif
  540.   dn = ldap_get_dn(my_ldap_fp, result);
  542. #if DEBUG_LDAP
  543.   printf("DN:    %sn",dn);
  544. #endif
  546.   if (dn == NULL) 
  547.     {
  548.       ldap_perror(my_ldap_fp, "ldap_get_dn");
  549.       return -1;
  550.     }
  552.   /* Get the pointer on this result */
  553.   entry=ldap_first_entry(my_ldap_fp,result);
  554.   if (entry==NULL)
  555.     {
  556.       ldap_perror(my_ldap_fp,"ldap_first_entry");
  557.       free(dn);
  558.       return -1;
  559.     }
  561.   /* Copy the directory and the password into struct */
  562.   copy_value(my_ldap_fp,entry,attributes[0],&homeDir);
  563.   if (attributes[1])
  564.   copy_value(my_ldap_fp,entry,attributes[1],&mailDir);
  565.   copy_value(my_ldap_fp,entry,attributes[2],&cn);
  566.   if (attributes[3])
  567.   copy_value(my_ldap_fp,entry,attributes[3],&userPassword);
  568.   if (attributes[4])
  569.   copy_value(my_ldap_fp,entry,attributes[4],&cryptPassword);
  571. au=my_ldap.uid;
  572. ag=my_ldap.gid;
  573.   if (attributes[5])
  574.   {
  575. char *p=0;
  576. unsigned long n;
  578. copy_value(my_ldap_fp, entry, attributes[5], &p);
  579. if (!p) return (0);
  582. if (sscanf(p, "%lu", &n) > 0)
  583. au= (uid_t)n;
  584. free(p);
  585.   }
  587.   if (attributes[6])
  588.   {
  589. char *p=0;
  590. unsigned long n;
  592. copy_value(my_ldap_fp, entry, attributes[6], &p);
  593. if (!p) return (0);
  595. if (sscanf(p, "%lu", &n) > 0)
  596. ag= (gid_t)n;
  597. free(p);
  598.   }
  599.   if (attributes[8])
  600.   copy_value(my_ldap_fp,entry,attributes[8],&quota);
  602. auth.sysusername=user;
  603. auth.sysuserid= &au;
  604. auth.sysgroupid= ag;
  605. auth.homedir=homeDir;
  606. auth.address=user;
  607. auth.fullname=cn;
  608. auth.maildir=mailDir;
  609. auth.clearpasswd=userPassword;
  610. auth.passwd=cryptPassword;
  611. auth.quota=quota;
  613. if (auth.sysusername == 0)
  614. auth.sysusername=auth.address="";
  616. if (homeDir == 0)
  617. auth.homedir="";
  619. rc=0;
  621. if (pass)
  622. {
  623. if (my_ldap.authbind) 
  624. {
  625. LDAP *bindp=ldapconnect();
  627. if (!bindp)
  628. rc=1;
  629. else
  630. {
  631. if (ldaperror(
  632. ldap_simple_bind_s(bindp, dn, (char *)pass)
  633. != LDAP_SUCCESS))
  634. {
  635. rc= my_ldap_fp ? 1:-1;
  636. }
  637. ldap_unbind(bindp);
  638. }
  639. }
  640. else
  641. {
  642. if (auth.clearpasswd)
  643. {
  644. if (strcmp(pass,auth.clearpasswd))
  645. rc= -1;
  646. }
  647. else
  648. {
  649. const char *p=auth.passwd;
  651. if (p && strncmp(p, "{crypt}", 7) == 0)
  652. p += 7; /* For authcheckpassword */
  654. if (!p || authcheckpassword(pass, p))
  655. rc= -1;
  656. }
  657. }
  658.         }
  659. free (dn);
  661. if (rc == 0)
  662. rc= (*callback)(&auth, arg);
  664. ldap_msgfree(result);
  666. if (homeDir) free(homeDir);
  667. if (mailDir) free(mailDir);
  668. if (userPassword) free(userPassword);
  669. if (cryptPassword) free(cryptPassword);
  670. if (cn) free(cn);
  671. if (quota) free(quota);
  672. return (rc);
  673. }