summaryrefslogtreecommitdiff
path: root/src/selfstrap
blob: 72fda3495406ed3fa2b9fccf95a1b4a9b8580096 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
#!/bin/bash
debian_mirror=http://httpredir.debian.org/debian
EXTRA_PACKAGES='apt debian-archive-keyring locales'

die() { printf 'Error: %s\n' "$*"; exit 1; }

usage()
{
    echo "Usage: $0 -t <target directory> [options] [packages]" >&2
    cat <<EOF
  Options:
    --target|-t        (Mandatory) Target directory
    --help|-h
    --verbose|-v
    --unpack           Only unpack; do not configure
    --chroot=<prog>    Use prog for chroot command
    --packages=<file>  Text file contains names of packages to install
    --real-apt         Use 'apt-get install' to install packages
EOF
    exit ${1:-1}
}

GETOPT=$(getopt -n "${0##*/}" -o t:hv --long help,target:,verbose,unpack,chroot:,packages:,real-apt -- "$@") || exit
eval set -- "$GETOPT"
while [ $# -gt 0 ]; do
    case "$1" in
        -t|--target) TARGET=$2; shift ;;
        -h|--help) usage 0 ;;
        -v|--verbose) VERBOSE=y ;;
        --unpack) UNPACK_ONLY=y; die 'unimplemented' ;;
        --packages) x=$(cat < "$2") || die "could not read file '$2'"
                    EXTRA_PACKAGES="$EXTRA_PACKAGES $x"
                    shift ;;
        --chroot) CHROOT_PROG=$2; shift ;;
        --real-apt) REAL_APT_INSTALL=y ;;
        --) shift; break ;;
        *) usage 1 ;;
    esac
    shift
done

[ "$TARGET" ] || usage

! [ "$REAL_APT_INSTALL" -a "$UNPACK_ONLY" ] || die "option --real-apt is incompatible with option --unpack"

EXTRA_PACKAGES="$EXTRA_PACKAGES $*"

am_root() { [ "$(id -u)" = 0 ]; }

current_debian_codename()
{
    # lsb_release -cs
    sed -ne 's/^VERSION=.* (\(.*\)).*/\1/p' /etc/os-release
}

sanity_checks()
{
    am_root || die 'you are not root'
    TARGET=$(realpath "$TARGET") || die 'realpath failed'
    [ "$TARGET" ] || die 'no $TARGET'
    [ -d "$TARGET" ] || mkdir "$TARGET" || die 'could not mkdir($TARGET)'
}

generate_apt_config()
{
    APT_CONFIG=$(mktemp) || exit
    chmod 644 "$APT_CONFIG"
    cat > "$APT_CONFIG" <<EOF
Dir::Etc "${TARGET}/etc/apt/";
Dir::Etc::Parts "${TARGET}/etc/apt/apt.conf.d/";
Dir::Etc::PreferencesParts "${TARGET}/etc/apt/preferences.d/";
EOF
    export APT_CONFIG
}

apt_()
{
    local apt_cmd="$1"
    shift

    [ "$TARGET" ] || die 'no $TARGET'
    [ "$APT_CONFIG" ] || die 'no $APT_CONFIG'

    if [ "$VERBOSE" ]; then
        printf "+ apt-${apt_cmd} %s\n" "$*" >&2
    fi

    set  --  -o  Apt::Install-Recommends=false                                "$@"

    # Set various paths to within the created system.
    set  --  -o  Apt::Architecture="$target_arch"                             "$@"
    set  --  -o  Apt::Default-Release="$target_release"                       "$@"
    set  --  -o  Dir="$TARGET"                                                "$@"
    set  --  -o  Dir::Cache="$TARGET"/var/cache/apt/                          "$@"
    set  --  -o  Dir::Etc::Parts="$TARGET"/etc/apt/apt.conf.d/                "$@"
    set  --  -o  Dir::Etc::PreferencesParts="$TARGET"/etc/apt/preferences.d/  "$@"
    set  --  -o  Dir::Etc="$TARGET"/etc/apt/                                  "$@"
    set  --  -o  Dir::State="$TARGET"/var/lib/apt/                            "$@"
    set  --  -o  Dir::State::Status="$TARGET"/var/lib/dpkg/status             "$@"

    # We must also set dpkg to use the created system.
    # Dpkg::options requires undocumented apt CLI magic.
    if [ "$DEBUG_DPKG" ]; then
        [ "$DEBUG_DPKG" -gt 0 ] 2>/dev/null || DEBUG_DPKG=10013
        set  --  -o  DPkg::options::arg0=--debug="${DEBUG_DPKG}"              "$@"
    fi
    # This is the important one:
    set  --  -o  DPkg::options::arg1=--root="$TARGET"                         "$@"
    set  --  -o  DPkg::options::arg2=--force-unsafe-io                        "$@"

    # Use the calling system for these.  This is an optimization.
    set  --  -o  Dir::Cache::archives=/var/cache/apt/archives                 "$@"
    set  --  -o  Dir::Etc::Trusted=/etc/apt/trusted.gpg                       "$@"
    set  --  -o  Dir::Etc::TrustedParts=/etc/apt/trusted.gpg.d                "$@"
    set  --  -o  Dir::State::Lists=/var/lib/apt/lists                         "$@"

    # Avoid deleting lists on the calling system.
    set  --  -o  APT::Get::List-Cleanup=false                                 "$@"

    apt-"${apt_cmd}" "$@"
}
apt_get() { apt_ get "$@"; }
apt_cache() { apt_ cache "$@"; }

idem() { if [ ! -e "${!#}" ]; then "$@"; fi; }
idem_mknod() { if [ ! -e "$3" ]; then mknod "$@"; fi; }

# This function is copied (with modifications) from debootstrap.
install_devices()
{
    [ "$TARGET" -a -d "$TARGET" ] || die 'no $TARGET'
    idem mkdir "$TARGET"/dev
    # The list of devices that can be created in a container comes from
    # src/core/cgroup.c in the systemd source tree.
    idem_mknod -m 666 "$TARGET"/dev/null  c 1 3
    idem_mknod -m 666 "$TARGET"/dev/zero  c 1 5
    idem_mknod -m 666 "$TARGET"/dev/full  c 1 7
    idem_mknod -m 666 "$TARGET"/dev/random        c 1 8
    idem_mknod -m 666 "$TARGET"/dev/urandom       c 1 9
    idem_mknod -m 666 "$TARGET"/dev/tty   c 5 0
    idem mkdir "$TARGET"/dev/pts/
    idem mkdir "$TARGET"/dev/shm/
    # Inside a container, we might not be allowed to create /dev/ptmx.
    # If not, do the next best thing.
    if ! idem_mknod -m 666 "$TARGET"/dev/ptmx c 5 2; then
        idem ln -s pts/ptmx "$TARGET"/dev/ptmx
    fi
    idem ln -s /proc/self/fd   "$TARGET"/dev/fd
    idem ln -s /proc/self/fd/0 "$TARGET"/dev/stdin
    idem ln -s /proc/self/fd/1 "$TARGET"/dev/stdout
    idem ln -s /proc/self/fd/2 "$TARGET"/dev/stderr
}

mount_virtfs()
{
    [ "$TARGET" ] || die 'no $TARGET'
    [ -d "$TARGET"/proc ] || mkdir "$TARGET"/proc
    [ -d "$TARGET"/sys  ] || mkdir "$TARGET"/sys
    mount -t proc proc "$TARGET"/proc
    mount -t sysfs sysfs "$TARGET"/sys
}

umount_virtfs()
{
    [ "$TARGET" ] || die 'no $TARGET'
    umount "$TARGET"/proc || fail=y
    umount "$TARGET"/sys || fail=y
    [ ! "$fail" ]
}

write_lines_once()
{
    local output="$1"
    shift
    [ -e "$output" ] || printf '%s\n' "$@" > "$output"
}

populate_rootfs()
{
    [ "$TARGET" ] || die 'no $TARGET'
    set -B
    mkdir -p \
          "$TARGET"/etc/apt/{preferences.d,apt.conf.d,trusted.gpg.d,sources.list.d} \
          "$TARGET"/var/{lib/{apt/lists/partial,dpkg/{info,parts,triggers,alternatives,updates}},cache/apt} \
          "$TARGET"/var/log/apt

    touch "$TARGET"/var/lib/dpkg/status

    [ -d "$TARGET"/usr/bin ] || mkdir -p "$TARGET"/usr/bin
    [ -e "$TARGET/usr/bin/awk" -o -L "$TARGET/usr/bin/awk" ] || ln -s mawk "$TARGET/usr/bin/awk"

    write_lines_once "$TARGET"/var/lib/dpkg/arch "$target_arch"
    write_lines_once "$TARGET"/etc/apt/sources.list \
                     "deb $debian_mirror $target_release main contrib non-free" \
                     "deb http://security.debian.org $target_release/updates main contrib non-free"
    install_devices
}

parse_apt_simul_line()
{
    set -- $*
    action=$1
    package=$2
    version=${3#\(}
    shift 3

    while [ "$1" ]; do
        case "$1" in
            *\))
                arch=${1%\)}
                arch=${arch#\[}
                arch=${arch%\]}
                return
                ;;
            *) shift ;;
        esac
    done
    return 1
}

dpkg_unpack()
{
    [ "$TARGET" -a -d "$TARGET" ] || die 'no $TARGET'
    local deb="$1" multiarch="$2" SET_STATUS="$3" command PKG
    PKG=${deb##*/}
    PKG=${PKG%%_*}
    PKG=$PKG$multiarch

    extract_tmp_ci "$deb"
    install_metadata_from_tmp_ci # uses TARGET PKG SET_STATUS
    remove_tmp_ci

    dpkg --fsys-tarfile "$deb" |
        (cd "$TARGET" && tar -xv) |
        sed 's?^\.??; s?^/$?/.?; s?/$??' > "$TARGET/var/lib/dpkg/info/$PKG.list"
}

install_metadata_from_tmp_ci() # uses TARGET PKG SET_STATUS
{
    (cd "$TARGET"/var/lib/dpkg/tmp.ci || die "cannot cd to /var/lib/dpkg/tmp.ci"
#    PKG=$(sed -n 's/^Package: *//p' control)
     for f in *; do
         [ "$f" = postinst ] && SET_STATUS=${SET_STATUS:+installed} || true
         [ "$f" = control ] || mv "$f" "$TARGET"/var/lib/dpkg/info/"$PKG"."$f"
     done
     if [ "$SET_STATUS" -a -e control ]; then
         (sed "/^Package:/a Status: install ok $SET_STATUS"; echo) < control >> "$TARGET"/var/lib/dpkg/status
     fi)
}

verbosely()
{
    if [ "$VERBOSE" ]; then
        (set -x; "$@")
    else
        "$@"
    fi
}

remove_tmp_ci()
{
    [ ! -e "$TARGET"/var/lib/dpkg/tmp.ci ] || rm -r "$TARGET"/var/lib/dpkg/tmp.ci
}

# /var/lib/dpkg/tmp.ci/control is read by debconf to determine the owner package
# See `grep -A3 control /usr/share/debconf/frontend`
extract_tmp_ci()
{
    local deb="$1"
    remove_tmp_ci
    mkdir "$TARGET"/var/lib/dpkg/tmp.ci
    dpkg --ctrl-tarfile "$deb" | tar -C "$TARGET"/var/lib/dpkg/tmp.ci -x
}

dpkg_configure_from_apt_actions()
{
    while read line; do
        parse_apt_simul_line "$line" || die "unexpected output from apt-get: $line"
        export LC_ALL=C
        export DEBIAN_FRONTEND=noninteractive
        export DPKG_MAINTSCRIPT_PACKAGE="$package" DPKG_MAINTSCRIPT_ARCH="$arch"
        is_multiarch_same "$package" && multiarch=":$arch" || multiarch=
        case "$action" in
            Inst)
                export DPKG_MAINTSCRIPT_NAME=preinst
                preinst=/var/lib/dpkg/info/${package}${multiarch}.preinst
                if [ -x "$TARGET"/"$preinst" ]; then
                    extract_tmp_ci "$deb"
                    verbosely ${CHROOT_PROG:-chroot} "$TARGET" "$preinst" install
                    remove_tmp_ci
                fi
                ;;
            Conf)
                export DPKG_MAINTSCRIPT_NAME=postinst
                postinst=/var/lib/dpkg/info/${package}${multiarch}.postinst
                if [ -x "$TARGET"/"$postinst" ]; then
                    extract_tmp_ci "$deb"
                    verbosely ${CHROOT_PROG:-chroot} "$TARGET" "$postinst" configure
                    remove_tmp_ci
                fi
                ;;
            Remv) ;;
            *) die "unexpected output from 'apt-get -s'" ;;
        esac
    done
}

apt_extract()
{
    apt_get -d -yqq install "$@"
    actions=$(mktemp) || die 'mktemp failed'
    apt_get -s -yqq install "$@" > "$actions" || die 'apt-get failed'

    dpkg_unpack_from_apt_actions < "$actions" || die 'dpkg unpack (using internal dpkg) failed'

    if [ ! "$UNPACK_ONLY" ]; then
        install_etc_passwd
        dpkg_configure_from_apt_actions < "$actions" || die 'dpkg configure (using internal dpkg) failed'
    fi

    rm "$actions"
}

dpkg_unpack_from_apt_actions()
{
    while read line; do

        parse_apt_simul_line "$line" || die "unexpected output from apt-get: $line"

        deb=/var/cache/apt/archives/${package}_${version//:/%3a}_${arch}.deb
        [ -f "$deb" ] || {
            echo "line=$line" >&2
            printf '%s\n' "$action" "$package" "$version" "$arch" >&2
            die "unexpected output from apt-get"
        }
        case "$action" in
            Inst)
                printf 'Unpacking %s\n' "${deb##*/}" >&2
                if [ "$REAL_APT_INSTALL" ]; then
                    dpkg --extract "$deb" "$TARGET" || die 'dpkg'
                else
                    is_multiarch_same "$package" && multiarch=":$arch" || multiarch=
                    [ "$UNPACK_ONLY" ] && set_status=unpacked || set_status=installed
                    dpkg_unpack "$deb" "$multiarch" "$set_status" || die "dpkg_unpack"
                fi
                ;;
            Conf) ;;
            Remv) ;;
            *) die "unexpected output from 'apt-get -s'" ;;
        esac
    done
}

install_etc_passwd()
{
    [ -e "$TARGET"/etc/passwd ] || cp "$TARGET"/usr/share/base-passwd/passwd.master "$TARGET"/etc/passwd
    [ -e "$TARGET"/etc/group  ] || cp "$TARGET"/usr/share/base-passwd/group.master  "$TARGET"/etc/group
}

required_packages()
{
    apt_cache dumpavail |
        perl -00 -ne '/^Priority: required/m || next; /^Package: (.*)$/m && print "$1\n"' |
        sort -u
}

declare -A is_multiarch_same
multicheck()
{
    local m
    if [ ! "$multichecked" ]; then
        for m in $(multiarch_same_packages); do
            is_multiarch_same[$m]=y
        done
    fi
    multichecked=y
}

multiarch_same_packages()
{
    apt_cache dumpavail |
        perl -00 -ne '/^Multi-Arch: same/mi || next; /^Package: (.*)$/m && print "$1\n"' |
        sort -u
}

is_multiarch_same()
{
    multicheck
    [ "${is_multiarch_same[$1]}" ]
}

set -e

target_arch=$(dpkg-architecture -q DEB_HOST_ARCH) || die 'dpkg-architecture failed'
target_release=$(current_debian_codename) && [ "$target_release" ] || die 'could not determine Debian release name'

# Set things up so apt-get update works.
sanity_checks
generate_apt_config
populate_rootfs
[ "$SKIP_UPDATE" ] || apt_get update

required_packages=$(required_packages) && [ "$required_packages" ] || die 'failed to determine list of required packages'

export LC_ALL=C
export DEBIAN_FRONTEND=noninteractive

if [ "$REAL_APT_INSTALL" ]; then
    # Some files need to be present before 'apt-get install' can install anything.
    # In particular:
    #
    #   1. binaries used by dpkg 'inst' scripts.
    #   2. /etc/passwd and /etc/group so that 'chown' works

    # Unpack required packages.  Handles (1)
    # Note: populate_rootfs() already created a necessary symlink /usr/bin/awk -> /usr/bin/mawk
    apt_extract $required_packages

    # This handles (2).
    # An alternative (used by debootstrap) is to configure base-passwd
    install_etc_passwd

    apt_get install -y $required_packages $EXTRA_PACKAGES
else
    apt_extract $required_packages
    apt_extract $EXTRA_PACKAGES
fi