usr.sbin/pkg/pkg.c

   1 /*-
   2  * Copyright (c) 2012 Baptiste Daroussin <bapt@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/elf_common.h>
  32 #include <sys/endian.h>
  33 #include <sys/wait.h>
  34
  35 #include <archive.h>
  36 #include <archive_entry.h>
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <fetch.h>
  42 #include <gelf.h>
  43 #include <paths.h>
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <time.h>
  48 #include <unistd.h>
  49
  50 #include "elf_tables.h"
  51
  52 #define _LOCALBASE "/usr/local"
  53 #define _PKGS_URL "http://pkgbeta.FreeBSD.org"
  54
  55 static const char *
  56 elf_corres_to_string(struct _elf_corres *m, int e)
  57 {
  58         int i;
  59
  60         for (i = 0; m[i].string != NULL; i++)
  61                 if (m[i].elf_nb == e)
  62                         return (m[i].string);
  63
  64         return ("unknown");
  65 }
  66
  67 static int
  68 pkg_get_myabi(char *dest, size_t sz)
  69 {
  70         Elf *elf;
  71         Elf_Data *data;
  72         Elf_Note note;
  73         Elf_Scn *scn;
  74         char *src, *osname;
  75         const char *abi;
  76         GElf_Ehdr elfhdr;
  77         GElf_Shdr shdr;
  78         int fd, i, ret;
  79         uint32_t version;
  80
  81         version = 0;
  82         ret = -1;
  83         scn = NULL;
  84         abi = NULL;
  85
  86         if (elf_version(EV_CURRENT) == EV_NONE) {
  87                 warnx("ELF library initialization failed: %s",
  88                     elf_errmsg(-1));
  89                 return (-1);
  90         }
  91
  92         if ((fd = open("/bin/sh", O_RDONLY)) < 0) {
  93                 warn("open()");
  94                 return (-1);
  95         }
  96
  97         if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
  98                 ret = -1;
  99                 warnx("elf_begin() failed: %s.", elf_errmsg(-1));
 100                 goto cleanup;
 101         }
 102
 103         if (gelf_getehdr(elf, &elfhdr) == NULL) {
 104                 ret = -1;
 105                 warn("getehdr() failed: %s.", elf_errmsg(-1));
 106                 goto cleanup;
 107         }
 108
 109         while ((scn = elf_nextscn(elf, scn)) != NULL) {
 110                 if (gelf_getshdr(scn, &shdr) != &shdr) {
 111                         ret = -1;
 112                         warn("getshdr() failed: %s.", elf_errmsg(-1));
 113                         goto cleanup;
 114                 }
 115
 116                 if (shdr.sh_type == SHT_NOTE)
 117                         break;
 118         }
 119
 120         if (scn == NULL) {
 121                 ret = -1;
 122                 warn("failed to get the note section");
 123                 goto cleanup;
 124         }
 125
 126         data = elf_getdata(scn, NULL);
 127         src = data->d_buf;
 128         for (;;) {
 129                 memcpy(&note, src, sizeof(Elf_Note));
 130                 src += sizeof(Elf_Note);
 131                 if (note.n_type == NT_VERSION)
 132                         break;
 133                 src += note.n_namesz + note.n_descsz;
 134         }
 135         osname = src;
 136         src += note.n_namesz;
 137         if (elfhdr.e_ident[EI_DATA] == ELFDATA2MSB)
 138                 version = be32dec(src);
 139         else
 140                 version = le32dec(src);
 141
 142         for (i = 0; osname[i] != '\0'; i++)
 143                 osname[i] = (char)tolower(osname[i]);
 144
 145         snprintf(dest, sz, "%s:%d:%s:%s",
 146             osname, version / 100000,
 147             elf_corres_to_string(mach_corres, (int)elfhdr.e_machine),
 148             elf_corres_to_string(wordsize_corres,
 149             (int)elfhdr.e_ident[EI_CLASS]));
 150
 151         ret = 0;
 152
 153         switch (elfhdr.e_machine) {
 154         case EM_ARM:
 155                 snprintf(dest + strlen(dest), sz - strlen(dest),
 156                     ":%s:%s:%s", elf_corres_to_string(endian_corres,
 157                     (int)elfhdr.e_ident[EI_DATA]),
 158                     (elfhdr.e_flags & EF_ARM_NEW_ABI) > 0 ?
 159                     "eabi" : "oabi",
 160                     (elfhdr.e_flags & EF_ARM_VFP_FLOAT) > 0 ?
 161                     "softfp" : "vfp");
 162                 break;
 163         case EM_MIPS:
 164                 /*
 165                  * this is taken from binutils sources:
 166                  * include/elf/mips.h
 167                  * mapping is figured out from binutils:
 168                  * gas/config/tc-mips.c
 169                  */
 170                 switch (elfhdr.e_flags & EF_MIPS_ABI) {
 171                 case E_MIPS_ABI_O32:
 172                         abi = "o32";
 173                         break;
 174                 case E_MIPS_ABI_N32:
 175                         abi = "n32";
 176                         break;
 177                 default:
 178                         if (elfhdr.e_ident[EI_DATA] ==
 179                             ELFCLASS32)
 180                                 abi = "o32";
 181                         else if (elfhdr.e_ident[EI_DATA] ==
 182                             ELFCLASS64)
 183                                 abi = "n64";
 184                         break;
 185                 }
 186                 snprintf(dest + strlen(dest), sz - strlen(dest),
 187                     ":%s:%s", elf_corres_to_string(endian_corres,
 188                     (int)elfhdr.e_ident[EI_DATA]), abi);
 189                 break;
 190         }
 191
 192 cleanup:
 193         if (elf != NULL)
 194                 elf_end(elf);
 195
 196         close(fd);
 197         return (ret);
 198 }
 199
 200 static int
 201 extract_pkg_static(int fd, char *p, int sz)
 202 {
 203         struct archive *a;
 204         struct archive_entry *ae;
 205         char *end;
 206         int ret, r;
 207
 208         ret = -1;
 209         a = archive_read_new();
 210         if (a == NULL) {
 211                 warn("archive_read_new");
 212                 return (ret);
 213         }
 214         archive_read_support_compression_all(a);
 215         archive_read_support_format_tar(a);
 216
 217         if (lseek(fd, 0, 0) == -1) {
 218                 warn("lseek");
 219                 goto cleanup;
 220         }
 221
 222         if (archive_read_open_fd(a, fd, 4096) != ARCHIVE_OK) {
 223                 warnx("archive_read_open_fd: %s", archive_error_string(a));
 224                 goto cleanup;
 225         }
 226
 227         ae = NULL;
 228         while ((r = archive_read_next_header(a, &ae)) == ARCHIVE_OK) {
 229                 end = strrchr(archive_entry_pathname(ae), '/');
 230                 if (end == NULL)
 231                         continue;
 232
 233                 if (strcmp(end, "/pkg-static") == 0) {
 234                         r = archive_read_extract(a, ae,
 235                             ARCHIVE_EXTRACT_OWNER | ARCHIVE_EXTRACT_PERM |
 236                             ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_ACL |
 237                             ARCHIVE_EXTRACT_FFLAGS | ARCHIVE_EXTRACT_XATTR);
 238                         strlcpy(p, archive_entry_pathname(ae), sz);
 239                         break;
 240                 }
 241         }
 242
 243         if (r == ARCHIVE_OK)
 244                 ret = 0;
 245         else
 246                 warnx("fail to extract pkg-static");
 247
 248 cleanup:
 249         archive_read_finish(a);
 250         return (ret);
 251
 252 }
 253
 254 static int
 255 install_pkg_static(char *path, char *pkgpath)
 256 {
 257         int pstat;
 258         pid_t pid;
 259
 260         switch ((pid = fork())) {
 261         case -1:
 262                 return (-1);
 263         case 0:
 264                 execl(path, "pkg-static", "add", pkgpath, (char *)NULL);
 265                 _exit(1);
 266         default:
 267                 break;
 268         }
 269
 270         while (waitpid(pid, &pstat, 0) == -1)
 271                 if (errno != EINTR)
 272                         return (-1);
 273
 274         if (WEXITSTATUS(pstat))
 275                 return (WEXITSTATUS(pstat));
 276         else if (WIFSIGNALED(pstat))
 277                 return (128 & (WTERMSIG(pstat)));
 278         return (pstat);
 279 }
 280
 281 static int
 282 bootstrap_pkg(void)
 283 {
 284         FILE *remote;
 285         FILE *config;
 286         char *site;
 287         char url[MAXPATHLEN];
 288         char conf[MAXPATHLEN];
 289         char abi[BUFSIZ];
 290         char tmppkg[MAXPATHLEN];
 291         char buf[10240];
 292         char pkgstatic[MAXPATHLEN];
 293         int fd, retry, ret;
 294         struct url_stat st;
 295         off_t done, r;
 296         time_t now;
 297         time_t last;
 298
 299         done = 0;
 300         last = 0;
 301         ret = -1;
 302         remote = NULL;
 303         config = NULL;
 304
 305         printf("Bootstrapping pkg please wait\n");
 306
 307         if (pkg_get_myabi(abi, MAXPATHLEN) != 0) {
 308                 warnx("failed to determine the system ABI");
 309                 return (-1);
 310         }
 311
 312         if (getenv("PACKAGESITE") != NULL)
 313                 snprintf(url, MAXPATHLEN, "%s/Latest/pkg.txz", getenv("PACKAGESITE"));
 314         else
 315                 snprintf(url, MAXPATHLEN, "%s/%s/latest/Latest/pkg.txz",
 316                     getenv("PACKAGEROOT") ? getenv("PACKAGEROOT") : _PKGS_URL,
 317                     getenv("ABI") ? getenv("ABI") : abi);
 318
 319         snprintf(tmppkg, MAXPATHLEN, "%s/pkg.txz.XXXXXX",
 320             getenv("TMPDIR") ? getenv("TMPDIR") : _PATH_TMP);
 321
 322         if ((fd = mkstemp(tmppkg)) == -1) {
 323                 warn("mkstemp()");
 324                 return (-1);
 325         }
 326
 327         retry = 3;
 328         do {
 329                 remote = fetchXGetURL(url, &st, "");
 330                 if (remote == NULL)
 331                         sleep(1);
 332         } while (remote == NULL && retry-- > 0);
 333
 334         if (remote == NULL)
 335                 goto fetchfail;
 336
 337         while (done < st.size) {
 338                 if ((r = fread(buf, 1, sizeof(buf), remote)) < 1)
 339                         break;
 340
 341                 if (write(fd, buf, r) != r) {
 342                         warn("write()");
 343                         goto cleanup;
 344                 }
 345
 346                 done += r;
 347                 now = time(NULL);
 348                 if (now > last || done == st.size)
 349                         last = now;
 350         }
 351
 352         if (ferror(remote))
 353                 goto fetchfail;
 354
 355         if ((ret = extract_pkg_static(fd, pkgstatic, MAXPATHLEN)) == 0)
 356                 ret = install_pkg_static(pkgstatic, tmppkg);
 357
 358         snprintf(conf, MAXPATHLEN, "%s/etc/pkg.conf",
 359             getenv("LOCALBASE") ? getenv("LOCALBASE") : _LOCALBASE);
 360
 361         if (access(conf, R_OK) == -1) {
 362                 site = strrchr(url, '/');
 363                 if (site == NULL)
 364                         goto cleanup;
 365                 site[0] = '\0';
 366                 site = strrchr(url, '/');
 367                 if (site == NULL)
 368                         goto cleanup;
 369                 site[0] = '\0';
 370
 371                 config = fopen(conf, "w+");
 372                 if (config == NULL)
 373                         goto cleanup;
 374                 fprintf(config, "packagesite: %s\n", url);
 375                 fclose(config);
 376         }
 377
 378         goto cleanup;
 379
 380 fetchfail:
 381         warnx("Error fetching %s: %s", url, fetchLastErrString);
 382
 383 cleanup:
 384         if (remote != NULL)
 385                 fclose(remote);
 386         close(fd);
 387         unlink(tmppkg);
 388
 389         return (ret);
 390 }
 391
 392 static const char confirmation_message[] =
 393 "The package management tool is not yet installed on your system.\n"
 394 "Do you want to fetch and install it now? [y/N]: ";
 395
 396 static int
 397 pkg_query_yes_no(void)
 398 {
 399         int ret, c;
 400
 401         c = getchar();
 402
 403         if (c == 'y' || c == 'Y')
 404                 ret = 1;
 405         else
 406                 ret = 0;
 407
 408         while (c != '\n' && c != EOF)
 409                 c = getchar();
 410
 411         return (ret);
 412 }
 413
 414 int
 415 main(__unused int argc, char *argv[])
 416 {
 417         char pkgpath[MAXPATHLEN];
 418
 419         snprintf(pkgpath, MAXPATHLEN, "%s/sbin/pkg",
 420             getenv("LOCALBASE") ? getenv("LOCALBASE") : _LOCALBASE);
 421
 422         if (access(pkgpath, X_OK) == -1) {
 423                 /*
 424                  * Do not ask for confirmation if either of stdin or stdout is
 425                  * not tty. Check the environment to see if user has answer
 426                  * tucked in there already.
 427                  */
 428                 if (getenv("ALWAYS_ASSUME_YES") == NULL &&
 429                     isatty(fileno(stdin))) {
 430                         printf("%s", confirmation_message);
 431                         if (pkg_query_yes_no() == 0)
 432                                 exit(EXIT_FAILURE);
 433                 }
 434                 if (bootstrap_pkg() != 0)
 435                         exit(EXIT_FAILURE);
 436         }
 437
 438         execv(pkgpath, argv);
 439
 440         /* NOT REACHED */
 441         return (EXIT_FAILURE);
 442 }