Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Samba utility functions
4 : Copyright (C) Andrew Tridgell 1992-1998
5 : Copyright (C) Jeremy Allison 2001-2002
6 : Copyright (C) Simo Sorce 2001
7 : Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003.
8 : Copyright (C) James J Myers 2003
9 : Copyright (C) Jelmer Vernooij 2005-2007
10 :
11 : This program is free software; you can redistribute it and/or modify
12 : it under the terms of the GNU General Public License as published by
13 : the Free Software Foundation; either version 3 of the License, or
14 : (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. See the
19 : GNU General Public License for more details.
20 :
21 : You should have received a copy of the GNU General Public License
22 : along with this program. If not, see <http://www.gnu.org/licenses/>.
23 : */
24 :
25 : #include "includes.h"
26 : #include "dynconfig/dynconfig.h"
27 : #include "system/network.h"
28 : #include "system/filesys.h"
29 : #include "system/dir.h"
30 : #include "param/param.h"
31 : #include "libds/common/roles.h"
32 : #include "tdb.h"
33 :
34 : /**
35 : * @file
36 : * @brief Misc utility functions
37 : */
38 :
39 :
40 5281 : bool lpcfg_is_mydomain(struct loadparm_context *lp_ctx,
41 : const char *domain)
42 : {
43 5281 : return strequal(lpcfg_workgroup(lp_ctx), domain);
44 : }
45 :
46 394966 : bool lpcfg_is_my_domain_or_realm(struct loadparm_context *lp_ctx,
47 : const char *domain)
48 : {
49 763314 : return strequal(lpcfg_workgroup(lp_ctx), domain) ||
50 368348 : strequal(lpcfg_realm(lp_ctx), domain);
51 : }
52 :
53 : /**
54 : see if a string matches either our primary or one of our secondary
55 : netbios aliases. do a case insensitive match
56 : */
57 19995 : bool lpcfg_is_myname(struct loadparm_context *lp_ctx, const char *name)
58 : {
59 : const char **aliases;
60 : int i;
61 :
62 19995 : if (strcasecmp_m(name, lpcfg_netbios_name(lp_ctx)) == 0) {
63 100 : return true;
64 : }
65 :
66 19895 : aliases = lpcfg_netbios_aliases(lp_ctx);
67 22035 : for (i=0; aliases && aliases[i]; i++) {
68 2140 : if (strcasecmp_m(name, aliases[i]) == 0) {
69 0 : return true;
70 : }
71 : }
72 :
73 19895 : return false;
74 : }
75 :
76 217346 : static char *lpcfg_common_path(TALLOC_CTX* mem_ctx,
77 : const char *parent,
78 : const char *name)
79 : {
80 : char *fname, *dname;
81 : bool ok;
82 :
83 217346 : if (name == NULL) {
84 0 : return NULL;
85 : }
86 217346 : if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
87 0 : return talloc_strdup(mem_ctx, name);
88 : }
89 :
90 217346 : dname = talloc_strdup(mem_ctx, parent);
91 217346 : if (dname == NULL) {
92 0 : return NULL;
93 : }
94 217346 : trim_string(dname,"","/");
95 :
96 217346 : ok = directory_create_or_exist(dname, 0755);
97 217346 : if (!ok) {
98 0 : DEBUG(1, ("Unable to create directory %s for file %s. "
99 : "Error was %s\n", dname, name, strerror(errno)));
100 0 : return NULL;
101 : }
102 :
103 217346 : fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
104 217346 : if (fname == NULL) {
105 0 : return dname;
106 : }
107 217346 : talloc_free(dname);
108 :
109 217346 : return fname;
110 : }
111 :
112 :
113 : /**
114 : A useful function for returning a path in the Samba lock directory.
115 : **/
116 217096 : char *lpcfg_lock_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
117 : const char *name)
118 : {
119 217096 : return lpcfg_common_path(mem_ctx, lpcfg_lock_directory(lp_ctx), name);
120 : }
121 :
122 : /**
123 : A useful function for returning a path in the Samba state directory.
124 : **/
125 106 : char *lpcfg_state_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
126 : const char *name)
127 : {
128 106 : return lpcfg_common_path(mem_ctx, lpcfg_state_directory(lp_ctx), name);
129 : }
130 :
131 : /**
132 : A useful function for returning a path in the Samba cache directory.
133 : **/
134 144 : char *lpcfg_cache_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
135 : const char *name)
136 : {
137 144 : return lpcfg_common_path(mem_ctx, lpcfg_cache_directory(lp_ctx), name);
138 : }
139 :
140 : /**
141 : * @brief Returns an absolute path to a file in the directory containing the current config file
142 : *
143 : * @param name File to find, relative to the config file directory.
144 : *
145 : * @retval Pointer to a talloc'ed string containing the full path.
146 : **/
147 :
148 232553 : char *lpcfg_config_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
149 : const char *name)
150 : {
151 : char *fname, *config_dir, *p;
152 232553 : config_dir = talloc_strdup(mem_ctx, lpcfg_configfile(lp_ctx));
153 232553 : if (config_dir == NULL) {
154 20051 : config_dir = talloc_strdup(mem_ctx, lp_default_path());
155 : }
156 232553 : p = strrchr(config_dir, '/');
157 232553 : if (p == NULL) {
158 0 : talloc_free(config_dir);
159 0 : config_dir = talloc_strdup(mem_ctx, ".");
160 0 : if (config_dir == NULL) {
161 0 : return NULL;
162 : }
163 : } else {
164 232553 : p[0] = '\0';
165 : }
166 232553 : fname = talloc_asprintf(mem_ctx, "%s/%s", config_dir, name);
167 232553 : talloc_free(config_dir);
168 232553 : return fname;
169 : }
170 :
171 : /**
172 : * @brief Returns an absolute path to a file in the Samba private directory.
173 : *
174 : * @param name File to find, relative to PRIVATEDIR.
175 : * if name is not relative, then use it as-is
176 : *
177 : * @retval Pointer to a talloc'ed string containing the full path.
178 : **/
179 499885 : char *lpcfg_private_path(TALLOC_CTX* mem_ctx,
180 : struct loadparm_context *lp_ctx,
181 : const char *name)
182 : {
183 : char *fname;
184 499885 : if (name == NULL) {
185 0 : return NULL;
186 : }
187 499885 : if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
188 24479 : return talloc_strdup(mem_ctx, name);
189 : }
190 475406 : fname = talloc_asprintf(mem_ctx, "%s/%s", lpcfg_private_dir(lp_ctx), name);
191 475406 : return fname;
192 : }
193 :
194 : /**
195 : * @brief Returns an absolute path to a NTDB or TDB file in the Samba
196 : * private directory.
197 : *
198 : * @param name File to find, relative to PRIVATEDIR, without .tdb extension.
199 : *
200 : * @retval Pointer to a talloc'ed string containing the full path, for
201 : * use with dbwrap_local_open().
202 : **/
203 62245 : char *lpcfg_private_db_path(TALLOC_CTX *mem_ctx,
204 : struct loadparm_context *lp_ctx,
205 : const char *name)
206 : {
207 62245 : return talloc_asprintf(mem_ctx, "%s/%s.tdb",
208 : lpcfg_private_dir(lp_ctx), name);
209 : }
210 :
211 : /**
212 : return a path in the smbd.tmp directory, where all temporary file
213 : for smbd go. If NULL is passed for name then return the directory
214 : path itself
215 : */
216 72937 : char *smbd_tmp_path(TALLOC_CTX *mem_ctx,
217 : struct loadparm_context *lp_ctx,
218 : const char *name)
219 : {
220 : char *fname, *dname;
221 : bool ok;
222 :
223 72937 : dname = lpcfg_private_path(mem_ctx, lp_ctx, "smbd.tmp");
224 72937 : if (dname == NULL) {
225 0 : return NULL;
226 : }
227 :
228 72937 : ok = directory_create_or_exist(dname, 0755);
229 72937 : if (!ok) {
230 0 : return NULL;
231 : }
232 :
233 72937 : if (name == NULL) {
234 53 : return dname;
235 : }
236 :
237 72884 : fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
238 72884 : if (fname == NULL) {
239 0 : return dname;
240 : }
241 72884 : talloc_free(dname);
242 :
243 72884 : return fname;
244 : }
245 :
246 6 : const char *lpcfg_imessaging_path(TALLOC_CTX *mem_ctx,
247 : struct loadparm_context *lp_ctx)
248 : {
249 6 : return smbd_tmp_path(mem_ctx, lp_ctx, "msg");
250 : }
251 :
252 116610 : const char *lpcfg_sam_name(struct loadparm_context *lp_ctx)
253 : {
254 116610 : switch (lpcfg_server_role(lp_ctx)) {
255 114039 : case ROLE_DOMAIN_BDC:
256 : case ROLE_DOMAIN_PDC:
257 : case ROLE_ACTIVE_DIRECTORY_DC:
258 : case ROLE_IPA_DC:
259 114039 : return lpcfg_workgroup(lp_ctx);
260 2571 : default:
261 2571 : return lpcfg_netbios_name(lp_ctx);
262 : }
263 : }
264 :
265 52180 : const char *lpcfg_sam_dnsname(struct loadparm_context *lp_ctx)
266 : {
267 52180 : switch (lpcfg_server_role(lp_ctx)) {
268 52082 : case ROLE_ACTIVE_DIRECTORY_DC:
269 52082 : return lpcfg_dnsdomain(lp_ctx);
270 98 : default:
271 98 : return NULL;
272 : }
273 : }
274 :
275 0 : static long tdb_fetch_lifetime(TALLOC_CTX *mem_ctx, struct tdb_context *tdb, const char *keystr)
276 : {
277 : TDB_DATA key;
278 : TDB_DATA ret;
279 0 : char *tmp = NULL;
280 : long result;
281 :
282 0 : key.dptr = discard_const_p(unsigned char, keystr);
283 0 : key.dsize = strlen(keystr);
284 :
285 0 : if (!key.dptr)
286 0 : return -1;
287 :
288 0 : ret = tdb_fetch(tdb, key);
289 0 : if (ret.dsize == 0)
290 0 : return -1;
291 :
292 0 : tmp = talloc_realloc(mem_ctx, tmp, char, ret.dsize+1);
293 0 : memset(tmp, 0, ret.dsize+1);
294 0 : memcpy(tmp, ret.dptr, ret.dsize);
295 0 : free(ret.dptr);
296 :
297 0 : result = atol(tmp);
298 0 : talloc_free(tmp);
299 0 : return result;
300 : }
301 :
302 144 : void lpcfg_default_kdc_policy(TALLOC_CTX *mem_ctx,
303 : struct loadparm_context *lp_ctx,
304 : time_t *svc_tkt_lifetime,
305 : time_t *usr_tkt_lifetime,
306 : time_t *renewal_lifetime)
307 : {
308 : long val;
309 144 : TDB_CONTEXT *ctx = NULL;
310 144 : const char *kdc_tdb = NULL;
311 :
312 144 : kdc_tdb = lpcfg_cache_path(mem_ctx, lp_ctx, "gpo.tdb");
313 144 : if (kdc_tdb)
314 144 : ctx = tdb_open(kdc_tdb, 0, TDB_DEFAULT, O_RDWR, 0600);
315 :
316 144 : if (!ctx || ( val = tdb_fetch_lifetime(mem_ctx, ctx, "kdc:service_ticket_lifetime") ) == -1 )
317 144 : val = lpcfg_parm_long(lp_ctx, NULL, "kdc", "service ticket lifetime", 10);
318 144 : *svc_tkt_lifetime = val * 60 * 60;
319 :
320 144 : if (!ctx || ( val = tdb_fetch_lifetime(mem_ctx, ctx, "kdc:user_ticket_lifetime") ) == -1 )
321 144 : val = lpcfg_parm_long(lp_ctx, NULL, "kdc", "user ticket lifetime", 10);
322 144 : *usr_tkt_lifetime = val * 60 * 60;
323 :
324 144 : if (!ctx || ( val = tdb_fetch_lifetime(mem_ctx, ctx, "kdc:renewal_lifetime") ) == -1 )
325 144 : val = lpcfg_parm_long(lp_ctx, NULL, "kdc", "renewal lifetime", 24 * 7);
326 144 : *renewal_lifetime = val * 60 * 60;
327 144 : }
|
