/* * dpkg - main program for package management * archives.c - actions that process archive files, mainly unpack * * Copyright (C) 1994,1995 Ian Jackson * Copyright (C) 2000 Wichert Akkerman * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2, * or (at your option) any later version. * * This is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public * License along with dpkg; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define obstack_chunk_alloc m_malloc #define obstack_chunk_free free #include #include #include #include #ifdef WITH_SELINUX #include static int selinux_enabled=-1; static security_context_t scontext = NULL; #endif #include "filesdb.h" #include "main.h" #include "archives.h" #define MAXCONFLICTORS 20 struct pkginfo *conflictor[MAXCONFLICTORS]; int cflict_index = 0; /* snprintf(3) doesn't work if format contains %.s and an argument has * invalid char for locale, then it returns -1. * ohshite() is ok, but fd_fd_copy(), which is used in tarobject() in this * file, is not ok, because * - fd_fd_copy() == buffer_copy_setup() [include/dpkg.h] * - buffer_copy_setup() uses varbufvprintf(&v, desc, al); [lib/mlib.c] * - varbufvprintf() fails and memory exausted, because it call * fmt = "backend dpkg-deb during `%.255s' * arg may contain some invalid char, for example, * /usr/share/doc/console-tools/examples/unicode/\342\231\252\342\231\254 * in console-tools. * In this case, if user uses some locale which doesn't support \342\231..., * vsnprintf() always returns -1 and varbufextend() get called again * and again until memory is exausted and it aborts. * * So, we need to escape invalid char, probably as in * tar-1.13.19/lib/quotearg.c: quotearg_buffer_restyled() * but here I escape all 8bit chars, in order to be simple. * - ukai@debian.or.jp */ static char * quote_filename(char *buf, int size, char *s) { char *r = buf; while (size > 0) { switch (*s) { case '\0': *buf = '\0'; return r; case '\\': *buf++ = '\\'; *buf++ = '\\'; size -= 2; break; default: if (((*s) & 0x80) == 0) { *buf++ = *s++; --size; } else { if (size > 4) { sprintf(buf, "\\%03o", *(unsigned char *)s); size -= 4; buf += 4; s++; } else { /* buffer full */ *buf = '\0'; /* XXX */ return r; } } } } *buf = '\0'; /* XXX */ return r; } /* special routine to handle partial reads from the tarfile */ static int safe_read(int fd, void *buf, int len) { int r, have= 0; char *p = (char *)buf; while (have < len) { if ((r= read(fd,p,len-have))==-1) { if (errno==EINTR || errno==EAGAIN) continue; return r; } if (r==0) break; have+= r; p+= r; } return have; } static struct obstack tar_obs; static int tarobs_init= 0; /* ensure the obstack is properly initialized */ static void ensureobstackinit(void) { if (!tarobs_init) { obstack_init(&tar_obs); tarobs_init= 1; } } /* destroy the obstack */ static void destroyobstack(void) { if (tarobs_init) { obstack_free(&tar_obs, NULL); tarobs_init= 0; } } int filesavespackage(struct fileinlist *file, struct pkginfo *pkgtobesaved, struct pkginfo *pkgbeinginstalled) { struct pkginfo *divpkg, *thirdpkg; struct filepackages *packageslump; int i; debug(dbg_eachfiledetail,"filesavespackage file `%s' package %s", file->namenode->name,pkgtobesaved->name); /* A package can only be saved by a file or directory which is part * only of itself - it must be neither part of the new package being * installed nor part of any 3rd package (this is important so that * shared directories don't stop packages from disappearing). */ /* If the file is a contended one and it's overridden by either * the package we're considering disappearing or the package * we're installing then they're not actually the same file, so * we can't disappear the package - it is saved by this file. */ if (file->namenode->divert && file->namenode->divert->useinstead) { divpkg= file->namenode->divert->pkg; if (divpkg == pkgtobesaved || divpkg == pkgbeinginstalled) { debug(dbg_eachfiledetail,"filesavespackage ... diverted -- save!"); return 1; } } /* Is the file in the package being installed ? If so then it can't save. */ if (file->namenode->flags & fnnf_new_inarchive) { debug(dbg_eachfiledetail,"filesavespackage ... in new archive -- no save"); return 0; } /* Look for a 3rd package which can take over the file (in case * it's a directory which is shared by many packages. */ for (packageslump= file->namenode->packages; packageslump; packageslump= packageslump->more) { for (i=0; i < PERFILEPACKAGESLUMP && packageslump->pkgs[i]; i++) { thirdpkg= packageslump->pkgs[i]; debug(dbg_eachfiledetail, "filesavespackage ... also in %s", thirdpkg->name); /* Is this not the package being installed or the one being * checked for disappearance ? */ if (thirdpkg == pkgbeinginstalled || thirdpkg == pkgtobesaved) continue; /* If !fileslistvalid then we've already disappeared this one, so * we shouldn't try to make it take over this shared directory. */ debug(dbg_eachfiledetail,"filesavespackage ... is 3rd package"); if (!thirdpkg->clientdata->fileslistvalid) { debug(dbg_eachfiledetail, _("process_archive ... already disappeared !")); continue; } /* We've found a package that can take this file. */ debug(dbg_eachfiledetail, "filesavespackage ... taken -- no save"); return 0; } } debug(dbg_eachfiledetail, "filesavespackage ... not taken -- save !"); return 1; } void cu_pathname(int argc, void **argv) { ensure_pathname_nonexisting((char*)(argv[0])); } int tarfileread(void *ud, char *buf, int len) { struct tarcontext *tc= (struct tarcontext*)ud; int r; if ((r= safe_read(tc->backendpipe,buf,len)) == -1) ohshite(_("error reading from dpkg-deb pipe")); return r; } int fnameidlu; struct varbuf fnamevb; struct varbuf fnametmpvb; struct varbuf fnamenewvb; struct packageinlist *deconfigure = NULL; static time_t currenttime; static int does_replace(struct pkginfo *newpigp, struct pkginfoperfile *newpifp, struct pkginfo *oldpigp) { struct dependency *dep; debug(dbg_depcon,"does_replace new=%s old=%s (%s)",newpigp->name, oldpigp->name,versiondescribe(&oldpigp->installed.version, vdew_always)); for (dep= newpifp->depends; dep; dep= dep->next) { if (dep->type != dep_replaces || dep->list->ed != oldpigp) continue; debug(dbg_depcondetail,"does_replace ... found old, version %s", versiondescribe(&dep->list->version,vdew_always)); if (!versionsatisfied(&oldpigp->installed,dep->list)) continue; debug(dbg_depcon,"does_replace ... yes"); return 1; } debug(dbg_depcon,"does_replace ... no"); return 0; } static void newtarobject_utime(const char *path, struct TarInfo *ti) { struct utimbuf utb; utb.actime= currenttime; utb.modtime= ti->ModTime; if (utime(path,&utb)) ohshite(_("error setting timestamps of `%.255s'"),ti->Name); } static void newtarobject_allmodes(const char *path, struct TarInfo *ti, struct filestatoverride* statoverride) { if (chown(path, statoverride ? statoverride->uid : ti->UserID, statoverride ? statoverride->gid : ti->GroupID)) ohshite(_("error setting ownership of `%.255s'"),ti->Name); if (chmod(path,(statoverride ? statoverride->mode : ti->Mode) & ~S_IFMT)) ohshite(_("error setting permissions of `%.255s'"),ti->Name); newtarobject_utime(path,ti); } void setupfnamevbs(const char *filename) { fnamevb.used= fnameidlu; varbufaddstr(&fnamevb,filename); varbufaddc(&fnamevb,0); fnametmpvb.used= fnameidlu; varbufaddstr(&fnametmpvb,filename); varbufaddstr(&fnametmpvb,DPKGTEMPEXT); varbufaddc(&fnametmpvb,0); fnamenewvb.used= fnameidlu; varbufaddstr(&fnamenewvb,filename); varbufaddstr(&fnamenewvb,DPKGNEWEXT); varbufaddc(&fnamenewvb,0); debug(dbg_eachfiledetail, "setupvnamevbs main=`%s' tmp=`%s' new=`%s'", fnamevb.buf, fnametmpvb.buf, fnamenewvb.buf); } int unlinkorrmdir(const char *filename) { /* Returns 0 on success or -1 on failure, just like unlink & rmdir */ int r, e; if (!rmdir(filename)) { debug(dbg_eachfiledetail,"unlinkorrmdir `%s' rmdir OK",filename); return 0; } if (errno != ENOTDIR) { e= errno; debug(dbg_eachfiledetail,"unlinkorrmdir `%s' rmdir %s",filename,strerror(e)); errno= e; return -1; } r= unlink(filename); e= errno; debug(dbg_eachfiledetail,"unlinkorrmdir `%s' unlink %s", filename, r ? strerror(e) : "OK"); errno= e; return r; } struct fileinlist *addfiletolist(struct tarcontext *tc, struct filenamenode *namenode) { struct fileinlist *nifd; nifd= obstack_alloc(&tar_obs, sizeof(struct fileinlist)); nifd->namenode= namenode; nifd->next = NULL; *tc->newfilesp = nifd; tc->newfilesp = &nifd->next; return nifd; } static int linktosameexistingdir(const struct TarInfo *ti, const char *fname, struct varbuf *symlinkfn) { struct stat oldstab, newstab; int statr; const char *lastslash; statr= stat(fname, &oldstab); if (statr) { if (!(errno == ENOENT || errno == ELOOP || errno == ENOTDIR)) ohshite(_("failed to stat (dereference) existing symlink `%.250s'"), fname); return 0; } if (!S_ISDIR(oldstab.st_mode)) return 0; /* But is it to the same dir ? */ varbufreset(symlinkfn); if (ti->LinkName[0] == '/') { varbufaddstr(symlinkfn, instdir); } else { lastslash= strrchr(fname, '/'); assert(lastslash); varbufaddbuf(symlinkfn, fname, (lastslash - fname) + 1); } varbufaddstr(symlinkfn, ti->LinkName); varbufaddc(symlinkfn, 0); statr= stat(symlinkfn->buf, &newstab); if (statr) { if (!(errno == ENOENT || errno == ELOOP || errno == ENOTDIR)) ohshite(_("failed to stat (dereference) proposed new symlink target" " `%.250s' for symlink `%.250s'"), symlinkfn->buf, fname); return 0; } if (!S_ISDIR(newstab.st_mode)) return 0; if (newstab.st_dev != oldstab.st_dev || newstab.st_ino != oldstab.st_ino) return 0; return 1; } int tarobject(struct TarInfo *ti) { static struct varbuf conffderefn, hardlinkfn, symlinkfn; const char *usename; struct conffile *conff; struct tarcontext *tc= (struct tarcontext*)ti->UserData; int statr, fd, i, existingdirectory, keepexisting; ssize_t r; struct stat stab, stabtmp; char databuf[TARBLKSZ]; struct fileinlist *nifd, **oldnifd; struct pkginfo *divpkg, *otherpkg; struct filepackages *packageslump; mode_t am; ensureobstackinit(); /* Append to list of files. * The trailing / put on the end of names in tarfiles has already * been stripped by TarExtractor (lib/tarfn.c). */ oldnifd= tc->newfilesp; nifd= addfiletolist(tc, findnamenode(ti->Name, 0)); nifd->namenode->flags |= fnnf_new_inarchive; debug(dbg_eachfile, "tarobject ti->Name=`%s' Mode=%lo owner=%u.%u Type=%d(%c)" " ti->LinkName=`%s' namenode=`%s' flags=%o instead=`%s'", ti->Name, (long)ti->Mode, (unsigned)ti->UserID, (unsigned)ti->GroupID, ti->Type, ti->Type == '\0' ? '_' : ti->Type >= '0' && ti->Type <= '6' ? "-hlcbdp"[ti->Type - '0'] : '?', ti->LinkName, nifd->namenode->name, nifd->namenode->flags, nifd->namenode->divert && nifd->namenode->divert->useinstead ? nifd->namenode->divert->useinstead->name : ""); if (nifd->namenode->divert && nifd->namenode->divert->camefrom) { divpkg= nifd->namenode->divert->pkg; if (divpkg) { forcibleerr(fc_overwritediverted, _("trying to overwrite `%.250s', which is the " "diverted version of `%.250s' (package: %.100s)"), nifd->namenode->name, nifd->namenode->divert->camefrom->name, divpkg->name); } else { forcibleerr(fc_overwritediverted, _("trying to overwrite `%.250s', which is the " "diverted version of `%.250s'"), nifd->namenode->name, nifd->namenode->divert->camefrom->name); } } usename= namenodetouse(nifd->namenode,tc->pkg)->name + 1; /* Skip the leading `/' */ if (nifd->namenode->flags & fnnf_new_conff) { /* If it's a conffile we have to extract it next to the installed * version (ie, we do the usual link-following). */ if (conffderef(tc->pkg, &conffderefn, usename)) usename= conffderefn.buf; debug(dbg_conff,"tarobject fnnf_new_conff deref=`%s'",usename); } setupfnamevbs(usename); statr= lstat(fnamevb.buf,&stab); if (statr) { /* The lstat failed. */ if (errno != ENOENT && errno != ENOTDIR) ohshite(_("unable to stat `%.255s' (which I was about to install)"),ti->Name); /* OK, so it doesn't exist. * However, it's possible that we were in the middle of some other * backup/restore operation and were rudely interrupted. * So, we see if we have .dpkg-tmp, and if so we restore it. */ if (rename(fnametmpvb.buf,fnamevb.buf)) { if (errno != ENOENT && errno != ENOTDIR) ohshite(_("unable to clean up mess surrounding `%.255s' before " "installing another version"),ti->Name); debug(dbg_eachfiledetail,"tarobject nonexistent"); } else { debug(dbg_eachfiledetail,"tarobject restored tmp to main"); statr= lstat(fnamevb.buf,&stab); if (statr) ohshite(_("unable to stat restored `%.255s' before installing" " another version"), ti->Name); } } else { debug(dbg_eachfiledetail,"tarobject already exists"); } /* Check to see if it's a directory or link to one and we don't need to * do anything. This has to be done now so that we don't die due to * a file overwriting conflict. */ existingdirectory= 0; switch (ti->Type) { case SymbolicLink: /* If it's already an existing directory, do nothing. */ if (!statr && S_ISDIR(stab.st_mode)) { debug(dbg_eachfiledetail,"tarobject SymbolicLink exists as directory"); existingdirectory= 1; } else if (!statr && S_ISLNK(stab.st_mode)) { if (linktosameexistingdir(ti, fnamevb.buf, &symlinkfn)) existingdirectory= 1; } break; case Directory: /* If it's already an existing directory, do nothing. */ if (!stat(fnamevb.buf,&stabtmp) && S_ISDIR(stabtmp.st_mode)) { debug(dbg_eachfiledetail,"tarobject Directory exists"); existingdirectory= 1; } break; case NormalFile0: case NormalFile1: case CharacterDevice: case BlockDevice: case FIFO: case HardLink: break; default: ohshit(_("archive contained object `%.255s' of unknown type 0x%x"),ti->Name,ti->Type); } keepexisting= 0; if (!existingdirectory) { for (packageslump= nifd->namenode->packages; packageslump; packageslump= packageslump->more) { for (i=0; i < PERFILEPACKAGESLUMP && packageslump->pkgs[i]; i++) { otherpkg= packageslump->pkgs[i]; if (otherpkg == tc->pkg) continue; debug(dbg_eachfile, "tarobject ... found in %s",otherpkg->name); if (nifd->namenode->divert && nifd->namenode->divert->useinstead) { /* Right, so we may be diverting this file. This makes the conflict * OK iff one of us is the diverting package (we don't need to * check for both being the diverting package, obviously). */ divpkg= nifd->namenode->divert->pkg; debug(dbg_eachfile, "tarobject ... diverted, divpkg=%s", divpkg ? divpkg->name : ""); if (otherpkg == divpkg || tc->pkg == divpkg) continue; } /* Nope ? Hmm, file conflict, perhaps. Check Replaces. */ switch (otherpkg->clientdata->replacingfilesandsaid) { case 2: keepexisting= 1; case 1: continue; } /* Is the package with the conflicting file in the `config files * only' state ? If so it must be a config file and we can * silenty take it over. */ if (otherpkg->status == stat_configfiles) continue; /* Perhaps we're removing a conflicting package ? */ if (otherpkg->clientdata->istobe == itb_remove) continue; /* Is the file an obsolete conffile in the other package * and a conffile in the new package ? */ if ((nifd->namenode->flags & fnnf_new_conff) && !statr && S_ISREG(stab.st_mode)) { for (conff= otherpkg->installed.conffiles; conff; conff= conff->next) { if (!conff->obsolete) continue; if (stat(conff->name, &stabtmp)) if (errno == ENOENT || errno == ENOTDIR || errno == ELOOP) continue; if (stabtmp.st_dev == stab.st_dev && stabtmp.st_ino == stab.st_ino) break; } if (conff) debug(dbg_eachfiledetail,"tarobject other's obsolete conffile"); /* processarc.c will have copied its hash already. */ continue; } if (does_replace(tc->pkg,&tc->pkg->available,otherpkg)) { printf(_("Replacing files in old package %s ...\n"),otherpkg->name); otherpkg->clientdata->replacingfilesandsaid= 1; } else if (does_replace(otherpkg,&otherpkg->installed,tc->pkg)) { printf(_("Replaced by files in installed package %s ...\n"), otherpkg->name); otherpkg->clientdata->replacingfilesandsaid= 2; keepexisting = 1; } else { if (!statr && S_ISDIR(stab.st_mode)) { forcibleerr(fc_overwritedir, _("trying to overwrite directory `%.250s' " "in package %.250s with nondirectory"), nifd->namenode->name,otherpkg->name); } else { /* WTA: At this point we are replacing something without a Replaces. * if the new object is a directory and the previous object does not * exist assume it's also a directory and don't complain */ if (! (statr && ti->Type==Directory)) forcibleerr(fc_overwrite, _("trying to overwrite `%.250s', which is also in package %.250s"), nifd->namenode->name,otherpkg->name); } } } } } /* Now, at this stage we want to make sure neither of .dpkg-new and .dpkg-tmp * are hanging around. */ ensure_pathname_nonexisting(fnamenewvb.buf); ensure_pathname_nonexisting(fnametmpvb.buf); if (existingdirectory) return 0; if (keepexisting) { obstack_free(&tar_obs, nifd); tc->newfilesp= oldnifd; *oldnifd = NULL; /* We need to advance the tar file to the next object, so read the * file data and set it to oblivion. */ if ((ti->Type == NormalFile0) || (ti->Type == NormalFile1)) { char fnamebuf[256]; fd_null_copy(tc->backendpipe, ti->Size, _("gobble replaced file `%.255s'"),quote_filename(fnamebuf,256,ti->Name)); r= ti->Size % TARBLKSZ; if (r > 0) r= safe_read(tc->backendpipe,databuf,TARBLKSZ - r); } return 0; } /* Now we start to do things that we need to be able to undo * if something goes wrong. Watch out for the CLEANUP comments to * keep an eye on what's installed on the disk at each point. */ push_cleanup(cu_installnew, ~ehflag_normaltidy, NULL, 0, 1, (void *)nifd); /* CLEANUP: Now we either have the old file on the disk, or not, in * its original filename. */ #ifdef WITH_SELINUX /* Set selinux_enabled if it is not already set (singleton) */ if (selinux_enabled < 0) selinux_enabled = (is_selinux_enabled() > 0); /* Since selinux is enabled, try and set the context */ if (selinux_enabled > 0) { /* * well, we could use * void set_matchpathcon_printf(void (*f)(const char *fmt, ...)); * to redirect the errors from the following bit, but that * seems too much effort. */ /* * Do nothing if we can't figure out what the context is, * or if it has no context; in which case the default * context shall be applied. */ if( ! ((matchpathcon(fnamevb.buf, (nifd->namenode->statoverride ? nifd->namenode->statoverride->mode : ti->Mode) & ~S_IFMT, &scontext) != 0) || (strcmp(scontext, "<>") == 0))) { if(setfscreatecon(scontext) < 0) perror("Error setting security context for file object:"); } } #endif /* WITH_SELINUX */ /* Extract whatever it is as .dpkg-new ... */ switch (ti->Type) { case NormalFile0: case NormalFile1: /* We create the file with mode 0 to make sure nobody can do anything with * it until we apply the proper mode, which might be a statoverride. */ fd= open(fnamenewvb.buf, (O_CREAT|O_EXCL|O_WRONLY), 0); if (fd < 0) ohshite(_("unable to create `%.255s'"),ti->Name); push_cleanup(cu_closefd, ehflag_bombout, NULL, 0, 1, &fd); debug(dbg_eachfiledetail,"tarobject NormalFile[01] open size=%lu", (unsigned long)ti->Size); { char fnamebuf[256]; fd_fd_copy(tc->backendpipe, fd, ti->Size, _("backend dpkg-deb during `%.255s'"),quote_filename(fnamebuf,256,ti->Name)); } r= ti->Size % TARBLKSZ; if (r > 0) r= safe_read(tc->backendpipe,databuf,TARBLKSZ - r); if (nifd->namenode->statoverride) debug(dbg_eachfile, "tarobject ... stat override, uid=%d, gid=%d, mode=%04o", nifd->namenode->statoverride->uid, nifd->namenode->statoverride->gid, nifd->namenode->statoverride->mode); if (fchown(fd, nifd->namenode->statoverride ? nifd->namenode->statoverride->uid : ti->UserID, nifd->namenode->statoverride ? nifd->namenode->statoverride->gid : ti->GroupID)) ohshite(_("error setting ownership of `%.255s'"),ti->Name); am=(nifd->namenode->statoverride ? nifd->namenode->statoverride->mode : ti->Mode) & ~S_IFMT; if (fchmod(fd,am)) ohshite(_("error setting permissions of `%.255s'"),ti->Name); pop_cleanup(ehflag_normaltidy); /* fd= open(fnamenewvb.buf) */ if (close(fd)) ohshite(_("error closing/writing `%.255s'"),ti->Name); newtarobject_utime(fnamenewvb.buf,ti); break; case FIFO: if (mkfifo(fnamenewvb.buf,0)) ohshite(_("error creating pipe `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject FIFO"); newtarobject_allmodes(fnamenewvb.buf,ti, nifd->namenode->statoverride); break; case CharacterDevice: if (mknod(fnamenewvb.buf,S_IFCHR, ti->Device)) ohshite(_("error creating device `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject CharacterDevice"); newtarobject_allmodes(fnamenewvb.buf,ti, nifd->namenode->statoverride); break; case BlockDevice: if (mknod(fnamenewvb.buf,S_IFBLK, ti->Device)) ohshite(_("error creating device `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject BlockDevice"); newtarobject_allmodes(fnamenewvb.buf,ti, nifd->namenode->statoverride); break; case HardLink: varbufreset(&hardlinkfn); varbufaddstr(&hardlinkfn,instdir); varbufaddc(&hardlinkfn,'/'); varbufaddstr(&hardlinkfn,ti->LinkName); varbufaddc(&hardlinkfn,0); if (link(hardlinkfn.buf,fnamenewvb.buf)) ohshite(_("error creating hard link `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject HardLink"); newtarobject_allmodes(fnamenewvb.buf,ti, nifd->namenode->statoverride); break; case SymbolicLink: /* We've already cheched for an existing directory. */ if (symlink(ti->LinkName,fnamenewvb.buf)) ohshite(_("error creating symbolic link `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject SymbolicLink creating"); #ifdef HAVE_LCHOWN if (lchown(fnamenewvb.buf, nifd->namenode->statoverride ? nifd->namenode->statoverride->uid : ti->UserID, nifd->namenode->statoverride ? nifd->namenode->statoverride->gid : ti->GroupID)) ohshite(_("error setting ownership of symlink `%.255s'"),ti->Name); #else if (chown(fnamenewvb.buf, nifd->namenode->statoverride ? nifd->namenode->statoverride->uid : ti->UserID, nifd->namenode->statoverride ? nifd->namenode->statoverride->gid : ti->GroupID)) ohshite(_("error setting ownership of symlink `%.255s'"),ti->Name); #endif break; case Directory: /* We've already checked for an existing directory. */ if (mkdir(fnamenewvb.buf,0)) ohshite(_("error creating directory `%.255s'"),ti->Name); debug(dbg_eachfiledetail,"tarobject Directory creating"); newtarobject_allmodes(fnamenewvb.buf,ti,nifd->namenode->statoverride); break; default: internerr("bad tar type, but already checked"); } /* CLEANUP: Now we have extracted the new object in .dpkg-new (or, * if the file already exists as a directory and we were trying to extract * a directory or symlink, we returned earlier, so we don't need * to worry about that here). * * The old file is still in the original filename, */ /* First, check to see if it's a conffile. If so we don't install * it now - we leave it in .dpkg-new for --configure to take care of */ if (nifd->namenode->flags & fnnf_new_conff) { debug(dbg_conffdetail,"tarobject conffile extracted"); nifd->namenode->flags |= fnnf_elide_other_lists; return 0; } /* Now we move the old file out of the way, the backup file will * be deleted later. */ if (statr) { /* Don't try to back it up if it didn't exist. */ debug(dbg_eachfiledetail,"tarobject new - no backup"); } else { if (ti->Type == Directory || S_ISDIR(stab.st_mode)) { /* One of the two is a directory - can't do atomic install. */ debug(dbg_eachfiledetail,"tarobject directory, nonatomic"); nifd->namenode->flags |= fnnf_no_atomic_overwrite; if (rename(fnamevb.buf,fnametmpvb.buf)) ohshite(_("unable to move aside `%.255s' to install new version"),ti->Name); } else if (S_ISLNK(stab.st_mode)) { /* We can't make a symlink with two hardlinks, so we'll have to copy it. * (Pretend that making a copy of a symlink is the same as linking to it.) */ varbufreset(&symlinkfn); do { varbufextend(&symlinkfn); r= readlink(fnamevb.buf,symlinkfn.buf,symlinkfn.size); if (r<0) ohshite(_("unable to read link `%.255s'"),ti->Name); } while ((size_t)r == symlinkfn.size); symlinkfn.used= r; varbufaddc(&symlinkfn,0); if (symlink(symlinkfn.buf,fnametmpvb.buf)) ohshite(_("unable to make backup symlink for `%.255s'"),ti->Name); #ifdef HAVE_LCHOWN if (lchown(fnametmpvb.buf,stab.st_uid,stab.st_gid)) ohshite(_("unable to chown backup symlink for `%.255s'"),ti->Name); #else if (chown(fnametmpvb.buf,stab.st_uid,stab.st_gid)) ohshite(_("unable to chown backup symlink for `%.255s'"),ti->Name); #endif } else { debug(dbg_eachfiledetail,"tarobject nondirectory, `link' backup"); if (link(fnamevb.buf,fnametmpvb.buf)) ohshite(_("unable to make backup link of `%.255s' before installing new version"), ti->Name); } } /* CLEANUP: now the old file is in dpkg-tmp, and the new file is still * in dpkg-new. */ #ifdef WITH_SELINUX /* * if selinux is enabled, try and set the default security context * for the renamed file */ if (selinux_enabled > 0) if(scontext) { if(setfscreatecon(scontext) < 0) perror("Error setting security context for next file object:"); freecon(scontext); } #endif /* WITH_SELINUX */ if (rename(fnamenewvb.buf,fnamevb.buf)) ohshite(_("unable to install new version of `%.255s'"),ti->Name); /* CLEANUP: now the new file is in the destination file, and the * old file is in dpkg-tmp to be cleaned up later. We now need * to take a different attitude to cleanup, because we need to * remove the new file. */ nifd->namenode->flags |= fnnf_placed_on_disk; #ifdef WITH_SELINUX /* * if selinux is enabled, restore the default security context */ if (selinux_enabled > 0) if(setfscreatecon(NULL) < 0) perror("Error restoring default security context:"); #endif /* WITH_SELINUX */ nifd->namenode->flags |= fnnf_elide_other_lists; debug(dbg_eachfiledetail,"tarobject done and installed"); return 0; } static int try_deconfigure_can(int (*force_p)(struct deppossi*), struct pkginfo *pkg, struct deppossi *pdep, const char *action, struct pkginfo *removal, const char *why) { /* Also checks whether the pdep is forced, first, according to force_p. * force_p may be 0 in which case nothing is considered forced. * * Action is a string describing the action which causes the * deconfiguration: * removal of (due to Conflicts+Depends removal!=0) * installation of (due to Breaks removal==0) * * Return values: 2: forced (no deconfiguration needed, why is printed) * 1: deconfiguration queued ok (no message printed) * 0: not possible (why is printed) */ struct packageinlist *newdeconf; if (force_p && force_p(pdep)) { fprintf(stderr, _("dpkg: warning - " "ignoring dependency problem with %s:\n%s"), action, why); return 2; } else if (f_autodeconf) { if (pkg->installed.essential) { if (fc_removeessential) { fprintf(stderr, _("dpkg: warning - considering deconfiguration of essential\n" " package %s, to enable %s.\n"), pkg->name, action); } else { fprintf(stderr, _("dpkg: no, %s is essential, will not deconfigure\n" " it in order to enable %s.\n"), pkg->name, action); return 0; } } pkg->clientdata->istobe= itb_deconfigure; newdeconf= malloc(sizeof(struct packageinlist)); newdeconf->next= deconfigure; newdeconf->pkg= pkg; newdeconf->xinfo= removal; deconfigure= newdeconf; return 1; } else { fprintf(stderr, _("dpkg: no, cannot proceed with %s (--auto-deconfigure will help):\n%s"), action, why); return 0; } } static int try_remove_can(struct deppossi *pdep, struct pkginfo *fixbyrm, const char *why) { char action[512]; sprintf(action, _("removal of %.250s"), fixbyrm->name); return try_deconfigure_can(force_depends, pdep->up->up, pdep, action, fixbyrm, why); } void check_breaks(struct dependency *dep, struct pkginfo *pkg, const char *pfilename) { struct pkginfo *fixbydeconf; struct varbuf why; int ok; varbufinit(&why); fixbydeconf = NULL; if (depisok(dep, &why, &fixbydeconf, 0)) { varbuffree(&why); return; } varbufaddc(&why, 0); if (fixbydeconf && f_autodeconf) { char action[512]; ensure_package_clientdata(fixbydeconf); assert(fixbydeconf->clientdata->istobe == itb_normal); sprintf(action, _("installation of %.250s"), pkg->name); fprintf(stderr, _("dpkg: considering deconfiguration of %s," " which would be broken by %s ...\n"), fixbydeconf->name, action); ok= try_deconfigure_can(force_breaks, fixbydeconf, dep->list, action, NULL, why.buf); if (ok == 1) { fprintf(stderr, _("dpkg: yes, will deconfigure %s (broken by %s).\n"), fixbydeconf->name, pkg->name); } } else { fprintf(stderr, _("dpkg: regarding %s containing %s:\n%s"), pfilename, pkg->name, why.buf); ok= 0; } varbuffree(&why); if (ok > 0) return; if (force_breaks(dep->list)) { fprintf(stderr, _("dpkg: warning - ignoring breakage," " may proceed anyway !\n")); return; } if (fixbydeconf && !f_autodeconf) { ohshit(_("installing %.250s would break %.250s, and\n" " deconfiguration is not permitted (--auto-deconfigure might help)"), pkg->name, fixbydeconf->name); } else { ohshit(_("installing %.250s would break existing software"), pkg->name); } } void check_conflict(struct dependency *dep, struct pkginfo *pkg, const char *pfilename) { struct pkginfo *fixbyrm; struct deppossi *pdep, flagdeppossi; struct varbuf conflictwhy, removalwhy; struct dependency *providecheck; varbufinit(&conflictwhy); varbufinit(&removalwhy); fixbyrm = NULL; if (depisok(dep, &conflictwhy, &fixbyrm, 0)) { varbuffree(&conflictwhy); varbuffree(&removalwhy); return; } if (fixbyrm) { ensure_package_clientdata(fixbyrm); if (fixbyrm->clientdata->istobe == itb_installnew) { fixbyrm= dep->up; ensure_package_clientdata(fixbyrm); } if (((pkg->available.essential && fixbyrm->installed.essential) || (((fixbyrm->want != want_install && fixbyrm->want != want_hold) || does_replace(pkg,&pkg->available,fixbyrm)) && (!fixbyrm->installed.essential || fc_removeessential)))) { assert(fixbyrm->clientdata->istobe == itb_normal || fixbyrm->clientdata->istobe == itb_deconfigure); fixbyrm->clientdata->istobe= itb_remove; fprintf(stderr, _("dpkg: considering removing %s in favour of %s ...\n"), fixbyrm->name, pkg->name); if (fixbyrm->status != stat_installed) { fprintf(stderr, _("%s is not properly installed - ignoring any dependencies on it.\n"), fixbyrm->name); pdep = NULL; } else { for (pdep= fixbyrm->installed.depended; pdep; pdep= pdep->nextrev) { if (pdep->up->type != dep_depends && pdep->up->type != dep_predepends) continue; if (depisok(pdep->up, &removalwhy, NULL, 0)) continue; varbufaddc(&removalwhy,0); if (!try_remove_can(pdep,fixbyrm,removalwhy.buf)) break; } if (!pdep) { /* If we haven't found a reason not to yet, let's look some more. */ for (providecheck= fixbyrm->installed.depends; providecheck; providecheck= providecheck->next) { if (providecheck->type != dep_provides) continue; for (pdep= providecheck->list->ed->installed.depended; pdep; pdep= pdep->nextrev) { if (pdep->up->type != dep_depends && pdep->up->type != dep_predepends) continue; if (depisok(pdep->up, &removalwhy, NULL, 0)) continue; varbufaddc(&removalwhy,0); fprintf(stderr, _("dpkg" ": may have trouble removing %s, as it provides %s ...\n"), fixbyrm->name, providecheck->list->ed->name); if (!try_remove_can(pdep,fixbyrm,removalwhy.buf)) goto break_from_both_loops_at_once; } } break_from_both_loops_at_once:; } } if (!pdep && skip_due_to_hold(fixbyrm)) { pdep= &flagdeppossi; } if (!pdep && (fixbyrm->eflag & eflagf_reinstreq)) { if (fc_removereinstreq) { fprintf(stderr, _("dpkg: package %s requires reinstallation, but will" " remove anyway as you request.\n"), fixbyrm->name); } else { fprintf(stderr, _("dpkg: package %s requires reinstallation, " "will not remove.\n"), fixbyrm->name); pdep= &flagdeppossi; } } if (!pdep) { if (cflict_index >= MAXCONFLICTORS) ohshit(_("package %s has too many Conflicts/Replaces pairs"), pkg->name); /* This conflict is OK - we'll remove the conflictor. */ conflictor[cflict_index++]= fixbyrm; varbuffree(&conflictwhy); varbuffree(&removalwhy); fprintf(stderr, _("dpkg: yes, will remove %s in favour of %s.\n"), fixbyrm->name, pkg->name); return; } fixbyrm->clientdata->istobe= itb_normal; /* put it back */ } } varbufaddc(&conflictwhy,0); fprintf(stderr, _("dpkg: regarding %s containing %s:\n%s"), pfilename, pkg->name, conflictwhy.buf); if (!force_conflicts(dep->list)) ohshit(_("conflicting packages - not installing %.250s"),pkg->name); fprintf(stderr, _("dpkg: warning - ignoring conflict, may proceed anyway !\n")); varbuffree(&conflictwhy); return; } void cu_cidir(int argc, void **argv) { char *cidir= (char*)argv[0]; char *cidirrest= (char*)argv[1]; cidirrest[-1]= 0; ensure_pathname_nonexisting(cidir); } void cu_fileslist(int argc, void **argv) { destroyobstack(); } void archivefiles(const char *const *argv) { const char *volatile thisarg; const char *const *volatile argp; jmp_buf ejbuf; int pi[2], fc, nfiles, c, i, r; FILE *pf; static struct varbuf findoutput; const char **arglist; char *p; modstatdb_init(admindir, f_noact ? msdbrw_readonly : cipaction->arg == act_avail ? msdbrw_write : fc_nonroot ? msdbrw_write : msdbrw_needsuperuser); checkpath(); if (f_recursive) { if (!*argv) badusage(_("--%s --recursive needs at least one path argument"),cipaction->olong); m_pipe(pi); if (!(fc= m_fork())) { const char *const *ap; int i; m_dup2(pi[1],1); close(pi[0]); close(pi[1]); for (i=0, ap=argv; *ap; ap++, i++); arglist = m_malloc(sizeof(char *) * (i + 15)); arglist[0] = FIND; for (i=1, ap=argv; *ap; ap++, i++) { if (strchr(FIND_EXPRSTARTCHARS,(*ap)[0])) { char *a; a= m_malloc(strlen(*ap)+10); strcpy(a,"./"); strcat(a,*ap); arglist[i] = a; } else { arglist[i] = (const char *)*ap; } } /* When editing these, make sure that arglist is malloced big enough, * above. */ arglist[i++] = "-follow"; arglist[i++] = "-name"; arglist[i++] = ARCHIVE_FILENAME_PATTERN; arglist[i++] = "-type"; arglist[i++] = "f"; arglist[i++] = "-print0"; arglist[i++] = NULL; execvp(FIND, (char *const *)arglist); ohshite(_("failed to exec find for --recursive")); } close(pi[1]); nfiles= 0; pf= fdopen(pi[0],"r"); if (!pf) ohshite(_("failed to fdopen find's pipe")); varbufreset(&findoutput); while ((c= fgetc(pf)) != EOF) { varbufaddc(&findoutput,c); if (!c) nfiles++; } if (ferror(pf)) ohshite(_("error reading find's pipe")); if (fclose(pf)) ohshite(_("error closing find's pipe")); r= waitsubproc(fc,"find",PROCNOERR); if(!(r==0 || r==1)) ohshit(_("find for --recursive returned unhandled error %i"),r); if (!nfiles) ohshit(_("searched, but found no packages (files matching *.deb)")); varbufaddc(&findoutput,0); varbufaddc(&findoutput,0); arglist= m_malloc(sizeof(char*)*(nfiles+1)); p= findoutput.buf; i=0; while (*p) { arglist[i++]= p; while ((c= *p++) != 0); } arglist[i] = NULL; argp= arglist; } else { if (!*argv) badusage(_("--%s needs at least one package archive file argument"), cipaction->olong); argp= argv; } currenttime = time(NULL); varbufinit(&fnamevb); varbufinit(&fnametmpvb); varbufinit(&fnamenewvb); varbufaddstr(&fnamevb,instdir); varbufaddc(&fnamevb,'/'); varbufaddstr(&fnametmpvb,instdir); varbufaddc(&fnametmpvb,'/'); varbufaddstr(&fnamenewvb,instdir); varbufaddc(&fnamenewvb,'/'); fnameidlu= fnamevb.used; ensure_diversions(); ensure_statoverrides(); while ((thisarg = *argp++) != NULL) { if (setjmp(ejbuf)) { error_unwind(ehflag_bombout); if (onerr_abort > 0) break; continue; } push_error_handler(&ejbuf,print_error_perpackage,thisarg); process_archive(thisarg); onerr_abort++; if (ferror(stdout)) werr("stdout"); if (ferror(stderr)) werr("stderr"); onerr_abort--; set_error_display(NULL, NULL); error_unwind(ehflag_normaltidy); } switch (cipaction->arg) { case act_install: case act_configure: case act_remove: case act_purge: process_queue(); case act_unpack: case act_avail: break; default: internerr("unknown action"); } modstatdb_shutdown(); } int wanttoinstall(struct pkginfo *pkg, const struct versionrevision *ver, int saywhy) { /* Decide whether we want to install a new version of the package. * ver is the version we might want to install. If saywhy is 1 then * if we skip the package we say what we are doing (and, if we are * selecting a previously deselected package, say so and actually do * the select). want_install returns 0 if the package should be * skipped and 1 if it should be installed. * * ver may be 0, in which case saywhy must be 0 and want_install may * also return -1 to mean it doesn't know because it would depend on * the version number. */ int r; if (pkg->want != want_install && pkg->want != want_hold) { if (f_alsoselect) { if (saywhy) { printf(_("Selecting previously deselected package %s.\n"),pkg->name); pkg->want= want_install; } return 1; } else { if (saywhy) printf(_("Skipping deselected package %s.\n"),pkg->name); return 0; } } if (pkg->status != stat_installed) return 1; if (!ver) return -1; r= versioncompare(ver,&pkg->installed.version); if (r > 0) { return 1; } else if (r == 0) { if (f_skipsame && /* same version fully installed ? */ pkg->status == stat_installed && !(pkg->eflag &= eflagf_reinstreq)) { if (saywhy) fprintf(stderr, _("Version %.250s of %.250s already installed, " "skipping.\n"), versiondescribe(&pkg->installed.version, vdew_nonambig), pkg->name); return 0; } else { return 1; } } else { if (fc_downgrade) { if (saywhy) fprintf(stderr, _("%s - warning: downgrading %.250s " "from %.250s to %.250s.\n"), DPKG, pkg->name, versiondescribe(&pkg->installed.version, vdew_nonambig), versiondescribe(&pkg->available.version, vdew_nonambig)); return 1; } else { if (saywhy) fprintf(stderr, _("Will not downgrade %.250s from version %.250s " "to %.250s, skipping.\n"), pkg->name, versiondescribe(&pkg->installed.version, vdew_nonambig), versiondescribe(&pkg->available.version, vdew_nonambig)); return 0; } } } struct fileinlist *newconff_append(struct fileinlist ***newconffileslastp_io, struct filenamenode *namenode) { struct fileinlist *newconff; newconff= m_malloc(sizeof(struct fileinlist)); newconff->next = NULL; newconff->namenode= namenode; **newconffileslastp_io= newconff; *newconffileslastp_io= &newconff->next; return newconff; } /* vi: ts=8 sw=2 */