6e6e12596bd932df940b43062816531b17d10da8
[kai/samba-autobuild/.git] / source4 / param / util.c
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.h"
27 #include "system/network.h"
28 #include "system/filesys.h"
29 #include "system/dir.h"
30
31 /**
32  * @file
33  * @brief Misc utility functions
34  */
35
36
37 /**
38   see if a string matches either our primary or one of our secondary 
39   netbios aliases. do a case insensitive match
40 */
41 _PUBLIC_ BOOL is_myname(const char *name)
42 {
43         const char **aliases;
44         int i;
45
46         if (strcasecmp(name, lp_netbios_name()) == 0) {
47                 return True;
48         }
49
50         aliases = lp_netbios_aliases();
51         for (i=0; aliases && aliases[i]; i++) {
52                 if (strcasecmp(name, aliases[i]) == 0) {
53                         return True;
54                 }
55         }
56
57         return False;
58 }
59
60
61 /**
62  A useful function for returning a path in the Samba lock directory.
63 **/
64 _PUBLIC_ char *lock_path(TALLOC_CTX* mem_ctx, const char *name)
65 {
66         char *fname, *dname;
67         if (name == NULL) {
68                 return NULL;
69         }
70         if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
71                 return talloc_strdup(mem_ctx, name);
72         }
73
74         dname = talloc_strdup(mem_ctx, lp_lockdir());
75         trim_string(dname,"","/");
76         
77         if (!directory_exist(dname)) {
78                 mkdir(dname,0755);
79         }
80         
81         fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
82
83         talloc_free(dname);
84
85         return fname;
86 }
87
88
89 /**
90  A useful function for returning a path in the Samba piddir directory.
91 **/
92 static char *pid_path(TALLOC_CTX* mem_ctx, const char *name)
93 {
94         char *fname, *dname;
95
96         dname = talloc_strdup(mem_ctx, lp_piddir());
97         trim_string(dname,"","/");
98         
99         if (!directory_exist(dname)) {
100                 mkdir(dname,0755);
101         }
102         
103         fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
104
105         talloc_free(dname);
106
107         return fname;
108 }
109
110
111 /**
112  * @brief Returns an absolute path to a file in the Samba lib directory.
113  *
114  * @param name File to find, relative to DATADIR.
115  *
116  * @retval Pointer to a talloc'ed string containing the full path.
117  **/
118
119 _PUBLIC_ char *data_path(TALLOC_CTX* mem_ctx, const char *name)
120 {
121         char *fname;
122         fname = talloc_asprintf(mem_ctx, "%s/%s", dyn_DATADIR, name);
123         return fname;
124 }
125
126 /**
127  * @brief Returns an absolute path to a file in the directory containing the current config file
128  *
129  * @param name File to find, relative to the config file directory.
130  *
131  * @retval Pointer to a talloc'ed string containing the full path.
132  **/
133
134 _PUBLIC_ char *config_path(TALLOC_CTX* mem_ctx, const char *name)
135 {
136         char *fname, *config_dir, *p;
137         config_dir = talloc_strdup(mem_ctx, lp_configfile());
138         p = strrchr(config_dir, '/');
139         if (!p) {
140                 return NULL;
141         }
142         p[0] = '\0';
143         fname = talloc_asprintf(mem_ctx, "%s/%s", config_dir, name);
144         talloc_free(config_dir);
145         return fname;
146 }
147
148 /**
149  * @brief Returns an absolute path to a file in the Samba private directory.
150  *
151  * @param name File to find, relative to PRIVATEDIR.
152  * if name is not relative, then use it as-is
153  *
154  * @retval Pointer to a talloc'ed string containing the full path.
155  **/
156 _PUBLIC_ char *private_path(TALLOC_CTX* mem_ctx, const char *name)
157 {
158         char *fname;
159         if (name == NULL) {
160                 return NULL;
161         }
162         if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
163                 return talloc_strdup(mem_ctx, name);
164         }
165         fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(), name);
166         return fname;
167 }
168
169 /**
170   return a path in the smbd.tmp directory, where all temporary file
171   for smbd go. If NULL is passed for name then return the directory 
172   path itself
173 */
174 _PUBLIC_ char *smbd_tmp_path(TALLOC_CTX *mem_ctx, const char *name)
175 {
176         char *fname, *dname;
177
178         dname = pid_path(mem_ctx, "smbd.tmp");
179         if (!directory_exist(dname)) {
180                 mkdir(dname,0755);
181         }
182
183         if (name == NULL) {
184                 return dname;
185         }
186
187         fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
188         talloc_free(dname);
189
190         return fname;
191 }
192
193 /**
194  * Obtain the init function from a shared library file
195  */
196 _PUBLIC_ init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path)
197 {
198         void *handle;
199         void *init_fn;
200
201         handle = dlopen(path, RTLD_NOW);
202         if (handle == NULL) {
203                 DEBUG(0, ("Unable to open %s: %s\n", path, dlerror()));
204                 return NULL;
205         }
206
207         init_fn = dlsym(handle, "init_module");
208
209         if (init_fn == NULL) {
210                 DEBUG(0, ("Unable to find init_module() in %s: %s\n", path, dlerror()));
211                 DEBUG(1, ("Loading module '%s' failed\n", path));
212                 dlclose(handle);
213                 return NULL;
214         }
215
216         return (init_module_fn)init_fn;
217 }
218
219 /**
220  * Obtain list of init functions from the modules in the specified
221  * directory
222  */
223 _PUBLIC_ init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path)
224 {
225         DIR *dir;
226         struct dirent *entry;
227         char *filename;
228         int success = 0;
229         init_module_fn *ret = talloc_array(mem_ctx, init_module_fn, 2);
230
231         ret[0] = NULL;
232         
233         dir = opendir(path);
234         if (dir == NULL) {
235                 talloc_free(ret);
236                 return NULL;
237         }
238
239         while((entry = readdir(dir))) {
240                 if (ISDOT(entry->d_name) || ISDOTDOT(entry->d_name))
241                         continue;
242
243                 filename = talloc_asprintf(mem_ctx, "%s/%s", path, entry->d_name);
244
245                 ret[success] = load_module(mem_ctx, filename);
246                 if (ret[success]) {
247                         ret = talloc_realloc(mem_ctx, ret, init_module_fn, success+2);
248                         success++;
249                         ret[success] = NULL;
250                 }
251
252                 talloc_free(filename);
253         }
254
255         closedir(dir);
256
257         return ret;
258 }
259
260 /**
261  * Run the specified init functions.
262  *
263  * @return true if all functions ran successfully, false otherwise
264  */
265 _PUBLIC_ bool run_init_functions(init_module_fn *fns)
266 {
267         int i;
268         bool ret = true;
269         
270         if (fns == NULL)
271                 return true;
272         
273         for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i]()); }
274
275         return ret;
276 }
277
278 static char *modules_path(TALLOC_CTX* mem_ctx, const char *name)
279 {
280         const char *env_moduledir = getenv("LD_SAMBA_MODULE_PATH");
281         return talloc_asprintf(mem_ctx, "%s/%s", 
282                                                    env_moduledir?env_moduledir:lp_modulesdir(), 
283                                                    name);
284 }
285
286 /**
287  * Load the initialization functions from DSO files for a specific subsystem.
288  *
289  * Will return an array of function pointers to initialization functions
290  */
291
292 _PUBLIC_ init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, const char *subsystem)
293 {
294         char *path = modules_path(mem_ctx, subsystem);
295         init_module_fn *ret;
296
297         ret = load_modules(mem_ctx, path);
298
299         talloc_free(path);
300
301         return ret;
302 }
303
304