r21315: ldb now supports filters like (&(dn=%s)(&(objectClass=kerberosSecret)(private...
[bbaumbach/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / update_keytab.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 /*
22  *  Name: ldb
23  *
24  *  Component: ldb update_keytabs module
25  *
26  *  Description: Update keytabs whenever their matching secret record changes
27  *
28  *  Author: Andrew Bartlett
29  */
30
31 #include "includes.h"
32 #include "ldb/include/includes.h"
33 #include "auth/credentials/credentials.h"
34 #include "auth/credentials/credentials_krb5.h"
35 #include "system/kerberos.h"
36
37 struct dn_list {
38         struct cli_credentials *creds;
39         struct dn_list *prev, *next;
40 };
41
42 struct update_kt_private {
43         struct dn_list *changed_dns;
44 };
45
46 static int add_modified(struct ldb_module *module, struct ldb_dn *dn, BOOL delete) {
47         struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
48         struct dn_list *item;
49         char *filter;
50         struct ldb_result *res;
51         const char *attrs[] = { NULL };
52         int ret;
53         NTSTATUS status;
54
55         filter = talloc_asprintf(data, "(&(dn=%s)(&(objectClass=kerberosSecret)(privateKeytab=*)))",
56                                  ldb_dn_get_linearized(dn));
57         if (!filter) {
58                 ldb_oom(module->ldb);
59                 return LDB_ERR_OPERATIONS_ERROR;
60         }
61
62         ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE,
63                          filter, attrs, &res);
64         if (ret != LDB_SUCCESS) {
65                 talloc_free(filter);
66                 return ret;
67         }
68
69         if (res->count != 1) {
70                 /* if it's not a kerberosSecret then we don't have anything to update */
71                 talloc_free(res);
72                 talloc_free(filter);
73                 return LDB_SUCCESS;
74         }
75         talloc_free(res);
76
77         item = talloc(data->changed_dns? (void *)data->changed_dns: (void *)data, struct dn_list);
78         if (!item) {
79                 talloc_free(filter);
80                 ldb_oom(module->ldb);
81                 return LDB_ERR_OPERATIONS_ERROR;
82         }
83         
84         item->creds = cli_credentials_init(item);
85         if (!item->creds) {
86                 DEBUG(1, ("cli_credentials_init failed!"));
87                 talloc_free(filter);
88                 ldb_oom(module->ldb);
89                 return LDB_ERR_OPERATIONS_ERROR;
90         }
91
92         cli_credentials_set_conf(item->creds);
93         status = cli_credentials_set_secrets(item->creds, module->ldb, NULL, filter);
94         talloc_free(filter);
95         if (NT_STATUS_IS_OK(status)) {
96                 if (delete) {
97                         /* Ensure we don't helpfully keep an old keytab entry */
98                         cli_credentials_set_kvno(item->creds, cli_credentials_get_kvno(item->creds)+2); 
99                         /* Wipe passwords */
100                         cli_credentials_set_nt_hash(item->creds, NULL, 
101                                                     CRED_SPECIFIED);
102                 }
103                 DLIST_ADD_END(data->changed_dns, item, struct dn_list *);
104         }
105         return LDB_SUCCESS;
106 }
107
108 /* add */
109 static int update_kt_add(struct ldb_module *module, struct ldb_request *req)
110 {
111         int ret;
112         ret = ldb_next_request(module, req);
113         if (ret != LDB_SUCCESS) {
114                 return ret;
115         }
116         return add_modified(module, req->op.add.message->dn, False);
117 }
118
119 /* modify */
120 static int update_kt_modify(struct ldb_module *module, struct ldb_request *req)
121 {
122         int ret;
123         ret = ldb_next_request(module, req);
124         if (ret != LDB_SUCCESS) {
125                 return ret;
126         }
127         return add_modified(module, req->op.mod.message->dn, False);
128 }
129
130 /* delete */
131 static int update_kt_delete(struct ldb_module *module, struct ldb_request *req)
132 {
133         int ret;
134         /* Before we delete it, record the details */
135         ret = add_modified(module, req->op.del.dn, True);
136         if (ret != LDB_SUCCESS) {
137                 return ret;
138         }
139         return ldb_next_request(module, req);
140 }
141
142 /* rename */
143 static int update_kt_rename(struct ldb_module *module, struct ldb_request *req)
144 {
145         int ret;
146         ret = ldb_next_request(module, req);
147         if (ret != LDB_SUCCESS) {
148                 return ret;
149         }
150         return add_modified(module, req->op.rename.newdn, False);
151 }
152
153 /* end a transaction */
154 static int update_kt_end_trans(struct ldb_module *module)
155 {
156         struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
157         
158         struct dn_list *p;
159         for (p=data->changed_dns; p; p = p->next) {
160                 int kret;
161                 kret = cli_credentials_update_keytab(p->creds);
162                 if (kret != 0) {
163                         talloc_free(data->changed_dns);
164                         data->changed_dns = NULL;
165                         ldb_asprintf_errstring(module->ldb, "Failed to update keytab: %s", error_message(kret));
166                         return LDB_ERR_OPERATIONS_ERROR;
167                 }
168         }
169
170         talloc_free(data->changed_dns);
171         data->changed_dns = NULL;
172         return ldb_next_end_trans(module);
173 }
174
175 /* end a transaction */
176 static int update_kt_del_trans(struct ldb_module *module)
177 {
178         struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
179         
180         talloc_free(data->changed_dns);
181         data->changed_dns = NULL;
182
183         return ldb_next_end_trans(module);
184 }
185
186 static int update_kt_init(struct ldb_module *module)
187 {
188         struct update_kt_private *data;
189
190         data = talloc(module, struct update_kt_private);
191         if (data == NULL) {
192                 ldb_oom(module->ldb);
193                 return LDB_ERR_OPERATIONS_ERROR;
194         }
195
196         module->private_data = data;
197         data->changed_dns = NULL;
198
199         return ldb_next_init(module);
200 }
201
202 static const struct ldb_module_ops update_kt_ops = {
203         .name              = "update_keytab",
204         .init_context      = update_kt_init,
205         .add               = update_kt_add,
206         .modify            = update_kt_modify,
207         .rename            = update_kt_rename,
208         .del               = update_kt_delete,
209         .end_transaction   = update_kt_end_trans,
210         .del_transaction   = update_kt_del_trans,
211 };
212
213 int ldb_update_kt_init(void)
214 {
215         return ldb_register_module(&update_kt_ops);
216 }