Patch Name: PHCO_27418 Patch Description: s700_800 11.00 ksh(1) cumulative patch Creation Date: 02/09/04 Post Date: 02/09/24 Hardware Platforms - OS Releases: s700: 11.00 s800: 11.00 Products: N/A Filesets: OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP Automatic Reboot?: No Status: General Release Critical: Yes PHCO_27418: CORRUPTION MEMORY_LEAK "set --" corrupts $0 when called using ksh(1). ksh(1) corrupts the memory in emacs mode of editing. Repeated use of getopts builtin inside ksh(1) introduces memory leak. PHCO_26783: OTHER ksh coredumps if sent an early SIGWINCH. Category Tags: defect_repair enhancement general_release critical corruption memory_leak Path Name: /hp-ux_patches/s700_800/11.X/PHCO_27418 Symptoms: PHCO_27418: 1. "set --" corrupts $0 when called using ksh(1). 2. ksh(1) removes here-document before RHS of pipe can read it. 3. ksh(1) corrupts memory in emacs mode of editing. 4. Repeated use of getopts builtin in ksh(1) introduces memory leak. PHCO_26783: 1. ksh does not work as expected, when trying to make a ~user substitution after login. 2. ksh(1) makes improper use of the file system. 3. Script using eval special builtin exits for ALL errors. 4. While using getopts, incrementing OPTIND causes ksh to coredump with SIGSEGV. 5. ksh ulimit does not report 'unlimited' for filesize. This causes users to incorrectly assume that ksh does not handle large files. 6. ksh coredumps if sent an early SIGWINCH. PHCO_22712: 1. ksh(1) follows regular expression standards now, after a defect fix. This is causing customer scripts that follow earlier behavior to fail. 2. When in a function, if REPLY is typeset and read is called to read input into REPLY, REPLY does not get initialized with the input. 3. ksh(1) core dumps while executing customer tcrun scripts which have ksh as underlying shell. 4. When eval is part of the last element of a pipe, and there is an error in the execution of eval builtin, the command buffer gets corrupted and the script which is expected to exit since eval is a special builtin, does not exit, but continues to execute. PHCO_22020: 1. When maximum number of file descriptors that can be opened by a process is more than 32 K ( given by executing "getconf _SC_OPEN_MAX") , CDE login with ksh(1) as login shell hangs. PHCO_21937: 1. ksh(1) does filename expansion inside bracket expressions. 2. ksh(1) core dumps if a script having multiple su - -c " &" is executed, when has ksh as login shell. 3. ksh(1) hangs while executing a script having multiple su - -c " > /dev/null &", when has ksh as login shell. 4. Using "~user" to refer to user's home directory fails for users in NSS, NIS+ or LDAP. 5. While executing a shell function, if ksh(1) gets a request for window resize, execution of the function gets aborted. PHCO_21185: 1. ksh(1) continues to wait for read to get completed even after receiving SIGINT signal. 2. ksh(1) coredumps if the history file is generated in heterogeneous environment and a shell function whose size is more than one kilobyte is executed. 3. Login attempt on ksh(1) fails and ksh(1) enters infinite loop if the size of the history file is more than four kilobytes. 4. ksh(1) getopts OPTARG is corrupted. i.e. If any other instruction other than echo is executed immediately after getopts is executed, OPTARG gets corrupted. 5. ksh(1) displays a misleading error message "no such process" when an attempt is made to kill a bad process group. 6. Login attempt with login shell as ksh(1) fails when all of the following occur : (i) Home directory is not owned by the user. (ii) User has 755 permission to home directory. (iii) User owns the history file. (iv) History file is corrupted. 7. ksh(1) does not work correctly in case of pattern matching involving bracket expressions. PHCO_19053: 1. ksh(1) exits after executing trap for SIGHUP. PHCO_18164: 1. ksh(1) does not trap SIGHUP if received within a function. 2. ksh(1) coredumps with script using many heredocs. 3. ksh(1) does not reap children fast enough. 4. The "return" built-in command of ksh(1) does not work as expected. 5. ksh(1) history search facility does not work correctly when history file is very large. 6. ksh(1) dumps core with very long environment variables. 7. A return statement in a do-while loop inside a function exits only the do-while loop, not the function. 8. ksh(1) does not handle command substitution of variables of length 2047, 3071, etc. correctly. When a variable is assigned a string of length equal to 2047/3071/..., the result of command substitution using this variable retains only the last 1023 bytes of the variable. 9. ksh(1) hangs when processing - "cat bigfile | while read ..." The right side of the pipe can be any shell commands (while, if, for, etc.) 10. ksh(1) does not wait(2) for zombies while in vi input mode. 11. When set -e is on, ksh(1) does not exit on encountering error while expanding the word list in a for statement. This happens even in a case statement and a pipe list. Defect Description: PHCO_27418: 1. "set --" corrupts $0 when called using ksh(1). The problem occurs when the shell script is run using "ksh -c" or it is invoked inside another script. The shell script that is getting executed should not begin with "#!/usr/bin/ksh" or "#!/usr/bin/sh". Problem Reproduction: --------------------- Step 1. Run the below script with -c option. $ cat ./script echo $0 ACTDIR=`dirname $0` VAR02345="00000000" VAR1="11111111" set -- 12345678 VAR2="22222222" VAR3="33333333" VAR4="44444444" ADIR=`dirname $0` echo "before test of \$0 output -- $0 +" set -- abcdefghijklmnopqrstuvwxyz echo "after test of \$0 output -- $0 -" $ ksh -c ./script The output may be as shown below: ./script before test of $0 output -- ./script + after test of $0 output -- @ - "set --" should not change the value of $0. Earlier in certain cases $0 was stored along with other positional parameters in the heap memory. Calling `set --` will free this memory which resulted in the pointer to $0, pointing to a freed memory. The problem is only visible if the freed memory is reused by ksh before we try to access $0. Resolution: Now $0 is stored in a separate memory and not along with the other positional parameters. 2. ksh(1) removes here-document before RHS of pipe can read it. Problem Reproduction: --------------------- Run the below script. $ cat ./script #!/usr/bin/ksh count=0 while [ count -ne 30000 ] do VAR=`echo value << end |grep -i value end` echo $VAR count=$((count+1)) done $ ./script ksh may give an error message /tmp/sh11503.1: cannot open. In the above script, shell on command substitution involving pipe forks a child to do the command substitution. This child in turn forks another child for executing the LHS of the pipe while the first child executes the RHS of the pipe. Before executing the RHS the first child deletes all the temporary files created by it. The problem occurred because of the race condition: RHS removed the temporary files before the LHS could open it for reading. Resolution: The problem has been solved by making the shell in RHS selective in removing the temporary files so that those files that are to be used and deleted in LHS are not deleted by RHS. Please refer to the WARNINGS section of the ksh(1) manpage for more information about here-documents. 3. ksh(1) corrupts memory in emacs mode of editing. The corruption occurs when the user repeatedly types <.> to insert the last word of the previous command on the same line. Problem Reproduction: --------------------- Step 1. On a ksh interactive shell set the editor mode to emacs. $ set -o emacs Step 2. Create and store a data to be yanked later. $ abcdefghijklmnopqrstuvwxyz

Step 3. Type the command as shown below. $ ls aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.... Step 4. Insert the last word of the previous command repeatedly as shown below. $ <.><.><.><.><.> <.><.> Step 5. Now yank the previously stored item. $ Due to memory corruption the yanked data will be "aaaaaaaaaaaaaaaaaaa" instead of "abcdefghijklmnopqrstuvwxyz". Repeated typing of <.> in step 4 can cause ksh(1) to report memory fault. The problem was due to ksh(1) not checking the boundary limits of the input buffer when <.> is typed, resulting in buffer overflow. Resolution: The proper boundary check has been introduced for <.>. 4. Repeated use of getopts builtin in ksh(1) introduces memory leak. Problem Reproduction: --------------------- Step 1. Run the below script $ cat ./script #!/usr/bin/ksh function leak { while getopts b: name "-b king" do case $name in b) ;; ?) echo "Test failed\n" exit 2;; esac done OPTIND=1; return } i=0 while test $i -le 3 do leak i=$(($i+1)) done i=0 UNIX95=1 ps -p$$ -osz | paste - - while test $i -le 30000 do leak i=$(($i+1)) done UNIX95=1 ps -p$$ -osz | paste - - # endof script $ ./script There will be an increase in the physical page size for ksh. SZ 52 SZ 146 Executing "getopts" assigns new value to shell variable OPTARG. ksh(1) does this by allocating a new memory for holding the value of OPTARG. However, the previous memory to which OPTARG was pointing was not freed resulting in memory leak. Resolution: Now the old memory location pointed to by OPTARG is freed before OPTARG is assigned new values. PHCO_26783: 1. Soon after invoking the shell, if a tilde substitution is attempted, ksh does not correctly display the result. ~ will result in "*", instead of "/". Problem Reproduction: --------------------- Run the following commands: * Invoke ksh as - /usr/bin/ksh -ksh * set -o vi * cd ~ The display will look like - cd /mnt/vts*, which is wrong. The display should have been - cd /mnt/vts/ Resolution: The problem was in the way ksh was handling its local stak during tilde substitution and filename generation. The stak data was overwritten due to mishandling of allocated space. This has been set right now. 2. ksh makes improper use of the file system. Resolution: The file system usage corrected. 3. Scripts using special builtin commands like eval, exit for All kinds of errors that occur during the execution of the special builtin commands. This behaviour was introduced to meet the ksh(1) man page documentation. ksh(1) man page documented that errors in special builtin commands cause the scripts containing them to abort. Problem Reproduction: Run the following script. Script - eval.scr #!/usr/bin/ksh eval cd /abc # /abc should not exist!!! echo hello #script ends. The script exits with the following output: ./eval.scr[3]: /abc: not found The correct behaviour would be to produce the following output: ./eval.scr[3]: /abc: not found hello Resolution: The earlier behaviour of ksh(1) wrt. handling errors in special builtins has been restored. ksh(1) man page has been corrected. 4. While using getopts, incrementing OPTIND causes ksh to coredump with SIGSEGV. When OPTIND is set to a value greater than the number of arguments passed to the builtin command getopts, ksh(1) tries to access memory beyond the array boundary. This causes coredump with SIGSEGV. Problem Reproduction: Run the following script: Script getopts.scr: #!/usr/bin/ksh function CORE_ME { OPTIND=1 while getopts q:i:e:c:I:Q:t:kmswC4Tgno opt do OPTIND=$(($OPTIND+1)) done } CORE_ME -i foo.exp echo $OPTARG #script ends. The script coredumps with SIGSEGV. The correct behaviour would be to produce the following output, without a coredump. foo.exp Resolution: getopts has been modified to return end-of-options, when the value of OPTIND is greater than the no. of arguments. Only if OPTIND is within the valid limit, it attempts to process the options and arguments. 5. ksh ulimit does not report 'unlimited' as the value of file size limit. It reports an incorrect value. This would mislead users to conclude that large files are not supported on HPUX. Unless the file size limit is set by the user, ulimit builtin should report "unlimited", as per the ksh documentation from O'reily and other vendors. Problem Reproduction: -------------------- * Ensure that the file size limit for the current session is not set (i.e. it is unlimited). * Invoke ksh * Execute the builtin command - ulimit The shell would output: 4194303 The correct behaviour would be to output: unlimited Resolution: ksh(1) used the system call ulimit() to get/set the file size limit. Now it makes use of getrlimit()/setrlimit() for this purpose which help in determining whether the limit is "unlimited" or a user defined value. The ulimit builtin has been enhanced to display/set other limits like coredump size, data segment size, file-descriptors, stack size, cpu time. ksh(1) man page has been modified to document the new features of ulimit builtin. 6. ksh coredumps if sent an early SIGWINCH. ksh installs a signal handler for SIGWINCH, which tries to initialise contents of pointers which are not yet allocated space. SIGWINCH was blocked after the signal handler is installed, until the various pointers were allocated space. If SIGWINCH was received in the window between the handler installation and signal blocking, the signal handler caused core dump. Problem Reproduction: This is a race condition. It happens if an early SIGWINCH is sent during the shell startup. For this problem to be seen, the SIGWINCH has to be received by the shell during a very small window between the signal handler installation and blocking of SIGWINCH. This can not be reproduced without manipulating (introducing a delay) the source code. Resolution: The solution is to remove the window between the handler installation and the blocking of SIGWINCH. SIGWINCH is now blocked before the signal handler installation and released after the required space allocations. PHCO_22712: 1. ksh(1) follows regular expression standards after a defect fix. This is causing customer scripts that follow earlier behavior to fail. This behavior is present in PHCO_21185,PHCO_21937 and PHCO_22020. Resolution: An environmental variable, KSH_QUOTEMC is used to switch between standard and non-standard behaviors. If KSH_QUOTEMC is not set or set to anything other than "true", old behavior is shown. If KSH_QUOTEMC is set to "true", ksh(1) follows standard behavior. Manpage is changed accordingly to depict the current behavior. 2. When REPLY is typeset in a function, a new scope is created for REPLY. But, read was initializing the input to the old scope of the REPLY. As a result, when REPLY was examined in the function, it is seen to be not initialized with the input. Resolution: Code has been changed so that read takes care in initializing the value to the REPLY of new scope. 3. ksh(1) has its own memory management routines. In the free() function of ksh(1), memory allocated is not actually freed but it is marked free. This caused the problem. Resolution: Code has been changed so that ksh(1) does not make use of the memory marked as free. 4. When eval is part of the last element of a pipe, and there is an error in the execution of eval builtin, the command buffer gets corrupted and the script which is expected to exit since eval is a special builtin, does not exit, but continues to execute. Resolution: The problem is resolved by checking for special builtins, while deciding to return to the script on encountering an error. If special builtin is being processed, then decide to exit the script if an error occurs. At this point, the command buffer is cleared, so that the next command is not corrupted. PHCO_22020: 1. CDE login with ksh(1) as login shell hangs because the first available file descriptor was 27232 with ksh(1) although ideally it should be 3. This prevents CDE login as the login process has to scan all the file descriptors from 0 to highest numbered open file descriptor (in this case 27232). Resolution: The code is changed so that first available file descriptor is 3. PHCO_21937: 1. ksh(1) does filename expansion inside bracket expressions. But manpage says this should not be done. Resolution: Now, filename expansion is avoided in case of bracket expression. 2. ksh(1) dumps core while executing a script having multiple su - -c " &". This was happening because shell was trying to write an error message saying "Cannot start jobcontrol" onto a non-existent buffer As a result, ksh was dumping core. Resolution: Now, error message printing is done onto standard error(STDERR), thus preventing writing onto an unallocated buffer. 3. ksh(1) hangs while executing a script having multiple su - -c " > /dev/null &". Here is the explanation of the problem - By the time the first su process completes and releases the terminal, the second su command is invoked and fails to get the terminal. It sends itself the signal SIGTTIN. The parent script sees this and sends a SIGCONT to the child. The parent sends SIGCONT only once, but the child sends SIGTTIN until it gets the terminal. As a result, the child hangs. Resolution: Now, the parent sends SIGCONT to the child, as many times the child sends itself a SIGTTIN. As a result, the child does not hang. 4. /etc/nsswitch.conf is a configuration file for name service switch. ksh(1) used to call API's which were not supporting this switch. So "~user" used to fail for users present in NSS, NIS+ or LDAP. Resolution: Now, new API's which can handle this switch are used to solve the problem. 5. ksh(1) aborts execution of a function on window resize. Earlier, while executing a function, a flag was set to indicate reception of SIGWINCH making ksh(1) to abort the execution of that function. Resolution: Now, this flag is not set to avoid the function being aborted. PHCO_21185: 1. Read waits for input evan after receiving SIGINT . Resolution: Made necessary changes and added conditional checking to trap SIGINT. 2. ksh(1) coredumps with history file in heterogeneous environment. Resolution: Problem was because of static allocation of arrays. Size of these static arrays were not sufficient. These datastructures are dynamically allocated depending on the amount of data read in. 3. Login fails if history file can not be trimmed. Resolution: If the history file size is more than 4KB, it should be trimmed. Earlier shell had a problem in trimming the history file due to recursion. Now recursion is avoided . 4. OPTARG gets corrupted if echo is not the next command. Resolution: getopts(1) stores the command in static memory. This use to cause problems if a command other than echo is executed immediately after getopts. This was happening as the memory allocated for OPTARG was getting overwritten. Now argument that is read from from command is stored in heap to avoid corruption. 5. kill builtin of ksh(1) displays misleading message when a process group is killed. Resolution: ksh(1) use to display same message for both killing a process and a process group. A new message is added to fix this problem. 6. Login attempt fails on ksh(1) if history file is corrupt. Resolution: ksh(1) hangs for a user when $HOME is not owned by user and history file is emptied thereby deleting the special characters at the beginning of history file. When ksh(1) is invoked, it checks whether .sh_history is of type history file. If it is not, it used to enter looping. Fix is made to avoid this looping condition. 7. ksh(1) doesn't behave correctly in case of string matching. Resolution: ksh(1) used to trim in case of binary operations. This was causing problem in case expression contained an escape sequence. i.e. "\ABC" and "ABC" used to be interpreted in the same manner.Code is changed to avoid trimming in case of string matching. PHCO_19053: 1. If SIGHUP is trapped and a SIGHUP signal received, ksh(1) exits after executing the trap. It should continue to run instead. Resolution: ksh(1) was deliberately exiting after executing the trap for SIGHUP. This part of the code has now been eliminated, so that it continues to execute. PHCO_18164: 1. The trap set for signal SIGHUP is not executed by ksh(1), if it is received while a function is being executed. Resolution: When executing a function, ksh(1) resets all traps to their default action. If SIGHUP was received while executing a function, ksh(1) used to exit without executing the trap set. This specific check for SIGHUP has been now removed so that ksh(1) does not exit immediately, but instead executes the trap set and then exits. 2. ksh(1) dumps core while executing scripts having large number of heredocs. Resolution: ksh(1) had limited the number of open files at any time to 20, which was not sufficient in the case of the script which used a large number of heredocs. ksh(1) didn't handle the case when this limit was exceeded, and hence it coredumped. ksh(1) now allows as many number of open files as the system allows, i.e. it retrieves the system configured value for the number of open files per process and allocates sufficient memory to the various data structures. Now, ksh(1) does not have internal restriction on the number of open files and handles the situation correctly by displaying appropriate error messages, when the number of open files is exceeded. 3. When ksh(1) scripts like the following are run, the child processes created by the shell are not reaped immediately after the job is done, as a result the number of user's processes may exceed the limit and the user will not be able to run any more jobs. count=0 while [[ $count -le 500 ]] do ll | aa=`awk '{ print $4 }'` let count=count+1 echo $count done Resolution: ksh(1) did not call the wait() system call to reap the child process in cases where a pipe and command substitution were used together. As a result, the child processes were left in the process table until the parent process died. A wait() call has been introduced to reap processes created when handling pipes and command substitution together. The child processes are reaped immediately after they are done. 4. The "return" command of ksh(1) does not return to the expected script, when used in scripts along with the dot built-in command. A return statement used as follows may not work as expected: script s1: . s2 echo s1 done script s2: . s3 echo s2 done script s3: echo s3 done return 0 The expected result from executing script s1 is: s3 done s2 done s1 done The actual result that is obtained is: s3 done s1 done Resolution: The problem was with the dot built-in command. It did not provide a means for the script being executed to return to it. A setjmp() call has been introduced in the dot built-in command to allow it to control the return from a return command. 5. The search facility for history file (ESC /) does not work in ksh(1) when history file is larger than 32K. Resolution: There was an inherent assumption about the size of the history file in ksh(1). Variables of type short were used to process the history file, which failed when the history file size was more than 32K. The variables have been changed to integer type so that the shell is able to handle the bigger sizes of history files. 6. ksh(1) dumps core when environment variables are set to very long values. For eg. if the variable HOME is set to a very long value and a "cd" command is issued, ksh(1) dumps core. Resolution: Core dump was occurring due to writing data into an array beyond its limits. The problem has been fixed by introducing a check before writing into the array. 7. A return statement within a do-while loop that is in a function, does not return from the function, but exits only the do-while loop. Running the following script demonstrates this fact. #!/usr/bin/ksh fxn() { cat /etc/passwd | while read line do echo $line return done echo after fxn return, still in fxn } fxn echo after fxn We see the message "after fxn return, still in fxn" even after the return statement is executed. Resolution: When a do-while loop is used along with pipe, return from a function was not returning control to the caller. setjmp() and longjmp() have been appropriately introduced now to handle the situation. 8. ksh does not handle command substitution of variables of length 2047, 3071, etc. correctly. In the following command, where variable "stuff" is assigned a string of length 2047, the contents of resulting string "str" will be the last 1023 bytes of "stuff". str=`echo $stuff` Resolution: During command substitution, the shell has a mechanism wherein the result of command substitution is stored in a buffer or a file depending on whether the result is lesser than or more than 1024 bytes. The mechanism by which this was decided had a defect. This has been corrected now. 9. ksh(1) hangs when executing scripts like the following: cat bigfile | while read m do printf "%s\n" $m done The file - bigfile is very large (size around 64k). Resolution: ksh(1) used to put all the commands in the do-while loop in a single job and waits for all the processes to complete before resuming the loop. In case of a large file this wait results in an infinite loop. This has been resolved by putting the processes associated with the do-while loop into a different job than the job in which other processes in the same pipeline are. 10. ksh(1) does not wait(2) for zombies while in vi input mode. Jobs which are started in the background and exit show up as zombies (defunct) until the user presses the return key in the xterm where the job was started. Resolution: The shell did not process any signal received during input reading in vi/emacs mode and hence it failed to recognize the SIGCHLD received when the background job terminated. As a result, zombies Stayed in the process list till the shell collected their exit status. This has been fixed by checking for SIGCHLD during input reading. 11. If set -e is ON, ksh should exit on encountering errors during processing the word list in a for statement, and case statement. When the last command in a pipe list fails also, it should exit if set -e is on. Currently it is not happening. Scripts like the following should exit on error. set -e for i in `sort a_non_existent_file` do echo Hello $i done echo "return code is " $? " -> Should not display this." Resolution: When set -e is ON, the shell did not check for failure in word expansion during for-loop processing, case word and pattern expansions and exit status of the last command of a pipeline. These checks have now been implemented and ksh(1) now exits on such errors if set -e is set. Enhancement: No (superseded patches contained enhancements) PHCO_26783: Builtin command - ulimit has been changed to display - "unlimited" by default, when the filesize limit is not set. Scripts that are checking for a numeric value by default as output from ulimit, will have to be suitably modified. SR: 8606273772 8606273770 8606267591 8606216997 8606199752 1653264812 8606249921 8606179356 8606226600 8606189689 8606186029 8606187216 8606165174 8606156063 8606156237 8606168292 8606147080 8606145334 8606145683 8606134084 5003467548 8606134264 8606132172 5003455519 5003442533 1653298927 8606101547 8606106706 8606109680 8606105008 1653302570 1653298422 4701413922 5003438358 1653284968 1653285585 4701398131 5003428490 5003424754 4701378364 1653236851 1653240390 Patch Files: OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64, v=HP: /usr/share/man/man1.Z/ksh.1 /usr/share/man/man1.Z/rksh.1 OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP: /usr/bin/ksh /usr/bin/rksh what(1) Output: OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP: /usr/bin/ksh: $Revision: 82.10.1.61 $ Version 11/16/88 PATCH_11_00: arith.o blok.o ctype.o defs.o edit.o ec ho.o expand.o fault.o io.o string.o stak.o w ord.o emacs.o vi.o hpux_rel.o args.o builtin .o cmd.o main.o msg.o print.o xec.o name.o m acro.o error.o service.o test.o jobs.o histo ry.o 02/09/04 OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP: /usr/bin/rksh: $Revision: 82.10.1.61 $ Version 11/16/88 PATCH_11_00: arith.o blok.o ctype.o defs.o edit.o ec ho.o expand.o fault.o io.o string.o stak.o w ord.o emacs.o vi.o hpux_rel.o args.o builtin .o cmd.o main.o msg.o print.o xec.o name.o m acro.o error.o service.o test.o jobs.o histo ry.o 02/09/04 OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64, v=HP: /usr/share/man/man1.Z/ksh.1: None OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64, v=HP: /usr/share/man/man1.Z/rksh.1: None cksum(1) Output: OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP: 1475674419 172032 /usr/bin/ksh OS-Core.UX-CORE,fr=B.11.00,fa=HP-UX_B.11.00_32/64,v=HP: 1475674419 172032 /usr/bin/rksh OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64, v=HP: 2727930322 42047 /usr/share/man/man1.Z/ksh.1 OS-Core.CORE-ENG-A-MAN,fr=B.11.00,fa=HP-UX_B.11.00_32/64, v=HP: 2727930322 42047 /usr/share/man/man1.Z/rksh.1 Patch Conflicts: None Patch Dependencies: None Hardware Dependencies: None Other Dependencies: None Supersedes: PHCO_18164 PHCO_19053 PHCO_21185 PHCO_21937 PHCO_22020 PHCO_22712 PHCO_26783 Equivalent Patches: None Patch Package Size: 270 KBytes Installation Instructions: Please review all instructions and the Hewlett-Packard SupportLine User Guide or your Hewlett-Packard support terms and conditions for precautions, scope of license, restrictions, and, limitation of liability and warranties, before installing this patch. ------------------------------------------------------------ 1. Back up your system before installing a patch. 2. Login as root. 3. Copy the patch to the /tmp directory. 4. Move to the /tmp directory and unshar the patch: cd /tmp sh PHCO_27418 5. Run swinstall to install the patch: swinstall -x autoreboot=true -x patch_match_target=true \ -s /tmp/PHCO_27418.depot By default swinstall will archive the original software in /var/adm/sw/save/PHCO_27418. If you do not wish to retain a copy of the original software, include the patch_save_files option in the swinstall command above: -x patch_save_files=false WARNING: If patch_save_files is false when a patch is installed, the patch cannot be deinstalled. Please be careful when using this feature. For future reference, the contents of the PHCO_27418.text file is available in the product readme: swlist -l product -a readme -d @ /tmp/PHCO_27418.depot To put this patch on a magnetic tape and install from the tape drive, use the command: dd if=/tmp/PHCO_27418.depot of=/dev/rmt/0m bs=2k Special Installation Instructions: None