/[gentoo-x86]/eclass/cvs.eclass
Gentoo

Diff of /eclass/cvs.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.49  
changed lines
  Added in v.1.59

  ViewVC Help
Powered by ViewVC 1.1.20