Magellan Linux

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

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

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 501 - (hide annotations) (download) (as text)
    Sat Jun 30 15:38:50 2007 UTC (16 years, 10 months ago) by niro
    File MIME type: application/x-sh
    File size: 63473 byte(s) 
    fixed a copy paste error
    1 niro 226 #!/bin/bash
    2     # Magellan Linux Installer Functions (mage.functions.sh)
    3 niro 501 # $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/mage4.functions.sh,v 1.33 2007-06-30 15:38:50 niro Exp $
    4 niro 226
    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 niro 312 local major
    365     local minor
    366 niro 226 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 niro 312 while read pathto posix major minor
    380 niro 226 do
    381     [ -z "${pathto}" ] && continue
    382     [[ ${VERBOSE} = on ]] && echo -e "\t>>> CHAR: ${MROOT}${pathto}"
    383    
    384 niro 314 mknod -m ${posix} "${MROOT}${pathto}" c ${major} ${minor}
    385 niro 226 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 niro 273 local i
    438 niro 226
    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 niro 273 for i in ${provide}
    510     do
    511     virtuals_add "${i}" "${pcat}/${pname}"
    512     done
    513 niro 226 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 niro 273 local i
    532 niro 226
    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 niro 294 # remove virtuals only if no other exist
    562     if [[ $(count_installed_pkgs --pcat ${pcat} --pname ${pname}) -le 1 ]]
    563 niro 226 then
    564 niro 294 # 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 niro 226 fi
    574    
    575     # removes database entry
    576     if [ -d ${dbrecorddir} ]
    577     then
    578     rm -rf ${dbrecorddir}
    579     fi
    580     }
    581    
    582 niro 294 # get the number of installed packages
    583     count_installed_pkgs()
    584     {
    585     local pcat
    586     local pname
    587     local pkg
    588     local i
    589 niro 226
    590 niro 294 # 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 niro 226 ###################################################
    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 niro 240 if [ ! -e "${MROOT}${pathto}" ]
    794 niro 226 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 niro 280 # 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 niro 226 ;;
    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 niro 240 # reversed order is mandatory !
    1010     tac ${MROOT}${INSTALLDB}/${pfull}/.dirs | while read pathto posix
    1011 niro 226 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 niro 240 echo -e "${COLRED}! .keep${COLDEFAULT} === DIR: ${MROOT}${pathto}"
    1026 niro 226 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 niro 240 done
    1043 niro 226
    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 niro 419 [ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your ${MAGERC}."
    1110 niro 226
    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 niro 286 ${opt} ${mirr}/${PACKAGES_SERVER_PATH}/${pkg}
    1162 niro 226 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 niro 419 die "You have no rsync-mirrors defined. Please edit your ${MAGERC}."
    1185 niro 226 fi
    1186    
    1187     local i
    1188     for i in ${RSYNC}
    1189     do
    1190 niro 386 rsync ${RSYNC_FETCH_OPTIONS} ${i} ${MAGEDIR}
    1191 niro 226 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 niro 419 #ARCH comes from ${MAGERC}
    1244 niro 226 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 niro 370 # first check if this magefile is not blacklisted
    1277     blacklisted "$1" || return 1
    1278    
    1279 niro 226 local STATE
    1280     STATE="$(get_value_from_magefile STATE "$1")"
    1281    
    1282     # state testing
    1283 niro 286 if [[ ${USE_TESTING} = true ]] || [[ ${MAGE_DISTRIBUTION} = testing ]]
    1284 niro 226 then
    1285     case ${STATE} in
    1286     testing|stable) return 0 ;;
    1287     *) return 1 ;;
    1288     esac
    1289     fi
    1290    
    1291     # state unstable
    1292 niro 286 if [[ ${USE_UNSTABLE} = true ]] || [[ ${MAGE_DISTRIBUTION} = unstable ]]
    1293 niro 226 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 niro 370 # 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 niro 226
    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 niro 451 [[ ! -e ${EXPFILE} ]] && return 0
    1379 niro 226
    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 niro 451 if [[ ${TEST} != ${EXPFILE} ]]
    1389 niro 226 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 niro 451 if [[ ${TEST} != ${EXPFILE} ]]
    1398 niro 226 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     ${MLIBDIR}/writeprotected "$1"
    1434     }
    1435    
    1436     # call with
    1437     # 'get_uninstall_candidates (--pcat cat --protected pcat/pfull) --pname PNAME'
    1438     # returns /path/to/magefile(s)
    1439     get_uninstall_candidates()
    1440     {
    1441     local search_pname
    1442     local pkg
    1443     local pcat
    1444     local pname
    1445     local pver
    1446     local pbuild
    1447     local list
    1448     local pcatdir
    1449     local protected
    1450 niro 449 local i
    1451 niro 226
    1452     # very basic getops
    1453     for i in $*
    1454     do
    1455     case $1 in
    1456     --pcat|-c) shift; pcatdir="$1" ;;
    1457     --pname|-n) shift; search_pname="$1" ;;
    1458     --protected|-p) shift; protected="$1" ;;
    1459     esac
    1460     shift
    1461     done
    1462    
    1463 niro 329 # it's not good to complain here about empty pnames; better to continue later anyway
    1464     # # sanity checks; abort if not given
    1465     # [ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."
    1466 niro 226
    1467    
    1468     # check needed global vars
    1469     [ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."
    1470    
    1471     # set pcatdir to '*' if empty
    1472 niro 329 [ -z "${pcatdir}" ] && pcatdir='*'
    1473 niro 226
    1474     for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*
    1475     do
    1476     # abort if not a dir
    1477     [ ! -d ${pkg} ] && continue
    1478    
    1479     pname="$(magename2pname ${pkg})"
    1480    
    1481     if [[ ${search_pname} = ${pname} ]]
    1482     then
    1483     pcat="$(magename2pcat ${pkg} installdb)"
    1484     pver="$(magename2pver ${pkg})"
    1485     pbuild="$(magename2pbuild ${pkg})"
    1486    
    1487     # exclude proteced
    1488     [[ ${protected} = ${pcat}/${pname}-${pver}-${pbuild} ]] && continue
    1489    
    1490     list="${list} ${pcat}/${pname}-${pver}-${pbuild}"
    1491     fi
    1492     done
    1493    
    1494     echo "${list}"
    1495     }
    1496    
    1497     # reads virtualdb file
    1498     #$1 = virtualname; $2 commands: showpkgs, showline
    1499     #return 0 == installed -> shows installed pkg as well
    1500     #return 1 == not installed
    1501     virtuals_read()
    1502     {
    1503     local virtualname="$1"
    1504     local command="$2"
    1505     local virtline
    1506     local line x i
    1507    
    1508     # parse file to get virtual_name line
    1509     IFS=$'\n'
    1510     for line in $(< ${MROOT}${VIRTUALDB_FILE})
    1511     do
    1512     IFS=$' '
    1513     for x in ${line}
    1514     do
    1515     if [[ ${x} = ${virtualname} ]]
    1516     then
    1517     virtline="${line}"
    1518     [[ ${command} = showline ]] && echo "${line}"
    1519     fi
    1520     done
    1521     IFS=$'\n'
    1522     done
    1523    
    1524     unset IFS
    1525    
    1526     # now read the packages linked to VIRTUAL_NAME and output them
    1527     if [ -n "${virtline}" ]
    1528     then
    1529     if [[ ${command} = showpkgs ]]
    1530     then
    1531     declare -i x=0
    1532     for i in ${virtline}
    1533     do
    1534     if [ ${x} -ge 1 ]
    1535     then
    1536     echo "${i}"
    1537     fi
    1538     ((x++))
    1539     done
    1540     fi
    1541     return 0
    1542     fi
    1543     return 1
    1544     }
    1545    
    1546    
    1547     #add pkg to virtualdb
    1548     # $1 == virtualname $2= pkgname
    1549     # retvals: 0=ok,added; 1=error; 3=pkg already in virtual
    1550     virtuals_add()
    1551     {
    1552     local virtualname="$1"
    1553     local pkgname="$2"
    1554     local oldline
    1555     local line i
    1556     local installed_file
    1557 niro 273 local OLDIFS
    1558 niro 226
    1559     if virtuals_read ${virtualname}
    1560     then
    1561 niro 329 # make sure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already
    1562 niro 226 for i in $(virtuals_read ${virtualname} showpkgs)
    1563     do
    1564     if [[ ${i} = ${pkgname} ]]
    1565     then
    1566     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1567     echo "${pkgname} already linked as ${virtualname} ..."
    1568     #return 3
    1569     return 0
    1570     fi
    1571     done
    1572    
    1573     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1574     echo "updating ${virtualname} entry with ${pkgname} ..."
    1575     oldline="$(virtuals_read ${virtualname} showline)"
    1576    
    1577     # make a backup
    1578     mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old
    1579    
    1580 niro 273 OLDIFS="${IFS}"
    1581 niro 226 IFS=$'\n'
    1582     for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)
    1583     do
    1584     # if the right line, append ${pkgname}, else do nothing
    1585     if [[ ${line} = ${oldline} ]]
    1586     then
    1587     echo "${line} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1588     else
    1589     echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}
    1590     fi
    1591     done
    1592 niro 273 # unset IFS
    1593     IFS="${OLDIFS}"
    1594 niro 226 else
    1595 niro 273 echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    1596 niro 226 echo "register ${pkgname} as ${virtualname} ..."
    1597     echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
    1598     fi
    1599    
    1600     return 0
    1601     }
    1602    
    1603     #deletes pakages from virtual database
    1604     #$1 virtualname; $2 pkgname
    1605     virtuals_del() {
    1606    
    1607 niro 273 local virtualname="$1"
    1608     local pkgname="$2"
    1609     local oldline
    1610     local method
    1611     local line i x
    1612     local pkg_installed
    1613     local OLDIFS
    1614    
    1615     # first check if exists
    1616     if virtuals_read ${virtualname}
    1617 niro 226 then
    1618 niro 273 # get method -> delall or update and check if ${PKG_NAME} exists in ${VIRTUAL_NAME}
    1619 niro 226 declare -i x=0
    1620 niro 273 for i in $(virtuals_read ${virtualname} showpkgs)
    1621 niro 226 do
    1622 niro 273 if [[ ${i} = ${pkgname} ]]
    1623 niro 226 then
    1624 niro 273 pkg_installed=true
    1625 niro 226 fi
    1626     ((x++))
    1627     done
    1628 niro 273
    1629     # abort if not installed
    1630     if [[ ${pkg_installed} != true ]]
    1631 niro 226 then
    1632 niro 273 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1633     echo "${pkgname} does not exists in ${virtualname}."
    1634 niro 226 return 0
    1635     fi
    1636 niro 273
    1637 niro 226 if [ ${x} -ge 2 ]
    1638     then
    1639 niro 273 method=update
    1640 niro 226 else
    1641 niro 273 method=delall
    1642 niro 226 fi
    1643 niro 273
    1644     # get the complete line
    1645     oldline="$(virtuals_read ${virtualname} showline)"
    1646    
    1647     # make a backup of the db
    1648 niro 226 mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old
    1649 niro 273
    1650     # parse virtualdb
    1651     OLDIFS="${IFS}"
    1652 niro 226 IFS=$'\n'
    1653     for line in $(< ${VIRTUALDB_FILE}.old)
    1654     do
    1655 niro 273 if [[ ${line} = ${oldline} ]]
    1656 niro 226 then
    1657     #delall or update?
    1658 niro 273 case ${method} in
    1659 niro 226 update)
    1660 niro 273 echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    1661     echo "Unlinking ${pkgname} from ${virtualname} in virtual database ..."
    1662     # del PKG_NAME from line
    1663     echo "${line/ ${pkgname}/}" >> ${VIRTUALDB_FILE}
    1664 niro 226 ;;
    1665     delall)
    1666 niro 273 echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    1667     echo "Deleting ${virtualname} in virtual database ..."
    1668     # continue; do not write anything
    1669 niro 226 continue
    1670     ;;
    1671     esac
    1672     else
    1673     echo "${line}" >> ${VIRTUALDB_FILE}
    1674     fi
    1675     done
    1676 niro 273 # unset IFS
    1677     IFS="${OLDIFS}"
    1678 niro 226 else
    1679 niro 273 echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    1680     echo "${virtualname} does not exists in virtual database."
    1681 niro 226 fi
    1682     }
    1683    
    1684     # gets real pkgname from virtuals.default
    1685     #$1=VIRTUAL_NAME; returns PKG_NAME
    1686     default_virtualname_to_pkgname()
    1687     {
    1688     local VIRTUAL_NAME PKG_NAME db_virtualname db_pkgname
    1689    
    1690     VIRTUAL_NAME=$1
    1691    
    1692     while read db_virtualname db_pkgname
    1693     do
    1694     if [ "${db_virtualname}" == "${VIRTUAL_NAME}" ]
    1695     then
    1696     PKG_NAME="${db_pkgname}"
    1697     fi
    1698     done << EOF
    1699     $(< ${VIRTUALDB_DEFAULTS})
    1700     EOF
    1701    
    1702     if [ -n "${PKG_NAME}" ]
    1703     then
    1704     echo "${PKG_NAME}"
    1705     fi
    1706     }
    1707    
    1708     minclude()
    1709     {
    1710     local i
    1711    
    1712 niro 437 if [[ -n $* ]]
    1713 niro 226 then
    1714 niro 437 for i in $*
    1715 niro 226 do
    1716     [[ ${MAGEDEBUG} = on ]] && \
    1717     echo "--- Including ${MAGEDIR}/include/${i}.minc"
    1718     source ${MAGEDIR}/include/${i}.minc
    1719     done
    1720     [[ ${MAGEDEBUG} = on ]] && echo
    1721     fi
    1722     }
    1723    
    1724     sminclude()
    1725     {
    1726     local i
    1727    
    1728 niro 437 if [[ -n $* ]]
    1729 niro 226 then
    1730 niro 437 for i in $*
    1731 niro 226 do
    1732     echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
    1733     source ${SMAGESCRIPTSDIR}/include/${i}.sminc
    1734     done
    1735     echo
    1736     fi
    1737     }
    1738    
    1739     # checks if an newer mage version is available
    1740     is_newer_mage_version_available()
    1741     {
    1742     local newest_mage
    1743     local installed_mage
    1744    
    1745 niro 252 newest_mage="$(basename $(get_highest_magefile app-mage mage) .mage)"
    1746 niro 226 installed_mage="$(magequery -n mage | cut -d' ' -f5)"
    1747    
    1748     if [[ ${newest_mage} > ${installed_mage} ]]
    1749     then
    1750     echo
    1751     echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}
    1752     echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}
    1753     echo "It is recommened to install this newer version"
    1754 niro 373 echo "or your current system installation may break."
    1755 niro 226 echo
    1756     echo -en "Please update mage by running "
    1757     echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}
    1758     echo
    1759     fi
    1760     }
    1761    
    1762    
    1763     # returns pname from pkgname
    1764     # pkgname2pname $PKGNAME
    1765     pkgname2pname()
    1766     {
    1767     local pname
    1768    
    1769     pname="${1%-*-*-*}"
    1770     echo "${pname}"
    1771     }
    1772    
    1773     # returns pver from pkgname
    1774     # pkgname2pver $PKGNAME
    1775     pkgname2pver()
    1776     {
    1777     local i pver
    1778    
    1779     i="${1/$(pkgname2pname $1)-/}"
    1780     pver="${i%-*-*}"
    1781     echo "${pver}"
    1782     }
    1783    
    1784     # returns pbuild from pkgname
    1785     # pkgname2pbuild $PKGNAME
    1786     pkgname2pbuild()
    1787     {
    1788     local pbuild
    1789    
    1790     pbuild="${1##*-}"
    1791     echo "${pbuild}"
    1792     }
    1793    
    1794     # returns parch from pkgname
    1795     # pkgname2parch $PKGNAME
    1796     pkgname2parch()
    1797     {
    1798     local i x parch
    1799    
    1800     i="${1%-*-*}-"
    1801     x="${1%-*}"
    1802     parch="${x/${i}/}"
    1803     echo "${parch}"
    1804     }
    1805    
    1806     # returns pname from magename
    1807     # magename2pname /PATH/TO/MAGE/FILE
    1808     magename2pname()
    1809     {
    1810     local i pname
    1811    
    1812     i="$(basename $1 .mage)"
    1813     pname="${i%-*-*}"
    1814     echo "${pname}"
    1815     }
    1816    
    1817     # returns pver from magename
    1818     # magename2pver /PATH/TO/MAGE/FILE
    1819     magename2pver()
    1820     {
    1821     local i pver
    1822    
    1823     i="$(basename $1 .mage)"
    1824     i="${i/$(magename2pname $1)-/}"
    1825     pver="${i%-*}"
    1826     echo "${pver}"
    1827     }
    1828    
    1829     # returns pbuild from magename
    1830     # magename2pbuild /PATH/TO/MAGE/FILE
    1831     magename2pbuild()
    1832     {
    1833     local i pbuild
    1834    
    1835     i="$(basename $1 .mage)"
    1836     pbuild="${i##*-}"
    1837     echo "${pbuild}"
    1838     }
    1839    
    1840     # returns pcat from magename
    1841     # magename2pcat /PATH/TO/MAGE/FILE
    1842     magename2pcat()
    1843     {
    1844     local i pcat
    1845    
    1846     if [[ ${2} = installdb ]]
    1847     then
    1848     # go 1 dir back
    1849     i="${1%/*}"
    1850     else
    1851     # go 2 dirs back
    1852     i="${1%/*/*}"
    1853     fi
    1854    
    1855     # get basename
    1856     pcat="${i##*/}"
    1857     echo "${pcat}"
    1858     }
    1859    
    1860     # returns pcat from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1861     # dep2pcat DEPEND
    1862     dep2pcat()
    1863     {
    1864     local pcat
    1865    
    1866     pcat="${1%/*}"
    1867     echo "${pcat}"
    1868     }
    1869    
    1870     # returns pname from DEPEND (without operand ! PCAT/PNAME-VERSION)
    1871     # $2=virtual is used to resolv VDEPEND from virtual packages
    1872     # dep2pcat DEPEND (virtual)
    1873     dep2pname()
    1874     {
    1875     local pname
    1876    
    1877     pname="${1##*/}"
    1878    
    1879     # cut version only if not virtual or it will cut the name
    1880     if [[ $(dep2pcat $1) != virtual ]] && \
    1881     [[ $2 != virtual ]]
    1882     then
    1883     pname="${pname%-*}"
    1884     fi
    1885    
    1886     echo "${pname}"
    1887     }
    1888    
    1889     dep2highest_magefile()
    1890     {
    1891     local pcat
    1892     local pname
    1893     local magefile
    1894     local installed_virtuals
    1895    
    1896     pcat="$(dep2pcat $1)"
    1897     pname="$(dep2pname $1)"
    1898    
    1899     if [[ ${pcat} = virtual ]]
    1900     then
    1901     # first check if virtual is already installed
    1902     installed_virtuals="$(virtuals_read ${pcat}/${pname} showpkgs)"
    1903     if [ -n "${installed_virtuals}" ]
    1904     then
    1905     for vpkg in ${installed_virtuals}
    1906     do
    1907     realpkgname="${vpkg}"
    1908     virtualpkgname="${pcat}/${pname}"
    1909     pcat="$(dep2pcat ${realpkgname})"
    1910     pname="$(dep2pname ${realpkgname} virtual)"
    1911     done
    1912     else
    1913     # choose one from virtualdb defaults (virtuals.defaults)
    1914     realpkgname="$(default_virtualname_to_pkgname ${pcat}/${pname})"
    1915     virtualpkgname="${pcat}/${pname}"
    1916     pcat="$(dep2pcat ${realpkgname})"
    1917     pname="$(dep2pname ${realpkgname} virtual)"
    1918     fi
    1919     fi
    1920    
    1921     magefile="$(get_highest_magefile ${pcat} ${pname})"
    1922     echo "${magefile}"
    1923     }
    1924    
    1925     # is_installed ${PCAT}/${PNAME}-${PVER}-${PBUILD}
    1926     is_installed()
    1927     {
    1928     local fullpkgname="$1"
    1929    
    1930     # return 0 if installed
    1931     [ -d ${MROOT}${INSTALLDB}/${fullpkgname} ] && return 0
    1932    
    1933     return 1
    1934     }
    1935    
    1936     install_packages()
    1937     {
    1938     local list="$@"
    1939     local pkg
    1940     local pcat
    1941     local pname
    1942     local pver
    1943     local pbuild
    1944     local total_pkgs
    1945     local current_pkg
    1946     local src_install
    1947     local uninstall_list
    1948    
    1949     # check for --src-install
    1950     if [[ $1 = --src-install ]]
    1951     then
    1952     # remove --src-install from list
    1953     list=${list/--src-install/}
    1954     # enable src-install
    1955     src_install="--src-install"
    1956     fi
    1957    
    1958     # reset MAGE_PROTECT_COUNTER
    1959     declare -i MAGE_PROTECT_COUNTER=0
    1960     export MAGE_PROTECT_COUNTER
    1961    
    1962     # get count of total packages
    1963     declare -i total_pkgs=0
    1964     declare -i current_pkg=0
    1965     for i in ${list}; do (( total_pkgs++ )); done
    1966    
    1967     echo
    1968    
    1969     if [[ -n ${MROOT} ]]
    1970     then
    1971     echo -ne ${COLRED}
    1972     echo "!! installing in MROOT=${MROOT}"
    1973     echo -ne ${COLDEFAULT}
    1974     echo
    1975     fi
    1976    
    1977     for pkg in ${list}
    1978     do
    1979     (( current_pkg++ ))
    1980     pcat=$(magename2pcat ${pkg})
    1981     pname=$(magename2pname ${pkg})
    1982     pver=$(magename2pver ${pkg})
    1983     pbuild=$(magename2pbuild ${pkg})
    1984    
    1985     mage_install \
    1986     --pcat ${pcat} \
    1987     --pname ${pname} \
    1988     --pver ${pver} \
    1989     --pbuild ${pbuild} \
    1990     --count-total ${total_pkgs} \
    1991     --count-current ${current_pkg} \
    1992     ${src_install}
    1993    
    1994     # check for allready installed packages and remove them
    1995     # except the package we have installed
    1996     uninstall_list="$(get_uninstall_candidates \
    1997     --pcat "${pcat}" \
    1998     --pname "${pname}" \
    1999     --protected ${pcat}/${pname}-${pver}-${pbuild})"
    2000    
    2001     # uninstall all packges in uninstall_list if not empty
    2002     if [ -n "${uninstall_list}" ]
    2003     then
    2004     echo
    2005     uninstall_packages ${uninstall_list} \
    2006     || die "install_packges() uninstalling not-needed."
    2007     fi
    2008    
    2009     # crlf for better view in VERBOSE mode
    2010     #if [[ ${VERBOSE} = on ]]; then echo; fi
    2011     echo
    2012     done
    2013    
    2014     #echo "DEBUG MAGE_PROTECT_COUNTER=${MAGE_PROTECT_COUNTER}"
    2015     show_etc_update_mesg
    2016     }
    2017    
    2018     # get_value_from_magefile VARIABLE
    2019     # returns the content of this VAR
    2020     get_value_from_magefile()
    2021     {
    2022     local var="$1"
    2023     local magefile="$2"
    2024     local value
    2025    
    2026 niro 370 [[ -z ${var} ]] && return 1
    2027     [[ -z ${magefile} ]] && return 1
    2028    
    2029 niro 226 # local all possible vars of a mage file
    2030     # to prevent bad issues
    2031     local PKGNAME
    2032     local STATE
    2033     local DESCRIPTION
    2034     local HOMEPAGE
    2035     local DEPEND
    2036     local SDEPEND
    2037     local PROVIDE
    2038     local PKGTYPE
    2039     local preinstall
    2040     local postinstall
    2041 niro 248 local preremove
    2042     local postremove
    2043 niro 226
    2044     # sanity checks
    2045     [ -f ${magefile} ] && source ${magefile} || \
    2046     die "get_value_from_magefile: ${magefile} not found."
    2047     [ -z "${var}" ] && die "get_value_from_magefile: \$var not given."
    2048    
    2049     source ${magefile}
    2050     eval value=\$$(echo ${var})
    2051     echo "${value}"
    2052 niro 248
    2053 niro 258 # unset these functions
    2054     unset -f preinstall
    2055     unset -f postinstall
    2056     unset -f preremove
    2057     unset -f postremove
    2058 niro 226 }
    2059    
    2060     mage_install()
    2061     {
    2062     # local all possible vars of a mage file
    2063     # to prevent bad issues
    2064     local PKGNAME
    2065     local STATE
    2066     local DESCRIPTION
    2067     local HOMEPAGE
    2068     local DEPEND
    2069     local SDEPEND
    2070     local PROVIDE
    2071     local PKGTYPE
    2072     local preinstall
    2073     local postinstall
    2074 niro 248 local preremove
    2075     local postremove
    2076 niro 226
    2077     local pcat
    2078     local pname
    2079     local pver
    2080     local pbuild
    2081     local count_total
    2082     local count_current
    2083     local magefile
    2084     local src_install
    2085    
    2086     # very basic getops
    2087     for i in $*
    2088     do
    2089     case $1 in
    2090     --pcat|-c) shift; pcat="$1" ;;
    2091     --pname|-n) shift; pname="$1" ;;
    2092     --pver|-v) shift; pver="$1" ;;
    2093     --pbuild|-b) shift; pbuild="$1" ;;
    2094     --count-total) shift; count_total="$1" ;;
    2095     --count-current) shift; count_current="$1" ;;
    2096     --src-install|-s) shift; src_install=true ;;
    2097     esac
    2098     shift
    2099     done
    2100    
    2101     # sanity checks; abort if not given
    2102     [ -z "${pcat}" ] && die "mage_install() \$pcat not given."
    2103     [ -z "${pname}" ] && die "mage_install() \$pname not given."
    2104     [ -z "${pver}" ] && die "mage_install() \$pver not given."
    2105     [ -z "${pbuild}" ] && die "mage_install() \$pbuild not given."
    2106    
    2107     # check needed global vars
    2108     [ -z "${MAGEDIR}" ] && die "mage_install() \$MAGEDIR not set."
    2109     [ -z "${INSTALLDB}" ] && die "mage_install() \$INSTALLDB not set."
    2110     [ -z "${BUILDDIR}" ] && die "mage_install() \$BUILDDIR not set."
    2111    
    2112     xtitle "[ (${count_current}/${count_total}) Installing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2113     echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
    2114     echo -n "installing (${count_current}/${count_total}): "
    2115     echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2116     echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2117    
    2118     magefile="${MAGEDIR}/${pcat}/${pname}/${pname}-${pver}-${pbuild}.mage"
    2119     source ${magefile}
    2120    
    2121     # abort on sources if no srcinstall
    2122     if [[ ${PKGTYPE} = sources ]] && [[ ${src_install} != true ]]
    2123     then
    2124     echo
    2125     echo -e "This Package is a Source Package."
    2126     echo
    2127     echo -e "Only 'srcinstall' works with this type of packages"
    2128     echo -en "If you have done a srcinstall before, "
    2129     echo -e "you will find the files in /usr/src."
    2130     echo
    2131     exit 1
    2132     fi
    2133    
    2134     ## preinstall scripts
    2135     if [ -n "$(typeset -f preinstall)" ]
    2136     then
    2137     echo -e " ${COLBLUE}***${COLDEFAULT} running preinstall ... "
    2138     preinstall
    2139     unset preinstall
    2140     fi
    2141    
    2142     if [[ ${src_install} = true ]]
    2143     then
    2144     local smage2file
    2145     # check needed global vars
    2146     [ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not set."
    2147     [ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not set."
    2148     [ -z "${BINDIR}" ] && die "\$BINDIR not set."
    2149    
    2150     # build the package first
    2151     if [[ ${MAGEDEBUG} = on ]]
    2152     then
    2153     echo M:${pname}
    2154     echo V:${pver}
    2155     echo B:${pbuild}
    2156     fi
    2157    
    2158     smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2
    2159     if [ -f "${smage2file}" ]
    2160     then
    2161 niro 385 echo -e " ${COLBLUE}***${COLDEFAULT} building package from source ... "
    2162 niro 226 smage2 ${smage2file} || die "compile failed"
    2163     else
    2164     echo
    2165     echo "$(basename ${SMAGEFILE}) not found."
    2166     echo "update your smage-tree and try it again."
    2167     echo
    2168     die
    2169     fi
    2170     fi
    2171    
    2172     if [[ ${PKGTYPE} != virtual ]] && \
    2173     [[ ${PKGTYPE} != sources ]]
    2174     then
    2175 niro 385 echo -e " ${COLBLUE}***${COLDEFAULT} merging files into system ... "
    2176 niro 226 build_doinstall ${PKGNAME}
    2177     fi
    2178    
    2179     ## postinstall scripts
    2180     if [ -n "$(typeset -f postinstall)" ]
    2181     then
    2182     echo -e " ${COLBLUE}***${COLDEFAULT} running postinstall ... "
    2183     postinstall
    2184     unset postinstall
    2185     fi
    2186    
    2187     # install a database entry
    2188     install_database_entry \
    2189     --pcat "${pcat}" \
    2190     --pname "${pname}" \
    2191     --pver "${pver}" \
    2192     --pbuild "${pbuild}" \
    2193     --pkgname "${PKGNAME}" \
    2194     --pkgtype "${PKGTYPE}" \
    2195     || die "error in mage_install() running install_database_entry()."
    2196    
    2197     # remove the package dir now
    2198     if [ -d ${BUILDDIR}/${PKGNAME} ]
    2199     then
    2200     rm -rf ${BUILDDIR}/${PKGNAME}
    2201     fi
    2202    
    2203     # rebuilds toplevel info node
    2204     if [[ ${MAGE_INFO_REBUILD} = true ]]
    2205     then
    2206     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2207     echo -n "rebuilding top-level info node ... "
    2208     ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2209     > ${MROOT}/usr/share/info/dir && \
    2210     echo "done." || echo "failure."
    2211     unset MAGE_INFO_REBUILD
    2212     fi
    2213    
    2214     # rebuilds the enviroment with the content of /etc/env.d
    2215     if [[ ${MAGE_ENV_REBUILD} = true ]]
    2216     then
    2217     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2218     echo -n "rebuilding environment ... "
    2219     ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2220     echo "done." || echo "failure."
    2221     unset MAGE_ENV_REBUILD
    2222     fi
    2223    
    2224     xtitleclean
    2225    
    2226     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2227     echo -n "package "
    2228     # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2229     # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2230     echo "successfully installed."
    2231 niro 248
    2232 niro 258 # unset these functions
    2233     unset -f preinstall
    2234     unset -f postinstall
    2235     unset -f preremove
    2236     unset -f postremove
    2237 niro 226 }
    2238    
    2239     md5sum_packages()
    2240     {
    2241     local list="$@"
    2242     local magefile
    2243     local pcat
    2244     local pname
    2245     local pkgname
    2246     local pkgfile
    2247     local pkgtype
    2248     local count_current
    2249     local count_total
    2250    
    2251     # get count of total packages
    2252     declare -i count_current=0
    2253     declare -i count_total=0
    2254    
    2255     for i in ${list}; do (( count_total++ )); done
    2256    
    2257     for magefile in ${list}
    2258     do
    2259     pcat=$(magename2pcat ${magefile})
    2260     pname=$(magename2pname ${magefile})
    2261     pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
    2262     md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
    2263     pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"
    2264     pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
    2265    
    2266     (( count_current++ ))
    2267     xtitle "[ (${count_current}/${count_total}) MD5SUM: ${pkgfile} ]"
    2268    
    2269     # abort on virtual pkg
    2270     if [[ ${pkgtype} = virtual ]]
    2271     then
    2272     echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2273     echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2274     continue
    2275     fi
    2276    
    2277     # abort on sources pkg
    2278     if [[ ${pkgtype} = sources ]]
    2279     then
    2280     echo -ne " ${COLBLUE}---${COLDEFAULT}"
    2281     echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "
    2282     continue
    2283     fi
    2284    
    2285     if [ -f "${md5file}" ]
    2286     then
    2287     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2288     echo -ne "checking md5sum (${count_current}/${count_total}): "
    2289     ( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"
    2290     else
    2291     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2292     echo -e "!! no md5sum file found for ${pkgfile} :("
    2293     fi
    2294     done
    2295    
    2296     # add a crlf for a better view
    2297     if [ ${count_total} -gt 1 ]; then echo; fi
    2298     }
    2299    
    2300     ## uninstall_packages ulist
    2301     uninstall_packages()
    2302     {
    2303     local list="$@"
    2304     local pcat
    2305     local pname
    2306     local pver
    2307     local pbuild
    2308     local can_pcat
    2309     local can_pname
    2310     local can_ver_list
    2311    
    2312     if [[ -n ${MROOT} ]]
    2313     then
    2314     echo -ne ${COLRED}
    2315     echo "!! uninstalling from MROOT=${MROOT}"
    2316     echo -ne ${COLDEFAULT}
    2317     echo
    2318     fi
    2319    
    2320     # generate a candidates list
    2321     for pkg in ${list}
    2322     do
    2323     pcat=$(dep2pcat ${pkg})
    2324     pname=$(magename2pname ${pkg})
    2325     pver=$(magename2pver ${pkg})
    2326     pbuild=$(magename2pbuild ${pkg})
    2327     can_pcat="${pcat}"
    2328     can_pname="${pname}"
    2329    
    2330     if [ -z "${can_ver_list}" ]
    2331     then
    2332     can_ver_list=" ${pver}-${pbuild}"
    2333     else
    2334     can_ver_list="${can_ver_list}, ${pver}-${pbuild}"
    2335     fi
    2336     done
    2337    
    2338     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2339     echo "following candidate(s) will be removed:"
    2340     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2341 niro 240 echo -ne "${COLBOLD}${can_pcat}/${can_pname}:${COLDEFAULT}"
    2342 niro 226 echo -e "${COLRED} ${can_ver_list} ${COLDEFAULT}"
    2343 niro 501 echo
    2344 niro 240 if [ ${MAGE_UNINSTALL_TIMEOUT} -gt 0 ]
    2345     then
    2346     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2347     echo "( Press [CTRL+C] to abort )"
    2348     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2349     echo -n "Waiting ${MAGE_UNINSTALL_TIMEOUT} seconds ..."
    2350     for ((i=MAGE_UNINSTALL_TIMEOUT; i >= 0; i--))
    2351     do
    2352     echo -ne "${COLRED} ${i}${COLDEFAULT}"
    2353     sleep 1
    2354     done
    2355     echo
    2356     echo
    2357     fi
    2358 niro 226
    2359     for pkg in ${list}
    2360     do
    2361     pcat=$(dep2pcat ${pkg})
    2362     pname=$(magename2pname ${pkg})
    2363     pver=$(magename2pver ${pkg})
    2364     pbuild=$(magename2pbuild ${pkg})
    2365    
    2366     mage_uninstall \
    2367     --pcat ${pcat} \
    2368     --pname ${pname} \
    2369     --pver ${pver} \
    2370     --pbuild ${pbuild} \
    2371     --count-total ${total_pkgs} \
    2372     --count-current ${current_pkg} \
    2373     ${src_install}
    2374    
    2375     # crlf for better view in VERBOSE mode
    2376     #if [[ ${VERBOSE} = on ]]; then echo; fi
    2377     echo
    2378     done
    2379     }
    2380    
    2381     mage_uninstall()
    2382     {
    2383     # local all possible vars of a mage file
    2384     # to prevent bad issues
    2385     local PKGNAME
    2386     local STATE
    2387     local DESCRIPTION
    2388     local HOMEPAGE
    2389     local DEPEND
    2390     local SDEPEND
    2391     local PROVIDE
    2392     local PKGTYPE
    2393     local preinstall
    2394     local postinstall
    2395 niro 248 local preremove
    2396     local postremove
    2397 niro 226
    2398     local pcat
    2399     local pname
    2400     local pver
    2401     local pbuild
    2402     local magefile
    2403     local i
    2404    
    2405     # very basic getops
    2406     for i in $*
    2407     do
    2408     case $1 in
    2409 niro 501 --pcat|-c) shift; pcat="$1" ;;
    2410 niro 226 --pname|-n) shift; pname="$1" ;;
    2411     --pver|-v) shift; pver="$1" ;;
    2412 niro 501 --pbuild|-b) shift; pbuild="$1" ;;
    2413 niro 226 esac
    2414     shift
    2415 niro 501 done
    2416 niro 226
    2417     # sanity checks; abort if not given
    2418 niro 501 [ -z "${pcat}" ] && die "mage_uninstall() \$pcat not given."
    2419 niro 226 [ -z "${pname}" ] && die "mage_uninstall() \$pname not given."
    2420     [ -z "${pver}" ] && die "mage_uninstall() \$pver not given."
    2421 niro 501 [ -z "${pbuild}" ] && die "mage_uninstall() \$pbuild not given."
    2422 niro 226
    2423     # check needed global vars
    2424     [ -z "${MAGEDIR}" ] && die "mage_uninstall() \$MAGEDIR not set."
    2425     [ -z "${INSTALLDB}" ] && die "mage_uninstall() \$INSTALLDB not set."
    2426     [ -z "${BUILDDIR}" ] && die "mage_uninstall() \$BUILDDIR not set."
    2427    
    2428     xtitle "[ (${count_current}/${count_total}) Removing ${pcat}/${pname}-${pver}-${pbuild} ]"
    2429     echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
    2430     echo -n "removing: "
    2431     echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2432 niro 416 echo -e "${COLRED}${pname}-${pver}-${pbuild}${COLDEFAULT}"
    2433 niro 226
    2434 niro 499 magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
    2435 niro 226 source ${magefile}
    2436    
    2437     ## preremove scripts
    2438     if [ -n "$(typeset -f preremove)" ]
    2439     then
    2440     echo -e " ${COLBLUE}***${COLDEFAULT} running preremove ... "
    2441     preremove
    2442     unset preremove
    2443     fi
    2444    
    2445     # runs uninstall
    2446     build_douninstall \
    2447     --pcat "${pcat}" \
    2448     --pname "${pname}" \
    2449     --pver "${pver}" \
    2450     --pbuild "${pbuild}"
    2451    
    2452     ## postremove scripts
    2453     if [ -n "$(typeset -f postremove)" ]
    2454     then
    2455     echo -e " ${COLBLUE}***${COLDEFAULT} running postremove ... "
    2456     postremove
    2457     unset postremove
    2458     fi
    2459    
    2460     # removes the database entry
    2461     remove_database_entry \
    2462     --pcat "${pcat}" \
    2463     --pname "${pname}" \
    2464     --pver "${pver}" \
    2465     --pbuild "${pbuild}" \
    2466     || die "error in mage_uninstall() running remove_database_entry()."
    2467    
    2468     # rebuilds toplevel info node
    2469     if [[ ${MAGE_INFO_REBUILD} = true ]]
    2470     then
    2471     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2472     echo -n "rebuilding top-level info node ... "
    2473     ${MLIBDIR}/mkinfodir ${MROOT}/usr/share/info \
    2474     > ${MROOT}/usr/share/info/dir && \
    2475     echo "done." || echo "failure."
    2476     unset MAGE_INFO_REBUILD
    2477     fi
    2478    
    2479     # rebuilds the enviroment with the content of /etc/env.d
    2480     if [[ ${MAGE_ENV_REBUILD} = true ]]
    2481     then
    2482     echo -ne "${COLBLUE} *** ${COLDEFAULT}"
    2483     echo -n "rebuilding environment ... "
    2484     ${MLIBDIR}/env-rebuild.sh > /dev/null && \
    2485     echo "done." || echo "failure."
    2486     unset MAGE_ENV_REBUILD
    2487     fi
    2488    
    2489     echo -ne "${COLBLUE} --- ${COLDEFAULT}"
    2490     echo -n "package "
    2491     # echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
    2492     # echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
    2493     echo "successfully removed."
    2494 niro 248
    2495 niro 258 # unset these functions
    2496     unset -f preinstall
    2497     unset -f postinstall
    2498     unset -f preremove
    2499     unset -f postremove
    2500 niro 226 }
    2501    
    2502     show_etc_update_mesg() {
    2503     [ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
    2504    
    2505     echo
    2506     echo -ne "${COLRED}"
    2507     echo "Important:"
    2508     echo -ne ${COLDEFAULT}
    2509     echo "${MAGE_PROTECT_COUNTER} protected file(s) were installed."
    2510     echo
    2511     echo "Please run 'etc-update' to update your configuration files."
    2512     echo
    2513     }
    2514 niro 237
    2515     pkgsearch()
    2516     {
    2517     local string="$1"
    2518     local result
    2519     local pkg
    2520     local pcat
    2521     local pname
    2522     local magefile
    2523     local pver
    2524     local pbuild
    2525     local state
    2526     local descriptiom
    2527     local homepage
    2528     local i
    2529     local all_installed
    2530     local ipver
    2531     local ipbuild
    2532 niro 445 local latest_available
    2533 niro 458 local depsfull
    2534     local sdepsfull
    2535     local deps
    2536     local sdeps
    2537     local dep
    2538     local sign
    2539 niro 237
    2540     # only names no versions
    2541 niro 391 result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name '*'${string}'*'| sed '/profiles/d' | sed '/includes/d')"
    2542 niro 328 #result="$(find ${MAGEDIR} -type f -name '*'${string}'*'.mage | sort)"
    2543 niro 237
    2544     # nothing found
    2545     [[ -z ${result} ]] && die "No package found containing '${string}' in the name."
    2546    
    2547     for pkg in ${result}
    2548     do
    2549     # dirty, but does the job
    2550     pcat="$(magename2pcat ${pkg}/foo)"
    2551     pname="$(magename2pname ${pkg}-foo-foo)"
    2552    
    2553     # get highest version available
    2554     magefile=$(get_highest_magefile ${pcat} ${pname})
    2555    
    2556 niro 445 if [[ ! -z ${magefile} ]]
    2557     then
    2558     # now get all needed infos to print a nice output
    2559     pver="$(magename2pver ${magefile})"
    2560     pbuild="$(magename2pbuild ${magefile})"
    2561     state="$(get_value_from_magefile STATE ${magefile})"
    2562     description="$(get_value_from_magefile DESCRIPTION ${magefile})"
    2563     homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
    2564    
    2565     # all installed
    2566     for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
    2567     do
    2568     ipver="$(magename2pver ${i})"
    2569     ipbuild="$(magename2pbuild ${i})"
    2570    
    2571     if [[ -z ${all_installed} ]]
    2572     then
    2573     all_installed="${ipver}-${ipbuild}"
    2574     else
    2575     all_installed="${all_installed} ${ipver}-${ipbuild}"
    2576     fi
    2577     done
    2578     [[ -z ${all_installed} ]] && all_installed="none"
    2579    
    2580     case ${state} in
    2581     stable) state=${COLGREEN}"[s] ";;
    2582     testing) state=${COLYELLOW}"[t] ";;
    2583     unstable) state=${COLRED}"[u] ";;
    2584     old) state=${COLGRAY}"[o] ";;
    2585     esac
    2586 niro 237
    2587 niro 445 latest_available="${pver}-${pbuild}"
    2588     else
    2589     # package is masked
    2590     state="${COLRED}[m] "
    2591     latest_available="${COLRED}masked for this distribution.${COLDEFAULT}"
    2592     fi
    2593 niro 237
    2594 niro 458 depsfull="$(get_value_from_magefile DEPEND ${magefile})"
    2595     sdepsfull="$(get_value_from_magefile SDEPEND ${magefile})"
    2596    
    2597     while read sign dep
    2598     do
    2599     case ${dep} in
    2600     "") continue;;
    2601     esac
    2602    
    2603     deps="${deps} $(basename ${dep%-*})"
    2604     done << EOF
    2605     ${depsfull}
    2606     EOF
    2607    
    2608     while read sign dep
    2609     do
    2610     case ${dep} in
    2611     "") continue;;
    2612     esac
    2613    
    2614     sdeps="${sdeps} $(basename ${dep%-*})"
    2615     done << EOF
    2616     ${sdepsfull}
    2617     EOF
    2618    
    2619 niro 237 echo -e "${state}${pcat}/${pname}"${COLDEFAULT}
    2620 niro 445 echo -e " Latest available: ${latest_available}"
    2621 niro 237 echo " Installed versions: ${all_installed}"
    2622     echo " Description: ${description}"
    2623     echo " Homepage: ${homepage}"
    2624 niro 458 echo " Depends: ${deps}"
    2625     echo " SDepends: ${sdeps}"
    2626 niro 237 echo
    2627    
    2628     unset pcat
    2629     unset pname
    2630     unset magefile
    2631     unset pver
    2632     unset pbuild
    2633     unset state
    2634     unset descriptiom
    2635     unset homepage
    2636     unset all_installed
    2637     unset ipver
    2638     unset ipbuild
    2639 niro 458 unset depsfull
    2640     unset sdepsfull
    2641     unset deps
    2642     unset sdeps
    2643     unset dep
    2644     unset sign
    2645 niro 237 done
    2646     }
    2647 niro 249
    2648     export_inherits()
    2649     {
    2650     local include="$1"
    2651     shift
    2652    
    2653     while [ "$1" ]
    2654     do
    2655     local functions="$1"
    2656    
    2657     # sanity checks
    2658     [ -z "${include}" ] && die "export_inherits(): \$include not given."
    2659     [ -z "${functions}" ] && die "export_inherits(): \$functions not given."
    2660    
    2661     eval "${functions}() { ${include}_${functions} ; }"
    2662    
    2663     # debug
    2664     [[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
    2665    
    2666     shift
    2667     done
    2668     }
    2669 niro 350
    2670     mlibdir()
    2671     {
    2672     local libdir=lib
    2673     [[ ${ARCH} = x86_64 ]] && libdir=lib64
    2674    
    2675     echo "${libdir}"
    2676     }
    2677 niro 370
    2678     ## blacklisted ${magefile}
    2679     blacklisted()
    2680     {
    2681     [[ -z ${MAGE_DISTRIBUTION} ]] && local MAGE_DISTRIBUTION=stable
    2682    
    2683     # compat
    2684     [[ ${USE_UNSTABLE} = true ]] && local MAGE_DISTRIBUTION=unstable
    2685     [[ ${USE_TESTING} = true ]] && local MAGE_DISTRIBUTION=testing
    2686    
    2687     local EXCLUDED="${MROOT}/etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION}"
    2688    
    2689     # return 0 if the list not exist; nothin is masked
    2690     [[ ! -f ${EXCLUDED} ]] && return 0
    2691    
    2692     local MAGEFILE="$1"
    2693    
    2694     local PCAT="$(magename2pcat ${MAGEFILE})"
    2695     local PNAME="$(magename2pname ${MAGEFILE})"
    2696     local PVER="$(magename2pver ${MAGEFILE})"
    2697     local PBUILD="$(magename2pbuild ${MAGEFILE})"
    2698    
    2699     local EXPCAT EXPNAME EXPVER EXPBUILD
    2700     while read EXPCAT EXPNAME EXPVER EXPBUILD
    2701     do
    2702     # ignore spaces and comments
    2703     case "${EXPCAT}" in
    2704     \#*|"") continue ;;
    2705     esac
    2706    
    2707     # exclude full pver
    2708     if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
    2709     [[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
    2710     [[ -n ${PVER} ]] && [[ -n ${PBUILD} ]] &&
    2711     [[ -n ${EXPVER} ]] && [[ -n ${EXPBUILD} ]]
    2712     then
    2713     [[ ${EXPCAT}/${EXPNAME}-${EXPVER}-${EXPBUILD} = ${PCAT}/${PNAME}-${PVER}-${PBUILD} ]] && return 1
    2714     fi
    2715    
    2716     # exclude pcat/pname only
    2717     if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
    2718     [[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
    2719     [[ -z ${EXPVER} ]] && [[ -z ${EXPBUILD} ]]
    2720     then
    2721     [[ ${EXPCAT}/${EXPNAME} = ${PCAT}/${PNAME} ]] && return 1
    2722     fi
    2723     done << EOF
    2724     $( cat ${EXCLUDED}; echo)
    2725     EOF
    2726    
    2727     return 0
    2728     }
    2729