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