This file is indexed.

/usr/share/dbconfig-common/dpkg/postinst is in dbconfig-common 2.0.8.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
# -*- mode: sh -*-
###
### load up common variables and functions
###
dbc_go(){
    local importing_from_non_dbc upgrading reconfiguring f tsubstfile upgrades_pending dbc_dumpfile _dbc_asuser reinstall nowtime need_adminpw _tmp_result

    . /usr/share/dbconfig-common/dpkg/common
    _dbc_debug "(postinst) dbc_go() $@"

    ## With dbconfig-no-thanks installed we don't need to do anything.
    if dbc_no_thanks ; then
        return 0
    fi

    dbc_config "$@" || return $?
    # the maintainer has the option of telling us to not generate include files
    # for manual installs in case it changes the apps behavior to have the file
    dbc_dgi_on_manual=${dbc_dgi_on_manual:-true}

    ###
    ### begin main code execution
    ###
    if [ "$dbc_command" = "configure" ] || [ "$dbc_command" = "reconfigure" ];
    then
        # read in debconf responses (which are seeded from the config)
        dbc_read_package_debconf || return $?
        # and write them to file.
        dbc_write_package_config || return $?
        # finally, re-read in the configuration from this file
        dbc_read_package_config || return $?

        ###
        ### if they don't want our help, quit
        ###
        if [ "$dbc_install" != "true" ]; then
            # Probably a little too much in most cases, but it is possible
            # that the app password is loaded or that the user backed up after
            # providing the admin password and decided not too install in the end
            dbc_postinst_cleanup || return $?
            return 0
        fi

        # export the config file if it exists, for the scripts
        if [ "$dbc_generate_include" ]; then
            # strip the leading format string for convenience
            dbc_config_include=$(echo "$dbc_generate_include" | sed -e 's/^[^:]*://')
            export dbc_generate_include
            export dbc_config_include
        fi

        # find out if we're upgrading/reinstalling
        if [ "$dbc_oldversion" ]; then
            # read that little crumb left in config if we're reconfiguring
            db_get $dbc_package/internal/reconfiguring && reconfiguring="$RET"
            # if not, we're definitely upgrading
            if [ "$reconfiguring" = "false" ]; then
                upgrading="yes"
            else
                db_get $dbc_package/dbconfig-reinstall && reinstall=$RET
                # if they've said they don't want to reinstall stuff...
                if [ "$reinstall" = "false" ]; then
                    dbc_postinst_cleanup
                    return 0
                fi
            fi
        fi

        # now, determine if we're upgrading from a non-dbc version.  if so,
        # there's a bunch of stuff that we do NOT want to do
        if [ "$upgrading" ] && [ "$dbc_first_version" ]; then
            if dpkg --compare-versions "$dbc_first_version" gt "$dbc_oldversion"; then
                dbc_logline "detected upgrade from previous non-dbconfig version"
                importing_from_non_dbc="true"
            fi
        fi

        # don't perform the following block of code during upgrades
        if [ ! "$upgrading" ]; then
            ###
            ### first things first, see if the database client package is installed,
            ### and in case of failure provide a more sensible error message.
            ###
            dbc_detect_installed_dbtype $dbc_dbtype || \
                dbc_missing_db_package_error $dbc_dbclientpackage || return $?
            [ "$dbc_tried_again" ] && return 0

            ###
            ### next, if we're connecting to a local database,
            ### see if the database server package is installed,
            ### and in case of failure provide a more sensible error message.
            ###
            if [ "$dbc_method" = "unix socket" ]; then
                $dbc_db_installed_cmd || dbc_missing_db_package_error $dbc_dbpackage || \
                    return $?
                [ "$dbc_tried_again" ] && return 0
            fi

            ###
            ### now, create the app user account
            ###

            # We check in multiple locations if we need the admin password to
            # either create the user and/or the database and/or run admin
            # scripts. We do that here in postinst instead of during config
            # because we want to avoid asking the password as much as possible
            # to enable setups where the system admin doesn't have database
            # admin rights (mostly remote db setups) and the installing package
            # doesn't need it for its scripts.

            _dbc_asuser=true
            _tmp_result=0
            $dbc_checkuser_cmd || _tmp_result=$?
            _dbc_asuser=""
            if [ $_tmp_result = 0 ] ; then
                dbc_logline "$dbc_dbuser already exists and has privileges on $dbc_dbname"
            else
                dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                [ "$dbc_tried_again" ] && return 0
                $dbc_createuser_cmd || dbc_install_error "creating user" || return $?
                [ "$dbc_tried_again" ] && return 0
            fi
            
            ###
            ### If we are reconfiguring, we should empty the old database
            ### to prevent errors like "table exists".
            ###
            if [ "$reconfiguring" = "true" ]; then
                # dump the database into a temporary file
                # Note: nearly equal logic exists in prerm; probably
                # should stay in sync
                nowtime=$(date +%Y-%m-%d-%H.%M)
                if [ ! $(dirname /var/tmp/$dbc_package) = /var/tmp ]; then
                    mkdir -p $(dirname /var/tmp/$dbc_package)
                fi
                dbc_dumpfile=$(mktemp /var/tmp/$dbc_package.$dbc_dbname.$nowtime.$dbc_dbtype.XXXXXX)
                if [ ! -f $dbc_dumpfile ]; then
                    dbc_install_error "creating temporary file for database dump" || return $?
                    [ "$dbc_tried_again" ] && return 0
                fi

                dbc_logline "dbconfig-common: dumping $dbc_dbtype database $dbc_dbname to $dbc_dumpfile"
                # Dump as user to enable admin password agnostic setups.
                _dbc_asuser=true
                _tmp_result=0
                $dbc_dump_cmd $dbc_dumpfile || _tmp_result=$?
                if [ $_tmp_result != 0 ] ; then
                    # If the dump fails as user, try again with dbadmin credentials (bug: #850190)
                    dbc_logline "dumping database as user failed, retrying with administrator credentials"
                    dbc_get_admin_pass || dbc_install_error "obtaining administator password" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                    _dbc_asuser=""
                    $dbc_dump_cmd $dbc_dumpfile || dbc_install_error "dumping old database" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                fi
                _dbc_asuser=""

                dbc_logline "dbconfig-common: dropping old $dbc_dbtype database $dbc_dbname"
                # Drop as user if possible to enable admin password agnostic
                # setups. Currently PostgreSQL doesn't support this.
                if [ "$dbc_dbtype" = pgsql ] ; then
                    dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                    [ "$dbc_tried_again" ] && return 0
                else
                    _dbc_asuser=true
                fi
                $dbc_dropdb_cmd || dbc_install_error "dropping old database" || return $?
                [ "$dbc_tried_again" ] && return 0
                _dbc_asuser=""
            fi

            ###
            ### create the database
            ###

            # Create database as user if possible to enable admin password
            # agnostic setups. Currently PostgreSQL doesn't support this.
            if [ "$dbc_dbtype" = pgsql ] ; then
                dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                [ "$dbc_tried_again" ] && return 0
            else
                _dbc_asuser=true
            fi
            $dbc_createdb_cmd || dbc_install_error "creating database" || return $?
            [ "$dbc_tried_again" ] && return 0
            _dbc_asuser=""

            ###
            ### populate the database
            ###
            # sqlfile is the file to use for installing the database
            dbc_sqlfile=$dbc_share/data/$dbc_basepackage/install/$dbc_dbtype
            dbc_sqlfile_adm=$dbc_share/data/$dbc_basepackage/install-dbadmin/$dbc_dbtype
            dbc_scriptfile=$dbc_share/scripts/$dbc_basepackage/install/$dbc_dbtype
            if [ -f "$dbc_scriptfile" ]; then
                dbc_logpart "populating database via scriptfile... "
                if ! sh -c "$dbc_scriptfile $*"; then
                    dbc_error="$dbc_scriptfile exited with non-zero status\nIf the script logged anything about what went wrong,\n it can be found in /var/log/apt/term.log."
                    dbc_install_error "populating database" || return $?
                    [ "$dbc_tried_again" ] && return 0
                fi
                dbc_logline "done"
            fi

            if [ -f "$dbc_sqlfile_adm" ]; then
                dbc_logpart "populating database via administrative sql... "
                if [ ! "$dbc_sql_substitutions" ]; then
                    $dbc_sqlfile_cmd $dbc_sqlfile_adm || \
                        dbc_install_error "populating database with administrative sql" || \
                        return $?                    
                    [ "$dbc_tried_again" ] && return 0
                else
                    tsubstfile=$(dbc_mktemp)
                    /usr/sbin/dbconfig-generate-include -f template -o template_infile=$dbc_sqlfile_adm $dbc_packageconfig > $tsubstfile
                    $dbc_sqlfile_cmd $tsubstfile || \
                        dbc_install_error "populating database with administrative sql" || \
                        return $?
                    rm -f $tsubstfile
                    [ "$dbc_tried_again" ] && return 0
                fi
                dbc_logline "done"
            fi

            if [ -f "$dbc_sqlfile" ]; then
                dbc_logpart "populating database via sql... "
                _dbc_asuser="yes"
                if [ ! "$dbc_sql_substitutions" ]; then
                    $dbc_sqlfile_cmd $dbc_sqlfile || dbc_install_error "populating database" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                else
                    tsubstfile=$(dbc_mktemp)
                    /usr/sbin/dbconfig-generate-include -f template -o template_infile=$dbc_sqlfile $dbc_packageconfig > $tsubstfile
                    $dbc_sqlfile_cmd $tsubstfile || dbc_install_error "populating database" || \
                        return $?
                    rm -f $tsubstfile
                    [ "$dbc_tried_again" ] && return 0
                fi
                _dbc_asuser=""
                dbc_logline "done"
            fi

            # now that we are sure that the database has been
            # (re-)installed, we can reset the purge flag.
            db_set $dbc_package/purge false
            db_fset $dbc_package/purge seen false
        fi

        # end install/reconfigure section

        if [ "$importing_from_non_dbc" ]; then
            if ! $dbc_checkuser_command; then
                upgrade_error "importing dbconfig-settings" || return $?
                [ "$dbc_tried_again" ] && return 0
            fi
        fi

        # begin upgrade section

        if [ "$upgrading" ]; then

            # Initialize need_adminpw to false, only set to true when we find
            # upgrade queries that require admin rights to avoid needless
            # querying the sysadmin
            need_adminpw="false"
            # next call may change need_adminpw
            upgrades_pending=$(_dbc_find_upgrades)

            # if there are any upgrades to be applied
            if [ "$upgrades_pending" ]; then
                # ask if they want our help in the process at all
                # but only if they didn't see the question before
                # or if we are here after an error
                db_set $dbc_package/dbconfig-upgrade $dbc_upgrade
                db_input $dbc_prio_high $dbc_package/dbconfig-upgrade || true
                db_go || true
                db_get $dbc_package/dbconfig-upgrade && dbc_upgrade="$RET"

                # and if they don't want our help, we'll go away
                if [ "$dbc_upgrade" != "true" ]; then return 0; fi

                # get the admin password if it's needed
                if [ "$need_adminpw" != "false" ] ; then
                    if echo "$dbc_authenticated_dbtypes" | grep -q "$dbc_dbtype"; then
                        if [ ! "$dbc_frontend" ]; then
                            if [ ! "$dbc_dbtype" = "pgsql" ] || [ ! "$dbc_authmethod_admin" = "ident" ]; then
                                dbc_get_admin_pass || return $?
                            fi
                        fi
                    fi
                fi

                db_input $dbc_prio_low $dbc_package/upgrade-backup || true
                db_go || true
                db_get $dbc_package/upgrade-backup && dbc_backup="$RET"

                if [ "$dbc_backup" = "true" ] ; then
                    # this is the file into which upgrade backups go
                    nowtime=$(date +%Y-%m-%d-%H.%M.%S)
                    dbc_dumpfile=/var/cache/dbconfig-common/backups/${dbc_package}_${dbc_oldversion}.$dbc_dbtype_$nowtime
                    dbc_logline "creating database backup in $dbc_dumpfile"
                    # backup before we upgrade
                    _dbc_asuser="yes"
                    _tmp_result=0
                    $dbc_dump_cmd $dbc_dumpfile || _tmp_result=$?
                    if [ $_tmp_result != 0 ] ; then
                        # If the dump fails as user, try again with dbadmin credentials (bug: #850190)
                        dbc_logline "dumping database as user failed, retrying with administrator credentials"
                        dbc_get_admin_pass || dbc_upgrade_error "obtaining administator password" || \
                            return $?
                        [ "$dbc_tried_again" ] && return 0
                        _dbc_asuser=""
                        $dbc_dump_cmd $dbc_dumpfile || dbc_upgrade_error "backing up the old database" || \
                            return $?
                        [ "$dbc_tried_again" ] && return 0
                    fi
                    _dbc_asuser=""
                fi
            fi

            # now perform the updates
            for f in $upgrades_pending; do
                _dbc_apply_upgrades $f || return $?
            done

        fi
        # end upgrade section
    fi

    # don't forget to clean up after ourselves
    dbc_postinst_cleanup
}


##
## search through the predefined upgrade directories, and return
## the versions for which *some* upgrade is available.  later for each
## upgrade version with a script we again search through the predefined
## directories to find which upgrade provides it.  it's definitely
## less efficient this way, but it's much cleaner and ensures that
## upgrades are provided in-order regardless of which methods are used.
##
_dbc_find_upgrades(){
    local f s sqldir admsqldir scriptdir upgradedirs pending sorted placed tlist
    # check for new upgrades in these three locations
    sqldir=$dbc_share/data/$dbc_basepackage/upgrade/$dbc_dbtype
    admsqldir=$dbc_share/data/$dbc_basepackage/upgrade-dbadmin/$dbc_dbtype
    scriptdir=$dbc_share/scripts/$dbc_basepackage/upgrade/$dbc_dbtype

    for f in $sqldir $admsqldir $scriptdir; do
        if [ -d "$f" ]; then
            upgradedirs="${upgradedirs:+$upgradedirs }$f"
        fi
    done

    if [ ! "${upgradedirs:-}" ]; then return 0; fi

    for f in $(find $upgradedirs -xtype f -print0 | \
              xargs --no-run-if-empty -0 -n1 basename | sort -n | uniq); do
        if dpkg --compare-versions $dbc_oldversion lt $f; then
            pending="${pending:+$pending }$f"
        fi
    done

    # for each pending update
    for f in ${pending:-}; do
        if [ -f "$admsqldir/$f" ] ; then
            # If the pending update was in the dbadmin dir we
            # need the adminpw
            need_adminpw="true"
        fi
        # if the sorted list is empty
        if [ ! "${sorted:-}" ]; then
            sorted="$f"
        else
            # a scratch list for a sorted insert of the next version
            tlist=""
            # for each already sorted version
            for s in ${sorted:-}; do
                # if we haven't already placed it
                if [ ! "${placed:-}" ]; then
                    # if the this version is less than the next sorted one
                    if dpkg --compare-versions $f lt $s; then
                        # insert it here
                        tlist="$tlist $f"
                        placed="yes"
                    fi
                fi
                tlist="$tlist $s"
            done
            # if we still haven't placed it, tack it on to the end of the list
            if [ ! "${placed:-}" ]; then
                tlist="$tlist $f"
            fi
            # and now reset the placed variable, and update the sorted list
            placed=""
            sorted="$tlist"
        fi
    done

    echo $sorted
}

##
## this function applies all available upgrade scripts/sql for a specific
## version ($1).  no checking is done to make sure that the upgrade *should*
## be applied, that is assumed to have been done by _dbc_find_upgrades().
##
_dbc_apply_upgrades(){
    local f vers sqlfile admsqlfile scriptfile
    _dbc_debug "_dbc_apply_upgrades() $@"
    # check for new upgrades in these three locations
    vers="$1"
    sqlfile="$dbc_share/data/$dbc_basepackage/upgrade/$dbc_dbtype/$vers"
    admsqlfile="$dbc_share/data/$dbc_basepackage/upgrade-dbadmin/$dbc_dbtype/$vers"
    scriptfile="$dbc_share/scripts/$dbc_basepackage/upgrade/$dbc_dbtype/$vers"


    # now go through script updates
    if [ -f "$scriptfile" ]; then
        dbc_logline "applying upgrade script for $dbc_oldversion -> $vers"
        # XXX $*
        if ! sh -c "$scriptfile $*"; then
            dbc_error="$scriptfile exited with non-zero status"
            dbc_upgrade_error "processing $scriptfile" || return $?
            [ "$dbc_tried_again" ] && return 0
        fi
    fi

    _dbc_asuser=""
    if [ -f "$admsqlfile" ]; then
        dbc_logline "applying upgrade admin sql for $dbc_oldversion -> $vers"
        $dbc_sqlfile_cmd $admsqlfile || dbc_upgrade_error "processing $admsqlfile" || return $?
        [ "$dbc_tried_again" ] && return 0
    fi

    if [ -f "$sqlfile" ]; then
        _dbc_asuser="yes"
        dbc_logline "applying upgrade sql for $dbc_oldversion -> $vers"
        $dbc_sqlfile_cmd $sqlfile || dbc_upgrade_error "processing $sqlfile" || return $?
        [ "$dbc_tried_again" ] && return 0
        _dbc_asuser=""
    fi
}