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