eclass/cvs.eclass

   1 # Copyright 1999-2014 Gentoo Foundation
   2 # Distributed under the terms of the GNU General Public License v2
   3 # $Id$
   4
   5 # @ECLASS: cvs.eclass
   6 # @MAINTAINER:
   7 # vapier@gentoo.org (and anyone who wants to help)
   8 # @BLURB: This eclass provides generic cvs fetching functions
   9 # @DESCRIPTION:
  10 # This eclass provides the generic cvs fetching functions. To use this from an
  11 # ebuild, set the ECLASS VARIABLES as specified below in your ebuild before
  12 # inheriting. Then either leave the default src_unpack or extend over
  13 # cvs_src_unpack. If you find that you need to call the cvs_* functions
  14 # directly, I'd be interested to hear about it.
  15
  16 if [[ -z ${_CVS_ECLASS} ]]; then
  17 _CVS_ECLASS=1
  18
  19 inherit eutils
  20
  21 # TODO:
  22
  23 # Implement more auth types (gserver?, kserver?)
  24
  25 # Support additional remote shells with `ext' authentication (does
  26 # anyone actually need to use it with anything other than SSH?)
  27
  28
  29 # Users shouldn't change these settings!  The ebuild/eclass inheriting
  30 # this eclass will take care of that.  If you want to set the global
  31 # KDE cvs ebuilds' settings, see the comments in kde-source.eclass.
  32
  33 # @ECLASS-VARIABLE: ECVS_CVS_COMPRESS
  34 # @DESCRIPTION:
  35 # Set the default compression level.  Has no effect when ECVS_CVS_COMMAND
  36 # is defined by ebuild/user.
  37 : ${ECVS_CVS_COMPRESS:=-z1}
  38
  39 # @ECLASS-VARIABLE: ECVS_CVS_OPTIONS
  40 # @DESCRIPTION:
  41 # Additional options to the cvs commands.  Has no effect when ECVS_CVS_COMMAND
  42 # is defined by ebuild/user.
  43 : ${ECVS_CVS_OPTIONS:=-q -f}
  44
  45 # @ECLASS-VARIABLE: ECVS_CVS_COMMAND
  46 # @DESCRIPTION:
  47 # CVS command to run
  48 #
  49 # You can set, for example, "cvs -t" for extensive debug information
  50 # on the cvs connection.  The default of "cvs -q -f -z4" means to be
  51 # quiet, to disregard the ~/.cvsrc config file and to use maximum
  52 # compression.
  53 : ${ECVS_CVS_COMMAND:=cvs ${ECVS_CVS_OPTIONS} ${ECVS_CVS_COMPRESS}}
  54
  55 # @ECLASS-VARIABLE: ECVS_UP_OPTS
  56 # @DESCRIPTION:
  57 # CVS options given after the cvs update command. Don't remove "-dP" or things
  58 # won't work.
  59 : ${ECVS_UP_OPTS:=-dP}
  60
  61 # @ECLASS-VARIABLE: ECVS_CO_OPTS
  62 # @DEFAULT_UNSET
  63 # @DESCRIPTION:
  64 # CVS options given after the cvs checkout command.
  65
  66 # @ECLASS-VARIABLE: ECVS_OFFLINE
  67 # @DESCRIPTION:
  68 # Set this variable to a non-empty value to disable the automatic updating of
  69 # a CVS source tree. This is intended to be set outside the cvs source
  70 # tree by users.
  71 : ${ECVS_OFFLINE:=${EVCS_OFFLINE}}
  72
  73 # @ECLASS-VARIABLE: ECVS_LOCAL
  74 # @DEFAULT_UNSET
  75 # @DESCRIPTION:
  76 # If this is set, the CVS module will be fetched non-recursively.
  77 # Refer to the information in the CVS man page regarding the -l
  78 # command option (not the -l global option).
  79
  80 # @ECLASS-VARIABLE: ECVS_LOCALNAME
  81 # @DEFAULT_UNSET
  82 # @DESCRIPTION:
  83 # Local name of checkout directory
  84 #
  85 # This is useful if the module on the server is called something
  86 # common like 'driver' or is nested deep in a tree, and you don't like
  87 # useless empty directories.
  88 #
  89 # WARNING: Set this only from within ebuilds!  If set in your shell or
  90 # some such, things will break because the ebuild won't expect it and
  91 # have e.g. a wrong $S setting.
  92
  93 # @ECLASS-VARIABLE: ECVS_TOP_DIR
  94 # @DESCRIPTION:
  95 # The directory under which CVS modules are checked out.
  96 : ${ECVS_TOP_DIR:="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/cvs-src"}
  97
  98 # @ECLASS-VARIABLE: ECVS_SERVER
  99 # @DESCRIPTION:
 100 # CVS path
 101 #
 102 # The format is "server:/dir", e.g. "anoncvs.kde.org:/home/kde".
 103 # Remove the other parts of the full CVSROOT, which might look like
 104 # ":pserver:anonymous@anoncvs.kde.org:/home/kde"; this is generated
 105 # using other settings also.
 106 #
 107 # Set this to "offline" to disable fetching (i.e. to assume the module
 108 # is already checked out in ECVS_TOP_DIR).
 109 : ${ECVS_SERVER:="offline"}
 110
 111 # @ECLASS-VARIABLE: ECVS_MODULE
 112 # @REQUIRED
 113 # @DESCRIPTION:
 114 # The name of the CVS module to be fetched
 115 #
 116 # This must be set when cvs_src_unpack is called.  This can include
 117 # several directory levels, i.e. "foo/bar/baz"
 118 #[[ -z ${ECVS_MODULE} ]] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue"
 119
 120 # @ECLASS-VARIABLE: ECVS_DATE
 121 # @DEFAULT_UNSET
 122 # @DESCRIPTION:
 123 # The date of the checkout.  See the -D date_spec option in the cvs
 124 # man page for more details.
 125
 126 # @ECLASS-VARIABLE: ECVS_BRANCH
 127 # @DEFAULT_UNSET
 128 # @DESCRIPTION:
 129 # The name of the branch/tag to use
 130 #
 131 # The default is "HEAD".  The following default _will_ reset your
 132 # branch checkout to head if used.
 133 #: ${ECVS_BRANCH:="HEAD"}
 134
 135 # @ECLASS-VARIABLE: ECVS_AUTH
 136 # @DESCRIPTION:
 137 # Authentication method to use
 138 #
 139 # Possible values are "pserver" and "ext".  If `ext' authentication is
 140 # used, the remote shell to use can be specified in CVS_RSH (SSH is
 141 # used by default).  Currently, the only supported remote shell for
 142 # `ext' authentication is SSH.
 143 #
 144 # Armando Di Cianno <fafhrd@gentoo.org> 2004/09/27
 145 # - Added "no" as a server type, which uses no AUTH method, nor
 146 #    does it login
 147 #  e.g.
 148 #   "cvs -danoncvs@savannah.gnu.org:/cvsroot/backbone co System"
 149 #   ( from gnustep-apps/textedit )
 150 : ${ECVS_AUTH:="pserver"}
 151
 152 # @ECLASS-VARIABLE: ECVS_USER
 153 # @DESCRIPTION:
 154 # Username to use for authentication on the remote server.
 155 : ${ECVS_USER:="anonymous"}
 156
 157 # @ECLASS-VARIABLE: ECVS_PASS
 158 # @DEFAULT_UNSET
 159 # @DESCRIPTION:
 160 # Password to use for authentication on the remote server
 161
 162 # @ECLASS-VARIABLE: ECVS_SSH_HOST_KEY
 163 # @DEFAULT_UNSET
 164 # @DESCRIPTION:
 165 # If SSH is used for `ext' authentication, use this variable to
 166 # specify the host key of the remote server.  The format of the value
 167 # should be the same format that is used for the SSH known hosts file.
 168 #
 169 # WARNING: If a SSH host key is not specified using this variable, the
 170 # remote host key will not be verified.
 171
 172 # @ECLASS-VARIABLE: ECVS_CLEAN
 173 # @DEFAULT_UNSET
 174 # @DESCRIPTION:
 175 # Set this to get a clean copy when updating (passes the
 176 # -C option to cvs update)
 177
 178 # @ECLASS-VARIABLE: ECVS_RUNAS
 179 # @DEFAULT_UNSET
 180 # @DESCRIPTION:
 181 # Specifies an alternate (non-root) user to use to run cvs.  Currently
 182 # b0rked and wouldn't work with portage userpriv anyway without
 183 # special magic.
 184
 185 # : ${ECVS_RUNAS:=$(whoami)}
 186
 187 # add cvs to deps
 188 # ssh is used for ext auth
 189 # sudo is used to run as a specified user
 190 DEPEND="dev-vcs/cvs"
 191
 192 [[ -n ${ECVS_RUNAS} ]] && DEPEND+=" app-admin/sudo"
 193
 194 if [[ ${ECVS_AUTH} == "ext" ]] ; then
 195         #default to ssh
 196         [[ -z ${CVS_RSH} ]] && export CVS_RSH="ssh"
 197         if [[ ${CVS_RSH} != "ssh" ]] ; then
 198                 die "Support for ext auth with clients other than ssh has not been implemented yet"
 199         fi
 200         DEPEND+=" net-misc/openssh"
 201 fi
 202
 203 # called from cvs_src_unpack
 204 cvs_fetch() {
 205         has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX=
 206
 207         # Make these options local variables so that the global values are
 208         # not affected by modifications in this function.
 209
 210         local ECVS_COMMAND=${ECVS_COMMAND}
 211         local ECVS_UP_OPTS=${ECVS_UP_OPTS}
 212         local ECVS_CO_OPTS=${ECVS_CO_OPTS}
 213
 214         debug-print-function ${FUNCNAME} "$@"
 215
 216         # Update variables that are modified by ebuild parameters, which
 217         # should be effective every time cvs_fetch is called, and not just
 218         # every time cvs.eclass is inherited
 219
 220         # Handle parameter for local (non-recursive) fetching
 221
 222         if [[ -n ${ECVS_LOCAL} ]] ; then
 223                 ECVS_UP_OPTS+=" -l"
 224                 ECVS_CO_OPTS+=" -l"
 225         fi
 226
 227         # Handle ECVS_BRANCH option
 228         #
 229         # Because CVS auto-switches branches, we just have to pass the
 230         # correct -rBRANCH option when updating.
 231
 232         if [[ -n ${ECVS_BRANCH} ]] ; then
 233                 ECVS_UP_OPTS+=" -r${ECVS_BRANCH}"
 234                 ECVS_CO_OPTS+=" -r${ECVS_BRANCH}"
 235         fi
 236
 237         # Handle ECVS_LOCALNAME, which specifies the local directory name
 238         # to use.  Note that the -d command option is not equivalent to
 239         # the global -d option.
 240
 241         if [[ ${ECVS_LOCALNAME} != "${ECVS_MODULE}" ]] ; then
 242                 ECVS_CO_OPTS+=" -d ${ECVS_LOCALNAME}"
 243         fi
 244
 245         if [[ -n ${ECVS_CLEAN} ]] ; then
 246                 ECVS_UP_OPTS+=" -C"
 247         fi
 248
 249         if [[ -n ${ECVS_DATE} ]] ; then
 250                 ECVS_CO_OPTS+=" -D ${ECVS_DATE}"
 251                 ECVS_UP_OPTS+=" -D ${ECVS_DATE}"
 252         fi
 253
 254         # It would be easiest to always be in "run-as mode", logic-wise,
 255         # if sudo didn't ask for a password even when sudo'ing to `whoami`.
 256
 257         if [[ -z ${ECVS_RUNAS} ]] ; then
 258                 run=""
 259         else
 260                 run="sudo -u ${ECVS_RUNAS}"
 261         fi
 262
 263         # Create the top dir if needed
 264
 265         if [[ ! -d ${ECVS_TOP_DIR} ]] ; then
 266                 # Note that the addwrite statements in this block are only
 267                 # there to allow creating ECVS_TOP_DIR; we allow writing
 268                 # inside it separately.
 269
 270                 # This is because it's simpler than trying to find out the
 271                 # parent path of the directory, which would need to be the
 272                 # real path and not a symlink for things to work (so we can't
 273                 # just remove the last path element in the string)
 274
 275                 debug-print "${FUNCNAME}: checkout mode. creating cvs directory"
 276                 addwrite /foobar
 277                 addwrite /
 278                 ${run} mkdir -p "/${ECVS_TOP_DIR}"
 279                 export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}"
 280         fi
 281
 282         # In case ECVS_TOP_DIR is a symlink to a dir, get the real path,
 283         # otherwise addwrite() doesn't work.
 284
 285         cd -P "${ECVS_TOP_DIR}" >/dev/null
 286         ECVS_TOP_DIR=$(pwd)
 287
 288         # Disable the sandbox for this dir
 289         addwrite "${ECVS_TOP_DIR}"
 290
 291         # Chown the directory and all of its contents
 292         if [[ -n ${ECVS_RUNAS} ]] ; then
 293                 ${run} chown -R "${ECVS_RUNAS}" "/${ECVS_TOP_DIR}"
 294         fi
 295
 296         # Determine the CVS command mode (checkout or update)
 297         if [[ ! -d ${ECVS_TOP_DIR}/${ECVS_LOCALNAME}/CVS ]] ; then
 298                 mode=checkout
 299         else
 300                 mode=update
 301         fi
 302
 303         # Our server string (i.e. CVSROOT) without the password so it can
 304         # be put in Root
 305         local connection="${ECVS_AUTH}"
 306         if [[ ${ECVS_AUTH} == "no" ]] ; then
 307                 local server="${ECVS_USER}@${ECVS_SERVER}"
 308         else
 309                 [[ -n ${ECVS_PROXY} ]] && connection+=";proxy=${ECVS_PROXY}"
 310                 [[ -n ${ECVS_PROXY_PORT} ]] && connection+=";proxyport=${ECVS_PROXY_PORT}"
 311                 local server=":${connection}:${ECVS_USER}@${ECVS_SERVER}"
 312         fi
 313
 314         # Switch servers automagically if needed
 315         if [[ ${mode} == "update" ]] ; then
 316                 cd "/${ECVS_TOP_DIR}/${ECVS_LOCALNAME}"
 317                 local oldserver=$(${run} cat CVS/Root)
 318                 if [[ ${server} != "${oldserver}" ]] ; then
 319                         einfo "Changing the CVS server from ${oldserver} to ${server}:"
 320                         debug-print "${FUNCNAME}: Changing the CVS server from ${oldserver} to ${server}:"
 321
 322                         einfo "Searching for CVS directories ..."
 323                         local cvsdirs=$(${run} find . -iname CVS -print)
 324                         debug-print "${FUNCNAME}: CVS directories found:"
 325                         debug-print "${cvsdirs}"
 326
 327                         einfo "Modifying CVS directories ..."
 328                         local x
 329                         for x in ${cvsdirs} ; do
 330                                 debug-print "In ${x}"
 331                                 ${run} echo "${server}" > "${x}/Root"
 332                         done
 333                 fi
 334         fi
 335
 336         # Prepare a cvspass file just for this session, we don't want to
 337         # mess with ~/.cvspass
 338         touch "${T}/cvspass"
 339         export CVS_PASSFILE="${T}/cvspass"
 340         if [[ -n ${ECVS_RUNAS} ]] ; then
 341                 chown "${ECVS_RUNAS}" "${T}/cvspass"
 342         fi
 343
 344         # The server string with the password in it, for login (only used for pserver)
 345         cvsroot_pass=":${connection}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}"
 346
 347         # Ditto without the password, for checkout/update after login, so
 348         # that the CVS/Root files don't contain the password in plaintext
 349         if [[ ${ECVS_AUTH} == "no" ]] ; then
 350                 cvsroot_nopass="${ECVS_USER}@${ECVS_SERVER}"
 351         else
 352                 cvsroot_nopass=":${connection}:${ECVS_USER}@${ECVS_SERVER}"
 353         fi
 354
 355         # Commands to run
 356         cmdlogin="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_pass}\" login"
 357         cmdupdate="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" update ${ECVS_UP_OPTS} ${ECVS_LOCALNAME}"
 358         cmdcheckout="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}"
 359
 360         # Execute commands
 361
 362         cd "${ECVS_TOP_DIR}"
 363         if [[ ${ECVS_AUTH} == "pserver" ]] ; then
 364                 einfo "Running ${cmdlogin}"
 365                 eval ${cmdlogin} || die "cvs login command failed"
 366                 if [[ ${mode} == "update" ]] ; then
 367                         einfo "Running ${cmdupdate}"
 368                         eval ${cmdupdate} || die "cvs update command failed"
 369                 elif [[ ${mode} == "checkout" ]] ; then
 370                         einfo "Running ${cmdcheckout}"
 371                         eval ${cmdcheckout} || die "cvs checkout command failed"
 372                 fi
 373         elif [[ ${ECVS_AUTH} == "ext" || ${ECVS_AUTH} == "no" ]] ; then
 374                 # Hack to support SSH password authentication
 375
 376                 # Backup environment variable values
 377                 local CVS_ECLASS_ORIG_CVS_RSH="${CVS_RSH}"
 378
 379                 if [[ ${SSH_ASKPASS+set} == "set" ]] ; then
 380                         local CVS_ECLASS_ORIG_SSH_ASKPASS="${SSH_ASKPASS}"
 381                 else
 382                         unset CVS_ECLASS_ORIG_SSH_ASKPASS
 383                 fi
 384
 385                 if [[ ${DISPLAY+set} == "set" ]] ; then
 386                         local CVS_ECLASS_ORIG_DISPLAY="${DISPLAY}"
 387                 else
 388                         unset CVS_ECLASS_ORIG_DISPLAY
 389                 fi
 390
 391                 if [[ ${CVS_RSH} == "ssh" ]] ; then
 392                         # Force SSH to use SSH_ASKPASS by creating python wrapper
 393
 394                         export CVS_RSH="${T}/cvs_sshwrapper"
 395                         cat > "${CVS_RSH}"<<EOF
 396 #!${EPREFIX}/usr/bin/python
 397 import fcntl
 398 import os
 399 import sys
 400 try:
 401         fd = os.open('/dev/tty', 2)
 402         TIOCNOTTY=0x5422
 403         try:
 404                 fcntl.ioctl(fd, TIOCNOTTY)
 405         except:
 406                 pass
 407         os.close(fd)
 408 except:
 409         pass
 410 newarglist = sys.argv[:]
 411 EOF
 412
 413                         # disable X11 forwarding which causes .xauth access violations
 414                         # - 20041205 Armando Di Cianno <fafhrd@gentoo.org>
 415                         echo "newarglist.insert(1, '-oClearAllForwardings=yes')" \
 416                                 >> "${CVS_RSH}"
 417                         echo "newarglist.insert(1, '-oForwardX11=no')" \
 418                                 >> "${CVS_RSH}"
 419
 420                         # Handle SSH host key checking
 421
 422                         local CVS_ECLASS_KNOWN_HOSTS="${T}/cvs_ssh_known_hosts"
 423                         echo "newarglist.insert(1, '-oUserKnownHostsFile=${CVS_ECLASS_KNOWN_HOSTS}')" \
 424                                 >> "${CVS_RSH}"
 425
 426                         if [[ -z ${ECVS_SSH_HOST_KEY} ]] ; then
 427                                 ewarn "Warning: The SSH host key of the remote server will not be verified."
 428                                 einfo "A temporary known hosts list will be used."
 429                                 local CVS_ECLASS_STRICT_HOST_CHECKING="no"
 430                                 touch "${CVS_ECLASS_KNOWN_HOSTS}"
 431                         else
 432                                 local CVS_ECLASS_STRICT_HOST_CHECKING="yes"
 433                                 echo "${ECVS_SSH_HOST_KEY}" > "${CVS_ECLASS_KNOWN_HOSTS}"
 434                         fi
 435
 436                         echo -n "newarglist.insert(1, '-oStrictHostKeyChecking=" \
 437                                 >> "${CVS_RSH}"
 438                         echo "${CVS_ECLASS_STRICT_HOST_CHECKING}')" \
 439                                 >> "${CVS_RSH}"
 440                         echo "os.execv('${EPREFIX}/usr/bin/ssh', newarglist)" \
 441                                 >> "${CVS_RSH}"
 442
 443                         chmod a+x "${CVS_RSH}"
 444
 445                         # Make sure DISPLAY is set (SSH will not use SSH_ASKPASS
 446                         # if DISPLAY is not set)
 447
 448                         : ${DISPLAY:="DISPLAY"}
 449                         export DISPLAY
 450
 451                         # Create a dummy executable to echo ${ECVS_PASS}
 452
 453                         export SSH_ASKPASS="${T}/cvs_sshechopass"
 454                         if [[ ${ECVS_AUTH} != "no" ]] ; then
 455                                 echo -en "#!/bin/bash\necho \"${ECVS_PASS}\"\n" \
 456                                         > "${SSH_ASKPASS}"
 457                         else
 458                                 echo -en "#!/bin/bash\nreturn\n" \
 459                                         > "${SSH_ASKPASS}"
 460                         fi
 461                         chmod a+x "${SSH_ASKPASS}"
 462                 fi
 463
 464                 if [[ ${mode} == "update" ]] ; then
 465                         einfo "Running ${cmdupdate}"
 466                         eval ${cmdupdate} || die "cvs update command failed"
 467                 elif [[ ${mode} == "checkout" ]] ; then
 468                         einfo "Running ${cmdcheckout}"
 469                         eval ${cmdcheckout} || die "cvs checkout command failed"
 470                 fi
 471
 472                 # Restore environment variable values
 473                 export CVS_RSH="${CVS_ECLASS_ORIG_CVS_RSH}"
 474                 if [[ ${CVS_ECLASS_ORIG_SSH_ASKPASS+set} == "set" ]] ; then
 475                         export SSH_ASKPASS="${CVS_ECLASS_ORIG_SSH_ASKPASS}"
 476                 else
 477                         unset SSH_ASKPASS
 478                 fi
 479
 480                 if [[ ${CVS_ECLASS_ORIG_DISPLAY+set} == "set" ]] ; then
 481                         export DISPLAY="${CVS_ECLASS_ORIG_DISPLAY}"
 482                 else
 483                         unset DISPLAY
 484                 fi
 485         fi
 486
 487         # Restore ownership.  Not sure why this is needed, but someone
 488         # added it in the orig ECVS_RUNAS stuff.
 489         if [[ -n ${ECVS_RUNAS} ]] ; then
 490                 chown $(whoami) "${T}/cvspass"
 491         fi
 492
 493 }
 494
 495 # @FUNCTION: cvs_src_unpack
 496 # @DESCRIPTION:
 497 # The cvs src_unpack function, which will be exported
 498 cvs_src_unpack() {
 499
 500         debug-print-function ${FUNCNAME} "$@"
 501
 502         debug-print "${FUNCNAME}: init:
 503         ECVS_CVS_COMMAND=${ECVS_CVS_COMMAND}
 504         ECVS_UP_OPTS=${ECVS_UP_OPTS}
 505         ECVS_CO_OPTS=${ECVS_CO_OPTS}
 506         ECVS_TOP_DIR=${ECVS_TOP_DIR}
 507         ECVS_SERVER=${ECVS_SERVER}
 508         ECVS_USER=${ECVS_USER}
 509         ECVS_PASS=${ECVS_PASS}
 510         ECVS_MODULE=${ECVS_MODULE}
 511         ECVS_LOCAL=${ECVS_LOCAL}
 512         ECVS_RUNAS=${ECVS_RUNAS}
 513         ECVS_LOCALNAME=${ECVS_LOCALNAME}"
 514
 515         [[ -z ${ECVS_MODULE} ]] && die "ERROR: CVS module not set, cannot continue."
 516
 517         local ECVS_LOCALNAME=${ECVS_LOCALNAME:-${ECVS_MODULE}}
 518
 519         local sanitized_pn=$(echo "${PN}" | LC_ALL=C sed -e 's:[^A-Za-z0-9_]:_:g')
 520         local offline_pkg_var="ECVS_OFFLINE_${sanitized_pn}"
 521         if [[ -n ${!offline_pkg_var}${ECVS_OFFLINE} ]] || [[ ${ECVS_SERVER} == "offline" ]] ; then
 522                 # We're not required to fetch anything; the module already
 523                 # exists and shouldn't be updated.
 524                 if [[ -d ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} ]] ; then
 525                         debug-print "${FUNCNAME}: offline mode"
 526                 else
 527                         debug-print "${FUNCNAME}: Offline mode specified but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found, exiting with error"
 528                         die "ERROR: Offline mode specified, but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found. Aborting."
 529                 fi
 530         elif [[ -n ${ECVS_SERVER} ]] ; then # ECVS_SERVER!=offline --> real fetching mode
 531                 einfo "Fetching CVS module ${ECVS_MODULE} into ${ECVS_TOP_DIR} ..."
 532                 cvs_fetch
 533         else # ECVS_SERVER not set
 534                 die "ERROR: CVS server not specified, cannot continue."
 535         fi
 536
 537         einfo "Copying ${ECVS_MODULE} from ${ECVS_TOP_DIR} ..."
 538         debug-print "Copying module ${ECVS_MODULE} local_mode=${ECVS_LOCAL} from ${ECVS_TOP_DIR} ..."
 539
 540         # This is probably redundant, but best to make sure.
 541         mkdir -p "${WORKDIR}/${ECVS_LOCALNAME}"
 542
 543         if [[ -n ${ECVS_LOCAL} ]] ; then
 544                 cp -f "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}"/* "${WORKDIR}/${ECVS_LOCALNAME}"
 545         else
 546                 cp -Rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" "${WORKDIR}/${ECVS_LOCALNAME}/.."
 547         fi
 548
 549         # Not exactly perfect, but should be pretty close #333773
 550         export ECVS_VERSION=$(
 551                 find "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}/" -ipath '*/CVS/Entries' -exec cat {} + | \
 552                         LC_ALL=C sort | \
 553                         sha1sum | \
 554                         awk '{print $1}'
 555         )
 556
 557         # If the directory is empty, remove it; empty directories cannot
 558         # exist in cvs.  This happens when, for example, kde-source
 559         # requests module/doc/subdir which doesn't exist.  Still create
 560         # the empty directory in workdir though.
 561         if [[ $(ls -A "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}") == "CVS" ]] ; then
 562                 debug-print "${FUNCNAME}: removing empty CVS directory ${ECVS_LOCALNAME}"
 563                 rm -rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}"
 564         fi
 565
 566         # Implement some of base_src_unpack's functionality; note however
 567         # that base.eclass may not have been inherited!
 568         if [[ -n ${PATCHES} ]] ; then
 569                 debug-print "${FUNCNAME}: PATCHES=${PATCHES,} S=${S}, autopatching"
 570                 cd "${S}"
 571                 epatch ${PATCHES}
 572                 # Make sure we don't try to apply patches more than once,
 573                 # since cvs_src_unpack is usually called several times from
 574                 # e.g. kde-source_src_unpack
 575                 export PATCHES=""
 576         fi
 577
 578         einfo "CVS module ${ECVS_MODULE} is now in ${WORKDIR}"
 579 }
 580
 581 EXPORT_FUNCTIONS src_unpack
 582
 583 fi