Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mage/usr/lib/mage/mage4.functions.sh

    Contents of /trunk/mage/usr/lib/mage/mage4.functions.sh

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 273 - (show annotations) (download) (as text)
    Fri Oct 21 14:50:13 2005 UTC (18 years, 6 months ago) by niro
    File MIME type: application/x-sh
    File size: 59490 byte(s) 
    fixed virtual_add and virtual_del calls with mutiple provides
    1 #!/bin/bash
    2 # Magellan Linux Installer Functions (mage.functions.sh)
    3 # $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/mage4.functions.sh,v 1.8 2005-10-21 14:50:13 niro Exp $
    4
    5 mage_setup()
    6 {
    7 [ ! -d ${MROOT}${INSTALLDB} ] && \
    8 install -d ${MROOT}${INSTALLDB}
    9 [ ! -f ${MROOT}${VIRTUALDB_FILE} ] && \
    10 touch ${MROOT}${VIRTUALDB_FILE}
    11 [ ! -d ${PKGDIR} ] && install -d ${PKGDIR}
    12 [ ! -d ${BUILDDIR} ] && install -d ${BUILDDIR}
    13 [ ! -d ${MAGEDIR} ] && install -d ${MAGEDIR}
    14
    15 return 0
    16 }
    17
    18 unpack_packages()
    19 {
    20 local list="$@"
    21 local magefile
    22 local pkg
    23 local pkgtype
    24 local count_current
    25 local count_total
    26
    27 # get count of total packages
    28 declare -i count_current=0
    29 declare -i count_total=0
    30
    31 for i in ${list}; do (( count_total++ )); done
    32
    33 for magefile in ${list}
    34 do
    35 pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"
    36 pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
    37
    38 (( count_current++ ))
    39 xtitle "[ (${count_current}/${count_total}) Unpacking ${pkg} ]"
    40
    41 # abort on virtual pkg
    42 if [[ ${pkgtype} = virtual ]]
    43 then
    44 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    45 echo " !unpack virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
    46 continue
    47 fi
    48
    49 # abort on sources pkg
    50 if [[ ${pkgtype} = sources ]]
    51 then
    52 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    53 echo " !unpack sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
    54 continue
    55 fi
    56
    57 echo -e " ${COLBLUE}***${COLDEFAULT} unpacking (${count_current}/${count_total}): ${pkg} ... "
    58 tar xjmf ${PKGDIR}/${pkg} -C ${BUILDDIR} || die "Unpacking package ${pkg}"
    59 done
    60
    61 # add a crlf for a better view
    62 if [ ${count_total} -gt 1 ]; then echo; fi
    63 }
    64
    65
    66 # fix_mtime path/to/$mtime/reffile $pathto/file
    67 # creates a given reference file and fixes given file
    68 # returns new mtime
    69 fix_mtime()
    70 {
    71 local reference="$1"
    72 local pathto="$2"
    73 local mtime
    74
    75 mtime=$(stat -c %Y "${reference}")
    76 touch \
    77 --no-create \
    78 --time=mtime \
    79 --reference "${reference}" \
    80 "${pathto}"
    81
    82 echo "${mtime}"
    83 }
    84
    85 # fix_descriptor pkgname/.dir "foo1" "foo2"
    86 fix_descriptor()
    87 {
    88 local descriptor="$1"
    89 local output
    90 local i
    91 shift
    92
    93 for i in $@
    94 do
    95 if [[ -z ${output} ]]
    96 then
    97 output="${i}"
    98 else
    99 output="${output}§${i}"
    100 fi
    101 done
    102
    103 echo "${output}" >> ${BUILDDIR}/${descriptor}_fixed
    104 }
    105
    106 ###################################################
    107 # function install_direcories #
    108 # install_direcories $PKGNAME #
    109 ###################################################
    110 install_directories()
    111 {
    112 local pkgname="$1"
    113 local pathto
    114 local posix
    115 local user
    116 local group
    117 local IFS
    118
    119 # sanity checks; abort if not given
    120 [ -z "${pkgname}" ] && die "install_directories() \$pkgname not given."
    121
    122 # check needed global vars
    123 [ -z "${BUILDDIR}" ] && die "install_directories() \$BUILDDIR not set."
    124
    125 [ ! -f ${BUILDDIR}/${pkgname}/.dirs ] && die "install_directories() .dirs not found"
    126
    127 # sets fieldseperator to "§" instead of " "
    128 IFS=§
    129
    130 while read pathto posix user group
    131 do
    132 [ -z "${pathto}" ] && continue
    133 [[ ${VERBOSE} = on ]] && echo -e "\t>>> DIR: ${MROOT}${pathto}"
    134
    135
    136 # monitors /etc/env.d -> env-rebuild
    137 [[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true
    138
    139 # monitors /usr/share/info -> info-rebuild
    140 [[ ${pathto} = /usr/share/info ]] && export MAGE_INFO_REBUILD=true
    141
    142 install -m "${posix}" -o "${user}" -g "${group}" -d "${MROOT}${pathto}"
    143 done < ${BUILDDIR}/${pkgname}/.dirs
    144
    145 # very important: unsetting the '§' fieldseperator
    146 IFS=$'\n'
    147 }
    148
    149
    150 ###################################################
    151 # function install_files #
    152 # install_files $PKGNAME #
    153 ###################################################
    154 install_files()
    155 {
    156
    157 local pkgname="$1"
    158 local pathto
    159 local posix
    160 local user
    161 local group
    162 local mtime
    163 local md5sum
    164
    165 local retval
    166 local counter
    167 local filename
    168 local dest_dirname
    169 local dest_protected
    170 local IFS
    171
    172 # sanity checks; abort if not given
    173 [ -z "${pkgname}" ] && die "install_files() \$pkgname not given."
    174
    175 # check needed global vars
    176 [ -z "${BUILDDIR}" ] && die "install_files() \$BUILDDIR not set."
    177
    178 [ ! -f ${BUILDDIR}/${pkgname}/.files ] && die "install_files() .files not found"
    179
    180 # delete old files
    181 [ -f ${BUILDDIR}/${pkgname}/.files_fixed ] && rm ${BUILDDIR}/${pkgname}/.files_fixed
    182
    183 # sets fieldseperator to "§" instead of " "
    184 IFS=§
    185
    186 while read pathto posix user group mtime md5sum
    187 do
    188 [ -z "${pathto}" ] && continue
    189
    190 # final destination dir of file ${pathto}
    191 dest_dirname="$(dirname "${MROOT}${pathto}")"
    192
    193 ### small hotfix fix ###
    194 [ ! -d "${dest_dirname}" ] && install -d "${dest_dirname}"
    195
    196 # check if the file is config_protected
    197 # ${MROOT} will automatically added if set !!
    198 is_config_protected "${pathto}"
    199 retval="$?"
    200
    201 # 0 - not protected #
    202 # 1 - error #
    203 # 2 - protected #
    204 # 3 - protected but masked #
    205
    206 case ${retval} in
    207 # file is not protected - (over)write it
    208 0|3)
    209 [[ ${VERBOSE} = on ]] && echo -e "\t>>> FILE: ${MROOT}${pathto}"
    210 install -m "${posix}" -o "${user}" -g "${group}" \
    211 ${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \
    212 "${MROOT}${pathto}"
    213
    214 # fix mtime and db
    215 fix_descriptor ${pkgname}/.files \
    216 "${pathto}" \
    217 "${posix}" \
    218 "${user}" \
    219 "${group}" \
    220 "$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
    221 "${MROOT}${pathto}")" \
    222 "${md5sum}"
    223 ;;
    224
    225 # file is protected, write backup file
    226 2)
    227 if [[ ${VERBOSE} = on ]]
    228 then
    229 echo -en "${COLRED}"
    230 echo -n "! prot "
    231 echo -en "${COLDEFAULT}"
    232 echo " === FILE: ${MROOT}${pathto}"
    233 fi
    234 filename="$(basename "${pathto}")"
    235 counter=$(count_protected_files "${pathto}")
    236 dest_protected="${dest_dirname}/._cfg${counter}_${filename}"
    237 install -m "${posix}" -o "${user}" -g "${group}" \
    238 ${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \
    239 "${dest_protected}"
    240
    241 # fix mtime and db
    242 fix_descriptor ${pkgname}/.files \
    243 "${pathto}" \
    244 "${posix}" \
    245 "${user}" \
    246 "${group}" \
    247 "$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
    248 "${dest_protected}")" \
    249 "${md5sum}"
    250
    251 # update global MAGE_PROTECT_COUNTER
    252 (( MAGE_PROTECT_COUNTER++ ))
    253 export MAGE_PROTECT_COUNTER
    254 ;;
    255 esac
    256 done < ${BUILDDIR}/${pkgname}/.files
    257
    258 # now copy the fixed file over the old one
    259 [ -f ${BUILDDIR}/${pkgname}/.files_fixed ] && \
    260 cp ${BUILDDIR}/${pkgname}/.files{_fixed,}
    261
    262 # very important: unsetting the '§' fieldseperator
    263 IFS=$'\n'
    264 }
    265
    266
    267 ###################################################
    268 # function install_symlinks #
    269 # install_symlinks $PKGNAME #
    270 ###################################################
    271 install_symlinks()
    272 {
    273 local pkgname="$1"
    274 local pathto
    275 local posix
    276 local link
    277 local mtime
    278 local IFS
    279
    280 # sanity checks; abort if not given
    281 [ -z "${pkgname}" ] && die "install_symlinks() \$pkgname not given."
    282
    283 # check needed global vars
    284 [ -z "${BUILDDIR}" ] && die "install_symlinks() \$BUILDDIR not set."
    285
    286 [ ! -f ${BUILDDIR}/${pkgname}/.symlinks ] && die "install_symlinks() .symlinks not found"
    287
    288 # delete old files
    289 [ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && rm ${BUILDDIR}/${pkgname}/.symlinks_fixed
    290
    291 # sets fieldseperator to "§" instead of " "
    292 IFS=§
    293
    294 while read pathto posix link mtime
    295 do
    296 [ -z "${pathto}" ] && continue
    297 [[ ${VERBOSE} = on ]] && echo -e "\t>>> LINK: ${MROOT}${pathto}"
    298
    299 ln -snf "${link}" "${MROOT}${pathto}"
    300
    301 # fix mtime and db
    302 fix_descriptor ${pkgname}/.symlinks \
    303 "${pathto}" \
    304 "${posix}" \
    305 "${link}" \
    306 "$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
    307 "${MROOT}${pathto}")"
    308
    309 done < ${BUILDDIR}/${pkgname}/.symlinks
    310
    311 # now copy the fixed file over the old one
    312 [ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && \
    313 cp -f ${BUILDDIR}/${pkgname}/.symlinks{_fixed,}
    314
    315 # very important: unsetting the '§' fieldseperator
    316 IFS=$'\n'
    317 }
    318
    319
    320 ###################################################
    321 # function install_blockdevices #
    322 # install_blockdevices $PKGNAME #
    323 ###################################################
    324 install_blockdevices()
    325 {
    326 local pkgname="$1"
    327 local pathto
    328 local posix
    329 local IFS
    330
    331 # sanity checks; abort if not given
    332 [ -z "${pkgname}" ] && die "install_blockdevices() \$pkgname not given."
    333
    334 # check needed global vars
    335 [ -z "${BUILDDIR}" ] && die "install_blockdevices() \$BUILDDIR not set."
    336
    337 [ ! -f ${BUILDDIR}/${pkgname}/.pipes ] && die "install_blockdevices() .pipes not found"
    338
    339 # sets fieldseperator to "§" instead of " "
    340 IFS=§
    341
    342 while read pathto posix
    343 do
    344 [ -z "${pathto}" ] && continue
    345 [[ ${VERBOSE} = on ]] && echo -e "\t>>> PIPE: ${MROOT}${pathto}"
    346
    347 mkfifo -m "${posix}" "${MROOT}$pathto"
    348 done < ${BUILDDIR}/${pkgname}/.pipes
    349
    350 # very important: unsetting the '§' fieldseperator
    351 IFS=$'\n'
    352 }
    353
    354
    355 ###################################################
    356 # function install_characterdevices #
    357 # install_characterdevices $PKGNAME #
    358 ###################################################
    359 install_characterdevices()
    360 {
    361 local pkgname="$1"
    362 local pathto
    363 local posix
    364 local IFS
    365
    366 # sanity checks; abort if not given
    367 [ -z "${pkgname}" ] && die "install_characterdevices() \$pkgname not given."
    368
    369 # check needed global vars
    370 [ -z "${BUILDDIR}" ] && die "install_characterdevices() \$BUILDDIR not set."
    371
    372 [ ! -f ${BUILDDIR}/${pkgname}/.char ] && die "install_characterdevices() .char not found"
    373
    374 # sets fieldseperator to "§" instead of " "
    375 IFS=§
    376
    377 while read pathto posix
    378 do
    379 [ -z "${pathto}" ] && continue
    380 [[ ${VERBOSE} = on ]] && echo -e "\t>>> CHAR: ${MROOT}${pathto}"
    381
    382 mknode -m ${posix} -c "${MROOT}${pathto}"
    383 done < ${BUILDDIR}/${pkgname}/.char
    384
    385 # very important: unsetting the '§' fieldseperator
    386 IFS=$'\n'
    387 }
    388
    389
    390 ###################################################
    391 # function build_doinstall #
    392 # build_doinstall $PKGNAME #
    393 # NOTE: this is an wrapper do install packages #
    394 ###################################################
    395 build_doinstall()
    396 {
    397 local pkgname="$1"
    398
    399 # sanity checks; abort if not given
    400 [ -z "${pkgname}" ] && die "build_doinstall() \$pkgname not given."
    401
    402 # this is only a wrapper
    403
    404 # NOTE:
    405 # !! we use § as field seperator !!
    406 # doing so prevent us to get errors by filenames with spaces
    407
    408 # create a new mtime reference file
    409 touch ${BUILDDIR}/${pkgname}/.mtime
    410
    411 install_directories ${pkgname} || die "install directories ${pkgname}"
    412 install_files ${pkgname} || die "install files ${pkgname}"
    413 install_symlinks ${pkgname} || die "install symlinks ${pkgname}"
    414 install_blockdevices ${pkgname} || die "install blockdevices ${pkgname}"
    415 install_characterdevices ${pkgname} || die "install chardevices ${pkgname}"
    416 }
    417
    418
    419 ###################################################
    420 # function install_database_entry #
    421 # install_database_entry $PKGNAME $PKGTYPE #
    422 # PKGTYPE can be "virtual", "sources" or nothing #
    423 ###################################################
    424 install_database_entry()
    425 {
    426 local pcat
    427 local pname
    428 local pver
    429 local pbuild
    430 local pkgtype
    431 local pkgname
    432 local magefile
    433 local dbrecorddir
    434 local provide
    435 local i
    436
    437 # very basic getops
    438 for i in $*
    439 do
    440 case $1 in
    441 --pcat|-c) shift; pcat="$1" ;;
    442 --pname|-n) shift; pname="$1" ;;
    443 --pver|-v) shift; pver="$1" ;;
    444 --pbuild|-b) shift; pbuild="$1" ;;
    445 --pkgname|-a) shift; pkgname="$1" ;;
    446 --pkgtype|-t) shift; pkgtype="$1" ;;
    447 esac
    448 shift
    449 done
    450
    451 # sanity checks; abort if not given
    452 [ -z "${pcat}" ] && die "install_database_entry() \$pcat not given."
    453 [ -z "${pname}" ] && die "install_database_entry() \$pname not given."
    454 [ -z "${pver}" ] && die "install_database_entry() \$pver not given."
    455 [ -z "${pbuild}" ] && die "install_database_entry() \$pbuild not given."
    456 [ -z "${pkgname}" ] && die "install_database_entry() \$pkgname not given."
    457
    458 # check needed global vars
    459 [ -z "${MAGEDIR}" ] && die "install_database_entry() \$MAGEDIR not set."
    460 [ -z "${INSTALLDB}" ] && die "install_database_entry() \$INSTALLDB not set."
    461
    462 # set needed vars
    463 magefile="${MAGEDIR}/${pcat}/${pname}/${pname}-${pver}-${pbuild}.mage"
    464 dbrecorddir="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}"
    465
    466 # abort if mage file not exists
    467 [ ! -f ${magefile} ] && die "install_database_entry() ${magefile} not exist."
    468
    469 # add package to database
    470 install -d ${dbrecorddir}
    471
    472 # install mage-file to database
    473 install -m 0644 -o root -g root ${magefile} ${dbrecorddir}
    474
    475 # create fake file descriptors
    476 # used by virtual and source packages
    477 for i in .dirs .symlinks .files .pipes .char
    478 do
    479 touch ${dbrecorddir}/${i}
    480 done
    481
    482 # put the category to database
    483 echo ${pcat} > ${dbrecorddir}/.categorie
    484
    485 # now install PKGTYPE specific files
    486 case ${pkgtype} in
    487 virtual) touch ${dbrecorddir}/.virtual ;;
    488 sources) touch ${dbrecorddir}/.sources ;;
    489 *)
    490 # !move! .mtime to database (only mv modifies not the mtime!!)
    491 mv ${BUILDDIR}/${pkgname}/.mtime ${dbrecorddir}/.mtime
    492
    493 # normal packages needs these files
    494 local i
    495 for i in .char .dirs .files .pipes .symlinks
    496 do
    497 install -m 0644 ${BUILDDIR}/${pkgname}/${i} \
    498 ${dbrecorddir}/${i}
    499 done
    500 ;;
    501 esac
    502
    503 # last but not least register virtuals
    504 provide="$(get_value_from_magefile PROVIDE ${magefile})"
    505 if [ -n "${provide}" ]
    506 then
    507 for i in ${provide}
    508 do
    509 virtuals_add "${i}" "${pcat}/${pname}"
    510 done
    511 fi
    512 }
    513
    514
    515 ###################################################
    516 # function remove_database_entry #
    517 # remove_database_entry $PKGNAME $PKGTYPE #
    518 # PKGTYPE can be "virtual", "sources" or nothing #
    519 ###################################################
    520 remove_database_entry()
    521 {
    522 local pcat
    523 local pname
    524 local pver
    525 local pbuild
    526 local magefile
    527 local dbrecorddir
    528 local provide
    529 local i
    530
    531 # very basic getops
    532 for i in $*
    533 do
    534 case $1 in
    535 --pcat|-c) shift; pcat="$1" ;;
    536 --pname|-n) shift; pname="$1" ;;
    537 --pver|-v) shift; pver="$1" ;;
    538 --pbuild|-b) shift; pbuild="$1" ;;
    539 esac
    540 shift
    541 done
    542
    543 # sanity checks; abort if not given
    544 [ -z "${pcat}" ] && die "remove_database_entry() \$pcat not given."
    545 [ -z "${pname}" ] && die "remove_database_entry() \$pname not given."
    546 [ -z "${pver}" ] && die "remove_database_entry() \$pver not given."
    547 [ -z "${pbuild}" ] && die "remove_database_entry() \$pbuild not given."
    548
    549 # check needed global vars
    550 [ -z "${INSTALLDB}" ] && die "remove_database_entry() \$INSTALLDB not set."
    551
    552 # set needed vars
    553 magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
    554 dbrecorddir="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}"
    555
    556 # abort if mage file not exists
    557 [ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."
    558
    559 # first unregister virtuals
    560 provide="$(get_value_from_magefile PROVIDE ${magefile})"
    561 if [ -n "${provide}" ]
    562 then
    563 for i in ${provide}
    564 do
    565 virtuals_del "${i}" "${pcat}/${pname}"
    566 done
    567 fi
    568
    569 # removes database entry
    570 if [ -d ${dbrecorddir} ]
    571 then
    572 rm -rf ${dbrecorddir}
    573 fi
    574 }
    575
    576
    577 ###################################################
    578 # function compare_mtime #
    579 # compare_mtime $pcat/$PKGNAME /path/to/file #
    580 # #
    581 # returns: #
    582 # 0=delete me #
    583 # 1=keep me #
    584 # #
    585 # compares mtime of given files in packages #
    586 ###################################################
    587 compare_mtime()
    588 {
    589 local pfull="$1"
    590 local pathto="$2"
    591 local mtime
    592 local pcat
    593 local x
    594
    595 mtime="$(stat -c %Y ${MROOT}${INSTALLDB}/${pfull}/.mtime)"
    596
    597 # if $pathto is a symlink than compare linked binary
    598 if [ -L "${MROOT}${pathto}" ]
    599 then
    600 # readlink -f resolves full path of linked file
    601 x="$(readlink -f "${MROOT}${pathto}")"
    602
    603 # abort if target does not exists
    604 # we keep safe here, theoretically the link can removed
    605 [ ! -e "${x}" ] && return 1
    606
    607 x=$(stat -c %Y "${x}")
    608 else
    609 x=$(stat -c %Y "${MROOT}${pathto}")
    610 fi
    611
    612 [[ ${mtime} = ${x} ]] && return 0
    613
    614 # echo "keep me : ${pathto}"
    615 return 1
    616 }
    617
    618
    619 ###################################################
    620 # function remove_symlinks #
    621 # remove_symlinks $PKGNAME #
    622 ###################################################
    623 remove_symlinks()
    624 {
    625 local pathto
    626 local posix
    627 local link
    628 local mtime
    629 local IFS
    630 local retval
    631 local pcat
    632 local pname
    633 local pver
    634 local pbuild
    635 local i
    636 local pfull
    637
    638 IFS=$'\n'
    639
    640 # very basic getops
    641 for i in $*
    642 do
    643 case $1 in
    644 --pcat|-c) shift; pcat="$1" ;;
    645 --pname|-n) shift; pname="$1" ;;
    646 --pver|-v) shift; pver="$1" ;;
    647 --pbuild|-b) shift; pbuild="$1" ;;
    648 esac
    649 shift
    650 done
    651
    652 # sanity checks; abort if not given
    653 [ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."
    654 [ -z "${pname}" ] && die "remove_symlinks() \$pname not given."
    655 [ -z "${pver}" ] && die "remove_symlinks() \$pver not given."
    656 [ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."
    657 pfull="${pcat}/${pname}-${pver}-${pbuild}"
    658
    659 # check needed global vars
    660 [ -z "${BUILDDIR}" ] && die "remove_symlinks() \$BUILDDIR not set."
    661
    662 [ ! -f ${MROOT}${INSTALLDB}/${pfull}/.symlinks ] && die "remove_symlinks() .symlinks not found"
    663
    664 # sets fieldseperator to "§" instead of " "
    665 IFS=§
    666
    667 while read pathto posix link mtime
    668 do
    669 [ -z "${pathto}" ] && continue
    670 if [ ! -L "${MROOT}${pathto}" ]
    671 then
    672 [[ ${VERBOSE} = on ]] && \
    673 echo -e "${COLRED}! exist${COLDEFAULT} === LINK: ${MROOT}${pathto}"
    674 continue
    675 fi
    676
    677 # *no* ${MROOT}, will be set internal
    678 compare_mtime "${pfull}" "${pathto}"
    679 retval=$?
    680 # 0=delete me #
    681 # 1=keep me #
    682 case ${retval} in
    683 0)
    684 [[ ${VERBOSE} = on ]] && echo -e "\t<<< LINK: ${MROOT}${pathto}"
    685 rm "${MROOT}${pathto}"
    686 ;;
    687
    688 1)
    689 [[ ${VERBOSE} = on ]] && \
    690 echo -e "${COLRED}! mtime${COLDEFAULT} === LINK: ${MROOT}${pathto}"
    691 ;;
    692 esac
    693 done < ${MROOT}${INSTALLDB}/${pfull}/.symlinks
    694
    695 # very important: unsetting the '§' fieldseperator
    696 IFS=$'\n'
    697 }
    698
    699
    700 ###################################################
    701 # function remove_files #
    702 # remove_files $PKGNAME #
    703 ###################################################
    704 remove_files()
    705 {
    706 local pathto
    707 local posix
    708 local user
    709 local group
    710 local mtime
    711 local md5sum
    712 local IFS
    713 local retval
    714 local pcat
    715 local pname
    716 local pver
    717 local pbuild
    718 local i
    719 local pfull
    720
    721 IFS=$'\n'
    722
    723 # very basic getops
    724 for i in $*
    725 do
    726 case $1 in
    727 --pcat|-c) shift; pcat="$1" ;;
    728 --pname|-n) shift; pname="$1" ;;
    729 --pver|-v) shift; pver="$1" ;;
    730 --pbuild|-b) shift; pbuild="$1" ;;
    731 esac
    732 shift
    733 done
    734
    735 # sanity checks; abort if not given
    736 [ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."
    737 [ -z "${pname}" ] && die "remove_symlinks() \$pname not given."
    738 [ -z "${pver}" ] && die "remove_symlinks() \$pver not given."
    739 [ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."
    740 pfull="${pcat}/${pname}-${pver}-${pbuild}"
    741
    742 # check needed global vars
    743 [ -z "${BUILDDIR}" ] && die "remove_files() \$BUILDDIR not set."
    744
    745 [ ! -f ${MROOT}${INSTALLDB}/${pfull}/.files ] && die "remove_files() .files not found"
    746
    747 # sets fieldseperator to "§" instead of " "
    748 IFS=§
    749
    750 while read pathto posix user group mtime md5sum
    751 do
    752 [ -z "${pathto}" ] && continue
    753
    754 if [ ! -e "${MROOT}${pathto}" ]
    755 then
    756 [[ ${VERBOSE} = on ]] && \
    757 echo -e "${COLRED}! exist${COLDEFAULT} === FILE: ${MROOT}${pathto}"
    758 continue
    759 fi
    760
    761 # *no* ${MROOT}, will be set internal
    762 compare_mtime "${pfull}" "${pathto}"
    763 retval=$?
    764 # 0=delete me #
    765 # 1=keep me #
    766 case ${retval} in
    767 0)
    768 [[ ${VERBOSE} = on ]] && echo -e "\t<<< FILE: ${MROOT}${pathto}"
    769 rm "${MROOT}${pathto}"
    770 ;;
    771
    772 1)
    773 [[ ${VERBOSE} = on ]] && \
    774 echo -e "${COLRED}! mtime${COLDEFAULT} === FILE: ${MROOT}${pathto}"
    775 ;;
    776 esac
    777 done < ${MROOT}${INSTALLDB}/${pfull}/.files
    778
    779 # very important: unsetting the '§' fieldseperator
    780 IFS=$'\n'
    781 }
    782
    783
    784 ###################################################
    785 # function remove_blockdevices #
    786 # remove_blockdevices $PKGNAME #
    787 ###################################################
    788 remove_blockdevices()
    789 {
    790 local pathto
    791 local posix
    792 local IFS
    793 local pcat
    794 local pname
    795 local pver
    796 local pbuild
    797 local i
    798 local pfull
    799
    800 IFS=$'\n'
    801
    802 # very basic getops
    803 for i in $*
    804 do
    805 case $1 in
    806 --pcat|-c) shift; pcat="$1" ;;
    807 --pname|-n) shift; pname="$1" ;;
    808 --pver|-v) shift; pver="$1" ;;
    809 --pbuild|-b) shift; pbuild="$1" ;;
    810 esac
    811 shift
    812 done
    813
    814 # sanity checks; abort if not given
    815 [ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."
    816 [ -z "${pname}" ] && die "remove_symlinks() \$pname not given."
    817 [ -z "${pver}" ] && die "remove_symlinks() \$pver not given."
    818 [ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."
    819 pfull="${pcat}/${pname}-${pver}-${pbuild}"
    820
    821 # check needed global vars
    822 [ -z "${BUILDDIR}" ] && die "remove_blockdevices() \$BUILDDIR not set."
    823
    824 [ ! -f ${MROOT}${INSTALLDB}/${pfull}/.pipes ] && die "remove_blockdevices() .pipes not found"
    825
    826 # sets fieldseperator to "§" instead of " "
    827 IFS=§
    828
    829 while read pathto posix
    830 do
    831 [ -z "${pathto}" ] && continue
    832
    833 [[ ${VERBOSE} = on ]] && echo -e "\t<<< PIPE: ${MROOT}${pathto}"
    834 rm "${MROOT}${pathto}"
    835 done < ${MROOT}${INSTALLDB}/${pfull}/.pipes
    836
    837 # very important: unsetting the '§' fieldseperator
    838 IFS=$'\n'
    839 }
    840
    841
    842 ###################################################
    843 # function remove_characterdevices #
    844 # remove_characterdevices $PKGNAME #
    845 ###################################################
    846 remove_characterdevices()
    847 {
    848 local pathto
    849 local posix
    850 local IFS
    851 local pcat
    852 local pname
    853 local pver
    854 local pbuild
    855 local i
    856 local pfull
    857
    858 IFS=$'\n'
    859
    860 # very basic getops
    861 for i in $*
    862 do
    863 case $1 in
    864 --pcat|-c) shift; pcat="$1" ;;
    865 --pname|-n) shift; pname="$1" ;;
    866 --pver|-v) shift; pver="$1" ;;
    867 --pbuild|-b) shift; pbuild="$1" ;;
    868 esac
    869 shift
    870 done
    871
    872 # sanity checks; abort if not given
    873 [ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."
    874 [ -z "${pname}" ] && die "remove_symlinks() \$pname not given."
    875 [ -z "${pver}" ] && die "remove_symlinks() \$pver not given."
    876 [ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."
    877 pfull="${pcat}/${pname}-${pver}-${pbuild}"
    878
    879 # check needed global vars
    880 [ -z "${BUILDDIR}" ] && die "remove_characterdevices() \$BUILDDIR not set."
    881
    882 [ ! -f ${MROOT}${INSTALLDB}/${pfull}/.char ] && die "remove_characterdevices() .char not found"
    883
    884 # sets fieldseperator to "§" instead of " "
    885 IFS=§
    886
    887 while read pathto posix
    888 do
    889 [ -z "${pathto}" ] && continue
    890
    891 [[ ${VERBOSE} = on ]] && echo -e "\t<<< CHAR: ${MROOT}${pathto}"
    892 rm "${MROOT}${pathto}"
    893 done < ${MROOT}${INSTALLDB}/${pfull}/.char
    894
    895 # very important: unsetting the '§' fieldseperator
    896 IFS=$'\n'
    897 }
    898
    899
    900 ###################################################
    901 # function remove_direcories #
    902 # remove_direcories $PKGNAME #
    903 ###################################################
    904 remove_directories()
    905 {
    906 local pathto
    907 local posix
    908 local IFS
    909 local pcat
    910 local pname
    911 local pver
    912 local pbuild
    913 local i
    914 local pfull
    915
    916 IFS=$'\n'
    917
    918 # very basic getops
    919 for i in $*
    920 do
    921 case $1 in
    922 --pcat|-c) shift; pcat="$1" ;;
    923 --pname|-n) shift; pname="$1" ;;
    924 --pver|-v) shift; pver="$1" ;;
    925 --pbuild|-b) shift; pbuild="$1" ;;
    926 esac
    927 shift
    928 done
    929
    930 # sanity checks; abort if not given
    931 [ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."
    932 [ -z "${pname}" ] && die "remove_symlinks() \$pname not given."
    933 [ -z "${pver}" ] && die "remove_symlinks() \$pver not given."
    934 [ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."
    935 pfull="${pcat}/${pname}-${pver}-${pbuild}"
    936
    937 # check needed global vars
    938 [ -z "${BUILDDIR}" ] && die "remove_directories() \$BUILDDIR not set."
    939
    940 [ ! -f ${MROOT}${INSTALLDB}/${pfull}/.char ] && die "remove_directories() .dirs not found"
    941
    942 # sets fieldseperator to "§" instead of " "
    943 IFS=§
    944
    945 # reversed order is mandatory !
    946 tac ${MROOT}${INSTALLDB}/${pfull}/.dirs | while read pathto posix
    947 do
    948 [ -z "${pathto}" ] && continue
    949
    950 if [ ! -d "${MROOT}${pathto}" ]
    951 then
    952 [[ ${VERBOSE} = on ]] && \
    953 echo -e "${COLRED}! exist${COLDEFAULT} === DIR: ${MROOT}${pathto}"
    954 continue
    955 fi
    956
    957 # exclude .keep directories
    958 if [ -f "${MROOT}${pathto}/.keep" ]
    959 then
    960 [[ ${VERBOSE} = on ]] && \
    961 echo -e "${COLRED}! .keep${COLDEFAULT} === DIR: ${MROOT}${pathto}"
    962 continue
    963 fi
    964
    965 # monitors /etc/env.d -> env-rebuild
    966 [[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true
    967
    968 # monitors /usr/share/info -> info-rebuild
    969 [[ ${pathto} = /usr/share/info ]] && export MAGE_INFO_REBUILD=true
    970
    971 if rmdir "${MROOT}${pathto}" &> /dev/null
    972 then
    973 [[ ${VERBOSE} = on ]] && echo -e "\t<<< DIR: ${MROOT}${pathto}"
    974 else
    975 [[ ${VERBOSE} = on ]] && \
    976 echo -e "${COLRED}! empty${COLDEFAULT} === DIR: ${MROOT}${pathto}"
    977 fi
    978 done
    979
    980 # very important: unsetting the '§' fieldseperator
    981 IFS=$'\n'
    982 }
    983
    984
    985 ###################################################
    986 # function build_douninstall #
    987 # build_douninstall $PKGNAME #
    988 # NOTE: this is an wrapper do remove packages #
    989 ###################################################
    990 build_douninstall()
    991 {
    992 local pcat
    993 local pname
    994 local pver
    995 local pbuild
    996 local i
    997
    998 # very basic getops
    999 for i in $*
    1000 do
    1001 case $1 in
    1002 --pcat|-c) shift; pcat="$1" ;;
    1003 --pname|-n) shift; pname="$1" ;;
    1004 --pver|-v) shift; pver="$1" ;;
    1005 --pbuild|-b) shift; pbuild="$1" ;;
    1006 esac
    1007 shift
    1008 done
    1009
    1010 # sanity checks; abort if not given
    1011 [ -z "${pcat}" ] && die "build_douninstall() \$pcat not given."
    1012 [ -z "${pname}" ] && die "build_douninstall() \$pname not given."
    1013 [ -z "${pver}" ] && die "build_douninstall() \$pver not given."
    1014 [ -z "${pbuild}" ] && die "build_douninstall() \$pbuild not given."
    1015
    1016 # this is only a wrapper
    1017
    1018 # NOTE:
    1019 # !! we use § as field seperator !!
    1020 # doing so prevent us to get errors by filenames with spaces
    1021
    1022 for i in symlinks files blockdevices characterdevices directories
    1023 do
    1024 remove_${i} \
    1025 --pcat "${pcat}" \
    1026 --pname "${pname}" \
    1027 --pver "${pver}" \
    1028 --pbuild "${pbuild}" \
    1029 || die "remove ${i} ${pcat}/${pname}-${pver}-${pbuild}"
    1030 done
    1031 }
    1032
    1033 # fetch_packages /path/to/mage/file1 /path/to/mage/file2
    1034 fetch_packages()
    1035 {
    1036 local list="$@"
    1037 local pkg
    1038 local mirr
    1039 local magefile
    1040 local md5file
    1041 local opt
    1042 local count_current
    1043 local count_total
    1044
    1045 [ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your /etc/mage.rc."
    1046
    1047 # get count of total packages
    1048 declare -i count_current=0
    1049 declare -i count_total=0
    1050
    1051 for i in ${list}; do (( count_total++ )); done
    1052
    1053 for magefile in ${list}
    1054 do
    1055 pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"
    1056 pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
    1057
    1058 (( count_current++ ))
    1059 xtitle "[ (${count_current}/${count_total}) Fetching ${pkg} ]"
    1060
    1061 # abort on virtual pkg
    1062 if [[ ${pkgtype} = virtual ]]
    1063 then
    1064 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    1065 echo " !fetch virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
    1066 continue
    1067 fi
    1068
    1069 # abort on sources pkg
    1070 if [[ ${pkgtype} = sources ]]
    1071 then
    1072 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    1073 echo " !fetch sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
    1074 continue
    1075 fi
    1076
    1077 # abort if already exist
    1078 if [ -f ${PKGDIR}/${pkg} ]
    1079 then
    1080 echo -ne " ${COLBLUE}***${COLDEFAULT}"
    1081 echo " fetch complete (${count_current}/${count_total}): ${pkg} ... "
    1082 continue
    1083 fi
    1084
    1085 for mirr in ${MIRRORS}
    1086 do
    1087 echo -ne " ${COLBLUE}***${COLDEFAULT}"
    1088 #echo -e " fetching (${count_current}/${count_total}): ${mirr}/${pkg} ... "
    1089 echo -e " fetching (${count_current}/${count_total}): ${pkg} ... "
    1090 [[ ${VERBOSE} = off ]] && opt="--quiet"
    1091 wget \
    1092 --passive-ftp \
    1093 --tries 3 \
    1094 --continue \
    1095 --progress bar \
    1096 --directory-prefix=${PKGDIR} \
    1097 ${opt} ${mirr}/packages/${pkg}
    1098 if [[ $? = 0 ]]
    1099 then
    1100 break
    1101 else
    1102 continue
    1103 fi
    1104 done
    1105
    1106 if [ ! -f ${PKGDIR}/${pkg} ]
    1107 then
    1108 die "Could not download ${pkg}"
    1109 fi
    1110 done
    1111
    1112 # add a crlf for a better view
    1113 if [ ${count_total} -gt 1 ]; then echo; fi
    1114 }
    1115
    1116 syncmage()
    1117 {
    1118 if [ -z "${RSYNC}" ]
    1119 then
    1120 die "You have no rsync-mirrors defined. Please edit your /etc/mage.rc."
    1121 fi
    1122
    1123 local i
    1124 for i in ${RSYNC}
    1125 do
    1126 rsync \
    1127 --recursive \
    1128 --links \
    1129 --perms \
    1130 --times \
    1131 --devices \
    1132 --timeout=600 \
    1133 --verbose \
    1134 --compress \
    1135 --progress \
    1136 --stats \
    1137 --delete \
    1138 --delete-after \
    1139 ${i} ${MAGEDIR}
    1140 if [[ $? = 0 ]]
    1141 then
    1142 break
    1143 else
    1144 continue
    1145 fi
    1146 done
    1147
    1148 # clean up backup files (foo~)
    1149 find ${MAGEDIR} -name *~ -exec rm '{}' ';'
    1150
    1151 # check if an newer mage version is available
    1152 is_newer_mage_version_available
    1153 }
    1154
    1155 cleanpkg()
    1156 {
    1157 if [ -d "${PKGDIR}" ]
    1158 then
    1159 echo -n "Removing downloaded packages... "
    1160 rm -rf ${PKGDIR}/*
    1161 echo "done."
    1162 fi
    1163 }
    1164
    1165 xtitle()
    1166 {
    1167 if [[ ${TERM} = xterm ]]
    1168 then
    1169 echo -ne "\033]0;Mage: $1\007"
    1170 fi
    1171 return 0
    1172 }
    1173
    1174
    1175 xtitleclean()
    1176 {
    1177 if [[ ${TERM} = xterm ]]
    1178 then
    1179 echo -ne "\033]0;\007"
    1180 fi
    1181 return 0
    1182 }
    1183
    1184
    1185 # cuts full pathnames or versioniezed names down to basename
    1186 choppkgname()
    1187 {
    1188 #we want this only if full name was used
    1189 if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
    1190 then
    1191 #cuts ARCH and PBUILD
    1192 #ARCH comes from /etc/mage.rc
    1193 MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}-r*.::g")
    1194
    1195 #cuts version number
    1196 MAGENAME=$(basename ${MAGENAME%-*} .mage)
    1197 fi
    1198 }
    1199
    1200 # get_categorie $PNAME, returns CATEGORIE
    1201 # $1=pname
    1202 # ret 0=ok, 1=not_found
    1203 pname2pcat()
    1204 {
    1205 local pname="$1"
    1206 local repo="$2"
    1207 local pcat
    1208 local categorie
    1209
    1210 for pcat in ${MAGEDIR}/*
    1211 do
    1212 if [ -d ${pcat}/${pname} ]
    1213 then
    1214 categorie=$(basename ${pcat})
    1215 fi
    1216 done
    1217
    1218 echo "${categorie}"
    1219 }
    1220
    1221 # check_stable_package /path/to/foo.mage
    1222 # returns 0=stable 1=unstable
    1223 check_stable_package()
    1224 {
    1225 local STATE
    1226 STATE="$(get_value_from_magefile STATE "$1")"
    1227
    1228 # state testing
    1229 if [[ ${USE_TESTING} = true ]]
    1230 then
    1231 case ${STATE} in
    1232 testing|stable) return 0 ;;
    1233 *) return 1 ;;
    1234 esac
    1235 fi
    1236
    1237 # state unstable
    1238 if [[ ${USE_UNSTABLE} = true ]]
    1239 then
    1240 case ${STATE} in
    1241 unstable|testing|stable) return 0 ;;
    1242 *) return 1 ;;
    1243 esac
    1244 fi
    1245
    1246 # no use_state given = stable
    1247 case ${STATE} in
    1248 stable) return 0 ;;
    1249 *) return 1 ;;
    1250 esac
    1251 }
    1252
    1253
    1254 # get_highest_magefile ${PCAT} ${PNAME}
    1255 # fake at moment returns only stable pkgs (must set to be one)
    1256 # return $HIGHEST_MAGEFILE
    1257 get_highest_magefile()
    1258 {
    1259 local HIGHEST_MAGEFILE
    1260 local PCAT="$1"
    1261 local PNAME="$2"
    1262 local magefile
    1263
    1264 for magefile in $(ls --format=single-column -v ${MAGEDIR}/${PCAT}/${PNAME}/*)
    1265 do
    1266 # we exclude subdirs (for stuff like a md5sum dir)
    1267 [ -d ${magefile} ] && continue
    1268 if check_stable_package ${magefile}
    1269 then
    1270 HIGHEST_MAGEFILE=${magefile}
    1271 #for debug only
    1272 [[ ${MAGEDEBUG} = on ]] && echo "HIGHEST_MAGEFILE=${HIGHEST_MAGEFILE}"
    1273 fi
    1274 done
    1275
    1276 # stop here if HIGHEST_MAGEFILE is zero
    1277 # this package must be unstable or old
    1278 if [ -z "${HIGHEST_MAGEFILE}" ]
    1279 then
    1280 echo
    1281 echo -n "All packages named "
    1282 echo -en ${COLRED}\""${PKGNAME%-*-*-*}\""${COLDEFAULT}
    1283 echo -n " are marked "
    1284 echo -en ${COLRED}"*UNSTABLE*"${COLDEFAULT}
    1285 echo "."
    1286 echo "You need to declare USE_UNSTABLE=true to install this."
    1287 echo
    1288 echo "Example:"
    1289 echo " USE_UNSTABLE=true mage install ${PKGNAME%-*-*-*}"
    1290 echo
    1291 echo "Be warned that these packages are not stable and may cause serious problems."
    1292 echo "You should know what you are doing, so don't complain about any damage."
    1293 echo
    1294 return 1
    1295 fi
    1296
    1297 echo "${HIGHEST_MAGEFILE}"
    1298 return 0
    1299 }
    1300
    1301
    1302 ###################################################
    1303 # function is_config_protected #
    1304 # is_config_protected /path/to/file #
    1305 # #
    1306 # returns: #
    1307 # 0 - not protected #
    1308 # 1 - error #
    1309 # 2 - protected #
    1310 # 3 - protected but masked #
    1311 # #
    1312 ###################################################
    1313 is_config_protected()
    1314 {
    1315 local EXPFILE
    1316 local TEST
    1317 local PROTECTED
    1318 local IFS
    1319
    1320 EXPFILE="${MROOT}$1"
    1321
    1322 # file does not exist; it can be written
    1323 [ ! -e ${EXPFILE} ] && return 0
    1324
    1325 # to be safe; it may be '§'
    1326 IFS=' '
    1327
    1328 # check ob in config protect
    1329 for i in ${CONFIG_PROTECT}
    1330 do
    1331 # ersetzen von $i nur wenn am anfang der variable
    1332 TEST="${EXPFILE/#${MROOT}${i}/Protected}"
    1333 if [ "${TEST}" != "${EXPFILE}" ]
    1334 then
    1335 # setzen das es protected ist
    1336 PROTECTED=TRUE
    1337
    1338 # check ob nicht doch maskiert
    1339 for x in ${CONFIG_PROTECT_MASK}
    1340 do
    1341 TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"
    1342 if [ "${TEST}" != "${EXPFILE}" ]
    1343 then
    1344 PROTECTED=MASKED
    1345 fi
    1346 done
    1347 fi
    1348 done
    1349
    1350 unset IFS
    1351
    1352 case ${PROTECTED} in
    1353 TRUE)
    1354 #echo "I'm protected"
    1355 return 2
    1356 ;;
    1357 MASKED)
    1358 #echo "I'm protected, but masked - delete me"
    1359 return 3
    1360 ;;
    1361 *)
    1362 #echo "delete me"
    1363 return 0
    1364 ;;
    1365 esac
    1366 }
    1367
    1368
    1369 ###################################################
    1370 # function count_protected_files #
    1371 # count_protected_files /path/to/file #
    1372 # #
    1373 # note: prints number of protected files #
    1374 # exp: 0012 #
    1375 ###################################################
    1376 count_protected_files()
    1377 {
    1378 ${MLIBDIR}/writeprotected "$1"
    1379 }
    1380
    1381 # call with
    1382 # 'get_uninstall_candidates (--pcat cat --protected pcat/pfull) --pname PNAME'
    1383 # returns /path/to/magefile(s)
    1384 get_uninstall_candidates()
    1385 {
    1386 local search_pname
    1387 local pkg
    1388 local pcat
    1389 local pname
    1390 local pver
    1391 local pbuild
    1392 local list
    1393 local pcatdir
    1394 local protected
    1395
    1396 # very basic getops
    1397 for i in $*
    1398 do
    1399 case $1 in
    1400 --pcat|-c) shift; pcatdir="$1" ;;
    1401 --pname|-n) shift; search_pname="$1" ;;
    1402 --protected|-p) shift; protected="$1" ;;
    1403 esac
    1404 shift
    1405 done
    1406
    1407 # sanity checks; abort if not given
    1408 [ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."
    1409
    1410
    1411 # check needed global vars
    1412 [ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."
    1413
    1414 # set pcatdir to '*' if empty
    1415 [ -z "${pcatdir}" ] && pcatdir=*
    1416
    1417 for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*
    1418 do
    1419 # abort if not a dir
    1420 [ ! -d ${pkg} ] && continue
    1421
    1422 pname="$(magename2pname ${pkg})"
    1423
    1424 if [[ ${search_pname} = ${pname} ]]
    1425 then
    1426 pcat="$(magename2pcat ${pkg} installdb)"
    1427 pver="$(magename2pver ${pkg})"
    1428 pbuild="$(magename2pbuild ${pkg})"
    1429
    1430 # exclude proteced
    1431 [[ ${protected} = ${pcat}/${pname}-${pver}-${pbuild} ]] && continue
    1432
    1433 list="${list} ${pcat}/${pname}-${pver}-${pbuild}"
    1434 fi
    1435 done
    1436
    1437 echo "${list}"
    1438 }
    1439
    1440 # reads virtualdb file
    1441 #$1 = virtualname; $2 commands: showpkgs, showline
    1442 #return 0 == installed -> shows installed pkg as well
    1443 #return 1 == not installed
    1444 virtuals_read()
    1445 {
    1446 local virtualname="$1"
    1447 local command="$2"
    1448 local virtline
    1449 local line x i
    1450
    1451 # parse file to get virtual_name line
    1452 IFS=$'\n'
    1453 for line in $(< ${MROOT}${VIRTUALDB_FILE})
    1454 do
    1455 IFS=$' '
    1456 for x in ${line}
    1457 do
    1458 if [[ ${x} = ${virtualname} ]]
    1459 then
    1460 virtline="${line}"
    1461 [[ ${command} = showline ]] && echo "${line}"
    1462 fi
    1463 done
    1464 IFS=$'\n'
    1465 done
    1466
    1467 unset IFS
    1468
    1469 # now read the packages linked to VIRTUAL_NAME and output them
    1470 if [ -n "${virtline}" ]
    1471 then
    1472 if [[ ${command} = showpkgs ]]
    1473 then
    1474 declare -i x=0
    1475 for i in ${virtline}
    1476 do
    1477 if [ ${x} -ge 1 ]
    1478 then
    1479 echo "${i}"
    1480 fi
    1481 ((x++))
    1482 done
    1483 fi
    1484 return 0
    1485 fi
    1486 return 1
    1487 }
    1488
    1489
    1490 #add pkg to virtualdb
    1491 # $1 == virtualname $2= pkgname
    1492 # retvals: 0=ok,added; 1=error; 3=pkg already in virtual
    1493 virtuals_add()
    1494 {
    1495 local virtualname="$1"
    1496 local pkgname="$2"
    1497 local oldline
    1498 local line i
    1499 local installed_file
    1500 local OLDIFS
    1501
    1502 if virtuals_read ${virtualname}
    1503 then
    1504 # make shure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already
    1505 for i in $(virtuals_read ${virtualname} showpkgs)
    1506 do
    1507 if [[ ${i} = ${pkgname} ]]
    1508 then
    1509 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1510 echo "${pkgname} already linked as ${virtualname} ..."
    1511 #return 3
    1512 return 0
    1513 fi
    1514 done
    1515
    1516 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1517 echo "updating ${virtualname} entry with ${pkgname} ..."
    1518 oldline="$(virtuals_read ${virtualname} showline)"
    1519
    1520 # make a backup
    1521 mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old
    1522
    1523 OLDIFS="${IFS}"
    1524 IFS=$'\n'
    1525 for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)
    1526 do
    1527 # if the right line, append ${pkgname}, else do nothing
    1528 if [[ ${line} = ${oldline} ]]
    1529 then
    1530 echo "${line} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1531 else
    1532 echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}
    1533 fi
    1534 done
    1535 # unset IFS
    1536 IFS="${OLDIFS}"
    1537 else
    1538 echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    1539 echo "register ${pkgname} as ${virtualname} ..."
    1540 echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1541 fi
    1542
    1543 return 0
    1544 }
    1545
    1546 #deletes pakages from virtual database
    1547 #$1 virtualname; $2 pkgname
    1548 virtuals_del() {
    1549
    1550 local virtualname="$1"
    1551 local pkgname="$2"
    1552 local oldline
    1553 local method
    1554 local line i x
    1555 local pkg_installed
    1556 local OLDIFS
    1557
    1558 # first check if exists
    1559 if virtuals_read ${virtualname}
    1560 then
    1561 # get method -> delall or update and check if ${PKG_NAME} exists in ${VIRTUAL_NAME}
    1562 declare -i x=0
    1563 for i in $(virtuals_read ${virtualname} showpkgs)
    1564 do
    1565 if [[ ${i} = ${pkgname} ]]
    1566 then
    1567 pkg_installed=true
    1568 fi
    1569 ((x++))
    1570 done
    1571
    1572 # abort if not installed
    1573 if [[ ${pkg_installed} != true ]]
    1574 then
    1575 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1576 echo "${pkgname} does not exists in ${virtualname}."
    1577 return 0
    1578 fi
    1579
    1580 if [ ${x} -ge 2 ]
    1581 then
    1582 method=update
    1583 else
    1584 method=delall
    1585 fi
    1586
    1587 # get the complete line
    1588 oldline="$(virtuals_read ${virtualname} showline)"
    1589
    1590 # make a backup of the db
    1591 mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old
    1592
    1593 # parse virtualdb
    1594 OLDIFS="${IFS}"
    1595 IFS=$'\n'
    1596 for line in $(< ${VIRTUALDB_FILE}.old)
    1597 do
    1598 if [[ ${line} = ${oldline} ]]
    1599 then
    1600 #delall or update?
    1601 case ${method} in
    1602 update)
    1603 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1604 echo "Unlinking ${pkgname} from ${virtualname} in virtual database ..."
    1605 # del PKG_NAME from line
    1606 echo "${line/ ${pkgname}/}" >> ${VIRTUALDB_FILE}
    1607 ;;
    1608 delall)
    1609 echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    1610 echo "Deleting ${virtualname} in virtual database ..."
    1611 # continue; do not write anything
    1612 continue
    1613 ;;
    1614 esac
    1615 else
    1616 echo "${line}" >> ${VIRTUALDB_FILE}
    1617 fi
    1618 done
    1619 # unset IFS
    1620 IFS="${OLDIFS}"
    1621 else
    1622 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1623 echo "${virtualname} does not exists in virtual database."
    1624 fi
    1625 }
    1626
    1627 # gets real pkgname from virtuals.default
    1628 #$1=VIRTUAL_NAME; returns PKG_NAME
    1629 default_virtualname_to_pkgname()
    1630 {
    1631 local VIRTUAL_NAME PKG_NAME db_virtualname db_pkgname
    1632
    1633 VIRTUAL_NAME=$1
    1634
    1635 while read db_virtualname db_pkgname
    1636 do
    1637 if [ "${db_virtualname}" == "${VIRTUAL_NAME}" ]
    1638 then
    1639 PKG_NAME="${db_pkgname}"
    1640 fi
    1641 done << EOF
    1642 $(< ${VIRTUALDB_DEFAULTS})
    1643 EOF
    1644
    1645 if [ -n "${PKG_NAME}" ]
    1646 then
    1647 echo "${PKG_NAME}"
    1648 fi
    1649 }
    1650
    1651 minclude()
    1652 {
    1653 local i
    1654
    1655 if [ -n "$@" ]
    1656 then
    1657 for i in $@
    1658 do
    1659 [[ ${MAGEDEBUG} = on ]] && \
    1660 echo "--- Including ${MAGEDIR}/include/${i}.minc"
    1661 source ${MAGEDIR}/include/${i}.minc
    1662 done
    1663 [[ ${MAGEDEBUG} = on ]] && echo
    1664 fi
    1665 }
    1666
    1667 sminclude()
    1668 {
    1669 local i
    1670
    1671 if [ -n "$@" ]
    1672 then
    1673 for i in $@
    1674 do
    1675 echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    1676 source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    1677 done
    1678 echo
    1679 fi
    1680 }
    1681
    1682 # checks if an newer mage version is available
    1683 is_newer_mage_version_available()
    1684 {
    1685 local newest_mage
    1686 local installed_mage
    1687
    1688 newest_mage="$(basename $(get_highest_magefile app-mage mage) .mage)"
    1689 installed_mage="$(magequery -n mage | cut -d' ' -f5)"
    1690
    1691 if [[ ${newest_mage} > ${installed_mage} ]]
    1692 then
    1693 echo
    1694 echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}
    1695 echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}
    1696 echo "It is recommened to install this newer version"
    1697 echo "or your current system installation may brake."
    1698 echo
    1699 echo -en "Please update mage by running "
    1700 echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}
    1701 echo
    1702 fi
    1703 }
    1704
    1705
    1706 # returns pname from pkgname
    1707 # pkgname2pname $PKGNAME
    1708 pkgname2pname()
    1709 {
    1710 local pname
    1711
    1712 pname="${1%-*-*-*}"
    1713 echo "${pname}"
    1714 }
    1715
    1716 # returns pver from pkgname
    1717 # pkgname2pver $PKGNAME
    1718 pkgname2pver()
    1719 {
    1720 local i pver
    1721
    1722 i="${1/$(pkgname2pname $1)-/}"
    1723 pver="${i%-*-*}"
    1724 echo "${pver}"
    1725 }
    1726
    1727 # returns pbuild from pkgname
    1728 # pkgname2pbuild $PKGNAME
    1729 pkgname2pbuild()
    1730 {
    1731 local pbuild
    1732
    1733 pbuild="${1##*-}"
    1734 echo "${pbuild}"
    1735 }
    1736
    1737 # returns parch from pkgname
    1738 # pkgname2parch $PKGNAME
    1739 pkgname2parch()
    1740 {
    1741 local i x parch
    1742
    1743 i="${1%-*-*}-"
    1744 x="${1%-*}"
    1745 parch="${x/${i}/}"
    1746 echo "${parch}"
    1747 }
    1748
    1749 # returns pname from magename
    1750 # magename2pname /PATH/TO/MAGE/FILE
    1751 magename2pname()
    1752 {
    1753 local i pname
    1754
    1755 i="$(basename $1 .mage)"
    1756 pname="${i%-*-*}"
    1757 echo "${pname}"
    1758 }
    1759
    1760 # returns pver from magename
    1761 # magename2pver /PATH/TO/MAGE/FILE
    1762 magename2pver()
    1763 {
    1764 local i pver
    1765
    1766 i="$(basename $1 .mage)"
    1767 i="${i/$(magename2pname $1)-/}"
    1768 pver="${i%-*}"
    1769 echo "${pver}"
    1770 }
    1771
    1772 # returns pbuild from magename
    1773 # magename2pbuild /PATH/TO/MAGE/FILE
    1774 magename2pbuild()
    1775 {
    1776 local i pbuild
    1777
    1778 i="$(basename $1 .mage)"
    1779 pbuild="${i##*-}"
    1780 echo "${pbuild}"
    1781 }
    1782
    1783 # returns pcat from magename
    1784 # magename2pcat /PATH/TO/MAGE/FILE
    1785 magename2pcat()
    1786 {
    1787 local i pcat
    1788
    1789 if [[ ${2} = installdb ]]
    1790 then
    1791 # go 1 dir back
    1792 i="${1%/*}"
    1793 else
    1794 # go 2 dirs back
    1795 i="${1%/*/*}"
    1796 fi
    1797
    1798 # get basename
    1799 pcat="${i##*/}"
    1800 echo "${pcat}"
    1801 }
    1802
    1803 # returns pcat from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1804 # dep2pcat DEPEND
    1805 dep2pcat()
    1806 {
    1807 local pcat
    1808
    1809 pcat="${1%/*}"
    1810 echo "${pcat}"
    1811 }
    1812
    1813 # returns pname from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1814 # $2=virtual is used to resolv VDEPEND from virtual packages
    1815 # dep2pcat DEPEND (virtual)
    1816 dep2pname()
    1817 {
    1818 local pname
    1819
    1820 pname="${1##*/}"
    1821
    1822 # cut version only if not virtual or it will cut the name
    1823 if [[ $(dep2pcat $1) != virtual ]] && \
    1824 [[ $2 != virtual ]]
    1825 then
    1826 pname="${pname%-*}"
    1827 fi
    1828
    1829 echo "${pname}"
    1830 }
    1831
    1832 dep2highest_magefile()
    1833 {
    1834 local pcat
    1835 local pname
    1836 local magefile
    1837 local installed_virtuals
    1838
    1839 pcat="$(dep2pcat $1)"
    1840 pname="$(dep2pname $1)"
    1841
    1842 if [[ ${pcat} = virtual ]]
    1843 then
    1844 # first check if virtual is already installed
    1845 installed_virtuals="$(virtuals_read ${pcat}/${pname} showpkgs)"
    1846 if [ -n "${installed_virtuals}" ]
    1847 then
    1848 for vpkg in ${installed_virtuals}
    1849 do
    1850 realpkgname="${vpkg}"
    1851 virtualpkgname="${pcat}/${pname}"
    1852 pcat="$(dep2pcat ${realpkgname})"
    1853 pname="$(dep2pname ${realpkgname} virtual)"
    1854 done
    1855 else
    1856 # choose one from virtualdb defaults (virtuals.defaults)
    1857 realpkgname="$(default_virtualname_to_pkgname ${pcat}/${pname})"
    1858 virtualpkgname="${pcat}/${pname}"
    1859 pcat="$(dep2pcat ${realpkgname})"
    1860 pname="$(dep2pname ${realpkgname} virtual)"
    1861 fi
    1862 fi
    1863
    1864 magefile="$(get_highest_magefile ${pcat} ${pname})"
    1865 echo "${magefile}"
    1866 }
    1867
    1868 # is_installed ${PCAT}/${PNAME}-${PVER}-${PBUILD}
    1869 is_installed()
    1870 {
    1871 local fullpkgname="$1"
    1872
    1873 # return 0 if installed
    1874 [ -d ${MROOT}${INSTALLDB}/${fullpkgname} ] && return 0
    1875
    1876 return 1
    1877 }
    1878
    1879 install_packages()
    1880 {
    1881 local list="$@"
    1882 local pkg
    1883 local pcat
    1884 local pname
    1885 local pver
    1886 local pbuild
    1887 local total_pkgs
    1888 local current_pkg
    1889 local src_install
    1890 local uninstall_list
    1891
    1892 # check for --src-install
    1893 if [[ $1 = --src-install ]]
    1894 then
    1895 # remove --src-install from list
    1896 list=${list/--src-install/}
    1897 # enable src-install
    1898 src_install="--src-install"
    1899 fi
    1900
    1901 # reset MAGE_PROTECT_COUNTER
    1902 declare -i MAGE_PROTECT_COUNTER=0
    1903 export MAGE_PROTECT_COUNTER
    1904
    1905 # get count of total packages
    1906 declare -i total_pkgs=0
    1907 declare -i current_pkg=0
    1908 for i in ${list}; do (( total_pkgs++ )); done
    1909
    1910 echo
    1911
    1912 if [[ -n ${MROOT} ]]
    1913 then
    1914 echo -ne ${COLRED}
    1915 echo "!! installing in MROOT=${MROOT}"
    1916 echo -ne ${COLDEFAULT}
    1917 echo
    1918 fi
    1919
    1920 for pkg in ${list}
    1921 do
    1922 (( current_pkg++ ))
    1923 pcat=$(magename2pcat ${pkg})
    1924 pname=$(magename2pname ${pkg})
    1925 pver=$(magename2pver ${pkg})
    1926 pbuild=$(magename2pbuild ${pkg})
    1927
    1928 mage_install \
    1929 --pcat ${pcat} \
    1930 --pname ${pname} \
    1931 --pver ${pver} \
    1932 --pbuild ${pbuild} \
    1933 --count-total ${total_pkgs} \
    1934 --count-current ${current_pkg} \
    1935 ${src_install}
    1936
    1937 # check for allready installed packages and remove them
    1938 # except the package we have installed
    1939 uninstall_list="$(get_uninstall_candidates \
    1940 --pcat "${pcat}" \
    1941 --pname "${pname}" \
    1942 --protected ${pcat}/${pname}-${pver}-${pbuild})"
    1943
    1944 # uninstall all packges in uninstall_list if not empty
    1945 if [ -n "${uninstall_list}" ]
    1946 then
    1947 echo
    1948 uninstall_packages ${uninstall_list} \
    1949 || die "install_packges() uninstalling not-needed."
    1950 fi
    1951
    1952 # crlf for better view in VERBOSE mode
    1953 #if [[ ${VERBOSE} = on ]]; then echo; fi
    1954 echo
    1955 done
    1956
    1957 #echo "DEBUG MAGE_PROTECT_COUNTER=${MAGE_PROTECT_COUNTER}"
    1958 show_etc_update_mesg
    1959 }
    1960
    1961 # get_value_from_magefile VARIABLE
    1962 # returns the content of this VAR
    1963 get_value_from_magefile()
    1964 {
    1965 local var="$1"
    1966 local magefile="$2"
    1967 local value
    1968
    1969 # local all possible vars of a mage file
    1970 # to prevent bad issues
    1971 local PKGNAME
    1972 local STATE
    1973 local DESCRIPTION
    1974 local HOMEPAGE
    1975 local DEPEND
    1976 local SDEPEND
    1977 local PROVIDE
    1978 local PKGTYPE
    1979 local preinstall
    1980 local postinstall
    1981 local preremove
    1982 local postremove
    1983
    1984 # sanity checks
    1985 [ -f ${magefile} ] && source ${magefile} || \
    1986 die "get_value_from_magefile: ${magefile} not found."
    1987 [ -z "${var}" ] && die "get_value_from_magefile: \$var not given."
    1988
    1989 source ${magefile}
    1990 eval value=\$$(echo ${var})
    1991 echo "${value}"
    1992
    1993 # unset these functions
    1994 unset -f preinstall
    1995 unset -f postinstall
    1996 unset -f preremove
    1997 unset -f postremove
    1998 }
    1999
    2000 mage_install()
    2001 {
    2002 # local all possible vars of a mage file
    2003 # to prevent bad issues
    2004 local PKGNAME
    2005 local STATE
    2006 local DESCRIPTION
    2007 local HOMEPAGE
    2008 local DEPEND
    2009 local SDEPEND
    2010 local PROVIDE
    2011 local PKGTYPE
    2012 local preinstall
    2013 local postinstall
    2014 local preremove
    2015 local postremove
    2016
    2017 local pcat
    2018 local pname
    2019 local pver
    2020 local pbuild
    2021 local count_total
    2022 local count_current
    2023 local magefile
    2024 local src_install
    2025
    2026 # very basic getops
    2027 for i in $*
    2028 do
    2029 case $1 in
    2030 --pcat|-c) shift; pcat="$1" ;;
    2031 --pname|-n) shift; pname="$1" ;;
    2032 --pver|-v) shift; pver="$1" ;;
    2033 --pbuild|-b) shift; pbuild="$1" ;;
    2034 --count-total) shift; count_total="$1" ;;
    2035 --count-current) shift; count_current="$1" ;;
    2036 --src-install|-s) shift; src_install=true ;;
    2037 esac
    2038 shift
    2039 done
    2040
    2041 # sanity checks; abort if not given
    2042 [ -z "${pcat}" ] && die "mage_install() \$pcat not given."
    2043 [ -z "${pname}" ] && die "mage_install() \$pname not given."
    2044 [ -z "${pver}" ] && die "mage_install() \$pver not given."
    2045 [ -z "${pbuild}" ] && die "mage_install() \$pbuild not given."
    2046
    2047 # check needed global vars
    2048 [ -z "${MAGEDIR}" ] && die "mage_install() \$MAGEDIR not set."
    2049 [ -z "${INSTALLDB}" ] && die "mage_install() \$INSTALLDB not set."
    2050 [ -z "${BUILDDIR}" ] && die "mage_install() \$BUILDDIR not set."
    2051
    2052 xtitle "[ (${count_current}/${count_total}) Installing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2053 echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    2054 echo -n "installing (${count_current}/${count_total}): "
    2055 echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2056 echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2057
    2058 magefile="${MAGEDIR}/${pcat}/${pname}/${pname}-${pver}-${pbuild}.mage"
    2059 source ${magefile}
    2060
    2061 # abort on sources if no srcinstall
    2062 if [[ ${PKGTYPE} = sources ]] && [[ ${src_install} != true ]]
    2063 then
    2064 echo
    2065 echo -e "This Package is a Source Package."
    2066 echo
    2067 echo -e "Only 'srcinstall' works with this type of packages"
    2068 echo -en "If you have done a srcinstall before, "
    2069 echo -e "you will find the files in /usr/src."
    2070 echo
    2071 exit 1
    2072 fi
    2073
    2074 ## preinstall scripts
    2075 if [ -n "$(typeset -f preinstall)" ]
    2076 then
    2077 echo -e " ${COLBLUE}***${COLDEFAULT} running preinstall ... "
    2078 preinstall
    2079 unset preinstall
    2080 fi
    2081
    2082 if [[ ${src_install} = true ]]
    2083 then
    2084 local smage2file
    2085 # check needed global vars
    2086 [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not set."
    2087 [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not set."
    2088 [ -z "${BINDIR}" ] && die "\$BINDIR not set."
    2089
    2090 # build the package first
    2091 if [[ ${MAGEDEBUG} = on ]]
    2092 then
    2093 echo M:${pname}
    2094 echo V:${pver}
    2095 echo B:${pbuild}
    2096 fi
    2097
    2098 smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2
    2099 if [ -f "${smage2file}" ]
    2100 then
    2101 smage2 ${smage2file} || die "compile failed"
    2102 else
    2103 echo
    2104 echo "$(basename ${SMAGEFILE}) not found."
    2105 echo "update your smage-tree and try it again."
    2106 echo
    2107 die
    2108 fi
    2109 fi
    2110
    2111 if [[ ${PKGTYPE} != virtual ]] && \
    2112 [[ ${PKGTYPE} != sources ]]
    2113 then
    2114 # show a verbose message on src-install
    2115 if [[ ${src_install} = true ]]
    2116 then
    2117 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2118 echo -ne "merging files: "
    2119 echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2120 echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2121 fi
    2122 build_doinstall ${PKGNAME}
    2123 fi
    2124
    2125 ## postinstall scripts
    2126 if [ -n "$(typeset -f postinstall)" ]
    2127 then
    2128 echo -e " ${COLBLUE}***${COLDEFAULT} running postinstall ... "
    2129 postinstall
    2130 unset postinstall
    2131 fi
    2132
    2133 # install a database entry
    2134 install_database_entry \
    2135 --pcat "${pcat}" \
    2136 --pname "${pname}" \
    2137 --pver "${pver}" \
    2138 --pbuild "${pbuild}" \
    2139 --pkgname "${PKGNAME}" \
    2140 --pkgtype "${PKGTYPE}" \
    2141 || die "error in mage_install() running install_database_entry()."
    2142
    2143 # remove the package dir now
    2144 if [ -d ${BUILDDIR}/${PKGNAME} ]
    2145 then
    2146 rm -rf ${BUILDDIR}/${PKGNAME}
    2147 fi
    2148
    2149 # rebuilds toplevel info node
    2150 if [[ ${MAGE_INFO_REBUILD} = true ]]
    2151 then
    2152 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2153 echo -n "rebuilding top-level info node ... "
    2154 ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2155 > ${MROOT}/usr/share/info/dir && \
    2156 echo "done." || echo "failure."
    2157 unset MAGE_INFO_REBUILD
    2158 fi
    2159
    2160 # rebuilds the enviroment with the content of /etc/env.d
    2161 if [[ ${MAGE_ENV_REBUILD} = true ]]
    2162 then
    2163 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2164 echo -n "rebuilding environment ... "
    2165 ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2166 echo "done." || echo "failure."
    2167 unset MAGE_ENV_REBUILD
    2168 fi
    2169
    2170 xtitleclean
    2171
    2172 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2173 echo -n "package "
    2174 # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2175 # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2176 echo "successfully installed."
    2177
    2178 # unset these functions
    2179 unset -f preinstall
    2180 unset -f postinstall
    2181 unset -f preremove
    2182 unset -f postremove
    2183 }
    2184
    2185 md5sum_packages()
    2186 {
    2187 local list="$@"
    2188 local magefile
    2189 local pcat
    2190 local pname
    2191 local pkgname
    2192 local pkgfile
    2193 local pkgtype
    2194 local count_current
    2195 local count_total
    2196
    2197 # get count of total packages
    2198 declare -i count_current=0
    2199 declare -i count_total=0
    2200
    2201 for i in ${list}; do (( count_total++ )); done
    2202
    2203 for magefile in ${list}
    2204 do
    2205 pcat=$(magename2pcat ${magefile})
    2206 pname=$(magename2pname ${magefile})
    2207 pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
    2208 md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
    2209 pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"
    2210 pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
    2211
    2212 (( count_current++ ))
    2213 xtitle "[ (${count_current}/${count_total}) MD5SUM: ${pkgfile} ]"
    2214
    2215 # abort on virtual pkg
    2216 if [[ ${pkgtype} = virtual ]]
    2217 then
    2218 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2219 echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2220 continue
    2221 fi
    2222
    2223 # abort on sources pkg
    2224 if [[ ${pkgtype} = sources ]]
    2225 then
    2226 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2227 echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2228 continue
    2229 fi
    2230
    2231 if [ -f "${md5file}" ]
    2232 then
    2233 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2234 echo -ne "checking md5sum (${count_current}/${count_total}): "
    2235 ( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"
    2236 else
    2237 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2238 echo -e "!! no md5sum file found for ${pkgfile} :("
    2239 fi
    2240 done
    2241
    2242 # add a crlf for a better view
    2243 if [ ${count_total} -gt 1 ]; then echo; fi
    2244 }
    2245
    2246 ## uninstall_packages ulist
    2247 uninstall_packages()
    2248 {
    2249 local list="$@"
    2250 local pcat
    2251 local pname
    2252 local pver
    2253 local pbuild
    2254 local can_pcat
    2255 local can_pname
    2256 local can_ver_list
    2257
    2258 if [[ -n ${MROOT} ]]
    2259 then
    2260 echo -ne ${COLRED}
    2261 echo "!! uninstalling from MROOT=${MROOT}"
    2262 echo -ne ${COLDEFAULT}
    2263 echo
    2264 fi
    2265
    2266 # generate a candidates list
    2267 for pkg in ${list}
    2268 do
    2269 pcat=$(dep2pcat ${pkg})
    2270 pname=$(magename2pname ${pkg})
    2271 pver=$(magename2pver ${pkg})
    2272 pbuild=$(magename2pbuild ${pkg})
    2273 can_pcat="${pcat}"
    2274 can_pname="${pname}"
    2275
    2276 if [ -z "${can_ver_list}" ]
    2277 then
    2278 can_ver_list=" ${pver}-${pbuild}"
    2279 else
    2280 can_ver_list="${can_ver_list}, ${pver}-${pbuild}"
    2281 fi
    2282 done
    2283
    2284 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2285 echo "following candidate(s) will be removed:"
    2286 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2287 echo -ne "${COLBOLD}${can_pcat}/${can_pname}:${COLDEFAULT}"
    2288 echo -e "${COLRED} ${can_ver_list} ${COLDEFAULT}"
    2289 echo
    2290 if [ ${MAGE_UNINSTALL_TIMEOUT} -gt 0 ]
    2291 then
    2292 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2293 echo "( Press [CTRL+C] to abort )"
    2294 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2295 echo -n "Waiting ${MAGE_UNINSTALL_TIMEOUT} seconds ..."
    2296 for ((i=MAGE_UNINSTALL_TIMEOUT; i >= 0; i--))
    2297 do
    2298 echo -ne "${COLRED} ${i}${COLDEFAULT}"
    2299 sleep 1
    2300 done
    2301 echo
    2302 echo
    2303 fi
    2304
    2305 for pkg in ${list}
    2306 do
    2307 pcat=$(dep2pcat ${pkg})
    2308 pname=$(magename2pname ${pkg})
    2309 pver=$(magename2pver ${pkg})
    2310 pbuild=$(magename2pbuild ${pkg})
    2311
    2312 mage_uninstall \
    2313 --pcat ${pcat} \
    2314 --pname ${pname} \
    2315 --pver ${pver} \
    2316 --pbuild ${pbuild} \
    2317 --count-total ${total_pkgs} \
    2318 --count-current ${current_pkg} \
    2319 ${src_install}
    2320
    2321 # crlf for better view in VERBOSE mode
    2322 #if [[ ${VERBOSE} = on ]]; then echo; fi
    2323 echo
    2324 done
    2325 }
    2326
    2327 mage_uninstall()
    2328 {
    2329 # local all possible vars of a mage file
    2330 # to prevent bad issues
    2331 local PKGNAME
    2332 local STATE
    2333 local DESCRIPTION
    2334 local HOMEPAGE
    2335 local DEPEND
    2336 local SDEPEND
    2337 local PROVIDE
    2338 local PKGTYPE
    2339 local preinstall
    2340 local postinstall
    2341 local preremove
    2342 local postremove
    2343
    2344 local pcat
    2345 local pname
    2346 local pver
    2347 local pbuild
    2348 local magefile
    2349 local i
    2350
    2351 # very basic getops
    2352 for i in $*
    2353 do
    2354 case $1 in
    2355 --pcat|-c) shift; pcat="$1" ;;
    2356 --pname|-n) shift; pname="$1" ;;
    2357 --pver|-v) shift; pver="$1" ;;
    2358 --pbuild|-b) shift; pbuild="$1" ;;
    2359 esac
    2360 shift
    2361 done
    2362
    2363 # sanity checks; abort if not given
    2364 [ -z "${pcat}" ] && die "mage_uninstall() \$pcat not given."
    2365 [ -z "${pname}" ] && die "mage_uninstall() \$pname not given."
    2366 [ -z "${pver}" ] && die "mage_uninstall() \$pver not given."
    2367 [ -z "${pbuild}" ] && die "mage_uninstall() \$pbuild not given."
    2368
    2369 # check needed global vars
    2370 [ -z "${MAGEDIR}" ] && die "mage_uninstall() \$MAGEDIR not set."
    2371 [ -z "${INSTALLDB}" ] && die "mage_uninstall() \$INSTALLDB not set."
    2372 [ -z "${BUILDDIR}" ] && die "mage_uninstall() \$BUILDDIR not set."
    2373
    2374 xtitle "[ (${count_current}/${count_total}) Removing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2375 echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    2376 echo -n "removing: "
    2377 echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2378 echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2379
    2380 magefile="${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
    2381 source ${magefile}
    2382
    2383 ## preremove scripts
    2384 if [ -n "$(typeset -f preremove)" ]
    2385 then
    2386 echo -e " ${COLBLUE}***${COLDEFAULT} running preremove ... "
    2387 preremove
    2388 unset preremove
    2389 fi
    2390
    2391 # runs uninstall
    2392 build_douninstall \
    2393 --pcat "${pcat}" \
    2394 --pname "${pname}" \
    2395 --pver "${pver}" \
    2396 --pbuild "${pbuild}"
    2397
    2398 ## postremove scripts
    2399 if [ -n "$(typeset -f postremove)" ]
    2400 then
    2401 echo -e " ${COLBLUE}***${COLDEFAULT} running postremove ... "
    2402 postremove
    2403 unset postremove
    2404 fi
    2405
    2406 # removes the database entry
    2407 remove_database_entry \
    2408 --pcat "${pcat}" \
    2409 --pname "${pname}" \
    2410 --pver "${pver}" \
    2411 --pbuild "${pbuild}" \
    2412 || die "error in mage_uninstall() running remove_database_entry()."
    2413
    2414 # rebuilds toplevel info node
    2415 if [[ ${MAGE_INFO_REBUILD} = true ]]
    2416 then
    2417 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2418 echo -n "rebuilding top-level info node ... "
    2419 ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2420 > ${MROOT}/usr/share/info/dir && \
    2421 echo "done." || echo "failure."
    2422 unset MAGE_INFO_REBUILD
    2423 fi
    2424
    2425 # rebuilds the enviroment with the content of /etc/env.d
    2426 if [[ ${MAGE_ENV_REBUILD} = true ]]
    2427 then
    2428 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2429 echo -n "rebuilding environment ... "
    2430 ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2431 echo "done." || echo "failure."
    2432 unset MAGE_ENV_REBUILD
    2433 fi
    2434
    2435 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2436 echo -n "package "
    2437 # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2438 # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2439 echo "successfully removed."
    2440
    2441 # unset these functions
    2442 unset -f preinstall
    2443 unset -f postinstall
    2444 unset -f preremove
    2445 unset -f postremove
    2446 }
    2447
    2448 show_etc_update_mesg() {
    2449 [ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
    2450
    2451 echo
    2452 echo -ne "${COLRED}"
    2453 echo "Important:"
    2454 echo -ne ${COLDEFAULT}
    2455 echo "${MAGE_PROTECT_COUNTER} protected file(s) were installed."
    2456 echo
    2457 echo "Please run 'etc-update' to update your configuration files."
    2458 echo
    2459 }
    2460
    2461 pkgsearch()
    2462 {
    2463 local string="$1"
    2464 local result
    2465 local pkg
    2466 local pcat
    2467 local pname
    2468 local magefile
    2469 local pver
    2470 local pbuild
    2471 local state
    2472 local descriptiom
    2473 local homepage
    2474 local i
    2475 local all_installed
    2476 local ipver
    2477 local ipbuild
    2478
    2479 # only names no versions
    2480 result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name *${string}*)"
    2481 #result="$(find ${MAGEDIR} -type f -name *${string}*.mage | sort)"
    2482
    2483 # nothing found
    2484 [[ -z ${result} ]] && die "No package found containing '${string}' in the name."
    2485
    2486 for pkg in ${result}
    2487 do
    2488 # dirty, but does the job
    2489 pcat="$(magename2pcat ${pkg}/foo)"
    2490 pname="$(magename2pname ${pkg}-foo-foo)"
    2491
    2492 # get highest version available
    2493 magefile=$(get_highest_magefile ${pcat} ${pname})
    2494
    2495 # now get all needed infos to print a nice output
    2496 pver="$(magename2pver ${magefile})"
    2497 pbuild="$(magename2pbuild ${magefile})"
    2498 state="$(get_value_from_magefile STATE ${magefile})"
    2499 description="$(get_value_from_magefile DESCRIPTION ${magefile})"
    2500 homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
    2501
    2502 # all installed
    2503 for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
    2504 do
    2505 ipver="$(magename2pver ${i})"
    2506 ipbuild="$(magename2pbuild ${i})"
    2507
    2508 if [[ -z ${all_installed} ]]
    2509 then
    2510 all_installed="${ipver}-${ipbuild}"
    2511 else
    2512 all_installed="${all_installed} ${ipver}-${ipbuild}"
    2513 fi
    2514 done
    2515 [[ -z ${all_installed} ]] && all_installed="none"
    2516
    2517 case ${state} in
    2518 stable) state=${COLGREEN}"[s] ";;
    2519 testing) state=${COLYELLOW}"[t] ";;
    2520 unstable) state=${COLRED}"[u] ";;
    2521 old) state=${COLGRAY}"[o] ";;
    2522 esac
    2523
    2524 echo -e "${state}${pcat}/${pname}"${COLDEFAULT}
    2525 echo " Latest available: ${pver}-${pbuild}"
    2526 echo " Installed versions: ${all_installed}"
    2527 echo " Description: ${description}"
    2528 echo " Homepage: ${homepage}"
    2529 echo
    2530
    2531 unset pcat
    2532 unset pname
    2533 unset magefile
    2534 unset pver
    2535 unset pbuild
    2536 unset state
    2537 unset descriptiom
    2538 unset homepage
    2539 unset all_installed
    2540 unset ipver
    2541 unset ipbuild
    2542 done
    2543 }
    2544
    2545 export_inherits()
    2546 {
    2547 local include="$1"
    2548 shift
    2549
    2550 while [ "$1" ]
    2551 do
    2552 local functions="$1"
    2553
    2554 # sanity checks
    2555 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    2556 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    2557
    2558 eval "${functions}() { ${include}_${functions} ; }"
    2559
    2560 # debug
    2561 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    2562
    2563 shift
    2564 done
    2565 }