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 675 - (show annotations) (download) (as text)
    Sun Feb 10 12:26:09 2008 UTC (16 years, 2 months ago) by niro
    File MIME type: application/x-sh
    File size: 64182 byte(s) 
    -fixed src_install with MAGE_TARGETS enabled
    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.35 2008-02-10 12:26:09 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 ${MAGERC}."
    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 ${MAGERC}."
    1185 fi
    1186
    1187 local i
    1188 for i in ${RSYNC}
    1189 do
    1190 rsync ${RSYNC_FETCH_OPTIONS} ${i} ${MAGEDIR}
    1191 if [[ $? = 0 ]]
    1192 then
    1193 break
    1194 else
    1195 continue
    1196 fi
    1197 done
    1198
    1199 # clean up backup files (foo~)
    1200 find ${MAGEDIR} -name *~ -exec rm '{}' ';'
    1201
    1202 # check if an newer mage version is available
    1203 is_newer_mage_version_available
    1204 }
    1205
    1206 cleanpkg()
    1207 {
    1208 if [ -d "${PKGDIR}" ]
    1209 then
    1210 echo -n "Removing downloaded packages... "
    1211 rm -rf ${PKGDIR}/*
    1212 echo "done."
    1213 fi
    1214 }
    1215
    1216 xtitle()
    1217 {
    1218 if [[ ${TERM} = xterm ]]
    1219 then
    1220 echo -ne "\033]0;Mage: $1\007"
    1221 fi
    1222 return 0
    1223 }
    1224
    1225
    1226 xtitleclean()
    1227 {
    1228 if [[ ${TERM} = xterm ]]
    1229 then
    1230 echo -ne "\033]0;\007"
    1231 fi
    1232 return 0
    1233 }
    1234
    1235
    1236 # cuts full pathnames or versioniezed names down to basename
    1237 choppkgname()
    1238 {
    1239 #we want this only if full name was used
    1240 if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
    1241 then
    1242 #cuts ARCH and PBUILD
    1243 #ARCH comes from ${MAGERC}
    1244 MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}-r*.::g")
    1245
    1246 #cuts version number
    1247 MAGENAME=$(basename ${MAGENAME%-*} .mage)
    1248 fi
    1249 }
    1250
    1251 # get_categorie $PNAME, returns CATEGORIE
    1252 # $1=pname
    1253 # ret 0=ok, 1=not_found
    1254 pname2pcat()
    1255 {
    1256 local pname="$1"
    1257 local repo="$2"
    1258 local pcat
    1259 local categorie
    1260
    1261 for pcat in ${MAGEDIR}/*
    1262 do
    1263 if [ -d ${pcat}/${pname} ]
    1264 then
    1265 categorie=$(basename ${pcat})
    1266 fi
    1267 done
    1268
    1269 echo "${categorie}"
    1270 }
    1271
    1272 # check_stable_package /path/to/foo.mage
    1273 # returns 0=stable 1=unstable
    1274 check_stable_package()
    1275 {
    1276 # first check if this magefile is not blacklisted
    1277 blacklisted "$1" || return 1
    1278
    1279 local STATE
    1280 STATE="$(get_value_from_magefile STATE "$1")"
    1281
    1282 # state testing
    1283 if [[ ${USE_TESTING} = true ]] || [[ ${MAGE_DISTRIBUTION} = testing ]]
    1284 then
    1285 case ${STATE} in
    1286 testing|stable) return 0 ;;
    1287 *) return 1 ;;
    1288 esac
    1289 fi
    1290
    1291 # state unstable
    1292 if [[ ${USE_UNSTABLE} = true ]] || [[ ${MAGE_DISTRIBUTION} = unstable ]]
    1293 then
    1294 case ${STATE} in
    1295 unstable|testing|stable) return 0 ;;
    1296 *) return 1 ;;
    1297 esac
    1298 fi
    1299
    1300 # no use_state given = stable
    1301 case ${STATE} in
    1302 stable) return 0 ;;
    1303 *) return 1 ;;
    1304 esac
    1305 }
    1306
    1307
    1308 # get_highest_magefile ${PCAT} ${PNAME}
    1309 # fake at moment returns only stable pkgs (must set to be one)
    1310 # return $HIGHEST_MAGEFILE
    1311 get_highest_magefile()
    1312 {
    1313 local HIGHEST_MAGEFILE
    1314 local PCAT="$1"
    1315 local PNAME="$2"
    1316 local magefile
    1317
    1318 for magefile in $(ls --format=single-column -v ${MAGEDIR}/${PCAT}/${PNAME}/*)
    1319 do
    1320 # we exclude subdirs (for stuff like a md5sum dir)
    1321 [ -d ${magefile} ] && continue
    1322 if check_stable_package ${magefile}
    1323 then
    1324 HIGHEST_MAGEFILE=${magefile}
    1325 #for debug only
    1326 [[ ${MAGEDEBUG} = on ]] && echo "HIGHEST_MAGEFILE=${HIGHEST_MAGEFILE}"
    1327 fi
    1328 done
    1329
    1330 # do not so anything
    1331 # # stop here if HIGHEST_MAGEFILE is zero
    1332 # # this package must be unstable or old
    1333 # if [ -z "${HIGHEST_MAGEFILE}" ]
    1334 # then
    1335 # echo
    1336 # echo -n "All packages named "
    1337 # echo -en ${COLRED}\""${PKGNAME%-*-*-*}\""${COLDEFAULT}
    1338 # echo -n " are marked "
    1339 # echo -en ${COLRED}"*UNSTABLE*"${COLDEFAULT}
    1340 # echo "."
    1341 # echo "You need to declare USE_UNSTABLE=true to install this."
    1342 # echo
    1343 # echo "Example:"
    1344 # echo " USE_UNSTABLE=true mage install ${PKGNAME%-*-*-*}"
    1345 # echo
    1346 # echo "Be warned that these packages are not stable and may cause serious problems."
    1347 # echo "You should know what you are doing, so don't complain about any damage."
    1348 # echo
    1349 # return 1
    1350 # fi
    1351
    1352 echo "${HIGHEST_MAGEFILE}"
    1353 return 0
    1354 }
    1355
    1356
    1357 ###################################################
    1358 # function is_config_protected #
    1359 # is_config_protected /path/to/file #
    1360 # #
    1361 # returns: #
    1362 # 0 - not protected #
    1363 # 1 - error #
    1364 # 2 - protected #
    1365 # 3 - protected but masked #
    1366 # #
    1367 ###################################################
    1368 is_config_protected()
    1369 {
    1370 local EXPFILE
    1371 local TEST
    1372 local PROTECTED
    1373 local IFS
    1374
    1375 EXPFILE="${MROOT}$1"
    1376
    1377 # file does not exist; it can be written
    1378 [[ ! -e ${EXPFILE} ]] && return 0
    1379
    1380 # to be safe; it may be '§'
    1381 IFS=' '
    1382
    1383 # check ob in config protect
    1384 for i in ${CONFIG_PROTECT}
    1385 do
    1386 # ersetzen von $i nur wenn am anfang der variable
    1387 TEST="${EXPFILE/#${MROOT}${i}/Protected}"
    1388 if [[ ${TEST} != ${EXPFILE} ]]
    1389 then
    1390 # setzen das es protected ist
    1391 PROTECTED=TRUE
    1392
    1393 # check ob nicht doch maskiert
    1394 for x in ${CONFIG_PROTECT_MASK}
    1395 do
    1396 TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"
    1397 if [[ ${TEST} != ${EXPFILE} ]]
    1398 then
    1399 PROTECTED=MASKED
    1400 fi
    1401 done
    1402 fi
    1403 done
    1404
    1405 unset IFS
    1406
    1407 case ${PROTECTED} in
    1408 TRUE)
    1409 #echo "I'm protected"
    1410 return 2
    1411 ;;
    1412 MASKED)
    1413 #echo "I'm protected, but masked - delete me"
    1414 return 3
    1415 ;;
    1416 *)
    1417 #echo "delete me"
    1418 return 0
    1419 ;;
    1420 esac
    1421 }
    1422
    1423
    1424 ###################################################
    1425 # function count_protected_files #
    1426 # count_protected_files /path/to/file #
    1427 # #
    1428 # note: prints number of protected files #
    1429 # exp: 0012 #
    1430 ###################################################
    1431 count_protected_files()
    1432 {
    1433 local file="$1"
    1434 local dirname="${file%/*}"
    1435 local filename="${file##*/}"
    1436 local count
    1437 local output
    1438 local i
    1439
    1440 declare -i count=0
    1441
    1442 # check if there are already protected files
    1443 for oldpretected in $(find ${dirname} -iname "._cfg????_${filename}" |
    1444 sed -e "s:\(^.*/\)\(._cfg*_\)\(/.*$\):\1\2\3\%\2\%\3:" |
    1445 sort -t'%' -k3 -k2 | cut -f1 -d'%')
    1446 do
    1447 count=$(echo ${oldpretected} | cut -d_ -f2 | sed -e "s:cfg::")
    1448 done
    1449 (( count ++ ))
    1450
    1451 # fill output up with zeros
    1452 for (( i=${#count}; i < 4; i++ )); do output="${output}0"; done
    1453 output="${output}${count}"
    1454
    1455 echo "${output}"
    1456 }
    1457
    1458 # call with
    1459 # 'get_uninstall_candidates (--pcat cat --protected pcat/pfull) --pname PNAME'
    1460 # returns /path/to/magefile(s)
    1461 get_uninstall_candidates()
    1462 {
    1463 local search_pname
    1464 local pkg
    1465 local pcat
    1466 local pname
    1467 local pver
    1468 local pbuild
    1469 local list
    1470 local pcatdir
    1471 local protected
    1472 local i
    1473
    1474 # very basic getops
    1475 for i in $*
    1476 do
    1477 case $1 in
    1478 --pcat|-c) shift; pcatdir="$1" ;;
    1479 --pname|-n) shift; search_pname="$1" ;;
    1480 --protected|-p) shift; protected="$1" ;;
    1481 esac
    1482 shift
    1483 done
    1484
    1485 # it's not good to complain here about empty pnames; better to continue later anyway
    1486 # # sanity checks; abort if not given
    1487 # [ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."
    1488
    1489
    1490 # check needed global vars
    1491 [ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."
    1492
    1493 # set pcatdir to '*' if empty
    1494 [ -z "${pcatdir}" ] && pcatdir='*'
    1495
    1496 for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*
    1497 do
    1498 # abort if not a dir
    1499 [ ! -d ${pkg} ] && continue
    1500
    1501 pname="$(magename2pname ${pkg})"
    1502
    1503 if [[ ${search_pname} = ${pname} ]]
    1504 then
    1505 pcat="$(magename2pcat ${pkg} installdb)"
    1506 pver="$(magename2pver ${pkg})"
    1507 pbuild="$(magename2pbuild ${pkg})"
    1508
    1509 # exclude proteced
    1510 [[ ${protected} = ${pcat}/${pname}-${pver}-${pbuild} ]] && continue
    1511
    1512 list="${list} ${pcat}/${pname}-${pver}-${pbuild}"
    1513 fi
    1514 done
    1515
    1516 echo "${list}"
    1517 }
    1518
    1519 # reads virtualdb file
    1520 #$1 = virtualname; $2 commands: showpkgs, showline
    1521 #return 0 == installed -> shows installed pkg as well
    1522 #return 1 == not installed
    1523 virtuals_read()
    1524 {
    1525 local virtualname="$1"
    1526 local command="$2"
    1527 local virtline
    1528 local line x i
    1529
    1530 # parse file to get virtual_name line
    1531 IFS=$'\n'
    1532 for line in $(< ${MROOT}${VIRTUALDB_FILE})
    1533 do
    1534 IFS=$' '
    1535 for x in ${line}
    1536 do
    1537 if [[ ${x} = ${virtualname} ]]
    1538 then
    1539 virtline="${line}"
    1540 [[ ${command} = showline ]] && echo "${line}"
    1541 fi
    1542 done
    1543 IFS=$'\n'
    1544 done
    1545
    1546 unset IFS
    1547
    1548 # now read the packages linked to VIRTUAL_NAME and output them
    1549 if [ -n "${virtline}" ]
    1550 then
    1551 if [[ ${command} = showpkgs ]]
    1552 then
    1553 declare -i x=0
    1554 for i in ${virtline}
    1555 do
    1556 if [ ${x} -ge 1 ]
    1557 then
    1558 echo "${i}"
    1559 fi
    1560 ((x++))
    1561 done
    1562 fi
    1563 return 0
    1564 fi
    1565 return 1
    1566 }
    1567
    1568
    1569 #add pkg to virtualdb
    1570 # $1 == virtualname $2= pkgname
    1571 # retvals: 0=ok,added; 1=error; 3=pkg already in virtual
    1572 virtuals_add()
    1573 {
    1574 local virtualname="$1"
    1575 local pkgname="$2"
    1576 local oldline
    1577 local line i
    1578 local installed_file
    1579 local OLDIFS
    1580
    1581 if virtuals_read ${virtualname}
    1582 then
    1583 # make sure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already
    1584 for i in $(virtuals_read ${virtualname} showpkgs)
    1585 do
    1586 if [[ ${i} = ${pkgname} ]]
    1587 then
    1588 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1589 echo "${pkgname} already linked as ${virtualname} ..."
    1590 #return 3
    1591 return 0
    1592 fi
    1593 done
    1594
    1595 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1596 echo "updating ${virtualname} entry with ${pkgname} ..."
    1597 oldline="$(virtuals_read ${virtualname} showline)"
    1598
    1599 # make a backup
    1600 mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old
    1601
    1602 OLDIFS="${IFS}"
    1603 IFS=$'\n'
    1604 for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)
    1605 do
    1606 # if the right line, append ${pkgname}, else do nothing
    1607 if [[ ${line} = ${oldline} ]]
    1608 then
    1609 echo "${line} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1610 else
    1611 echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}
    1612 fi
    1613 done
    1614 # unset IFS
    1615 IFS="${OLDIFS}"
    1616 else
    1617 echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    1618 echo "register ${pkgname} as ${virtualname} ..."
    1619 echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1620 fi
    1621
    1622 return 0
    1623 }
    1624
    1625 #deletes pakages from virtual database
    1626 #$1 virtualname; $2 pkgname
    1627 virtuals_del() {
    1628
    1629 local virtualname="$1"
    1630 local pkgname="$2"
    1631 local oldline
    1632 local method
    1633 local line i x
    1634 local pkg_installed
    1635 local OLDIFS
    1636
    1637 # first check if exists
    1638 if virtuals_read ${virtualname}
    1639 then
    1640 # get method -> delall or update and check if ${PKG_NAME} exists in ${VIRTUAL_NAME}
    1641 declare -i x=0
    1642 for i in $(virtuals_read ${virtualname} showpkgs)
    1643 do
    1644 if [[ ${i} = ${pkgname} ]]
    1645 then
    1646 pkg_installed=true
    1647 fi
    1648 ((x++))
    1649 done
    1650
    1651 # abort if not installed
    1652 if [[ ${pkg_installed} != true ]]
    1653 then
    1654 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1655 echo "${pkgname} does not exists in ${virtualname}."
    1656 return 0
    1657 fi
    1658
    1659 if [ ${x} -ge 2 ]
    1660 then
    1661 method=update
    1662 else
    1663 method=delall
    1664 fi
    1665
    1666 # get the complete line
    1667 oldline="$(virtuals_read ${virtualname} showline)"
    1668
    1669 # make a backup of the db
    1670 mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old
    1671
    1672 # parse virtualdb
    1673 OLDIFS="${IFS}"
    1674 IFS=$'\n'
    1675 for line in $(< ${VIRTUALDB_FILE}.old)
    1676 do
    1677 if [[ ${line} = ${oldline} ]]
    1678 then
    1679 #delall or update?
    1680 case ${method} in
    1681 update)
    1682 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1683 echo "Unlinking ${pkgname} from ${virtualname} in virtual database ..."
    1684 # del PKG_NAME from line
    1685 echo "${line/ ${pkgname}/}" >> ${VIRTUALDB_FILE}
    1686 ;;
    1687 delall)
    1688 echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    1689 echo "Deleting ${virtualname} in virtual database ..."
    1690 # continue; do not write anything
    1691 continue
    1692 ;;
    1693 esac
    1694 else
    1695 echo "${line}" >> ${VIRTUALDB_FILE}
    1696 fi
    1697 done
    1698 # unset IFS
    1699 IFS="${OLDIFS}"
    1700 else
    1701 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1702 echo "${virtualname} does not exists in virtual database."
    1703 fi
    1704 }
    1705
    1706 # gets real pkgname from virtuals.default
    1707 #$1=VIRTUAL_NAME; returns PKG_NAME
    1708 default_virtualname_to_pkgname()
    1709 {
    1710 local VIRTUAL_NAME PKG_NAME db_virtualname db_pkgname
    1711
    1712 VIRTUAL_NAME=$1
    1713
    1714 while read db_virtualname db_pkgname
    1715 do
    1716 if [ "${db_virtualname}" == "${VIRTUAL_NAME}" ]
    1717 then
    1718 PKG_NAME="${db_pkgname}"
    1719 fi
    1720 done << EOF
    1721 $(< ${VIRTUALDB_DEFAULTS})
    1722 EOF
    1723
    1724 if [ -n "${PKG_NAME}" ]
    1725 then
    1726 echo "${PKG_NAME}"
    1727 fi
    1728 }
    1729
    1730 minclude()
    1731 {
    1732 local i
    1733
    1734 if [[ -n $* ]]
    1735 then
    1736 for i in $*
    1737 do
    1738 [[ ${MAGEDEBUG} = on ]] && \
    1739 echo "--- Including ${MAGEDIR}/include/${i}.minc"
    1740 source ${MAGEDIR}/include/${i}.minc
    1741 done
    1742 [[ ${MAGEDEBUG} = on ]] && echo
    1743 fi
    1744 }
    1745
    1746 sminclude()
    1747 {
    1748 local i
    1749
    1750 if [[ -n $* ]]
    1751 then
    1752 for i in $*
    1753 do
    1754 echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    1755 source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    1756 done
    1757 echo
    1758 fi
    1759 }
    1760
    1761 # checks if an newer mage version is available
    1762 is_newer_mage_version_available()
    1763 {
    1764 local newest_mage
    1765 local installed_mage
    1766
    1767 newest_mage="$(basename $(get_highest_magefile app-mage mage) .mage)"
    1768 installed_mage="$(magequery -n mage | cut -d' ' -f5)"
    1769
    1770 if [[ ${newest_mage} > ${installed_mage} ]]
    1771 then
    1772 echo
    1773 echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}
    1774 echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}
    1775 echo "It is recommened to install this newer version"
    1776 echo "or your current system installation may break."
    1777 echo
    1778 echo -en "Please update mage by running "
    1779 echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}
    1780 echo
    1781 fi
    1782 }
    1783
    1784
    1785 # returns pname from pkgname
    1786 # pkgname2pname $PKGNAME
    1787 pkgname2pname()
    1788 {
    1789 local pname
    1790
    1791 pname="${1%-*-*-*}"
    1792 echo "${pname}"
    1793 }
    1794
    1795 # returns pver from pkgname
    1796 # pkgname2pver $PKGNAME
    1797 pkgname2pver()
    1798 {
    1799 local i pver
    1800
    1801 i="${1/$(pkgname2pname $1)-/}"
    1802 pver="${i%-*-*}"
    1803 echo "${pver}"
    1804 }
    1805
    1806 # returns pbuild from pkgname
    1807 # pkgname2pbuild $PKGNAME
    1808 pkgname2pbuild()
    1809 {
    1810 local pbuild
    1811
    1812 pbuild="${1##*-}"
    1813 echo "${pbuild}"
    1814 }
    1815
    1816 # returns parch from pkgname
    1817 # pkgname2parch $PKGNAME
    1818 pkgname2parch()
    1819 {
    1820 local i x parch
    1821
    1822 i="${1%-*-*}-"
    1823 x="${1%-*}"
    1824 parch="${x/${i}/}"
    1825 echo "${parch}"
    1826 }
    1827
    1828 # returns pname from magename
    1829 # magename2pname /PATH/TO/MAGE/FILE
    1830 magename2pname()
    1831 {
    1832 local i pname
    1833
    1834 i="$(basename $1 .mage)"
    1835 pname="${i%-*-*}"
    1836 echo "${pname}"
    1837 }
    1838
    1839 # returns pver from magename
    1840 # magename2pver /PATH/TO/MAGE/FILE
    1841 magename2pver()
    1842 {
    1843 local i pver
    1844
    1845 i="$(basename $1 .mage)"
    1846 i="${i/$(magename2pname $1)-/}"
    1847 pver="${i%-*}"
    1848 echo "${pver}"
    1849 }
    1850
    1851 # returns pbuild from magename
    1852 # magename2pbuild /PATH/TO/MAGE/FILE
    1853 magename2pbuild()
    1854 {
    1855 local i pbuild
    1856
    1857 i="$(basename $1 .mage)"
    1858 pbuild="${i##*-}"
    1859 echo "${pbuild}"
    1860 }
    1861
    1862 # returns pcat from magename
    1863 # magename2pcat /PATH/TO/MAGE/FILE
    1864 magename2pcat()
    1865 {
    1866 local i pcat
    1867
    1868 if [[ ${2} = installdb ]]
    1869 then
    1870 # go 1 dir back
    1871 i="${1%/*}"
    1872 else
    1873 # go 2 dirs back
    1874 i="${1%/*/*}"
    1875 fi
    1876
    1877 # get basename
    1878 pcat="${i##*/}"
    1879 echo "${pcat}"
    1880 }
    1881
    1882 # returns pcat from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1883 # dep2pcat DEPEND
    1884 dep2pcat()
    1885 {
    1886 local pcat
    1887
    1888 pcat="${1%/*}"
    1889 echo "${pcat}"
    1890 }
    1891
    1892 # returns pname from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1893 # $2=virtual is used to resolv VDEPEND from virtual packages
    1894 # dep2pcat DEPEND (virtual)
    1895 dep2pname()
    1896 {
    1897 local pname
    1898
    1899 pname="${1##*/}"
    1900
    1901 # cut version only if not virtual or it will cut the name
    1902 if [[ $(dep2pcat $1) != virtual ]] && \
    1903 [[ $2 != virtual ]]
    1904 then
    1905 pname="${pname%-*}"
    1906 fi
    1907
    1908 echo "${pname}"
    1909 }
    1910
    1911 dep2highest_magefile()
    1912 {
    1913 local pcat
    1914 local pname
    1915 local magefile
    1916 local installed_virtuals
    1917
    1918 pcat="$(dep2pcat $1)"
    1919 pname="$(dep2pname $1)"
    1920
    1921 if [[ ${pcat} = virtual ]]
    1922 then
    1923 # first check if virtual is already installed
    1924 installed_virtuals="$(virtuals_read ${pcat}/${pname} showpkgs)"
    1925 if [ -n "${installed_virtuals}" ]
    1926 then
    1927 for vpkg in ${installed_virtuals}
    1928 do
    1929 realpkgname="${vpkg}"
    1930 virtualpkgname="${pcat}/${pname}"
    1931 pcat="$(dep2pcat ${realpkgname})"
    1932 pname="$(dep2pname ${realpkgname} virtual)"
    1933 done
    1934 else
    1935 # choose one from virtualdb defaults (virtuals.defaults)
    1936 realpkgname="$(default_virtualname_to_pkgname ${pcat}/${pname})"
    1937 virtualpkgname="${pcat}/${pname}"
    1938 pcat="$(dep2pcat ${realpkgname})"
    1939 pname="$(dep2pname ${realpkgname} virtual)"
    1940 fi
    1941 fi
    1942
    1943 magefile="$(get_highest_magefile ${pcat} ${pname})"
    1944 echo "${magefile}"
    1945 }
    1946
    1947 # is_installed ${PCAT}/${PNAME}-${PVER}-${PBUILD}
    1948 is_installed()
    1949 {
    1950 local fullpkgname="$1"
    1951
    1952 # return 0 if installed
    1953 [ -d ${MROOT}${INSTALLDB}/${fullpkgname} ] && return 0
    1954
    1955 return 1
    1956 }
    1957
    1958 install_packages()
    1959 {
    1960 local list="$@"
    1961 local pkg
    1962 local pcat
    1963 local pname
    1964 local pver
    1965 local pbuild
    1966 local total_pkgs
    1967 local current_pkg
    1968 local src_install
    1969 local uninstall_list
    1970
    1971 # check for --src-install
    1972 if [[ $1 = --src-install ]]
    1973 then
    1974 # remove --src-install from list
    1975 list=${list/--src-install/}
    1976 # enable src-install
    1977 src_install="--src-install"
    1978 fi
    1979
    1980 # reset MAGE_PROTECT_COUNTER
    1981 declare -i MAGE_PROTECT_COUNTER=0
    1982 export MAGE_PROTECT_COUNTER
    1983
    1984 # get count of total packages
    1985 declare -i total_pkgs=0
    1986 declare -i current_pkg=0
    1987 for i in ${list}; do (( total_pkgs++ )); done
    1988
    1989 echo
    1990
    1991 if [[ -n ${MROOT} ]]
    1992 then
    1993 echo -ne ${COLRED}
    1994 echo "!! installing in MROOT=${MROOT}"
    1995 echo -ne ${COLDEFAULT}
    1996 echo
    1997 fi
    1998
    1999 for pkg in ${list}
    2000 do
    2001 (( current_pkg++ ))
    2002 pcat=$(magename2pcat ${pkg})
    2003 pname=$(magename2pname ${pkg})
    2004 pver=$(magename2pver ${pkg})
    2005 pbuild=$(magename2pbuild ${pkg})
    2006
    2007 mage_install \
    2008 --pcat ${pcat} \
    2009 --pname ${pname} \
    2010 --pver ${pver} \
    2011 --pbuild ${pbuild} \
    2012 --count-total ${total_pkgs} \
    2013 --count-current ${current_pkg} \
    2014 ${src_install}
    2015
    2016 # check for allready installed packages and remove them
    2017 # except the package we have installed
    2018 uninstall_list="$(get_uninstall_candidates \
    2019 --pcat "${pcat}" \
    2020 --pname "${pname}" \
    2021 --protected ${pcat}/${pname}-${pver}-${pbuild})"
    2022
    2023 # uninstall all packges in uninstall_list if not empty
    2024 if [ -n "${uninstall_list}" ]
    2025 then
    2026 echo
    2027 uninstall_packages ${uninstall_list} \
    2028 || die "install_packges() uninstalling not-needed."
    2029 fi
    2030
    2031 # crlf for better view in VERBOSE mode
    2032 #if [[ ${VERBOSE} = on ]]; then echo; fi
    2033 echo
    2034 done
    2035
    2036 #echo "DEBUG MAGE_PROTECT_COUNTER=${MAGE_PROTECT_COUNTER}"
    2037 show_etc_update_mesg
    2038 }
    2039
    2040 # get_value_from_magefile VARIABLE
    2041 # returns the content of this VAR
    2042 get_value_from_magefile()
    2043 {
    2044 local var="$1"
    2045 local magefile="$2"
    2046 local value
    2047
    2048 [[ -z ${var} ]] && return 1
    2049 [[ -z ${magefile} ]] && return 1
    2050
    2051 # local all possible vars of a mage file
    2052 # to prevent bad issues
    2053 local PKGNAME
    2054 local STATE
    2055 local DESCRIPTION
    2056 local HOMEPAGE
    2057 local DEPEND
    2058 local SDEPEND
    2059 local PROVIDE
    2060 local PKGTYPE
    2061 local preinstall
    2062 local postinstall
    2063 local preremove
    2064 local postremove
    2065
    2066 # sanity checks
    2067 [ -f ${magefile} ] && source ${magefile} || \
    2068 die "get_value_from_magefile: ${magefile} not found."
    2069 [ -z "${var}" ] && die "get_value_from_magefile: \$var not given."
    2070
    2071 source ${magefile}
    2072 eval value=\$$(echo ${var})
    2073 echo "${value}"
    2074
    2075 # unset these functions
    2076 unset -f preinstall
    2077 unset -f postinstall
    2078 unset -f preremove
    2079 unset -f postremove
    2080 }
    2081
    2082 mage_install()
    2083 {
    2084 # local all possible vars of a mage file
    2085 # to prevent bad issues
    2086 local PKGNAME
    2087 local STATE
    2088 local DESCRIPTION
    2089 local HOMEPAGE
    2090 local DEPEND
    2091 local SDEPEND
    2092 local PROVIDE
    2093 local PKGTYPE
    2094 local preinstall
    2095 local postinstall
    2096 local preremove
    2097 local postremove
    2098
    2099 local pcat
    2100 local pname
    2101 local pver
    2102 local pbuild
    2103 local count_total
    2104 local count_current
    2105 local magefile
    2106 local src_install
    2107
    2108 # very basic getops
    2109 for i in $*
    2110 do
    2111 case $1 in
    2112 --pcat|-c) shift; pcat="$1" ;;
    2113 --pname|-n) shift; pname="$1" ;;
    2114 --pver|-v) shift; pver="$1" ;;
    2115 --pbuild|-b) shift; pbuild="$1" ;;
    2116 --count-total) shift; count_total="$1" ;;
    2117 --count-current) shift; count_current="$1" ;;
    2118 --src-install|-s) shift; src_install=true ;;
    2119 esac
    2120 shift
    2121 done
    2122
    2123 # sanity checks; abort if not given
    2124 [ -z "${pcat}" ] && die "mage_install() \$pcat not given."
    2125 [ -z "${pname}" ] && die "mage_install() \$pname not given."
    2126 [ -z "${pver}" ] && die "mage_install() \$pver not given."
    2127 [ -z "${pbuild}" ] && die "mage_install() \$pbuild not given."
    2128
    2129 # check needed global vars
    2130 [ -z "${MAGEDIR}" ] && die "mage_install() \$MAGEDIR not set."
    2131 [ -z "${INSTALLDB}" ] && die "mage_install() \$INSTALLDB not set."
    2132 [ -z "${BUILDDIR}" ] && die "mage_install() \$BUILDDIR not set."
    2133
    2134 xtitle "[ (${count_current}/${count_total}) Installing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2135 echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    2136 echo -n "installing (${count_current}/${count_total}): "
    2137 echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2138 echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2139
    2140 magefile="${MAGEDIR}/${pcat}/${pname}/${pname}-${pver}-${pbuild}.mage"
    2141 source ${magefile}
    2142
    2143 # abort on sources if no srcinstall
    2144 if [[ ${PKGTYPE} = sources ]] && [[ ${src_install} != true ]]
    2145 then
    2146 echo
    2147 echo -e "This Package is a Source Package."
    2148 echo
    2149 echo -e "Only 'srcinstall' works with this type of packages"
    2150 echo -en "If you have done a srcinstall before, "
    2151 echo -e "you will find the files in /usr/src."
    2152 echo
    2153 exit 1
    2154 fi
    2155
    2156 ## preinstall scripts
    2157 if [ -n "$(typeset -f preinstall)" ]
    2158 then
    2159 echo -e " ${COLBLUE}***${COLDEFAULT} running preinstall ... "
    2160 preinstall
    2161 unset preinstall
    2162 fi
    2163
    2164 if [[ ${src_install} = true ]]
    2165 then
    2166 local smage2file
    2167 # check needed global vars
    2168 [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not set."
    2169 [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not set."
    2170 [ -z "${BINDIR}" ] && die "\$BINDIR not set."
    2171
    2172 # build the package first
    2173 if [[ ${MAGEDEBUG} = on ]]
    2174 then
    2175 echo M:${pname}
    2176 echo V:${pver}
    2177 echo B:${pbuild}
    2178 fi
    2179
    2180 if [[ -z ${MAGE_TARGETS} ]]
    2181 then
    2182 smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2
    2183 else
    2184 smage2file=${SMAGESCRIPTSDIR}/${pname/${MAGE_TARGETS}/}/${pname/${MAGE_TARGETS}/}-${pver}-${pbuild}.smage2
    2185 fi
    2186 if [ -f "${smage2file}" ]
    2187 then
    2188 echo -e " ${COLBLUE}***${COLDEFAULT} building package from source ... "
    2189 smage2 ${smage2file} || die "compile failed"
    2190 else
    2191 echo
    2192 echo "$(basename ${SMAGEFILE}) not found."
    2193 echo "update your smage-tree and try it again."
    2194 echo
    2195 die
    2196 fi
    2197 fi
    2198
    2199 if [[ ${PKGTYPE} != virtual ]] && \
    2200 [[ ${PKGTYPE} != sources ]]
    2201 then
    2202 echo -e " ${COLBLUE}***${COLDEFAULT} merging files into system ... "
    2203 build_doinstall ${PKGNAME}
    2204 fi
    2205
    2206 ## postinstall scripts
    2207 if [ -n "$(typeset -f postinstall)" ]
    2208 then
    2209 echo -e " ${COLBLUE}***${COLDEFAULT} running postinstall ... "
    2210 postinstall
    2211 unset postinstall
    2212 fi
    2213
    2214 # install a database entry
    2215 install_database_entry \
    2216 --pcat "${pcat}" \
    2217 --pname "${pname}" \
    2218 --pver "${pver}" \
    2219 --pbuild "${pbuild}" \
    2220 --pkgname "${PKGNAME}" \
    2221 --pkgtype "${PKGTYPE}" \
    2222 || die "error in mage_install() running install_database_entry()."
    2223
    2224 # remove the package dir now
    2225 if [ -d ${BUILDDIR}/${PKGNAME} ]
    2226 then
    2227 rm -rf ${BUILDDIR}/${PKGNAME}
    2228 fi
    2229
    2230 # rebuilds toplevel info node
    2231 if [[ ${MAGE_INFO_REBUILD} = true ]]
    2232 then
    2233 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2234 echo -n "rebuilding top-level info node ... "
    2235 ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2236 > ${MROOT}/usr/share/info/dir && \
    2237 echo "done." || echo "failure."
    2238 unset MAGE_INFO_REBUILD
    2239 fi
    2240
    2241 # rebuilds the enviroment with the content of /etc/env.d
    2242 if [[ ${MAGE_ENV_REBUILD} = true ]]
    2243 then
    2244 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2245 echo -n "rebuilding environment ... "
    2246 ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2247 echo "done." || echo "failure."
    2248 unset MAGE_ENV_REBUILD
    2249 fi
    2250
    2251 xtitleclean
    2252
    2253 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2254 echo -n "package "
    2255 # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2256 # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2257 echo "successfully installed."
    2258
    2259 # unset these functions
    2260 unset -f preinstall
    2261 unset -f postinstall
    2262 unset -f preremove
    2263 unset -f postremove
    2264 }
    2265
    2266 md5sum_packages()
    2267 {
    2268 local list="$@"
    2269 local magefile
    2270 local pcat
    2271 local pname
    2272 local pkgname
    2273 local pkgfile
    2274 local pkgtype
    2275 local count_current
    2276 local count_total
    2277
    2278 # get count of total packages
    2279 declare -i count_current=0
    2280 declare -i count_total=0
    2281
    2282 for i in ${list}; do (( count_total++ )); done
    2283
    2284 for magefile in ${list}
    2285 do
    2286 pcat=$(magename2pcat ${magefile})
    2287 pname=$(magename2pname ${magefile})
    2288 pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
    2289 md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
    2290 pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"
    2291 pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
    2292
    2293 (( count_current++ ))
    2294 xtitle "[ (${count_current}/${count_total}) MD5SUM: ${pkgfile} ]"
    2295
    2296 # abort on virtual pkg
    2297 if [[ ${pkgtype} = virtual ]]
    2298 then
    2299 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2300 echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2301 continue
    2302 fi
    2303
    2304 # abort on sources pkg
    2305 if [[ ${pkgtype} = sources ]]
    2306 then
    2307 echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2308 echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2309 continue
    2310 fi
    2311
    2312 if [ -f "${md5file}" ]
    2313 then
    2314 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2315 echo -ne "checking md5sum (${count_current}/${count_total}): "
    2316 ( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"
    2317 else
    2318 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2319 echo -e "!! no md5sum file found for ${pkgfile} :("
    2320 fi
    2321 done
    2322
    2323 # add a crlf for a better view
    2324 if [ ${count_total} -gt 1 ]; then echo; fi
    2325 }
    2326
    2327 ## uninstall_packages ulist
    2328 uninstall_packages()
    2329 {
    2330 local list="$@"
    2331 local pcat
    2332 local pname
    2333 local pver
    2334 local pbuild
    2335 local can_pcat
    2336 local can_pname
    2337 local can_ver_list
    2338
    2339 if [[ -n ${MROOT} ]]
    2340 then
    2341 echo -ne ${COLRED}
    2342 echo "!! uninstalling from MROOT=${MROOT}"
    2343 echo -ne ${COLDEFAULT}
    2344 echo
    2345 fi
    2346
    2347 # generate a candidates list
    2348 for pkg in ${list}
    2349 do
    2350 pcat=$(dep2pcat ${pkg})
    2351 pname=$(magename2pname ${pkg})
    2352 pver=$(magename2pver ${pkg})
    2353 pbuild=$(magename2pbuild ${pkg})
    2354 can_pcat="${pcat}"
    2355 can_pname="${pname}"
    2356
    2357 if [ -z "${can_ver_list}" ]
    2358 then
    2359 can_ver_list=" ${pver}-${pbuild}"
    2360 else
    2361 can_ver_list="${can_ver_list}, ${pver}-${pbuild}"
    2362 fi
    2363 done
    2364
    2365 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2366 echo "following candidate(s) will be removed:"
    2367 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2368 echo -ne "${COLBOLD}${can_pcat}/${can_pname}:${COLDEFAULT}"
    2369 echo -e "${COLRED} ${can_ver_list} ${COLDEFAULT}"
    2370 echo
    2371 if [ ${MAGE_UNINSTALL_TIMEOUT} -gt 0 ]
    2372 then
    2373 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2374 echo "( Press [CTRL+C] to abort )"
    2375 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2376 echo -n "Waiting ${MAGE_UNINSTALL_TIMEOUT} seconds ..."
    2377 for ((i=MAGE_UNINSTALL_TIMEOUT; i >= 0; i--))
    2378 do
    2379 echo -ne "${COLRED} ${i}${COLDEFAULT}"
    2380 sleep 1
    2381 done
    2382 echo
    2383 echo
    2384 fi
    2385
    2386 for pkg in ${list}
    2387 do
    2388 pcat=$(dep2pcat ${pkg})
    2389 pname=$(magename2pname ${pkg})
    2390 pver=$(magename2pver ${pkg})
    2391 pbuild=$(magename2pbuild ${pkg})
    2392
    2393 mage_uninstall \
    2394 --pcat ${pcat} \
    2395 --pname ${pname} \
    2396 --pver ${pver} \
    2397 --pbuild ${pbuild} \
    2398 --count-total ${total_pkgs} \
    2399 --count-current ${current_pkg} \
    2400 ${src_install}
    2401
    2402 # crlf for better view in VERBOSE mode
    2403 #if [[ ${VERBOSE} = on ]]; then echo; fi
    2404 echo
    2405 done
    2406 }
    2407
    2408 mage_uninstall()
    2409 {
    2410 # local all possible vars of a mage file
    2411 # to prevent bad issues
    2412 local PKGNAME
    2413 local STATE
    2414 local DESCRIPTION
    2415 local HOMEPAGE
    2416 local DEPEND
    2417 local SDEPEND
    2418 local PROVIDE
    2419 local PKGTYPE
    2420 local preinstall
    2421 local postinstall
    2422 local preremove
    2423 local postremove
    2424
    2425 local pcat
    2426 local pname
    2427 local pver
    2428 local pbuild
    2429 local magefile
    2430 local i
    2431
    2432 # very basic getops
    2433 for i in $*
    2434 do
    2435 case $1 in
    2436 --pcat|-c) shift; pcat="$1" ;;
    2437 --pname|-n) shift; pname="$1" ;;
    2438 --pver|-v) shift; pver="$1" ;;
    2439 --pbuild|-b) shift; pbuild="$1" ;;
    2440 esac
    2441 shift
    2442 done
    2443
    2444 # sanity checks; abort if not given
    2445 [ -z "${pcat}" ] && die "mage_uninstall() \$pcat not given."
    2446 [ -z "${pname}" ] && die "mage_uninstall() \$pname not given."
    2447 [ -z "${pver}" ] && die "mage_uninstall() \$pver not given."
    2448 [ -z "${pbuild}" ] && die "mage_uninstall() \$pbuild not given."
    2449
    2450 # check needed global vars
    2451 [ -z "${MAGEDIR}" ] && die "mage_uninstall() \$MAGEDIR not set."
    2452 [ -z "${INSTALLDB}" ] && die "mage_uninstall() \$INSTALLDB not set."
    2453 [ -z "${BUILDDIR}" ] && die "mage_uninstall() \$BUILDDIR not set."
    2454
    2455 xtitle "[ (${count_current}/${count_total}) Removing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2456 echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    2457 echo -n "removing: "
    2458 echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2459 echo -e "${COLRED}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2460
    2461 magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
    2462 source ${magefile}
    2463
    2464 ## preremove scripts
    2465 if [ -n "$(typeset -f preremove)" ]
    2466 then
    2467 echo -e " ${COLBLUE}***${COLDEFAULT} running preremove ... "
    2468 preremove
    2469 unset preremove
    2470 fi
    2471
    2472 # runs uninstall
    2473 build_douninstall \
    2474 --pcat "${pcat}" \
    2475 --pname "${pname}" \
    2476 --pver "${pver}" \
    2477 --pbuild "${pbuild}"
    2478
    2479 ## postremove scripts
    2480 if [ -n "$(typeset -f postremove)" ]
    2481 then
    2482 echo -e " ${COLBLUE}***${COLDEFAULT} running postremove ... "
    2483 postremove
    2484 unset postremove
    2485 fi
    2486
    2487 # removes the database entry
    2488 remove_database_entry \
    2489 --pcat "${pcat}" \
    2490 --pname "${pname}" \
    2491 --pver "${pver}" \
    2492 --pbuild "${pbuild}" \
    2493 || die "error in mage_uninstall() running remove_database_entry()."
    2494
    2495 # rebuilds toplevel info node
    2496 if [[ ${MAGE_INFO_REBUILD} = true ]]
    2497 then
    2498 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2499 echo -n "rebuilding top-level info node ... "
    2500 ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2501 > ${MROOT}/usr/share/info/dir && \
    2502 echo "done." || echo "failure."
    2503 unset MAGE_INFO_REBUILD
    2504 fi
    2505
    2506 # rebuilds the enviroment with the content of /etc/env.d
    2507 if [[ ${MAGE_ENV_REBUILD} = true ]]
    2508 then
    2509 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2510 echo -n "rebuilding environment ... "
    2511 ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2512 echo "done." || echo "failure."
    2513 unset MAGE_ENV_REBUILD
    2514 fi
    2515
    2516 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2517 echo -n "package "
    2518 # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2519 # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2520 echo "successfully removed."
    2521
    2522 # unset these functions
    2523 unset -f preinstall
    2524 unset -f postinstall
    2525 unset -f preremove
    2526 unset -f postremove
    2527 }
    2528
    2529 show_etc_update_mesg() {
    2530 [ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
    2531
    2532 echo
    2533 echo -ne "${COLRED}"
    2534 echo "Important:"
    2535 echo -ne ${COLDEFAULT}
    2536 echo "${MAGE_PROTECT_COUNTER} protected file(s) were installed."
    2537 echo
    2538 echo "Please run 'etc-update' to update your configuration files."
    2539 echo
    2540 }
    2541
    2542 pkgsearch()
    2543 {
    2544 local string="$1"
    2545 local result
    2546 local pkg
    2547 local pcat
    2548 local pname
    2549 local magefile
    2550 local pver
    2551 local pbuild
    2552 local state
    2553 local descriptiom
    2554 local homepage
    2555 local i
    2556 local all_installed
    2557 local ipver
    2558 local ipbuild
    2559 local latest_available
    2560 local depsfull
    2561 local sdepsfull
    2562 local deps
    2563 local sdeps
    2564 local dep
    2565 local sign
    2566
    2567 # only names no versions
    2568 result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name '*'${string}'*'| sed '/profiles/d' | sed '/includes/d')"
    2569 #result="$(find ${MAGEDIR} -type f -name '*'${string}'*'.mage | sort)"
    2570
    2571 # nothing found
    2572 [[ -z ${result} ]] && die "No package found containing '${string}' in the name."
    2573
    2574 for pkg in ${result}
    2575 do
    2576 # dirty, but does the job
    2577 pcat="$(magename2pcat ${pkg}/foo)"
    2578 pname="$(magename2pname ${pkg}-foo-foo)"
    2579
    2580 # get highest version available
    2581 magefile=$(get_highest_magefile ${pcat} ${pname})
    2582
    2583 if [[ ! -z ${magefile} ]]
    2584 then
    2585 # now get all needed infos to print a nice output
    2586 pver="$(magename2pver ${magefile})"
    2587 pbuild="$(magename2pbuild ${magefile})"
    2588 state="$(get_value_from_magefile STATE ${magefile})"
    2589 description="$(get_value_from_magefile DESCRIPTION ${magefile})"
    2590 homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
    2591
    2592 # all installed
    2593 for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
    2594 do
    2595 ipver="$(magename2pver ${i})"
    2596 ipbuild="$(magename2pbuild ${i})"
    2597
    2598 if [[ -z ${all_installed} ]]
    2599 then
    2600 all_installed="${ipver}-${ipbuild}"
    2601 else
    2602 all_installed="${all_installed} ${ipver}-${ipbuild}"
    2603 fi
    2604 done
    2605 [[ -z ${all_installed} ]] && all_installed="none"
    2606
    2607 case ${state} in
    2608 stable) state=${COLGREEN}"[s] ";;
    2609 testing) state=${COLYELLOW}"[t] ";;
    2610 unstable) state=${COLRED}"[u] ";;
    2611 old) state=${COLGRAY}"[o] ";;
    2612 esac
    2613
    2614 latest_available="${pver}-${pbuild}"
    2615 else
    2616 # package is masked
    2617 state="${COLRED}[m] "
    2618 latest_available="${COLRED}masked for this distribution.${COLDEFAULT}"
    2619 fi
    2620
    2621 depsfull="$(get_value_from_magefile DEPEND ${magefile})"
    2622 sdepsfull="$(get_value_from_magefile SDEPEND ${magefile})"
    2623
    2624 while read sign dep
    2625 do
    2626 case ${dep} in
    2627 "") continue;;
    2628 esac
    2629
    2630 deps="${deps} $(basename ${dep%-*})"
    2631 done << EOF
    2632 ${depsfull}
    2633 EOF
    2634
    2635 while read sign dep
    2636 do
    2637 case ${dep} in
    2638 "") continue;;
    2639 esac
    2640
    2641 sdeps="${sdeps} $(basename ${dep%-*})"
    2642 done << EOF
    2643 ${sdepsfull}
    2644 EOF
    2645
    2646 echo -e "${state}${pcat}/${pname}"${COLDEFAULT}
    2647 echo -e " Latest available: ${latest_available}"
    2648 echo " Installed versions: ${all_installed}"
    2649 echo " Description: ${description}"
    2650 echo " Homepage: ${homepage}"
    2651 echo " Depends: ${deps}"
    2652 echo " SDepends: ${sdeps}"
    2653 echo
    2654
    2655 unset pcat
    2656 unset pname
    2657 unset magefile
    2658 unset pver
    2659 unset pbuild
    2660 unset state
    2661 unset descriptiom
    2662 unset homepage
    2663 unset all_installed
    2664 unset ipver
    2665 unset ipbuild
    2666 unset depsfull
    2667 unset sdepsfull
    2668 unset deps
    2669 unset sdeps
    2670 unset dep
    2671 unset sign
    2672 done
    2673 }
    2674
    2675 export_inherits()
    2676 {
    2677 local include="$1"
    2678 shift
    2679
    2680 while [ "$1" ]
    2681 do
    2682 local functions="$1"
    2683
    2684 # sanity checks
    2685 [ -z "${include}" ] && die "export_inherits(): \$include not given."
    2686 [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    2687
    2688 eval "${functions}() { ${include}_${functions} ; }"
    2689
    2690 # debug
    2691 [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    2692
    2693 shift
    2694 done
    2695 }
    2696
    2697 mlibdir()
    2698 {
    2699 local libdir=lib
    2700 [[ ${ARCH} = x86_64 ]] && libdir=lib64
    2701
    2702 echo "${libdir}"
    2703 }
    2704
    2705 ## blacklisted ${magefile}
    2706 blacklisted()
    2707 {
    2708 [[ -z ${MAGE_DISTRIBUTION} ]] && local MAGE_DISTRIBUTION=stable
    2709
    2710 # compat
    2711 [[ ${USE_UNSTABLE} = true ]] && local MAGE_DISTRIBUTION=unstable
    2712 [[ ${USE_TESTING} = true ]] && local MAGE_DISTRIBUTION=testing
    2713
    2714 local EXCLUDED="${MROOT}/etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION}"
    2715
    2716 # return 0 if the list not exist; nothin is masked
    2717 [[ ! -f ${EXCLUDED} ]] && return 0
    2718
    2719 local MAGEFILE="$1"
    2720
    2721 local PCAT="$(magename2pcat ${MAGEFILE})"
    2722 local PNAME="$(magename2pname ${MAGEFILE})"
    2723 local PVER="$(magename2pver ${MAGEFILE})"
    2724 local PBUILD="$(magename2pbuild ${MAGEFILE})"
    2725
    2726 local EXPCAT EXPNAME EXPVER EXPBUILD
    2727 while read EXPCAT EXPNAME EXPVER EXPBUILD
    2728 do
    2729 # ignore spaces and comments
    2730 case "${EXPCAT}" in
    2731 \#*|"") continue ;;
    2732 esac
    2733
    2734 # exclude full pver
    2735 if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
    2736 [[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
    2737 [[ -n ${PVER} ]] && [[ -n ${PBUILD} ]] &&
    2738 [[ -n ${EXPVER} ]] && [[ -n ${EXPBUILD} ]]
    2739 then
    2740 [[ ${EXPCAT}/${EXPNAME}-${EXPVER}-${EXPBUILD} = ${PCAT}/${PNAME}-${PVER}-${PBUILD} ]] && return 1
    2741 fi
    2742
    2743 # exclude pcat/pname only
    2744 if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
    2745 [[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
    2746 [[ -z ${EXPVER} ]] && [[ -z ${EXPBUILD} ]]
    2747 then
    2748 [[ ${EXPCAT}/${EXPNAME} = ${PCAT}/${PNAME} ]] && return 1
    2749 fi
    2750 done << EOF
    2751 $( cat ${EXCLUDED}; echo)
    2752 EOF
    2753
    2754 return 0
    2755 }
    2756