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 _PUBLIC_ 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 _PUBLIC_ 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 _PUBLIC_ 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 _PUBLIC_ 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         p = strrchr(config_dir, '/');
 110         if (!p) {
 111                 return NULL;
 112         }
 113         p[0] = '\0';
 114         fname = talloc_asprintf(mem_ctx, "%s/%s", config_dir, name);
 115         talloc_free(config_dir);
 116         return fname;
 117 }
 118
 119 /**
 120  * @brief Returns an absolute path to a file in the Samba private directory.
 121  *
 122  * @param name File to find, relative to PRIVATEDIR.
 123  * if name is not relative, then use it as-is
 124  *
 125  * @retval Pointer to a talloc'ed string containing the full path.
 126  **/
 127 _PUBLIC_ char *private_path(TALLOC_CTX* mem_ctx,
 128                             struct loadparm_context *lp_ctx,
 129                             const char *name)
 130 {
 131         char *fname;
 132         if (name == NULL) {
 133                 return NULL;
 134         }
 135         if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
 136                 return talloc_strdup(mem_ctx, name);
 137         }
 138         fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(lp_ctx), name);
 139         return fname;
 140 }
 141
 142 /**
 143   return a path in the smbd.tmp directory, where all temporary file
 144   for smbd go. If NULL is passed for name then return the directory
 145   path itself
 146 */
 147 _PUBLIC_ char *smbd_tmp_path(TALLOC_CTX *mem_ctx,
 148                              struct loadparm_context *lp_ctx,
 149                              const char *name)
 150 {
 151         char *fname, *dname;
 152
 153         dname = private_path(mem_ctx, lp_ctx, "smbd.tmp");
 154         if (!directory_exist(dname)) {
 155                 mkdir(dname,0755);
 156         }
 157
 158         if (name == NULL) {
 159                 return dname;
 160         }
 161
 162         fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
 163         talloc_free(dname);
 164
 165         return fname;
 166 }
 167
 168 /**
 169  * Obtain the init function from a shared library file
 170  */
 171 _PUBLIC_ init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path)
 172 {
 173         void *handle;
 174         void *init_fn;
 175
 176         handle = dlopen(path, RTLD_NOW);
 177         if (handle == NULL) {
 178                 DEBUG(0, ("Unable to open %s: %s\n", path, dlerror()));
 179                 return NULL;
 180         }
 181
 182         init_fn = dlsym(handle, "init_module");
 183
 184         if (init_fn == NULL) {
 185                 DEBUG(0, ("Unable to find init_module() in %s: %s\n", path, dlerror()));
 186                 DEBUG(1, ("Loading module '%s' failed\n", path));
 187                 dlclose(handle);
 188                 return NULL;
 189         }
 190
 191         return (init_module_fn)init_fn;
 192 }
 193
 194 /**
 195  * Obtain list of init functions from the modules in the specified
 196  * directory
 197  */
 198 _PUBLIC_ init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path)
 199 {
 200         DIR *dir;
 201         struct dirent *entry;
 202         char *filename;
 203         int success = 0;
 204         init_module_fn *ret = talloc_array(mem_ctx, init_module_fn, 2);
 205
 206         ret[0] = NULL;
 207
 208         dir = opendir(path);
 209         if (dir == NULL) {
 210                 talloc_free(ret);
 211                 return NULL;
 212         }
 213
 214         while((entry = readdir(dir))) {
 215                 if (ISDOT(entry->d_name) || ISDOTDOT(entry->d_name))
 216                         continue;
 217
 218                 filename = talloc_asprintf(mem_ctx, "%s/%s", path, entry->d_name);
 219
 220                 ret[success] = load_module(mem_ctx, filename);
 221                 if (ret[success]) {
 222                         ret = talloc_realloc(mem_ctx, ret, init_module_fn, success+2);
 223                         success++;
 224                         ret[success] = NULL;
 225                 }
 226
 227                 talloc_free(filename);
 228         }
 229
 230         closedir(dir);
 231
 232         return ret;
 233 }
 234
 235 /**
 236  * Run the specified init functions.
 237  *
 238  * @return true if all functions ran successfully, false otherwise
 239  */
 240 _PUBLIC_ bool run_init_functions(init_module_fn *fns)
 241 {
 242         int i;
 243         bool ret = true;
 244
 245         if (fns == NULL)
 246                 return true;
 247
 248         for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i]()); }
 249
 250         return ret;
 251 }
 252
 253 static char *modules_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
 254                           const char *name)
 255 {
 256         const char *env_moduledir = getenv("LD_SAMBA_MODULE_PATH");
 257         return talloc_asprintf(mem_ctx, "%s/%s",
 258                                env_moduledir?env_moduledir:lp_modulesdir(lp_ctx),
 259                                name);
 260 }
 261
 262 /**
 263  * Load the initialization functions from DSO files for a specific subsystem.
 264  *
 265  * Will return an array of function pointers to initialization functions
 266  */
 267
 268 _PUBLIC_ init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, const char *subsystem)
 269 {
 270         char *path = modules_path(mem_ctx, lp_ctx, subsystem);
 271         init_module_fn *ret;
 272
 273         ret = load_modules(mem_ctx, path);
 274
 275         talloc_free(path);
 276
 277         return ret;
 278 }
 279
 280 _PUBLIC_ const char *lp_messaging_path(TALLOC_CTX *mem_ctx,
 281                                        struct loadparm_context *lp_ctx)
 282 {
 283         return smbd_tmp_path(mem_ctx, lp_ctx, "messaging");
 284 }
 285