Configure tsocks with a simple heuristic.
Consider the proxy has to be in a 'local' network. It means it is directly
reachable by the local machine, even if the local machine has to hop through
one or more gates to reach the proxy (often the case in enterprise networks
where class A 10.0.0.0/8 is in fact sub-divided into smaller networks, each
one of them in a different location, eg. 10.1.0.0/16 in a place, while
10.2.0.0/16 would be on the other side of the world). Not being in the same
subnet does not mean the proxy is not available.
So we will build a mask with at most high bits set, which defines a network
that has both the local machine and the proxy. Because a machine may have
more than one interface, build a mask for each of them, removing 127.0.0.1
which is added automagically by tsocks, and removing duplicate masks.
If all of this does not work, then it means the local machine can NOT in fact
reach the proxy, which in turn means the user mis-configured something (most
probably a typo...).
/trunk/scripts/crosstool.sh | 61 52 9 0 +++++++++++++++++++++++++++++++++++++++++++--------
1 file changed, 52 insertions(+), 9 deletions(-)
2 # Copyright 2007 Yann E. MORIN
3 # Licensed under the GPL v2. See COPYING in the root of this package.
5 # This is the main entry point to crosstool
7 # - download, extract and patch the toolchain components
8 # - build and install each components in turn
9 # - and eventually test the resulting toolchain
11 # What this file does is prepare the environment, based upon the user-choosen
12 # options. It also checks the existing environment for un-friendly variables,
13 # and builds the tools.
15 # Parse the common functions
16 . "${CT_LIB_DIR}/scripts/functions"
18 CT_STAR_DATE=`CT_DoDate +%s%N`
19 CT_STAR_DATE_HUMAN=`CT_DoDate +%Y%m%d.%H%M%S`
21 # Are we configured? We'll need that later...
22 CT_TestOrAbort "Configuration file not found. Please create one." -f "${CT_TOP_DIR}/.config"
24 # Parse the configuration file
25 # It has some info about the logging facility, so include it early
26 . "${CT_TOP_DIR}/.config"
28 # Yes! We can do full logging from now on!
29 CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
32 renice ${CT_NICE} $$ |CT_DoLog DEBUG
34 CT_DoStep DEBUG "Dumping crosstool-NG configuration"
35 cat "${CT_TOP_DIR}/.config" |egrep '^(# |)CT_' |CT_DoLog DEBUG
38 # Some sanity checks in the environment and needed tools
39 CT_DoLog INFO "Checking environment sanity"
41 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
45 # Other environment sanity checks
46 CT_TestAndAbort "Don't set LD_LIBRARY_PATH. It screws up the build." -n "${LD_LIBRARY_PATH}"
47 CT_TestAndAbort "Don't set CFLAGS. It screws up the build." -n "${CFLAGS}"
48 CT_TestAndAbort "Don't set CXXFLAGS. It screws up the build." -n "${CXXFLAGS}"
49 CT_Test "GREP_OPTIONS screws up the build. Resetting." -n "${GREP_OPTIONS}"
57 CT_DoLog INFO "Building environment variables"
59 # Parse architecture-specific functions
60 . "${CT_LIB_DIR}/arch/${CT_ARCH}/functions"
62 # Target tuple: CT_TARGET needs a little love:
65 # Kludge: If any of the configured options needs CT_TARGET,
66 # then rescan the options file now:
67 . "${CT_TOP_DIR}/.config"
69 # Second kludge: merge user-supplied target CFLAGS with architecture-provided
71 CT_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_TARGET_CFLAGS}"
73 # Now, build up the variables from the user-configured options.
74 CT_KERNEL_FILE="${CT_KERNEL}-${CT_KERNEL_VERSION}"
75 CT_BINUTILS_FILE="binutils-${CT_BINUTILS_VERSION}"
76 CT_CC_FILE="${CT_CC}-${CT_CC_VERSION}"
77 CT_LIBC_FILE="${CT_LIBC}-${CT_LIBC_VERSION}"
80 CT_TARBALLS_DIR="${CT_TOP_DIR}/targets/tarballs"
81 CT_SRC_DIR="${CT_TOP_DIR}/targets/src"
82 CT_BUILD_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/build"
83 CT_DEBUG_INSTALL_DIR="${CT_INSTALL_DIR}/${CT_TARGET}/debug-root"
84 # Note: we'll always install the core compiler in its own directory, so as to
85 # not mix the two builds: core and final.
86 CT_CC_CORE_STATIC_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-static"
87 CT_CC_CORE_SHARED_PREFIX_DIR="${CT_BUILD_DIR}/${CT_CC}-core-shared"
88 CT_STATE_DIR="${CT_TOP_DIR}/targets/${CT_TARGET}/state"
90 # We must ensure that we can restart if asked for!
91 if [ -n "${CT_RESTART}" -a ! -d "${CT_STATE_DIR}" ]; then
92 CT_DoLog ERROR "You asked to restart a non-restartable build"
93 CT_DoLog ERROR "This happened because you didn't set CT_DEBUG_CT_SAVE_STEPS"
94 CT_DoLog ERROR "in the config options for the previous build, or the state"
95 CT_DoLog ERROR "directory for the previous build was deleted."
96 CT_Abort "I will stop here to avoid any carnage"
99 # Make all path absolute, it so much easier!
100 CT_LOCAL_TARBALLS_DIR="`CT_MakeAbsolutePath \"${CT_LOCAL_TARBALLS_DIR}\"`"
102 # If the local tarball directory does not exist, say so, and don't try to save there!
103 if [ ! -d "${CT_LOCAL_TARBALLS_DIR}" ]; then
104 CT_DoLog WARN "Directory \"${CT_LOCAL_TARBALLS_DIR}\" does not exist. Will not save downloaded tarballs to local storage."
108 # Some more sanity checks now that we have all paths set up
109 case "${CT_LOCAL_TARBALLS_DIR},${CT_TARBALLS_DIR},${CT_SRC_DIR},${CT_BUILD_DIR},${CT_PREFIX_DIR},${CT_INSTALL_DIR}" in
110 *" "*) CT_Abort "Don't use spaces in paths, it breaks things.";;
113 # Check now if we can write to the destination directory:
114 if [ -d "${CT_INSTALL_DIR}" ]; then
115 CT_TestAndAbort "Destination directory \"${CT_INSTALL_DIR}\" is not removable" ! -w `dirname "${CT_INSTALL_DIR}"`
118 # Good, now grab a bit of informations on the system we're being run on,
119 # just in case something goes awok, and it's not our fault:
120 CT_SYS_USER="`id -un`"
121 CT_SYS_HOSTNAME=`hostname -f 2>/dev/null || true`
122 # Hmmm. Some non-DHCP-enabled machines do not have an FQDN... Fall back to node name.
123 CT_SYS_HOSTNAME="${CT_SYS_HOSTNAME:-`uname -n`}"
124 CT_SYS_KERNEL=`uname -s`
125 CT_SYS_REVISION=`uname -r`
126 # MacOS X lacks '-o' :
127 CT_SYS_OS=`uname -o || echo "Unknown (maybe MacOS-X)"`
128 CT_SYS_MACHINE=`uname -m`
129 CT_SYS_PROCESSOR=`uname -p`
130 CT_SYS_GCC=`gcc -dumpversion`
131 CT_SYS_TARGET=`CT_DoConfigGuess`
132 CT_TOOLCHAIN_ID="crosstool-${CT_VERSION} build ${CT_STAR_DATE_HUMAN} by ${CT_SYS_USER}@${CT_SYS_HOSTNAME}"
134 CT_DoLog EXTRA "Preparing working directories"
136 # Ah! The build directory shall be eradicated, even if we restart!
137 if [ -d "${CT_BUILD_DIR}" ]; then
138 mv "${CT_BUILD_DIR}" "${CT_BUILD_DIR}.$$"
139 chmod -R u+w "${CT_BUILD_DIR}.$$"
140 setsid nohup rm -rf "${CT_BUILD_DIR}.$$" >/dev/null 2>&1 &
143 # Don't eradicate directories if we need to restart
144 if [ -z "${CT_RESTART}" ]; then
145 # Get rid of pre-existing installed toolchain and previous build directories.
146 # We need to do that _before_ we can safely log, because the log file will
147 # most probably be in the toolchain directory.
148 if [ "${CT_FORCE_DOWNLOAD}" = "y" -a -d "${CT_TARBALLS_DIR}" ]; then
149 mv "${CT_TARBALLS_DIR}" "${CT_TARBALLS_DIR}.$$"
150 chmod -R u+w "${CT_TARBALLS_DIR}.$$"
151 setsid nohup rm -rf "${CT_TARBALLS_DIR}.$$" >/dev/null 2>&1 &
153 if [ "${CT_FORCE_EXTRACT}" = "y" -a -d "${CT_SRC_DIR}" ]; then
154 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
155 chmod -R u+w "${CT_SRC_DIR}.$$"
156 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1 &
158 if [ -d "${CT_INSTALL_DIR}" ]; then
159 mv "${CT_INSTALL_DIR}" "${CT_INSTALL_DIR}.$$"
160 chmod -R u+w "${CT_INSTALL_DIR}.$$"
161 setsid nohup rm -rf "${CT_INSTALL_DIR}.$$" >/dev/null 2>&1 &
163 if [ -d "${CT_DEBUG_INSTALL_DIR}" ]; then
164 mv "${CT_DEBUG_INSTALL_DIR}" "${CT_DEBUG_INSTALL_DIR}.$$"
165 chmod -R u+w "${CT_DEBUG_INSTALL_DIR}.$$"
166 setsid nohup rm -rf "${CT_DEBUG_INSTALL_DIR}.$$" >/dev/null 2>&1 &
168 # In case we start anew, get rid of the previously saved state directory
169 if [ -d "${CT_STATE_DIR}" ]; then
170 mv "${CT_STATE_DIR}" "${CT_STATE_DIR}.$$"
171 chmod -R u+w "${CT_STATE_DIR}.$$"
172 setsid nohup rm -rf "${CT_STATE_DIR}.$$" >/dev/null 2>&1 &
176 # Create the directories we'll use, even if restarting: it does no harm to
177 # create already existent directories, and CT_BUILD_DIR needs to be created
179 mkdir -p "${CT_TARBALLS_DIR}"
180 mkdir -p "${CT_SRC_DIR}"
181 mkdir -p "${CT_BUILD_DIR}"
182 mkdir -p "${CT_INSTALL_DIR}"
183 mkdir -p "${CT_PREFIX_DIR}"
184 mkdir -p "${CT_DEBUG_INSTALL_DIR}"
185 mkdir -p "${CT_CC_CORE_STATIC_PREFIX_DIR}"
186 mkdir -p "${CT_CC_CORE_SHARED_PREFIX_DIR}"
187 mkdir -p "${CT_STATE_DIR}"
189 # Kludge: CT_INSTALL_DIR and CT_PREFIX_DIR might have grown read-only if
190 # the previous build was successful. To be able to move the logfile there,
191 # switch them back to read/write
192 chmod -R u+w "${CT_INSTALL_DIR}" "${CT_PREFIX_DIR}"
194 # Redirect log to the actual log file now we can
195 # It's quite understandable that the log file will be installed in the install
196 # directory, so we must first ensure it exists and is writeable (above) before
199 case "${CT_LOG_TO_FILE}" in
200 y) CT_LOG_FILE="${CT_PREFIX_DIR}/build.log"
201 cat "${tmp_log_file}" >>"${CT_LOG_FILE}"
202 rm -f "${tmp_log_file}"
203 exec >>"${CT_LOG_FILE}"
205 *) rm -f "${tmp_log_file}"
209 # Set environment for proxy access
210 # This has to be done even if we are restarting, as they don't get
211 # saved in the step snapshot.
212 case "${CT_PROXY_TYPE}" in
216 case "${CT_PROXY_USER}:${CT_PROXY_PASS}" in
218 :*) http_proxy="${http_proxy}:${CT_PROXY_PASS}@";;
219 *:) http_proxy="${http_proxy}${CT_PROXY_USER}@";;
220 *:*) http_proxy="${http_proxy}${CT_PROXY_USER}:${CT_PROXY_PASS}@";;
222 export http_proxy="${http_proxy}${CT_PROXY_HOST}:${CT_PROXY_PORT}/"
223 export https_proxy="${http_proxy}"
224 export ftp_proxy="${http_proxy}"
225 CT_DoLog DEBUG "http_proxy='${http_proxy}'"
229 # Force not using HTTP proxy
230 unset http_proxy ftp_proxy https_proxy
235 # Force not using HTTP proxy
236 unset http_proxy ftp_proxy https_proxy
237 # Remove any lingering config file from any previous run
238 rm -f "${CT_BUILD_DIR}/tsocks.conf"
239 # Find all interfaces and build locally accessible networks
240 server_ip=$(ping -c 1 -W 2 "${CT_PROXY_HOST}" |head -n 1 |sed -r -e 's/^[^\(]+\(([^\)]+)\).*$/\1/;' || true)
241 CT_TestOrAbort "SOCKS proxy '${CT_PROXY_HOST}' has no IP." -n "${server_ip}"
242 /sbin/ifconfig |gawk -v server_ip="${server_ip}" '
244 split( server_ip, tmp, "\\." );
245 server_ip_num = tmp[1] * 2^24 + tmp[2] * 2^16 + tmp[3] * 2^8 + tmp[4] * 2^0;
249 $0 ~ /^[[:space:]]*inet addr:/ {
250 split( $2, tmp, ":|\\." );
251 if( ( tmp[2] == 127 ) && ( tmp[3] == 0 ) && ( tmp[4] == 0 ) && ( tmp[5] == 1 ) ) {
252 /* Skip 127.0.0.1, it'\''s taken care of by tsocks itself */
255 ip_num = tmp[2] * 2^24 + tmp[3] * 2^16 + tmp[4] * 2 ^8 + tmp[5] * 2^0;
260 } while( (i!=0) && ( and( server_ip_num, mask ) == and( ip_num, mask ) ) );
261 mask = and( 0xFFFFFFFF, lshift( mask, 1 ) );
262 if( (i!=0) && (mask!=0) ) {
263 masked_ip = and( ip_num, mask );
264 for( i=0; i<pairs; i++ ) {
265 if( ( masked_ip == ips[i] ) && ( mask == masks[i] ) ) {
269 ips[pairs] = masked_ip;
272 printf( "local = %d.%d.%d.%d/%d.%d.%d.%d\n",
273 and( 0xFF, masked_ip / 2^24 ),
274 and( 0xFF, masked_ip / 2^16 ),
275 and( 0xFF, masked_ip / 2^8 ),
276 and( 0xFF, masked_ip / 2^0 ),
277 and( 0xFF, mask / 2^24 ),
278 and( 0xFF, mask / 2^16 ),
279 and( 0xFF, mask / 2^8 ),
280 and( 0xFF, mask / 2^0 ) );
283 ' >"${CT_BUILD_DIR}/tsocks.conf"
284 ( echo "server = ${server_ip}";
285 echo "server_port = ${CT_PROXY_PORT}";
286 [ -n "${CT_PROXY_USER}" ] && echo "default_user=${CT_PROXY_USER}";
287 [ -n "${CT_PROXY_PASS}" ] && echo "default_pass=${CT_PROXY_PASS}";
288 ) >>"${CT_BUILD_DIR}/tsocks.conf"
289 case "${CT_PROXY_TYPE/socks}" in
290 4|5) proxy_type="${CT_PROXY_TYPE/socks}";;
292 reply=$(inspectsocks "${server_ip}" "${CT_PROXY_PORT}" 2>&1 || true)
294 *"server is a version 4 socks server") proxy_type=4;;
295 *"server is a version 5 socks server") proxy_type=5;;
296 *) CT_Abort "Unable to determine SOCKS proxy type for '${CT_PROXY_HOST}:${CT_PROXY_PORT}'"
300 echo "server_type = ${proxy_type}" >> "${CT_BUILD_DIR}/tsocks.conf"
301 validateconf -f "${CT_BUILD_DIR}/tsocks.conf" 2>&1 |CT_DoLog DEBUG
302 export TSOCKS_CONF_FILE="${CT_BUILD_DIR}/tsocks.conf"
307 # Setting up the rest of the environment only if not restarting
308 if [ -z "${CT_RESTART}" ]; then
309 # Determine build system if not set by the user
310 CT_Test "You did not specify the build system. That's OK, I can guess..." -z "${CT_BUILD}"
311 CT_BUILD="${CT_BUILD:-`CT_DoConfigGuess`}"
312 CT_BUILD=`CT_DoConfigSub "${CT_BUILD}"`
314 # Arrange paths depending on wether we use sys-root or not.
315 if [ "${CT_USE_SYSROOT}" = "y" ]; then
316 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}/sys-root"
317 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/usr/include"
318 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
319 CC_CORE_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
320 CC_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
322 # glibc's prefix must be exactly /usr, else --with-sysroot'd gcc will get
323 # confused when $sysroot/usr/include is not present.
324 # Note: --prefix=/usr is magic!
325 # See http://www.gnu.org/software/libc/FAQ.html#s-2.2
327 # plain old way. All libraries in prefix/target/lib
328 CT_SYSROOT_DIR="${CT_PREFIX_DIR}/${CT_TARGET}"
329 CT_HEADERS_DIR="${CT_SYSROOT_DIR}/include"
330 # hack! Always use --with-sysroot for binutils.
331 # binutils 2.14 and later obey it, older binutils ignore it.
332 # Lets you build a working 32->64 bit cross gcc
333 BINUTILS_SYSROOT_ARG="--with-sysroot=${CT_SYSROOT_DIR}"
334 # Use --with-headers, else final gcc will define disable_glibc while
335 # building libgcc, and you'll have no profiling
336 CC_CORE_SYSROOT_ARG="--without-headers"
337 CC_SYSROOT_ARG="--with-headers=${CT_HEADERS_DIR}"
338 LIBC_SYSROOT_ARG="prefix="
341 # Prepare the 'lib' directories in sysroot, else the ../lib64 hack used by
342 # 32 -> 64 bit crosscompilers won't work, and build of final gcc will fail with
343 # "ld: cannot open crti.o: No such file or directory"
344 mkdir -p "${CT_SYSROOT_DIR}/lib"
345 mkdir -p "${CT_SYSROOT_DIR}/usr/lib"
347 # Canadian-cross are really picky on the way they are built. Tweak the values.
348 CT_UNIQ_BUILD=`echo "${CT_BUILD}" |sed -r -e 's/-/-build_/'`
349 if [ "${CT_CANADIAN}" = "y" ]; then
350 # Arrange so that gcc never, ever think that build system == host system
351 CT_CANADIAN_OPT="--build=${CT_UNIQ_BUILD}"
352 # We shall have a compiler for this target!
355 CT_HOST="${CT_BUILD}"
356 CT_CANADIAN_OPT="--build=${CT_BUILD}"
357 # Add the target toolchain in the path so that we can build the C library
358 # Carefully add paths in the order we want them:
359 # - first try in ${CT_PREFIX_DIR}/bin
360 # - then try in ${CT_CC_CORE_SHARED_PREFIX_DIR}/bin
361 # - then try in ${CT_CC_CORE_STATIC_PREFIX_DIR}/bin
362 # - fall back to searching user's PATH
363 export PATH="${CT_PREFIX_DIR}/bin:${CT_CC_CORE_SHARED_PREFIX_DIR}/bin:${CT_CC_CORE_STATIC_PREFIX_DIR}/bin:${PATH}"
366 # Modify GCC_HOST to never be equal to $BUILD or $TARGET
367 # This strange operation causes gcc to always generate a cross-compiler
368 # even if the build machine is the same kind as the host.
369 # This is why CC has to be set when doing a canadian cross; you can't find a
370 # host compiler by appending -gcc to our whacky $GCC_HOST
371 # Kludge: it is reported that the above causes canadian crosses with cygwin
372 # hosts to fail, so avoid it just in that one case. It would be cleaner to
373 # just move this into the non-canadian case above, but I'm afraid that might
374 # cause some configure script somewhere to decide that since build==host, they
375 # could run host binaries.
376 # (Copied almost as-is from original crosstool):
377 case "${CT_KERNEL},${CT_CANADIAN}" in
379 *,y) CT_HOST="`echo \"${CT_HOST}\" |sed -r -e 's/-/-host_/;'`";;
382 # Ah! Recent versions of binutils need some of the build and/or host system
383 # (read CT_BUILD and CT_HOST) tools to be accessible (ar is but an example).
385 CT_DoLog DEBUG "Making build system tools available"
386 mkdir -p "${CT_PREFIX_DIR}/bin"
387 for tool in ar as dlltool gcc g++ gnatbind gnatmake ld nm ranlib strip windres objcopy objdump; do
388 tmp=`CT_Which ${tool}`
389 if [ -n "${tmp}" ]; then
390 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_BUILD}-${tool}"
391 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_UNIQ_BUILD}-${tool}"
392 ln -sfv "${tmp}" "${CT_PREFIX_DIR}/bin/${CT_HOST}-${tool}"
398 [ "${CT_USE_PIPES}" = "y" ] && CT_CFLAGS_FOR_HOST="${CT_CFLAGS_FOR_HOST} -pipe"
400 # Override the configured jobs with what's been given on the command line
401 [ -n "${CT_JOBS}" ] && CT_PARALLEL_JOBS="${CT_JOBS}"
403 # And help make go faster
405 [ ${CT_PARALLEL_JOBS} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -j${CT_PARALLEL_JOBS}"
406 [ ${CT_LOAD} -ne 0 ] && PARALLELMFLAGS="${PARALLELMFLAGS} -l${CT_LOAD}"
408 CT_DoStep EXTRA "Dumping internal crosstool-NG configuration"
409 CT_DoLog EXTRA "Building a toolchain for:"
410 CT_DoLog EXTRA " build = ${CT_BUILD}"
411 CT_DoLog EXTRA " host = ${CT_HOST}"
412 CT_DoLog EXTRA " target = ${CT_TARGET}"
413 set |egrep '^CT_.+=' |sort |CT_DoLog DEBUG
417 # Include sub-scripts instead of calling them: that way, we do not have to
418 # export any variable, nor re-parse the configuration and functions files.
419 . "${CT_LIB_DIR}/scripts/build/kernel_${CT_KERNEL}.sh"
420 . "${CT_LIB_DIR}/scripts/build/binutils.sh"
421 . "${CT_LIB_DIR}/scripts/build/libc_${CT_LIBC}.sh"
422 . "${CT_LIB_DIR}/scripts/build/cc_${CT_CC}.sh"
423 . "${CT_LIB_DIR}/scripts/build/debug.sh"
424 . "${CT_LIB_DIR}/scripts/build/tools.sh"
426 if [ -z "${CT_RESTART}" ]; then
427 CT_DoStep INFO "Retrieving needed toolchain components' tarballs"
436 if [ "${CT_ONLY_DOWNLOAD}" != "y" ]; then
437 if [ "${CT_FORCE_EXTRACT}" = "y" ]; then
438 mv "${CT_SRC_DIR}" "${CT_SRC_DIR}.$$"
439 setsid nohup rm -rf "${CT_SRC_DIR}.$$" >/dev/null 2>&1
441 CT_DoStep INFO "Extracting and patching toolchain components"
452 # Now for the job by itself. Go have a coffee!
453 if [ "${CT_ONLY_DOWNLOAD}" != "y" -a "${CT_ONLY_EXTRACT}" != "y" ]; then
454 # Because of CT_RESTART, this becomes quite complex
457 [ -n "${CT_RESTART}" ] && do_it=0 || do_it=1
458 for step in libc_check_config \
459 kernel_check_config \
472 if [ ${do_it} -eq 0 ]; then
473 if [ "${CT_RESTART}" = "${step}" ]; then
474 CT_DoLoadState "${step}"
479 CT_DoSaveState ${step}
480 if [ ${do_stop} -eq 1 ]; then
481 CT_DoLog ERROR "Stopping just after step \"${prev_step}\", as requested."
485 if [ ${do_it} -eq 1 ]; then
487 if [ "${CT_STOP}" = "${step}" ]; then
490 if [ "${CTDEBUG_CT_PAUSE_STEPS}" = "y" ]; then
491 CT_DoPause "Step \"${step}\" finished"
497 CT_DoLog DEBUG "Removing access to the build system tools"
498 find "${CT_PREFIX_DIR}/bin" -name "${CT_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
499 find "${CT_PREFIX_DIR}/bin" -name "${CT_UNIQ_BUILD}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
500 find "${CT_PREFIX_DIR}/bin" -name "${CT_HOST}-"'*' -exec rm -fv {} \; |CT_DoLog DEBUG
502 # Install the /populator/
503 CT_DoLog EXTRA "Installing the populate helper"
504 sed -r -e 's,@@CT_READELF@@,'"${CT_PREFIX_DIR}/bin/${CT_TARGET}-readelf"',g;' \
505 -e 's,@@CT_SYSROOT_DIR@@,'"${CT_SYSROOT_DIR}"',g;' \
506 "${CT_LIB_DIR}/tools/populate.in" >"${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
507 chmod 755 "${CT_PREFIX_DIR}/bin/${CT_TARGET}-populate"
509 # Create the aliases to the target tools
510 CT_DoStep EXTRA "Creating toolchain aliases"
511 CT_Pushd "${CT_PREFIX_DIR}/bin"
512 for t in "${CT_TARGET}-"*; do
513 if [ -n "${CT_TARGET_ALIAS}" ]; then
514 _t="`echo \"$t\" |sed -r -e 's/^'\"${CT_TARGET}\"'-/'\"${CT_TARGET_ALIAS}\"'-/;'`"
515 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
516 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
518 if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
519 _t="`echo \"$t\" |sed -r -e \"${CT_TARGET_ALIAS_SED_EXPR}\"`"
520 CT_DoLog DEBUG "Linking \"${_t}\" -> \"${t}\""
521 ln -sv "${t}" "${_t}" 2>&1 |CT_DoLog ALL
527 # Remove the generated documentation files
528 if [ "${CT_REMOVE_DOCS}" = "y" ]; then
529 CT_DoLog INFO "Removing installed documentation"
530 rm -rf "${CT_PREFIX_DIR}/"{,usr/}{man,info}
531 rm -rf "${CT_SYSROOT_DIR}/"{,usr/}{man,info}
532 rm -rf "${CT_DEBUG_INSTALL_DIR}/"{,usr/}{man,info}
538 if [ "${CT_LOG_FILE_COMPRESS}" = y ]; then
539 CT_DoLog EXTRA "Compressing log file"
541 bzip2 -9 "${CT_LOG_FILE}"
544 if [ "${CT_INSTALL_DIR_RO}" = "y" ]; then
545 # OK, now we're done, set the toolchain read-only
546 # Don't log, the log file may become read-only any moment...
547 chmod -R a-w "${CT_INSTALL_DIR}" >/dev/null 2>&1