lib/libalpm/handle.c

   1 /*
   2  *  handle.c
   3  *
   4  *  Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
   5  *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
   6  *  Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
   7  *  Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <limits.h>
  29 #include <sys/types.h>
  30 #include <syslog.h>
  31 #include <sys/stat.h>
  32 #include <fcntl.h>
  33
  34 /* libalpm */
  35 #include "handle.h"
  36 #include "alpm_list.h"
  37 #include "util.h"
  38 #include "log.h"
  39 #include "trans.h"
  40 #include "alpm.h"
  41
  42 alpm_handle_t *_alpm_handle_new()
  43 {
  44         alpm_handle_t *handle;
  45
  46         CALLOC(handle, 1, sizeof(alpm_handle_t), return NULL);
  47
  48         handle->siglevel = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL |
  49                 ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
  50
  51         return handle;
  52 }
  53
  54 void _alpm_handle_free(alpm_handle_t *handle)
  55 {
  56         if(handle == NULL) {
  57                 return;
  58         }
  59
  60         /* close logfile */
  61         if(handle->logstream) {
  62                 fclose(handle->logstream);
  63                 handle->logstream= NULL;
  64         }
  65         if(handle->usesyslog) {
  66                 handle->usesyslog = 0;
  67                 closelog();
  68         }
  69
  70 #ifdef HAVE_LIBCURL
  71         /* release curl handle */
  72         curl_easy_cleanup(handle->curl);
  73 #endif
  74
  75         /* free memory */
  76         _alpm_trans_free(handle->trans);
  77         FREE(handle->root);
  78         FREE(handle->dbpath);
  79         FREELIST(handle->cachedirs);
  80         FREE(handle->logfile);
  81         FREE(handle->lockfile);
  82         FREE(handle->arch);
  83         FREE(handle->gpgdir);
  84         FREELIST(handle->dbs_sync);
  85         FREELIST(handle->noupgrade);
  86         FREELIST(handle->noextract);
  87         FREELIST(handle->ignorepkg);
  88         FREELIST(handle->ignoregroup);
  89         FREE(handle);
  90 }
  91
  92 /** Lock the database */
  93 int _alpm_handle_lock(alpm_handle_t *handle)
  94 {
  95         int fd;
  96         char *dir, *ptr;
  97
  98         ASSERT(handle->lockfile != NULL, return -1);
  99         ASSERT(handle->lckstream == NULL, return 0);
 100
 101         /* create the dir of the lockfile first */
 102         dir = strdup(handle->lockfile);
 103         ptr = strrchr(dir, '/');
 104         if(ptr) {
 105                 *ptr = '\0';
 106         }
 107         if(_alpm_makepath(dir)) {
 108                 FREE(dir);
 109                 return -1;
 110         }
 111         FREE(dir);
 112
 113         do {
 114                 fd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL, 0000);
 115         } while(fd == -1 && errno == EINTR);
 116         if(fd > 0) {
 117                 FILE *f = fdopen(fd, "w");
 118                 fprintf(f, "%ld\n", (long)getpid());
 119                 fflush(f);
 120                 fsync(fd);
 121                 handle->lckstream = f;
 122                 return 0;
 123         }
 124         return -1;
 125 }
 126
 127 /** Remove a lock file */
 128 int _alpm_handle_unlock(alpm_handle_t *handle)
 129 {
 130         ASSERT(handle->lockfile != NULL, return -1);
 131         ASSERT(handle->lckstream != NULL, return 0);
 132
 133         if(handle->lckstream != NULL) {
 134                 fclose(handle->lckstream);
 135                 handle->lckstream = NULL;
 136         }
 137         if(unlink(handle->lockfile) && errno != ENOENT) {
 138                 return -1;
 139         }
 140         return 0;
 141 }
 142
 143
 144 alpm_cb_log SYMEXPORT alpm_option_get_logcb(alpm_handle_t *handle)
 145 {
 146         CHECK_HANDLE(handle, return NULL);
 147         return handle->logcb;
 148 }
 149
 150 alpm_cb_download SYMEXPORT alpm_option_get_dlcb(alpm_handle_t *handle)
 151 {
 152         CHECK_HANDLE(handle, return NULL);
 153         return handle->dlcb;
 154 }
 155
 156 alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb(alpm_handle_t *handle)
 157 {
 158         CHECK_HANDLE(handle, return NULL);
 159         return handle->fetchcb;
 160 }
 161
 162 alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb(alpm_handle_t *handle)
 163 {
 164         CHECK_HANDLE(handle, return NULL);
 165         return handle->totaldlcb;
 166 }
 167
 168 const char SYMEXPORT *alpm_option_get_root(alpm_handle_t *handle)
 169 {
 170         CHECK_HANDLE(handle, return NULL);
 171         return handle->root;
 172 }
 173
 174 const char SYMEXPORT *alpm_option_get_dbpath(alpm_handle_t *handle)
 175 {
 176         CHECK_HANDLE(handle, return NULL);
 177         return handle->dbpath;
 178 }
 179
 180 alpm_list_t SYMEXPORT *alpm_option_get_cachedirs(alpm_handle_t *handle)
 181 {
 182         CHECK_HANDLE(handle, return NULL);
 183         return handle->cachedirs;
 184 }
 185
 186 const char SYMEXPORT *alpm_option_get_logfile(alpm_handle_t *handle)
 187 {
 188         CHECK_HANDLE(handle, return NULL);
 189         return handle->logfile;
 190 }
 191
 192 const char SYMEXPORT *alpm_option_get_lockfile(alpm_handle_t *handle)
 193 {
 194         CHECK_HANDLE(handle, return NULL);
 195         return handle->lockfile;
 196 }
 197
 198 const char SYMEXPORT *alpm_option_get_gpgdir(alpm_handle_t *handle)
 199 {
 200         CHECK_HANDLE(handle, return NULL);
 201         return handle->gpgdir;
 202 }
 203
 204 int SYMEXPORT alpm_option_get_usesyslog(alpm_handle_t *handle)
 205 {
 206         CHECK_HANDLE(handle, return -1);
 207         return handle->usesyslog;
 208 }
 209
 210 alpm_list_t SYMEXPORT *alpm_option_get_noupgrades(alpm_handle_t *handle)
 211 {
 212         CHECK_HANDLE(handle, return NULL);
 213         return handle->noupgrade;
 214 }
 215
 216 alpm_list_t SYMEXPORT *alpm_option_get_noextracts(alpm_handle_t *handle)
 217 {
 218         CHECK_HANDLE(handle, return NULL);
 219         return handle->noextract;
 220 }
 221
 222 alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs(alpm_handle_t *handle)
 223 {
 224         CHECK_HANDLE(handle, return NULL);
 225         return handle->ignorepkg;
 226 }
 227
 228 alpm_list_t SYMEXPORT *alpm_option_get_ignoregroups(alpm_handle_t *handle)
 229 {
 230         CHECK_HANDLE(handle, return NULL);
 231         return handle->ignoregroup;
 232 }
 233
 234 const char SYMEXPORT *alpm_option_get_arch(alpm_handle_t *handle)
 235 {
 236         CHECK_HANDLE(handle, return NULL);
 237         return handle->arch;
 238 }
 239
 240 int SYMEXPORT alpm_option_get_usedelta(alpm_handle_t *handle)
 241 {
 242         CHECK_HANDLE(handle, return -1);
 243         return handle->usedelta;
 244 }
 245
 246 int SYMEXPORT alpm_option_get_checkspace(alpm_handle_t *handle)
 247 {
 248         CHECK_HANDLE(handle, return -1);
 249         return handle->checkspace;
 250 }
 251
 252 alpm_db_t SYMEXPORT *alpm_option_get_localdb(alpm_handle_t *handle)
 253 {
 254         CHECK_HANDLE(handle, return NULL);
 255         return handle->db_local;
 256 }
 257
 258 alpm_list_t SYMEXPORT *alpm_option_get_syncdbs(alpm_handle_t *handle)
 259 {
 260         CHECK_HANDLE(handle, return NULL);
 261         return handle->dbs_sync;
 262 }
 263
 264 int SYMEXPORT alpm_option_set_logcb(alpm_handle_t *handle, alpm_cb_log cb)
 265 {
 266         CHECK_HANDLE(handle, return -1);
 267         handle->logcb = cb;
 268         return 0;
 269 }
 270
 271 int SYMEXPORT alpm_option_set_dlcb(alpm_handle_t *handle, alpm_cb_download cb)
 272 {
 273         CHECK_HANDLE(handle, return -1);
 274         handle->dlcb = cb;
 275         return 0;
 276 }
 277
 278 int SYMEXPORT alpm_option_set_fetchcb(alpm_handle_t *handle, alpm_cb_fetch cb)
 279 {
 280         CHECK_HANDLE(handle, return -1);
 281         handle->fetchcb = cb;
 282         return 0;
 283 }
 284
 285 int SYMEXPORT alpm_option_set_totaldlcb(alpm_handle_t *handle, alpm_cb_totaldl cb)
 286 {
 287         CHECK_HANDLE(handle, return -1);
 288         handle->totaldlcb = cb;
 289         return 0;
 290 }
 291
 292 static char *canonicalize_path(const char *path) {
 293         char *new_path;
 294         size_t len;
 295
 296         /* verify path ends in a '/' */
 297         len = strlen(path);
 298         if(path[len - 1] != '/') {
 299                 len += 1;
 300         }
 301         CALLOC(new_path, len + 1, sizeof(char), return NULL);
 302         strcpy(new_path, path);
 303         new_path[len - 1] = '/';
 304         return new_path;
 305 }
 306
 307 enum _alpm_errno_t _alpm_set_directory_option(const char *value,
 308                 char **storage, int must_exist)
 309  {
 310         struct stat st;
 311         char *real = NULL;
 312         const char *path;
 313
 314         path = value;
 315         if(!path) {
 316                 return ALPM_ERR_WRONG_ARGS;
 317         }
 318         if(must_exist) {
 319                 if(stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
 320                         return ALPM_ERR_NOT_A_DIR;
 321                 }
 322                 CALLOC(real, PATH_MAX, sizeof(char), return ALPM_ERR_MEMORY);
 323                 if(!realpath(path, real)) {
 324                         free(real);
 325                         return ALPM_ERR_NOT_A_DIR;
 326                 }
 327                 path = real;
 328         }
 329
 330         if(*storage) {
 331                 FREE(*storage);
 332         }
 333         *storage = canonicalize_path(path);
 334         if(!*storage) {
 335                 return ALPM_ERR_MEMORY;
 336         }
 337         free(real);
 338         return 0;
 339 }
 340
 341 int SYMEXPORT alpm_option_add_cachedir(alpm_handle_t *handle, const char *cachedir)
 342 {
 343         char *newcachedir;
 344
 345         CHECK_HANDLE(handle, return -1);
 346         ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 347         /* don't stat the cachedir yet, as it may not even be needed. we can
 348          * fail later if it is needed and the path is invalid. */
 349
 350         newcachedir = canonicalize_path(cachedir);
 351         if(!newcachedir) {
 352                 RET_ERR(handle, ALPM_ERR_MEMORY, -1);
 353         }
 354         handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
 355         _alpm_log(handle, ALPM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
 356         return 0;
 357 }
 358
 359 int SYMEXPORT alpm_option_set_cachedirs(alpm_handle_t *handle, alpm_list_t *cachedirs)
 360 {
 361         alpm_list_t *i;
 362         CHECK_HANDLE(handle, return -1);
 363         if(handle->cachedirs) {
 364                 FREELIST(handle->cachedirs);
 365         }
 366         for(i = cachedirs; i; i = i->next) {
 367                 int ret = alpm_option_add_cachedir(handle, i->data);
 368                 if(ret) {
 369                         return ret;
 370                 }
 371         }
 372         return 0;
 373 }
 374
 375 int SYMEXPORT alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cachedir)
 376 {
 377         char *vdata = NULL;
 378         char *newcachedir;
 379         CHECK_HANDLE(handle, return -1);
 380         ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 381
 382         newcachedir = canonicalize_path(cachedir);
 383         if(!newcachedir) {
 384                 RET_ERR(handle, ALPM_ERR_MEMORY, -1);
 385         }
 386         handle->cachedirs = alpm_list_remove_str(handle->cachedirs, newcachedir, &vdata);
 387         FREE(newcachedir);
 388         if(vdata != NULL) {
 389                 FREE(vdata);
 390                 return 1;
 391         }
 392         return 0;
 393 }
 394
 395 int SYMEXPORT alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile)
 396 {
 397         char *oldlogfile = handle->logfile;
 398
 399         CHECK_HANDLE(handle, return -1);
 400         if(!logfile) {
 401                 handle->pm_errno = ALPM_ERR_WRONG_ARGS;
 402                 return -1;
 403         }
 404
 405         handle->logfile = strdup(logfile);
 406
 407         /* free the old logfile path string, and close the stream so logaction
 408          * will reopen a new stream on the new logfile */
 409         if(oldlogfile) {
 410                 FREE(oldlogfile);
 411         }
 412         if(handle->logstream) {
 413                 fclose(handle->logstream);
 414                 handle->logstream = NULL;
 415         }
 416         _alpm_log(handle, ALPM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
 417         return 0;
 418 }
 419
 420 int SYMEXPORT alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir)
 421 {
 422         CHECK_HANDLE(handle, return -1);
 423         if(!gpgdir) {
 424                 handle->pm_errno = ALPM_ERR_WRONG_ARGS;
 425                 return -1;
 426         }
 427
 428         if(handle->gpgdir) {
 429                 FREE(handle->gpgdir);
 430         }
 431         handle->gpgdir = strdup(gpgdir);
 432
 433         _alpm_log(handle, ALPM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
 434         return 0;
 435 }
 436
 437 int SYMEXPORT alpm_option_set_usesyslog(alpm_handle_t *handle, int usesyslog)
 438 {
 439         CHECK_HANDLE(handle, return -1);
 440         handle->usesyslog = usesyslog;
 441         return 0;
 442 }
 443
 444 int SYMEXPORT alpm_option_add_noupgrade(alpm_handle_t *handle, const char *pkg)
 445 {
 446         CHECK_HANDLE(handle, return -1);
 447         handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(pkg));
 448         return 0;
 449 }
 450
 451 int SYMEXPORT alpm_option_set_noupgrades(alpm_handle_t *handle, alpm_list_t *noupgrade)
 452 {
 453         CHECK_HANDLE(handle, return -1);
 454         if(handle->noupgrade) FREELIST(handle->noupgrade);
 455         handle->noupgrade = alpm_list_strdup(noupgrade);
 456         return 0;
 457 }
 458
 459 int SYMEXPORT alpm_option_remove_noupgrade(alpm_handle_t *handle, const char *pkg)
 460 {
 461         char *vdata = NULL;
 462         CHECK_HANDLE(handle, return -1);
 463         handle->noupgrade = alpm_list_remove_str(handle->noupgrade, pkg, &vdata);
 464         if(vdata != NULL) {
 465                 FREE(vdata);
 466                 return 1;
 467         }
 468         return 0;
 469 }
 470
 471 int SYMEXPORT alpm_option_add_noextract(alpm_handle_t *handle, const char *pkg)
 472 {
 473         CHECK_HANDLE(handle, return -1);
 474         handle->noextract = alpm_list_add(handle->noextract, strdup(pkg));
 475         return 0;
 476 }
 477
 478 int SYMEXPORT alpm_option_set_noextracts(alpm_handle_t *handle, alpm_list_t *noextract)
 479 {
 480         CHECK_HANDLE(handle, return -1);
 481         if(handle->noextract) FREELIST(handle->noextract);
 482         handle->noextract = alpm_list_strdup(noextract);
 483         return 0;
 484 }
 485
 486 int SYMEXPORT alpm_option_remove_noextract(alpm_handle_t *handle, const char *pkg)
 487 {
 488         char *vdata = NULL;
 489         CHECK_HANDLE(handle, return -1);
 490         handle->noextract = alpm_list_remove_str(handle->noextract, pkg, &vdata);
 491         if(vdata != NULL) {
 492                 FREE(vdata);
 493                 return 1;
 494         }
 495         return 0;
 496 }
 497
 498 int SYMEXPORT alpm_option_add_ignorepkg(alpm_handle_t *handle, const char *pkg)
 499 {
 500         CHECK_HANDLE(handle, return -1);
 501         handle->ignorepkg = alpm_list_add(handle->ignorepkg, strdup(pkg));
 502         return 0;
 503 }
 504
 505 int SYMEXPORT alpm_option_set_ignorepkgs(alpm_handle_t *handle, alpm_list_t *ignorepkgs)
 506 {
 507         CHECK_HANDLE(handle, return -1);
 508         if(handle->ignorepkg) FREELIST(handle->ignorepkg);
 509         handle->ignorepkg = alpm_list_strdup(ignorepkgs);
 510         return 0;
 511 }
 512
 513 int SYMEXPORT alpm_option_remove_ignorepkg(alpm_handle_t *handle, const char *pkg)
 514 {
 515         char *vdata = NULL;
 516         CHECK_HANDLE(handle, return -1);
 517         handle->ignorepkg = alpm_list_remove_str(handle->ignorepkg, pkg, &vdata);
 518         if(vdata != NULL) {
 519                 FREE(vdata);
 520                 return 1;
 521         }
 522         return 0;
 523 }
 524
 525 int SYMEXPORT alpm_option_add_ignoregroup(alpm_handle_t *handle, const char *grp)
 526 {
 527         CHECK_HANDLE(handle, return -1);
 528         handle->ignoregroup = alpm_list_add(handle->ignoregroup, strdup(grp));
 529         return 0;
 530 }
 531
 532 int SYMEXPORT alpm_option_set_ignoregroups(alpm_handle_t *handle, alpm_list_t *ignoregrps)
 533 {
 534         CHECK_HANDLE(handle, return -1);
 535         if(handle->ignoregroup) FREELIST(handle->ignoregroup);
 536         handle->ignoregroup = alpm_list_strdup(ignoregrps);
 537         return 0;
 538 }
 539
 540 int SYMEXPORT alpm_option_remove_ignoregroup(alpm_handle_t *handle, const char *grp)
 541 {
 542         char *vdata = NULL;
 543         CHECK_HANDLE(handle, return -1);
 544         handle->ignoregroup = alpm_list_remove_str(handle->ignoregroup, grp, &vdata);
 545         if(vdata != NULL) {
 546                 FREE(vdata);
 547                 return 1;
 548         }
 549         return 0;
 550 }
 551
 552 int SYMEXPORT alpm_option_set_arch(alpm_handle_t *handle, const char *arch)
 553 {
 554         CHECK_HANDLE(handle, return -1);
 555         if(handle->arch) FREE(handle->arch);
 556         if(arch) {
 557                 handle->arch = strdup(arch);
 558         } else {
 559                 handle->arch = NULL;
 560         }
 561         return 0;
 562 }
 563
 564 int SYMEXPORT alpm_option_set_usedelta(alpm_handle_t *handle, int usedelta)
 565 {
 566         CHECK_HANDLE(handle, return -1);
 567         handle->usedelta = usedelta;
 568         return 0;
 569 }
 570
 571 int SYMEXPORT alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace)
 572 {
 573         CHECK_HANDLE(handle, return -1);
 574         handle->checkspace = checkspace;
 575         return 0;
 576 }
 577
 578 int SYMEXPORT alpm_option_set_default_siglevel(alpm_handle_t *handle,
 579                 alpm_siglevel_t level)
 580 {
 581         CHECK_HANDLE(handle, return -1);
 582         handle->siglevel = level;
 583         return 0;
 584 }
 585
 586 alpm_siglevel_t SYMEXPORT alpm_option_get_default_siglevel(alpm_handle_t *handle)
 587 {
 588         CHECK_HANDLE(handle, return -1);
 589         return handle->siglevel;
 590 }
 591
 592 /* vim: set ts=2 sw=2 noet: */