external/bsd/pkg_install/dist/lib/pkgdb.c

   1 /*      $NetBSD: pkgdb.c,v 1.36 2009/10/22 22:51:29 joerg Exp $ */
   2
   3 #if HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6 #include <nbcompat.h>
   7 #if HAVE_SYS_CDEFS_H
   8 #include <sys/cdefs.h>
   9 #endif
  10 __RCSID("$NetBSD: pkgdb.c,v 1.36 2009/10/22 22:51:29 joerg Exp $");
  11
  12 /*-
  13  * Copyright (c) 1999-2008 The NetBSD Foundation, Inc.
  14  * All rights reserved.
  15  *
  16  * This code is derived from software contributed to The NetBSD Foundation
  17  * by Hubert Feyrer <hubert@feyrer.de>.
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  * 1. Redistributions of source code must retain the above copyright
  23  *    notice, this list of conditions and the following disclaimer.
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 #ifdef NETBSD
  42 #include <db.h>
  43 #else
  44 #include <nbcompat/db.h>
  45 #endif
  46 #if HAVE_ERR_H
  47 #include <err.h>
  48 #endif
  49 #if HAVE_ERRNO_H
  50 #include <errno.h>
  51 #endif
  52 #if HAVE_FCNTL_H
  53 #include <fcntl.h>
  54 #endif
  55 #if HAVE_STDARG_H
  56 #include <stdarg.h>
  57 #endif
  58 #if HAVE_STDIO_H
  59 #include <stdio.h>
  60 #endif
  61 #if HAVE_STRING_H
  62 #include <string.h>
  63 #endif
  64
  65 #include "lib.h"
  66
  67 #define PKGDB_FILE      "pkgdb.byfile.db"       /* indexed by filename */
  68
  69 /*
  70  * Where we put logging information by default if PKG_DBDIR is unset.
  71  */
  72 #ifndef DEF_LOG_DIR
  73 #define DEF_LOG_DIR             "/var/db/pkg"
  74 #endif
  75
  76 /* just in case we change the environment variable name */
  77 #define PKG_DBDIR               "PKG_DBDIR"
  78
  79 static DB   *pkgdbp;
  80 static char *pkgdb_dir = NULL;
  81
  82 /*
  83  *  Open the pkg-database
  84  *  Return value:
  85  *   1: everything ok
  86  *   0: error
  87  */
  88 int
  89 pkgdb_open(int mode)
  90 {
  91         BTREEINFO info;
  92         char    cachename[MaxPathSize];
  93
  94         /* try our btree format first */
  95         info.flags = 0;
  96         info.cachesize = 2*1024*1024;
  97         info.maxkeypage = 0;
  98         info.minkeypage = 0;
  99         info.psize = 4096;
 100         info.compare = NULL;
 101         info.prefix = NULL;
 102         info.lorder = 0;
 103         pkgdbp = (DB *) dbopen(_pkgdb_getPKGDB_FILE(cachename, sizeof(cachename)),
 104             (mode == ReadOnly) ? O_RDONLY : O_RDWR | O_CREAT,
 105             0644, DB_BTREE, (void *) &info);
 106         return (pkgdbp != NULL);
 107 }
 108
 109 /*
 110  * Close the pkg database
 111  */
 112 void
 113 pkgdb_close(void)
 114 {
 115         if (pkgdbp != NULL) {
 116                 (void) (*pkgdbp->close) (pkgdbp);
 117                 pkgdbp = NULL;
 118         }
 119 }
 120
 121 /*
 122  * Store value "val" with key "key" in database
 123  * Return value is as from ypdb_store:
 124  *  0: ok
 125  *  1: key already present
 126  * -1: some other error, see errno
 127  */
 128 int
 129 pkgdb_store(const char *key, const char *val)
 130 {
 131         DBT     keyd, vald;
 132
 133         if (pkgdbp == NULL)
 134                 return -1;
 135
 136         keyd.data = __UNCONST(key);
 137         keyd.size = strlen(key) + 1;
 138         vald.data = __UNCONST(val);
 139         vald.size = strlen(val) + 1;
 140
 141         if (keyd.size > MaxPathSize || vald.size > MaxPathSize)
 142                 return -1;
 143
 144         return (*pkgdbp->put) (pkgdbp, &keyd, &vald, R_NOOVERWRITE);
 145 }
 146
 147 /*
 148  * Recall value for given key
 149  * Return value:
 150  *  NULL if some error occurred or value for key not found (check errno!)
 151  *  String for "value" else
 152  */
 153 char   *
 154 pkgdb_retrieve(const char *key)
 155 {
 156         DBT     keyd, vald;
 157         int     status;
 158
 159         if (pkgdbp == NULL)
 160                 return NULL;
 161
 162         keyd.data = __UNCONST(key);
 163         keyd.size = strlen(key) + 1;
 164         errno = 0;              /* to be sure it's 0 if the key doesn't match anything */
 165
 166         vald.data = (void *)NULL;
 167         vald.size = 0;
 168         status = (*pkgdbp->get) (pkgdbp, &keyd, &vald, 0);
 169         if (status) {
 170                 vald.data = NULL;
 171                 vald.size = 0;
 172         }
 173
 174         return vald.data;
 175 }
 176
 177 /* dump contents of the database to stdout */
 178 int
 179 pkgdb_dump(void)
 180 {
 181         DBT     key;
 182         DBT     val;
 183         int     type;
 184
 185         if (pkgdb_open(ReadOnly)) {
 186                 for (type = R_FIRST ; (*pkgdbp->seq)(pkgdbp, &key, &val, type) == 0 ; type = R_NEXT) {
 187                         printf("file: %.*s pkg: %.*s\n",
 188                                 (int) key.size, (char *) key.data,
 189                                 (int) val.size, (char *) val.data);
 190                 }
 191                 pkgdb_close();
 192                 return 0;
 193         } else
 194                 return -1;
 195 }
 196
 197 /*
 198  *  Remove data set from pkgdb
 199  *  Return value as ypdb_delete:
 200  *   0: everything ok
 201  *   1: key not present
 202  *  -1: some error occurred (see errno)
 203  */
 204 int
 205 pkgdb_remove(const char *key)
 206 {
 207         DBT     keyd;
 208
 209         if (pkgdbp == NULL)
 210                 return -1;
 211
 212         keyd.data = __UNCONST(key);
 213         keyd.size = strlen(key) + 1;
 214         if (keyd.size > MaxPathSize)
 215                 return -1;
 216
 217         return (*pkgdbp->del) (pkgdbp, &keyd, 0);
 218 }
 219
 220 /*
 221  *  Remove any entry from the cache which has a data field of `pkg'.
 222  *  Return value:
 223  *   1: everything ok
 224  *   0: error
 225  */
 226 int
 227 pkgdb_remove_pkg(const char *pkg)
 228 {
 229         DBT     data;
 230         DBT     key;
 231         int     type;
 232         int     ret;
 233         size_t  cc;
 234         char    cachename[MaxPathSize];
 235
 236         if (pkgdbp == NULL) {
 237                 return 0;
 238         }
 239         (void) _pkgdb_getPKGDB_FILE(cachename, sizeof(cachename));
 240         cc = strlen(pkg);
 241         for (ret = 1, type = R_FIRST; (*pkgdbp->seq)(pkgdbp, &key, &data, type) == 0 ; type = R_NEXT) {
 242                 if ((cc + 1) == data.size && strncmp(data.data, pkg, cc) == 0) {
 243                         if (Verbose) {
 244                                 printf("Removing file `%s' from %s\n", (char *)key.data, cachename);
 245                         }
 246                         switch ((*pkgdbp->del)(pkgdbp, &key, 0)) {
 247                         case -1:
 248                                 warn("Error removing `%s' from %s", (char *)key.data, cachename);
 249                                 ret = 0;
 250                                 break;
 251                         case 1:
 252                                 warn("Key `%s' not present in %s", (char *)key.data, cachename);
 253                                 ret = 0;
 254                                 break;
 255
 256                         }
 257                 }
 258         }
 259         return ret;
 260 }
 261
 262 /*
 263  *  Return the location of the package reference counts database directory.
 264  */
 265 char *
 266 pkgdb_refcount_dir(void)
 267 {
 268         static char buf[MaxPathSize];
 269         char *tmp;
 270
 271         if ((tmp = getenv(PKG_REFCOUNT_DBDIR_VNAME)) != NULL)
 272                 strlcpy(buf, tmp, sizeof(buf));
 273         else
 274                 snprintf(buf, sizeof(buf), "%s.refcount", _pkgdb_getPKGDB_DIR());
 275         return buf;
 276 }
 277
 278 /*
 279  *  Return name of cache file in the buffer that was passed.
 280  */
 281 char *
 282 _pkgdb_getPKGDB_FILE(char *buf, unsigned size)
 283 {
 284         (void) snprintf(buf, size, "%s/%s", _pkgdb_getPKGDB_DIR(), PKGDB_FILE);
 285         return buf;
 286 }
 287
 288 /*
 289  *  Return directory where pkgdb is stored
 290  */
 291 const char *
 292 _pkgdb_getPKGDB_DIR(void)
 293 {
 294         char *tmp;
 295
 296         if (pkgdb_dir == NULL) {
 297                 if ((tmp = getenv(PKG_DBDIR)) != NULL)
 298                         _pkgdb_setPKGDB_DIR(tmp);
 299                 else
 300                         _pkgdb_setPKGDB_DIR(DEF_LOG_DIR);
 301         }
 302
 303         return pkgdb_dir;
 304 }
 305
 306 /*
 307  *  Set the first place we look for where pkgdb is stored.
 308  */
 309 void
 310 _pkgdb_setPKGDB_DIR(const char *dir)
 311 {
 312         char *new_dir;
 313
 314         if (dir == pkgdb_dir)
 315                 return;
 316         new_dir = xstrdup(dir);
 317         free(pkgdb_dir);
 318         pkgdb_dir = new_dir;
 319 }
 320
 321 char *
 322 pkgdb_pkg_file(const char *pkg, const char *file)
 323 {
 324         return xasprintf("%s/%s/%s", _pkgdb_getPKGDB_DIR(), pkg, file);
 325 }