Remove extra whitespace at the end of some lines.
[dragonfly.git] / contrib / libpam / modules / pam_userdb / pam_userdb.c
1 /* pam_userdb module */
2  
3 /*
4  * $Id: pam_userdb.c,v 1.4 2000/12/04 15:02:16 baggins Exp $
5  * $FreeBSD: src/contrib/libpam/modules/pam_userdb/pam_userdb.c,v 1.1.1.1.2.2 2001/06/11 15:28:33 markm Exp $
6  * $DragonFly: src/contrib/libpam/modules/pam_userdb/Attic/pam_userdb.c,v 1.2 2003/06/17 04:24:03 dillon Exp $
7  * Written by Cristian Gafton <gafton@redhat.com> 1996/09/10
8  * See the end of the file for Copyright Information
9  */
10
11 #include <security/_pam_aconf.h>
12
13 #include <stdlib.h>
14 #include <unistd.h>
15 #include <string.h>
16 #include <syslog.h>
17 #include <stdarg.h>
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <errno.h>
22
23 #include "pam_userdb.h"
24
25 #ifdef HAVE_NDBM_H
26 # include <ndbm.h>
27 #else
28 # ifdef HAVE_DB_H
29 #  define DB_DBM_HSEARCH    1 /* use the dbm interface */
30 #  include <db.h>
31 # else
32 #  error "failed to find a libdb or equivalent"
33 # endif
34 #endif
35
36 /*
37  * here, we make a definition for the externally accessible function
38  * in this file (this definition is required for static a module
39  * but strongly encouraged generally) it is used to instruct the
40  * modules include file to define the function prototypes.
41  */
42
43 #define PAM_SM_AUTH
44 #define PAM_SM_ACCOUNT
45
46 #include <security/pam_modules.h>
47
48 /* some syslogging */
49
50 static void _pam_log(int err, const char *format, ...)
51 {
52     va_list args;
53
54     va_start(args, format);
55     openlog(MODULE_NAME, LOG_CONS|LOG_PID, LOG_AUTH);
56     vsyslog(err, format, args);
57     va_end(args);
58     closelog();
59 }
60
61 char * database  = NULL;
62 static int ctrl  = 0;
63
64 static int _pam_parse(int argc, const char **argv)
65 {
66      /* step through arguments */
67      for (ctrl = 0; argc-- > 0; ++argv) {
68
69           /* generic options */
70
71           if (!strcmp(*argv,"debug"))
72                ctrl |= PAM_DEBUG_ARG;
73           else if (!strcasecmp(*argv, "icase"))
74               ctrl |= PAM_ICASE_ARG;
75           else if (!strcasecmp(*argv, "dump"))
76               ctrl |= PAM_DUMP_ARG;
77           else if (!strncasecmp(*argv,"db=", 3)) {
78               database = strdup((*argv) + 3);
79               if (database == NULL)
80                   _pam_log(LOG_ERR, "pam_parse: could not parse argument \"%s\"",
81                            *argv);
82           } else {
83                _pam_log(LOG_ERR, "pam_parse: unknown option; %s", *argv);
84           }
85      }
86
87      return ctrl;
88 }
89
90
91 /*
92  * Looks up an user name in a database and checks the password
93  *
94  * return values:
95  *       1  = User not found
96  *       0  = OK
97  *      -1  = Password incorrect
98  *      -2  = System error
99  */
100 static int user_lookup(const char *user, const char *pass)
101 {
102     DBM *dbm;
103     datum key, data;
104
105     /* Open the DB file. */
106     dbm = dbm_open(database, O_RDONLY, 0644);
107     if (dbm == NULL) {
108         _pam_log(LOG_ERR, "user_lookup: could not open database `%s'",
109                  database);
110         return -2;
111     }
112
113     if (ctrl &PAM_DUMP_ARG) {
114         _pam_log(LOG_INFO, "Database dump:");
115         for (key = dbm_firstkey(dbm);  key.dptr != NULL;
116              key = dbm_nextkey(dbm)) {
117             data = dbm_fetch(dbm, key);
118             _pam_log(LOG_INFO, "key[len=%d] = `%s', data[len=%d] = `%s'",
119                      key.dsize, key.dptr, data.dsize, data.dptr);
120         }
121     } 
122     /* do some more init work */
123
124     memset(&key, 0, sizeof(key));
125     memset(&data, 0, sizeof(data));
126     key.dptr = x_strdup(user);
127     key.dsize = strlen(user);
128     user = NULL;
129
130     if (key.dptr) {
131         data = dbm_fetch(dbm, key);
132         memset(key.dptr, 0, key.dsize);
133         free(key.dptr);
134     }
135
136     if (ctrl & PAM_DEBUG_ARG) {
137         _pam_log(LOG_INFO, "password in database is [%p]`%s', len is %d",
138                  data.dptr, (char *) data.dptr, data.dsize);
139     }
140
141     if (data.dptr != NULL) {
142         int compare = 0;
143         /* bingo, got it */
144         if (ctrl & PAM_ICASE_ARG)
145             compare = strncasecmp(pass, data.dptr, data.dsize);
146         else
147             compare = strncmp(pass, data.dptr, data.dsize);
148         dbm_close(dbm);
149         if (compare == 0)
150             return 0; /* match */
151         else
152             return -1; /* wrong */
153     } else {
154         if (ctrl & PAM_DEBUG_ARG) {    
155             _pam_log(LOG_INFO, "error returned by dbm_fetch: %s",
156                      strerror(errno));
157         }
158         dbm_close(dbm);
159         /* probably we should check dbm_error() here */
160         return 1; /* not found */
161     }
162
163     /* NOT REACHED */
164     return -2;
165 }
166
167 /* --- authentication management functions (only) --- */
168
169 PAM_EXTERN
170 int pam_sm_authenticate(pam_handle_t *pamh, int flags,
171                         int argc, const char **argv)
172 {
173      const char *username;
174      const char *password;
175      int retval = PAM_AUTH_ERR;
176     
177      /* parse arguments */
178      ctrl = _pam_parse(argc, argv);
179
180      /* Get the username */
181      retval = pam_get_user(pamh, &username, NULL);
182      if ((retval != PAM_SUCCESS) || (!username)) {
183         if (ctrl & PAM_DEBUG_ARG)
184             _pam_log(LOG_DEBUG,"can not get the username");
185         return PAM_SERVICE_ERR;
186      }
187      
188      /* Converse just to be sure we have the password */
189      retval = conversation(pamh);
190      if (retval != PAM_SUCCESS) {
191          _pam_log(LOG_ERR, "could not obtain password for `%s'",
192                   username);
193          return -2;
194      }
195      
196      /* Get the password */
197      retval = pam_get_item(pamh, PAM_AUTHTOK, (const void **)&password);
198      if (retval != PAM_SUCCESS) {
199          _pam_log(LOG_ERR, "Could not retrive user's password");
200          return -2;
201      }
202      
203      if (ctrl & PAM_DEBUG_ARG)
204          _pam_log(LOG_INFO, "Verify user `%s' with password `%s'",
205                   username, password);
206      
207      /* Now use the username to look up password in the database file */
208      retval = user_lookup(username, password);
209      switch (retval) {
210          case -2:
211              /* some sort of system error. The log was already printed */
212              return PAM_SERVICE_ERR;    
213          case -1:
214              /* incorrect password */
215              _pam_log(LOG_WARNING,
216                       "user `%s' denied access (incorrect password)",
217                       username);
218              return PAM_AUTH_ERR;
219          case 1:
220              /* the user does not exist in the database */
221              if (ctrl & PAM_DEBUG_ARG)
222                  _pam_log(LOG_NOTICE, "user `%s' not found in the database",
223                           username);
224              return PAM_USER_UNKNOWN;
225          case 0:
226              /* Otherwise, the authentication looked good */
227              _pam_log(LOG_NOTICE, "user '%s' granted acces", username);
228              return PAM_SUCCESS;
229          default:
230              /* we don't know anything about this return value */
231              _pam_log(LOG_ERR,
232                       "internal module error (retval = %d, user = `%s'",
233                       retval, username);
234              return PAM_SERVICE_ERR;
235      }
236
237      /* should not be reached */
238      return PAM_IGNORE;
239 }
240
241 PAM_EXTERN
242 int pam_sm_setcred(pam_handle_t *pamh, int flags,
243                    int argc, const char **argv)
244 {
245     return PAM_SUCCESS;
246 }
247
248 PAM_EXTERN
249 int pam_sm_acct_mgmt(pam_handle_t *pamh, int flags,
250                    int argc, const char **argv)
251 {
252     return PAM_SUCCESS;
253 }
254
255
256 #ifdef PAM_STATIC
257
258 /* static module data */
259
260 struct pam_module _pam_userdb_modstruct = {
261      "pam_userdb",
262      pam_sm_authenticate,
263      pam_sm_setcred,
264      NULL,
265      NULL,
266      NULL,
267      NULL,
268 };
269
270 #endif
271
272 /*
273  * Copyright (c) Cristian Gafton <gafton@redhat.com>, 1999
274  *                                              All rights reserved
275  *
276  * Redistribution and use in source and binary forms, with or without
277  * modification, are permitted provided that the following conditions
278  * are met:
279  * 1. Redistributions of source code must retain the above copyright
280  *    notice, and the entire permission notice in its entirety,
281  *    including the disclaimer of warranties.
282  * 2. Redistributions in binary form must reproduce the above copyright
283  *    notice, this list of conditions and the following disclaimer in the
284  *    documentation and/or other materials provided with the distribution.
285  * 3. The name of the author may not be used to endorse or promote
286  *    products derived from this software without specific prior
287  *    written permission.
288  *
289  * ALTERNATIVELY, this product may be distributed under the terms of
290  * the GNU Public License, in which case the provisions of the GPL are
291  * required INSTEAD OF the above restrictions.  (This clause is
292  * necessary due to a potential bad interaction between the GPL and
293  * the restrictions contained in a BSD-style copyright.)
294  *
295  * THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESS OR IMPLIED
296  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
297  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
298  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
299  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
300  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
301  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
302  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
303  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
304  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
305  * OF THE POSSIBILITY OF SUCH DAMAGE.
306  */