libatalk/cnid/cnid.c

   1 /*
   2  * Copyright (c) 2003 the Netatalk Team
   3  * Copyright (c) 2003 Rafal Lewczuk <rlewczuk@pronet.pl>
   4  *
   5  * This program is free software; you can redistribute and/or modify
   6  * it under the terms of the GNU General Public License as published
   7  * by the Free Software Foundation version 2 of the License or later
   8  * version if explicitly stated by any of above copyright holders.
   9  *
  10  */
  11 #define USE_LIST
  12
  13 #ifdef HAVE_CONFIG_H
  14 #include "config.h"
  15 #endif /* HAVE_CONFIG_H */
  16
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <sys/param.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <time.h>
  24 #include <signal.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27
  28 #include <atalk/cnid.h>
  29 #include <atalk/list.h>
  30 #include <atalk/logger.h>
  31 #include <atalk/util.h>
  32 #include <atalk/compat.h>
  33
  34 /* List of all registered modules. */
  35 static struct list_head modules = ATALK_LIST_HEAD_INIT(modules);
  36
  37 static sigset_t sigblockset;
  38 static const struct itimerval none = {{0, 0}, {0, 0}};
  39
  40 /* Registers new CNID backend module. */
  41
  42 /* Once module has been registered, it cannot be unregistered. */
  43 void cnid_register(struct _cnid_module *module)
  44 {
  45     struct list_head *ptr;
  46
  47     /* Check if our module is already registered. */
  48     list_for_each(ptr, &modules)
  49         if (0 == strcmp(list_entry(ptr, cnid_module, db_list)->name, module->name)) {
  50         LOG(log_error, logtype_afpd, "Module with name [%s] is already registered !", module->name);
  51         return;
  52     }
  53
  54     LOG(log_info, logtype_afpd, "Registering CNID module [%s]", module->name);
  55     ptr = &(module->db_list);
  56     list_add_tail(ptr, &modules);
  57 }
  58
  59 /* --------------- */
  60 static int cnid_dir(const char *dir, mode_t mask)
  61 {
  62    struct stat st, st1;
  63    char tmp[MAXPATHLEN];
  64
  65    if (stat(dir, &st) < 0) {
  66        if (errno != ENOENT)
  67            return -1;
  68        if (ad_stat( dir, &st) < 0)
  69           return -1;
  70
  71        LOG(log_info, logtype_cnid, "Setting uid/gid to %d/%d", st.st_uid, st.st_gid);
  72        if (setegid(st.st_gid) < 0 || seteuid(st.st_uid) < 0) {
  73            LOG(log_error, logtype_cnid, "uid/gid: %s", strerror(errno));
  74            return -1;
  75        }
  76
  77        if (mkdir(dir, 0777 & ~mask) < 0)
  78            return -1;
  79    } else {
  80        strlcpy(tmp, dir, sizeof(tmp));
  81        strlcat(tmp, "/.AppleDB", sizeof(tmp));
  82        if (stat(tmp, &st1) < 0) /* use .AppleDB owner, if folder already exists */
  83            st1 = st;
  84        LOG(log_info, logtype_cnid, "Setting uid/gid to %d/%d", st1.st_uid, st1.st_gid);
  85        if (setegid(st1.st_gid) < 0 || seteuid(st1.st_uid) < 0) {
  86            LOG(log_error, logtype_cnid, "uid/gid: %s", strerror(errno));
  87            return -1;
  88        }
  89    }
  90    return 0;
  91 }
  92
  93 /* Opens CNID database using particular back-end */
  94 struct _cnid_db *cnid_open(const char *volpath, mode_t mask, char *type, int flags,
  95                            const char *cnidsrv, const char *cnidport)
  96 {
  97     struct _cnid_db *db;
  98     cnid_module *mod = NULL;
  99     struct list_head *ptr;
 100     uid_t uid = -1;
 101     gid_t gid = -1;
 102
 103     list_for_each(ptr, &modules) {
 104         if (0 == strcmp(list_entry(ptr, cnid_module, db_list)->name, type)) {
 105             mod = list_entry(ptr, cnid_module, db_list);
 106         break;
 107         }
 108     }
 109
 110     if (NULL == mod) {
 111         LOG(log_error, logtype_afpd, "Cannot find module named [%s] in registered module list!", type);
 112         return NULL;
 113     }
 114
 115     if ((mod->flags & CNID_FLAG_SETUID) && !(flags & CNID_FLAG_MEMORY)) {
 116         uid = geteuid();
 117         gid = getegid();
 118         if (seteuid(0)) {
 119             LOG(log_error, logtype_afpd, "seteuid failed %s", strerror(errno));
 120             return NULL;
 121         }
 122         if (cnid_dir(volpath, mask) < 0) {
 123             if ( setegid(gid) < 0 || seteuid(uid) < 0) {
 124                 LOG(log_error, logtype_afpd, "can't seteuid back %s", strerror(errno));
 125                 exit(EXITERR_SYS);
 126             }
 127             return NULL;
 128         }
 129     }
 130
 131     struct cnid_open_args args = {volpath, mask, flags, cnidsrv, cnidport};
 132     db = mod->cnid_open(&args);
 133
 134     if ((mod->flags & CNID_FLAG_SETUID) && !(flags & CNID_FLAG_MEMORY)) {
 135         seteuid(0);
 136         if ( setegid(gid) < 0 || seteuid(uid) < 0) {
 137             LOG(log_error, logtype_afpd, "can't seteuid back %s", strerror(errno));
 138             exit(EXITERR_SYS);
 139         }
 140     }
 141
 142     if (NULL == db) {
 143         LOG(log_error, logtype_afpd, "Cannot open CNID db at [%s].", volpath);
 144         return NULL;
 145     }
 146     /* FIXME should module know about it ? */
 147     if ((flags & CNID_FLAG_NODEV)) {
 148         db->flags |= CNID_FLAG_NODEV;
 149     }
 150     db->flags |= mod->flags;
 151
 152     if ((db->flags & CNID_FLAG_BLOCK)) {
 153         sigemptyset(&sigblockset);
 154         sigaddset(&sigblockset, SIGTERM);
 155         sigaddset(&sigblockset, SIGHUP);
 156         sigaddset(&sigblockset, SIGUSR1);
 157         sigaddset(&sigblockset, SIGUSR2);
 158         sigaddset(&sigblockset, SIGALRM);
 159     }
 160
 161     return db;
 162 }
 163
 164 /* ------------------- */
 165 static void block_signal( u_int32_t flags)
 166 {
 167     if ((flags & CNID_FLAG_BLOCK)) {
 168         pthread_sigmask(SIG_BLOCK, &sigblockset, NULL);
 169     }
 170 }
 171
 172 /* ------------------- */
 173 static void unblock_signal(u_int32_t flags)
 174 {
 175     if ((flags & CNID_FLAG_BLOCK)) {
 176         pthread_sigmask(SIG_UNBLOCK, &sigblockset, NULL);
 177     }
 178 }
 179
 180 /* -------------------
 181   protect against bogus value from the DB.
 182   adddir really doesn't like 2
 183 */
 184 static cnid_t valide(cnid_t id)
 185 {
 186   if (id == CNID_INVALID)
 187       return id;
 188
 189   if (id < CNID_START) {
 190     static int err = 0;
 191     if (!err) {
 192         err = 1;
 193         LOG(log_error, logtype_afpd, "Error: Invalid cnid, corrupted DB?");
 194     }
 195     return CNID_INVALID;
 196   }
 197   return id;
 198 }
 199
 200 /* Closes CNID database. Currently it's just a wrapper around db->cnid_close(). */
 201 void cnid_close(struct _cnid_db *db)
 202 {
 203 u_int32_t flags;
 204
 205     if (NULL == db) {
 206         LOG(log_error, logtype_afpd, "Error: cnid_close called with NULL argument !");
 207         return;
 208     }
 209     /* cnid_close free db */
 210     flags = db->flags;
 211     block_signal(flags);
 212     db->cnid_close(db);
 213     unblock_signal(flags);
 214 }
 215
 216 /* --------------- */
 217 cnid_t cnid_add(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 218                 const char *name, const size_t len, cnid_t hint)
 219 {
 220 cnid_t ret;
 221
 222     block_signal(cdb->flags);
 223     ret = valide(cdb->cnid_add(cdb, st, did, name, len, hint));
 224     unblock_signal(cdb->flags);
 225     return ret;
 226 }
 227
 228 /* --------------- */
 229 int cnid_delete(struct _cnid_db *cdb, cnid_t id)
 230 {
 231 int ret;
 232
 233     block_signal(cdb->flags);
 234     ret = cdb->cnid_delete(cdb, id);
 235     unblock_signal(cdb->flags);
 236     return ret;
 237 }
 238
 239
 240 /* --------------- */
 241 cnid_t cnid_get(struct _cnid_db *cdb, const cnid_t did, char *name,const size_t len)
 242 {
 243 cnid_t ret;
 244
 245     block_signal(cdb->flags);
 246     ret = valide(cdb->cnid_get(cdb, did, name, len));
 247     unblock_signal(cdb->flags);
 248     return ret;
 249 }
 250
 251 /* --------------- */
 252 int cnid_getstamp(struct _cnid_db *cdb,  void *buffer, const size_t len)
 253 {
 254 cnid_t ret;
 255 time_t t;
 256
 257     if (!cdb->cnid_getstamp) {
 258         memset(buffer, 0, len);
 259         /* return the current time. it will invalide cache */
 260         if (len < sizeof(time_t))
 261             return -1;
 262         t = time(NULL);
 263         memcpy(buffer, &t, sizeof(time_t));
 264         return 0;
 265     }
 266     block_signal(cdb->flags);
 267     ret = cdb->cnid_getstamp(cdb, buffer, len);
 268     unblock_signal(cdb->flags);
 269     return ret;
 270 }
 271
 272 /* --------------- */
 273 cnid_t cnid_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 274                    char *name, const size_t len)
 275 {
 276     cnid_t ret;
 277
 278     block_signal(cdb->flags);
 279     ret = valide(cdb->cnid_lookup(cdb, st, did, name, len));
 280     unblock_signal(cdb->flags);
 281     return ret;
 282 }
 283
 284 /* --------------- */
 285 int cnid_find(struct _cnid_db *cdb, const char *name, size_t namelen, void *buffer, size_t buflen)
 286 {
 287     int ret;
 288
 289     if (cdb->cnid_find == NULL) {
 290         LOG(log_error, logtype_cnid, "cnid_find not supported by CNID backend");
 291         return -1;
 292     }
 293
 294     block_signal(cdb->flags);
 295     ret = cdb->cnid_find(cdb, name, namelen, buffer, buflen);
 296     unblock_signal(cdb->flags);
 297     return ret;
 298 }
 299
 300 /* --------------- */
 301 char *cnid_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
 302 {
 303 char *ret;
 304
 305     block_signal(cdb->flags);
 306     ret = cdb->cnid_resolve(cdb, id, buffer, len);
 307     unblock_signal(cdb->flags);
 308     if (ret && !strcmp(ret, "..")) {
 309         LOG(log_error, logtype_afpd, "cnid_resolve: name is '..', corrupted db? ");
 310         ret = NULL;
 311     }
 312     return ret;
 313 }
 314
 315 /* --------------- */
 316 int cnid_update   (struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
 317                         const cnid_t did, char *name, const size_t len)
 318 {
 319 int ret;
 320
 321     block_signal(cdb->flags);
 322     ret = cdb->cnid_update(cdb, id, st, did, name, len);
 323     unblock_signal(cdb->flags);
 324     return ret;
 325 }
 326
 327 /* --------------- */
 328 cnid_t cnid_rebuild_add(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 329                        char *name, const size_t len, cnid_t hint)
 330 {
 331 cnid_t ret;
 332
 333     block_signal(cdb->flags);
 334     ret = cdb->cnid_rebuild_add(cdb, st, did, name, len, hint);
 335     unblock_signal(cdb->flags);
 336     return ret;
 337 }