source/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, "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