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