Part III System Administrator Information

This part includes system administration information.

Chapter 8 Configuring a Korean Solaris System

You can use the procedures this chapter to set a system-wide default locale or to add a new locale from the Solaris DVD and CD media. You also change the font path set by the Xsession script included in the Korean Solaris Operating System. The following sections are included in this chapter.

• Setting the Default Locale

• Using Aliases to Set the Locale

Setting the Default Locale

You can use the procedure in this section to make a system-wide change to the default locale.

How to Set the Default Locale

1. Become superuser.

2. Edit the /etc/default/init file.

3. Add or update the LANG variable with the appropriate locale.

   LANG=locale

   locale

   C, ko, or the ko.UTF-8

4. Instruct all users to exit CDE.

5. Kill the dtconfig process.

   # /usr/dt/bin/dtconfig -kill

6. Reboot the system.

   # reboot

Using Aliases to Set the Locale

You can use aliases to change a terminal-emulation window between the Korean locales and ASCII/English locale without typing long command lines or editing your .dtlogin file and running source every time.

How to Set Locale Aliases for the Korn Shell

Put aliases such as the following in your .profile file.

alias kor_EUC "export LANG=ko; /bin/stty cs8 -istrip defeucw" alias kor_UTF "export LANG=ko.UTF-8; /bin/stty cs8 -istrip \defeucw" alias asc "export LANG=C; /bin/stty cs7 istrip defeucw"

How to Set Locale Aliases for the C Shell

Put aliases such as the following in your .cshrc file.

alias kor_EUC "setenv LANG ko; /bin/stty cs8 -istrip defeucw" alias kor_UTF "setenv LANG ko.UTF-8; /bin/stty cs8 -istrip \defeucw" alias asc "setenv LANG C; /bin/stty cs7 istrip defeucw"

Chapter 9 Managing the htt Input Method Server

The input method server (IM Server) handles Korean input for Korean Solaris software. The IM Server receives keyboard input and makes the input available as Korean characters to Korean Solaris system applications. The IM Server can serve any internationalized X Window application that uses the X Windows Input Method (XIM) application program interfaces (API) to receive language input.

This following sections in this chapter explain the basic display features of the IM Server.

• Input Method Server Basic Properties

• htt Application Display

• How and When htt is Started

• Using the iiim Server in the ko_KR.UTF-8 Locales

Input Method Server Basic Properties

The Korean Solaris Operating System starts the IM Server automatically when you log in to a locale that requires an input method.

The Korean Solaris applications that use the IM Server for Korean character input typically find the IM Server running when the applications starts. To connect to the IM Server for language input, the IM Server should be running before the application starts. If the IM Server is not running before the application starts, the application might not be able to connect to the input service. Even if the IM Server starts later, the application might not be able to connect to the input service.

Three htt Processes

The input method server comprises three related programs. The htt, htt_server, and htt_xbe, processes are run together. One process controls the properties of the input method server. A watch dog process controls the population of the input method server and a third process handles the input methods of clients.

Usually, you don't need to know the details of these three processes. When htt starts, the htt_props and htt_server start also.

htt Application Display

The following figure shows a typical application display when the htt input method is in use.

How and When htt is Started

Any application that uses the IM server to receive Korean characters must find htt running before the server can receive Korean character input. If the default locale is C, which does not require htt, and you change from C to another locale in a single Terminal, for example, you must start htt with a command line like the following:

system% /user/openwin/bin/htt -if kole -xim htt_xbe &

With the locale set to ko_KR.EUC, htt starts automatically when the Korean windowing environment is started. In CDE, htt is started from a script, /usr/dt/config/Xsession.d/0020.dtims. The script is executed by Xsession, which runs at every initialization stage when you log in from dtlogin. The script ensures that htt is started before other applications in CDE.

Using the iiim Server in the ko_KR.UTF-8 Locales

The Internet Intranet Input Method Server (iiim) supports the European Local Input Methods that use the Compose key. The iiim server also supports the Asian Remote Input Methods that use IIIM Protocol. The default Language Engine is English/European which supports ASCII and some European Languages such as German and French.

To switch to Korean Input Methods, press Control-spacebar.

To switch to other language engines, click the left mouse button in the Status Area.

The following language engine list appears.

• Cyrillic

• Greek

• Thai

• Arabic

• Hebrew

• Hindi

• Unicode Hex

• Unicode Octal

• Lookup

• Korean

The following language engines appear if the corresponding locales are installed:

• Japanese — if the ja locale is installed

• Simplified Chinese — if the zh locale is installed

• Traditional Chinese — if the zh_TW locale is installed

• Traditional Chinese (Hong Kong) — if the zh_HK locale is installed

For more information about how to use Korean input methods, see Chapter 4, Entering Korean Text.

Chapter 10 Fonts

The following sections in this chapter describe how to use and edit the Korean Solaris fonts.

• Display PostScript System (DPS)

• BDF and PCF Formats

• Changing Font Directories

• Bitmap and TrueType Fonts

This chapter also describes how to convert BDF font files to Portable Compiled Format (PCF) format and how to make the fonts usable on your system.

Display PostScript System (DPS)

The Korean Solaris Operating System provides PostScript fonts in the Display PostScript System (DPS). This section describes what you need to use DPS in Korean Solaris software. For further details, see Programming the Display PostScript System with X, published by Adobe Systems.

Using Korean PostScript Fonts and DPS Facilities

The Korean Solaris Operating System DPS provides the fonts listed in the following table.

You can use the following Korean fonts just as you would use Roman fonts.

• Kodig-Medium-EUC-H

• Kodig-Medium-EUC-V

• Kodig-Medium

• Myeongjo-Medium-EUC-H

• Myeongjo-Medium-EUC-V

• Myeongjo-Medium

The following figure shows a sample of Kodig-Medium and Myeongjo-Medium text.

You can also use the following Korean fonts for pure Hangul between the SO and SI characters with no intermediate ASCII (0x20) characters.

• Kodig-Medium-H

• Kodig-Medium-V

Creating Composite Korean Fonts

You can create composite fonts using one Roman font and one of the following Korean fonts.

• Kodig-Medium-COMB-H

• Kodig-Medium-COMB-V

• Myeongjo-Medium-COMB-H

• Myeongjo-Medium-COMB-V

For example, the following PostScript code defines a sample composite font. The ASCII characters of the Times-Italic+Kodig-Medium font are combined with the Korean characters of the Kodig-Medium horizontal font.

/Times-Italic+Kodig-Medium
13 dict begin
				/FontName 1 index def
				/FMapType 4 def
				/Encoding [ 0 1 ] def
				/WMode 0 def
				/FontType 0 def
				/FontMatrix [1.0 0.0 0.0 1.0 0.0 0.0] def
				/FDepVector [
								/Times-Italic findfont
								/Kodig-Medium-COMB-H findfont
				] def
currentdict
end
definefont pop

Using Korean Fonts in DPS Programming

You can use Korean fonts just as you use Roman fonts in DPS wrap definitions. This sample code creates the display which follows.

defineps PSWDisplayText(char *text)
			/pointSize 50 def
			/Helvetica pointSize selectfont
			(Hello World) stringwidth pop 2 div neg 0 moveto
			(Hello World) show

			/cpSize 40 def
			/Kodig-Medium-KO cpSize selectfont
			(text) stringwidth pop 2 div neg pointSize neg moveto
			(text) show
endps

You can set PSWDisplayText in a C program to display the designated Korean text.

BDF and PCF Formats

You must convert BDF fonts to PCF format to make the fonts usable in Korean Solaris applications.

How to Convert BDF Fonts to PCF Format

Use the bdftopcf command to convert a BDF font to PCF format.

system% bdftopcf -o myfont14.pcf myfont14.bdf

The -o option enables the matrix encoding used for Asian PCF font files.

How to Install and Check an Edited Font

1. Compress the .pcf font file and move it to your font directory.

   system% compress myfont14.pcf

2. Run the following commands in your font directory.

   The .bdf file should not be in the font directory.

   system% cat >> fonts.alias -new-myfont-medium-r-normal--16-140-75-75-c-140-ksc5601.1987-0 Myfont-Medium14 ^D system% mkfontdir system% xset +fp `pwd`

3. Use a command line such as the following to view your font.

   system% xfd -fn Myfont-Medium14

Changing Font Directories

The Xsession script in /usr/dt/bin directory of the Korean Solaris Operating System includes the following font path: /usr/openwin/lib/locale/locale/X11/fonts, where locale is either ko or ko.UTF-8. To dynamically add a different font directory path, type the following commands:

system% xset +fp font_directory-path
system% xset fp rehash

Bitmap and TrueType Fonts

The tables in this section list the bitmap and TrueType fonts that are supported for the ko, the ko.UTF-8, and the ko/ko.UTF-8 locales.

The following table shows the Korean bitmap fonts for the ko locale.

The following table shows the Korean bitmap fonts for the ko.UTF-8 locale.

The following table shows the Korean TrueType Fonts for the ko/ko.UTF-8 locales.

Chapter 11 Korean Printing Facilities

This chapter includes the following sections:

• Printing Korean Output to a Line Printer

• Using the mp Utility

Printing Korean Output to a Line Printer

You can use the commands in this section to print files of different formats to a line printer.

Use this command to print an EUC file.

system% lp euc-filename

Use this command to print a Packed format file to a printer that supports Packed format.

system% lp -T PACK PACK-filename

Use this command to print a Johap format file to a printer that supports Johap format.

system% lp -T JOHAP JOHAP-filename

Use commands such as the following to print a ko.UTF-8 file to an EUC printer.

The first command line converts the file to an EUC format. The second line prints the file.

system% iconv -f ko_KR-UTF-8 -t ko_KR-euc ko.UTF-8_filename > euc-filename system% lp euc-filename

---

Note –

The printed output includes only the characters that are defined in the EUC code set.

---

Use commands such as the following to print a ko.UTF-8 file to a Johap (KS C 5601-1992) printer.

The first command line converts the file to a Johap format. The second line prints the file.

system% iconv -f ko_KR-UTF-8 -t ko_KR-johap92ko.UTF-8_filename >\ johap92-filename system% lp johap92-filename

---

Note –

The printed output includes only the characters that are defined in the Johap code set.

---

Using the mp Utility

The enhanced mp print utility is available in the current Korean Solaris release. You can use mp to print ko files in ko locale or UTF-8 files in ko.UTF-8 locales.

The output from the utility is standard PostScript that you can send to any PostScript printer.

Use the following command to print a file with the mp utility.

system% mp filename | lp

You can also use the utility as a filter because mp accepts stdin stream.

system% cat filename | mp | lp

You can set the utility as a print filter for a line printer. For example, the following command sequence signals the print service that the printer lp1 accepts only mp format files. The command also installs the printer lp1 on port /dev/ttya. See the lpadmin(1M) man page for more details.

system% lpadmin -p lp1 -v /dev/ttya -I MP
system% accept lp1
system% enable lp1 

You can use the following command to add a filter for an LP print service.

system% lpfilter -f filtername -F pathname

The filter converts the default input type to PostScript output with the /usr/bin/mp command.

To print a UTF-8 text file, use a command line such as the following.

system% lp -T MP UTF-8-file

For more details on the mp(1), see the man page.

Using mp as an Xprt (X Print Server) Client

Using mp as an Xprt client enables mp to print the output of any printer connected to a network supported by an Xprt print service. As an Xprt client, mp supports PostScript and many versions of PCL.

The Xprt client attempts a connection to an Xprt server based on the following rules:

• When the -D printer_name@machine[:dispNum] or -P printer_name@machine[:dispNum] options are used with the mp command, mp attempts to connect to an Xprt print service on machine[:dispNum] with printer_name.

  If the above attempted connection to machine[:dispNum] fails or if the argument given to -D or -P is just printer_name, then the mp command checks the XPSERVERLIST for Xprt servers that support the printer_name argument. For example:

  system% setenv XPSERVERLIST "machine1[:dispNum1] machine2[:dispNum2] machine3[:dispNum3]"

• If no server is found using above rules, mp checks for an XPDISPLAY environment variable set to machine[:dispNum]. For example:

  system% setenv XPDISPLAY "machine[:dispNum]"

• If the XPDISPLAY variable is not set or if the variable is invalid, mp tries to connect to the default display :2100. If the default display value is also invalid, mp exits with an error message.

  The /usr/lib/lp/locale/C/mp directory contains .xpr print page sample layout files for Xprt client. The sample files are for 300 dpi printers. If the target printer has a different dpi value, the dpi value of the sample files is automatically converted to the resolution of the target printer.

Chapter 12 TTY Environment and Support

This chapter assumes that you are familiar with the following information.

• The Solaris Operating System communicates with external devices using STREAMS and ioctl.

• Different terminal types are supported by termcap and terminfo.

This chapter includes the following sections:

• TTY STREAMS

• TTY Utilities

• TTY Commands

• TTY Setup Examples

• Terminal Support

• Installing a Terminal

Refer to the termio(7I) man page for background information on STREAMS and TTY drivers.

TTY STREAMS

The data path between a user's shell and the terminal is called a stream. The data on a stream contain characters and control information that affect data handling, such as the control sequences that precede a change in code set or communication protocols. Data that enters the stream from the terminal is raw or unprocessed. Data is sequentially processed by STREAMS modules for appropriate use by the shell or an application.

STREAMS provides a way to modularize the processing on a line, allowing processing instructions to be grouped in functional modules. These modules can be added or removed from the line so that different environments can be provided to a terminal according to the user's needs.

Traditional STREAMS

The traditional STREAMS TTY environment contains a raw device driver, a line discipline module, and a stream head. The raw device driver provides an I/O interface between the kernel and the hardware. Because it is closest to the physical hardware, it provides basic communication protocols, baud rate switching, and other low level services. The line discipline module is a set of instructions or disciplines that transforms the raw data to processed data. This includes handling the delete character, line kill character, and others. The stream head provides an interface between the user's process and the stream.

Korean Solaris STREAMS

The Korean Solaris Operating System uses the modular nature of STREAMS to support Korean. In addition to the traditional TTY modules, this product implements code conversion in STREAMS. Hangul-Hanja conversion is typically supplied by many existing Korean TTYs and is not available in the Korean Solaris TTY environment.

The Korean Solaris Operating System enhances the traditional modules. The line discipline of the operating system handles proper cursor movement for wide characters as well as normal protocols. The Korean Solaris code conversion modules convert between two different character code formats. For example, Packed format, combination code of KS C 5601-1987, can be converted to EUC format, completion code.

Code conversion depends on the appropriate flags or parameters being set. For example, if a Packed code terminal is being used, the input from the terminal is converted to EUC and the output to the terminal is converted to Packed code.

The major modules that can be pushed onto the stream are ldterm, kpack and kjohap.

• ldterm is a generic EUC line discipline module. It processes all normal line discipline functions and also handles proper cursor movement and backspacing for wide characters (EUC). See ldterm(7M) for more information.

• kpack controls code conversion between Combination code of KS C 5601-1987 and EUC.

• kjohap controls code conversion between Combination code of KS C 5601-1992 code and EUC.

TTY Utilities

ioctl (input/output control) calls are low-level routines for handling device input and output.

The termcap and terminfo databases are used by applications to configure their terminal display appropriately.

EUC ioctl Features

The Korean Solaris Operating System uses ioctl STREAMS commands for general EUC handling. The table describes the ioctl requests.

Character code conversion to and from the terminal is controlled by EUC_OXLON and EUC_OXLOFF.

The termcap database

The termcap and terminfo databases used to tailor the terminal characteristics for an application. The following table describes the variables of the termcap database.

The terminfo database

The following are extensions to terminfo. The s0-s3 string values are used as data announcement mechanisms for the respective code sets during terminal I/O.

TTY Commands

The two commands for configuring and using the TTY environment are setterm and /bin/stty. setterm is used primarily to build the TTY stream for a particular terminal type, pushing the necessary modules onto the stream. stty changes the behavior of the modules in the stream.

setterm Command

setterm is used to configure the TTY STREAMS environment. It can inquire about and manipulate STREAMS modules for a particular TTY port. setterm allows users to tailor their TTY STREAMS environment using system-provided or user-provided STREAMS modules.

setterm uses a terminal device name that reflects the devt (device type) field in the terminfo database for configuring STREAMS modules for a TTY port. This device name is matched with an entry of the same name in the setterm configuration file, /usr/share/lib/setterm/ko/conf.file or /usr/share/lib/setterm/ko.UTF-8/conf.file. This entry contains detailed instructions on which modules to pop and push in order to properly configure the STREAMS environment.

setterm can also take the device type as a direct argument. This device type is similarly matched with an entry in /usr/share/lib/setterm/ko/conf.file or /usr/share/lib/setterm/ko.UTF-8/conf.file.

The setterm configuration file uses a special language for instructions on what actions to take. This language allows users to determine the names of modules on the STREAMS stack, to push or pop modules on the stack, and to do other operations. setterm manipulates the STREAMS stack by making ioctl calls.

/bin/stty Command

The defeucw option to the /bin/stty command is for modifying STREAMS modules to reflect changes in the user's environment. It does not work with the /usr/ucb version of stty, which has not been internationalized.

The following command queries the user's environment for information on EUC code set width and sets.

system% /bin/stty defeucw

For example, if the user has the environment variable LC_CTYPE set to locale, this option gets information on the number of bytes per character and the screen width per character for the code sets in the ko and ko.UTF-8 environments and then sends this information to relevant modules in the stream.

TTY Setup Examples

The system administrator can add setterm in the startup script in /etc/rcn.d directory (where n is the run level), to run at the system boot time. Also, users can run the setterm command at login to configure the stream for their terminal, including the appropriate modules for Korean input code conversion. The following examples using setterm work as commands typed at a system prompt or included in system files such as .cshrc, .login, and the startup script. Such commands can either explicitly set the device type or use the terminfo database.

Configuring STREAMS for Korean Solaris Software

You can use the commands in this section to configure STREAMS modules.

Use the following command to explicitly configure the STREAMS module for the EUC, completion code, terminal type.

system% setterm -x EUC

Use the following command to explicitly initialize the Packed STREAMS module that supports the combination code of KS C 5601-1987.

system% setterm -x PACK

Use the following command to explicitly initialize the Johap STREAMS module that supports a combination code of KS C 5601-1992.

system% setterm -x JOHAP

Use this procedure to run a configuration command that references an entry in the terminfo database.

1. Add the following entry for a FAST-15 Packed code terminal to the terminfo database.

   fast-15 | fast-pack | korean terminal packed mode, devt=PACK, use=vt100-w,

2. Use the following configuration command to reference the entry for the FAST-15 Packed code terminal.

   system% setterm -t fast-15

For setterm to work properly, the /usr/share/lib/setterm/ko/conf.file must contain an entry that corresponds to the device type. This entry gives setterm instructions for placing the appropriate conversion modules in the TTY stream.

Add the following entry that corresponds to the device type to the /usr/share/lib/setterm/ko/conf.file.

# KoreanPACK|PACKthrow \ popto zs|mcp|mti|ptem \ push kpack \ push ldterm \ push ttcompat \ run {stty defeucw} \ catch # KoreanJOHAP|JOHAP throw \ popto zs|mcp|mti|ptem \ push kjohap \ push ldterm \ push ttcompat \ run {stty defeucw} \ catch # GenericEUC|EUCthrow \ popto zs|mcp|mti|ptem \ push ldterm \ push ttcompat \ run {stty defeucw} \ catch # ASCIIthrow \ popto zs|mcp|mti|ptem \ push ldterm \ push ttcompat \ catch #

Configuring STREAMS for the ko.UTF-8 Locale

You can use the commands in this section to configure STREAMS modules the ko.UTF-8 Locale.

Use the following command to explicitly configure the STREAMS module for the ko.UTF-8 locale.

system% setterm -x u8

Use the following command to explicitly initialize an EUC terminal to use the ko.UTF-8 locale

system% setterm -x ku8euc

Use the following command to explicitly initialize the Johap STREAMS module. This module supports combination code of the KS C 5601-1992 terminal to use the ko.UTF-8 locale.

system% setterm -x ku8johap system% stty defeucw cs8 -istrip

Use this procedure to run a configuration command that references an entry in the terminfo database.

1. Add the following entry for a FAST-15 Packed code terminal to the terminfo database.

   fast-15 | fast-pack | korean terminal packed mode, devt=PACK, use=vt100-w,

2. Use the following configuration command to reference the entry for the FAST-15 Packed code terminal.

   system% setterm -t fast-15

For setterm to work properly, the /usr/share/lib/setterm/ko.UTF-8/conf.file must contain an entry that corresponds to the device type. This entry gives setterm instructions for placing the appropriate conversion modules in the TTY stream.

Add the following entry that corresponds to the device type to the /usr/share/lib/setterm/ko.UTF-8/conf.file.

# Korean specific entries: # # Completion/Wansung/EUC code terminal support (KS C 5601-1992) KoreanU8EUC|KU8EUCthrow \ popto zs|mcp|mti|ptem \ push ku8euc \ push eucu8 \ push ldterm \ push ttcompat \ push u8euc \ run {stty defeucw} \ catch # # Combination code terminal support (KS C 5601-1992 Annex 3) KoreanU8JOHAP|KU8JOHAPthrow \ popto zs|mcp|mti|ptem \ push ku8johap \ push eucu8 \ push ldterm \ push ttcompat \ push u8euc \ run {stty defeucw} \ catch #

Terminal Support

The Korean Solaris Operating System supports completion-code terminals and Packed-code terminals. The terminals should have built-in automata, Hangul/Hanja fonts, and Hangul/Hanja input methods.

Packed code is also called combination code, KS C 5601-1987 and KS C 5601-1992.

Installing a Terminal

If you have not added a terminal to your system before, first try installing a terminal in ASCII mode only.

How to Install a Terminal to Support KS C 5601

1. Become superuser.

   system% su

2. Type admintool.

   The admintool menu will appear.

   system# admintool

3. Select the serial ports icon.

4. Click edit on the serial ports menu.

   The modify service submenu appears.

5. From the modify service submenu, select enabled, baud rate 9600. Then enter the terminal type.

   

6. Under expert options, select the create utemp entry and enter the appropriate module in the streams modules field.

   To install a terminal that supports the KS C 5601-1987 version of combination code for the Korean Solaris Operating System, add kpack to the streams modules field.

   To install a terminal that supports the KS C 5601-1992 version of combination code for the Korean Solaris Operating System, add kjohap to the streams modules field.

   

   For more information on admintool, see the System Administration Guide: Solaris Containers, Resource Management, and Virtualization.

How to Set Up a ttya Port from the Command Line

Use the following procedure to set up a terminal on ttya port from the command line.

1. Determine the port monitor version number.

   # ttyadm -V

   The port monitor version number will display.

2. Enter the following commands and substitute the port monitor version number for ver.

   # pmadm -r -p zsmon -s ttya #sacadm -a -p zsmon -t ttymon -c /usr/lib/saf/ttymon -v ver

   For more information, see pmadm(1M) and sacadm(1M) man pages.

3. Use the pmadm command that matches your terminal type to add a login service.

   For EUC terminals, use the following command.

   # pmadm -a -p zsmon -s ttya -i root -fu -v ver -m “ `ttyadm -S y \ -T terminal_type -d /dev/ttya -l 9600 -m ldterm,ttcompat -s \ /usr/bin/login`”

   For Korean Packed code terminals that use the KS C 5601-1987 version of Combination code, type the STREAMS module kpack in the ttyadm command.

   # pmadm -a -p zsmon -s ttya -i root -fu -v ver -m “`ttyadm -S y \ -T terminal_type -d /dev/ttya -l 9600 -m kpack,ldterm,ttcompat -s \ /usr/bin/login`”

   For Korean Combination code terminals, which use the KS C 5601-1992 version of Combination code, type the STREAMS module kjohap in the ttyadm command.

   # pmadm -a -p zsmon -s ttya -i root -fu -v ver -m “`ttyadm -S y \ -T terminal_type -d /dev/ttya -l 9600 -m kjohap,ldterm,ttcompat -s \ /usr/bin/login`”

4. Turn on the terminal.

   Refer to the documentation that accompanies the terminal.

5. Log in the terminal.

6. Check to see that the installation is correct.

   # setenv LANG ko # /bin/stty cs8 -istrip defeucw

   ---

   Note –

   These values show that the operating system is set to communicate with the terminal in 8-bit no-parity mode. Make sure the terminal is set up in 8-bit no-parity mode. Refer to the terminal's setup manual for the proper way to set terminal options.

   ---

How to Verify TTY Set Up

Use the following procedure to verify that the TTY is properly set up.

1. Type the /bin/stty command with the -a option.

   system% /bin/stty -a

2. If the cs8, -istrip values set in the previous procedure are not listed, use the following command to set them.

   system% /bin/stty cs8 -istrip defeucw

This is the last step in setting up a terminal. The default setting of a Korean terminal is the completion-code mode. Continue to the next section to install a Packed-code TTY.

How to Use Packed Code and Johap TTY in the ko Locale

If you use a Packed code (KS C 5601-1987) terminal , you must load the kpack STREAMS module into the kernel.

1. Become superuser.

   system% su Password: (Type superuser password here if required.)

2. Load the kpack module.

   #modload /kernel/strmod/kpack

3. Type the following command to enable the module.

   system% setterm -x PACK

How to Use Combination Code and Johap TTY in the ko Locale

If you use a combination code (KS C 5601-1992) terminal , you must load the kjohap STREAMS module into the kernel.

1. Become superuser.

   system% su Password: (Type superuser password here if required.)

2. Load the kjohap module.

   # modload /usr/kernel/strmod/kjohap

3. Type the following command to enable the module.

   system% setterm -x JOHAP

How to Use the EUC TTY in the ko.UTF-8 Locale

If you use an EUC (KS C 5601-1987-0) terminal , you must load the ku8euc STREAMS module into the kernel.

1. Become superuser.

   system% su Password: (Type superuser password here if required.)

2. Load the ku8euc module.

   #modload /kernel/strmod/ku8euc

3. Type the following command to enable the stream module.

   system% setterm -x KU8EUC

4. Type the following command to enable 8-bit I/O.

   system% stty defeucw cs8 -istrip

5. If you want to use dtterm, type the following command.

   system% setterm -x u8

How to Use the Johap TTY in the ko.UTF-8 Locale

If you use a Johap (KS C 5601-1992-3) code terminal , load the ku8johap STREAMS module into the kernel.

1. Become superuser.

   system% su Password: (Type superuser password here if required.)

2. Load the ku8johap module.

   #modload /kernel/strmod/ku8johap

3. Type the following command to enable the module.

   system% setterm -x KU8JOHAP

4. Type the following command to enable 8-bit I/O.

   system% stty defeucw cs8 -istrip

5. If you want to use dtterm, type the following command.

   system% setterm -x u8