← Back to branch summary

~ubuntu-branches/ubuntu/vivid/dovecot/vivid

« back to all changes in this revision

Viewing changes to src/auth/passdb-passwd-file.c

  • Committer: Bazaar Package Importer
  • Author(s): Jaldhar H. Vyas
  • Date: 2005-11-05 23:19:19 UTC
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20051105231919-ydujs4y7687fpor2
Tags: upstream-1.0.alpha4
Import upstream version 1.0.alpha4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/auth/passdb-passwd-file.c
1
1
/* Copyright (C) 2002-2003 Timo Sirainen */
2
2
 
3
 
#include "config.h"
4
 
#undef HAVE_CONFIG_H
 
3
#include "common.h"
5
4
 
6
5
#ifdef PASSDB_PASSWD_FILE
7
6
 
8
 
#include "common.h"
9
7
#include "passdb.h"
10
8
#include "password-scheme.h"
11
9
#include "db-passwd-file.h"
12
10
 
13
 
struct passwd_file *passdb_pwf = NULL;
 
11
#define PASSWD_FILE_CACHE_KEY "%u"
 
12
#define PASSWD_FILE_DEFAULT_SCHEME "CRYPT"
 
13
 
 
14
struct passwd_file_passdb_module {
 
15
        struct passdb_module module;
 
16
 
 
17
        struct db_passwd_file *pwf;
 
18
};
14
19
 
15
20
static void
16
21
passwd_file_verify_plain(struct auth_request *request, const char *password,
17
22
                         verify_plain_callback_t *callback)
18
23
{
 
24
        struct passdb_module *_module = request->passdb->passdb;
 
25
        struct passwd_file_passdb_module *module =
 
26
                (struct passwd_file_passdb_module *)_module;
19
27
        struct passwd_user *pu;
20
28
        const char *scheme, *crypted_pass;
21
29
        int ret;
22
30
 
23
 
        pu = db_passwd_file_lookup(passdb_pwf, request->user);
 
31
        pu = db_passwd_file_lookup(module->pwf, request);
24
32
        if (pu == NULL) {
25
33
                callback(PASSDB_RESULT_USER_UNKNOWN, request);
26
34
                return;
28
36
 
29
37
        crypted_pass = pu->password;
30
38
        scheme = password_get_scheme(&crypted_pass);
31
 
        if (scheme == NULL) scheme = "CRYPT";
 
39
        if (scheme == NULL) scheme = _module->default_pass_scheme;
 
40
 
 
41
        /* save the password so cache can use it */
 
42
        auth_request_set_field(request, "password", crypted_pass, scheme);
32
43
 
33
44
        ret = password_verify(password, crypted_pass, scheme,
34
45
                              request->user);
36
47
                callback(PASSDB_RESULT_OK, request);
37
48
        else {
38
49
                if (ret < 0) {
39
 
                        i_error("passwd-file(%s): Unknown password scheme %s",
40
 
                                pu->user_realm, scheme);
41
 
                } else if (verbose) {
42
 
                        i_info("passwd-file(%s): %s password mismatch",
43
 
                               pu->user_realm, scheme);
 
50
                        auth_request_log_error(request, "passwd-file",
 
51
                                "unknown password scheme %s", scheme);
 
52
                } else {
 
53
                        auth_request_log_info(request, "passwd-file",
 
54
                                              "password mismatch");
44
55
                }
45
56
                callback(PASSDB_RESULT_PASSWORD_MISMATCH, request);
46
57
        }
48
59
 
49
60
static void
50
61
passwd_file_lookup_credentials(struct auth_request *request,
51
 
                               enum passdb_credentials credentials,
52
62
                               lookup_credentials_callback_t *callback)
53
63
{
 
64
        struct passdb_module *_module = request->passdb->passdb;
 
65
        struct passwd_file_passdb_module *module =
 
66
                (struct passwd_file_passdb_module *)_module;
54
67
        struct passwd_user *pu;
55
68
        const char *crypted_pass, *scheme;
56
69
 
57
 
        pu = db_passwd_file_lookup(passdb_pwf, request->user);
 
70
        pu = db_passwd_file_lookup(module->pwf, request);
58
71
        if (pu == NULL) {
59
 
                callback(NULL, request);
 
72
                callback(PASSDB_RESULT_USER_UNKNOWN, NULL, request);
60
73
                return;
61
74
        }
62
75
 
63
76
        crypted_pass = pu->password;
64
77
        scheme = password_get_scheme(&crypted_pass);
65
78
 
66
 
        passdb_handle_credentials(credentials, request->user, crypted_pass,
67
 
                                  scheme, callback, request);
68
 
}
69
 
 
70
 
static void passwd_file_init(const char *args)
71
 
{
72
 
        if (userdb_pwf != NULL && strcmp(userdb_pwf->path, args) == 0) {
73
 
                passdb_pwf = userdb_pwf;
74
 
                passdb_pwf->refcount++;
75
 
        } else {
76
 
                passdb_pwf = db_passwd_file_parse(args, FALSE);
77
 
        }
78
 
}
79
 
 
80
 
static void passwd_file_deinit(void)
81
 
{
82
 
        db_passwd_file_unref(passdb_pwf);
83
 
}
84
 
 
85
 
struct passdb_module passdb_passwd_file = {
 
79
        passdb_handle_credentials(PASSDB_RESULT_OK, crypted_pass, scheme,
 
80
                                  callback, request);
 
81
}
 
82
 
 
83
static struct passdb_module *
 
84
passwd_file_preinit(struct auth_passdb *auth_passdb,
 
85
                    const char *args __attr_unused__)
 
86
{
 
87
        struct passwd_file_passdb_module *module;
 
88
 
 
89
        module = p_new(auth_passdb->auth->pool,
 
90
                       struct passwd_file_passdb_module, 1);
 
91
        module->module.cache_key = PASSWD_FILE_CACHE_KEY;
 
92
        module->module.default_pass_scheme = PASSWD_FILE_DEFAULT_SCHEME;
 
93
        return &module->module;
 
94
}
 
95
 
 
96
static void passwd_file_init(struct passdb_module *_module, const char *args)
 
97
{
 
98
        struct passwd_file_passdb_module *module =
 
99
                (struct passwd_file_passdb_module *)_module;
 
100
 
 
101
        module->pwf = db_passwd_file_parse(args, FALSE);
 
102
}
 
103
 
 
104
static void passwd_file_deinit(struct passdb_module *_module)
 
105
{
 
106
        struct passwd_file_passdb_module *module =
 
107
                (struct passwd_file_passdb_module *)_module;
 
108
 
 
109
        db_passwd_file_unref(module->pwf);
 
110
}
 
111
 
 
112
struct passdb_module_interface passdb_passwd_file = {
 
113
        "passwd-file",
 
114
 
 
115
        passwd_file_preinit,
86
116
        passwd_file_init,
87
117
        passwd_file_deinit,
88
118