by Robert Pfister

IN THIS CHAPTER

• The Current Status of Wine

• Setting Up Wine

• Using Wine

• How Wine Works

• Where Does Wine End and MS-Windows Begin?

• The Limitations of Wine

• The History of Wine

Wine stands for Windows Emulator. It enables MS-Windows programs to run under a UNIX X Window environment. Like DOSemu, Wine takes direct advantage of the Intel 386 architecture to actually run the MS-Windows application. Wine simply translates any MS-Windows API calls into appropriate UNIX and X Window calls. Like OS/2, MS-Windows programs running under Wine get to take advantage of features of the underlying operating system. Wine is simply another user-mode Linux process that is protected from corruption by other processes. This is dubbed crash-protection under OS/2. Because Linux uses preemptive multitasking, Wine processes can coexist with other processes without some of the problems experienced by applications running under native MS-Windows.

Wine is available only as source code. If you have the prerequisite software and a little patience, setting up Wine is not very difficult--even if you are not a programmer.

Any Linux machine suitable for running X Window will run Wine applications at a reasonable speed. In theory, Wine should have some advantages running under Linux, as opposed to under MS-Windows, which is confined to the MS-DOS environment. Experiences with current versions of Wine show that an application running under Wine is slower on the same machine running MS-DOS and MS-Windows.

To make full use of Wine, you need MS-Windows 3.1 installed on a disk partition that is accessible under Linux. It is also convenient to run existing MS-Windows applications from the same directory in which they are installed under native MS-DOS and MS-Windows. The typical Linux user also has MS-DOS and MS-Windows installed on a hard drive; thus it is only a matter of making the directories available under Linux. Linux kernels as of version 1.1.83 do not support compressed MS-DOS file systems made by MS-DOS utilities such as stacker and drvspace.

/dev/hda1 /c MSDOS defaults

to your /etc/fstab, where hda1 is the partition that contains MS-DOS and /c is the Linux subdirectory to use. In this example it is assumed that the /c subdirectory exists. Otherwise, use mkdir to create the subdirectory.

---

Wine is distributed as source code, and must be compiled before use. It requires approximately 10MB of disk space. 3.5MB of that disk space is the source code alone. To build Wine, you need to have the following:

• GCC

• LibC

• XFree with development parts loaded

• Linux kernel newer than 99.13

A new version of Wine is released about once a week. Major Linux FTP sites on the Internet contain the most recent release. On sunsite.unc.edu, look in the /pub/Linux/ALPHA/Wine directory. Wine releases are named after the date they are released. Wine-950727.tar.gz was released on 7/27/95. The most current release is the one with the latest date. For more information, check out the Web page at http://daedalus.dra.hmg.gb/gale/wine/wine.html.

Unlike DOSemu, the Wine distribution is not sensitive to where it is installed. For brevity, make a symbolic link from the actual directory (say /usr/src/Wine950122) to /usr/wine using the ln command, as follows:

bash# ln -s /usr/src/Wine950122 /usr/wine

A Wine distribution consists of a compressed tar file. To unpack the distribution, use a shell command such as

bash# tar -zxvf filename.tar.gz

Wine must be configured before being built. The configure utility prompts the user for the necessary information and automatically builds the appropriate configuration files. There are three major steps to configuring Wine:

1. Compilation configuration

2. Run-time parameters

3. Automatic system specific configuration

The configure script begins with the following questions:

Build Wine as emulator or library (E/L) [E]?

Short filenames (Y/N) [N]?

Use the XPM library (Y/N) [N]?

Language [En/De/No] ?

Global configfile name  /usr/local/etc/wine.conf

It is safe to press Enter and accept the default answers. These parameters are added to a global configuration file, autoconf.h. If parameter changes are necessary, re-run configure. To avoid errors, do not attempt to edit this file. Initially Configuring Runtime Parameters with configure The questions in this section relate to lines in the global configuration file /usr/local/etc/wine.conf. Following each question is an explanation of its meaning.

Which directory do you want to use as A:

Which directory do you want to use as C:

Answer these questions with the Linux directory where the MS-DOS A: and C: drives are mounted. If your disk partition on which MS-Windows is mounted is /c, then use /c. If you do not plan on using a floppy disk, do not worry if A: does not point to a valid directory.

Where is the Windows directory `c:\windows\'

Where is the System directory `c:\windows\system'

Where should Windows apps store temp files `c:\windows\temp'

Which path should be used to find progs/DLL's `c:\windows;c:\windows\system'

These directories should match where MS-Windows is installed on your MS-DOS partition. Because the default MS-Windows installation is in c:\windows, the default answers are usually sufficient.

Where is sysres.dll  /usr/wine/sysres.dll'

The sysres.dll is a DLL that contains Wine-specific resources. These resources include bitmaps and dialog boxes for things like the About Wine menu item. The default value is sufficient here as well.

Where is COM1" CF_Com1 `/dev/cua0'

Where is COM2" CF_Com2 `/dev/cua1'

Where is LPT1" CF_Lpt1 `/dev/lp0'

As with DOSemu, the communication and printer ports under Wine can be configured as any similar port under Linux. For simplicity, it is best to map the COM and LPT ports to the same ones that would appear under native MS-DOS.

Log messages to which file (CON = stdout) `CON'

This defines where the system messages generated by Wine will go. Sending messages to CON will send them to stdout. This is the most useful place, as these messages can easily be redirected elsewhere. By default, Wine generates a lot of informational messages, which slows things down a bit. A casual user will likely want to redirect these messages to /dev/null. To make this be the default action, use /dev/null for the log file.

Configure displays a long list of message types and asks the following question:

Exclude which messages from the log  `WM_SIZE;WM_TIMER'

If you don't care about any status messages from Wine, leave this as the default. Individual error messages can be turned on or off, as well as redirected from the command line.

At this point, configure will display the global configuration file, based on your responses to the questions. You will be asked if you want to edit the file using your default editor:

Do you want to edit it using vi (Y/N) [N]?

You can always edit this file later with your favorite text editor, so it is safe to answer no to this question. Automatic System-Specific Configuration After the wine.conf file has been successfully built, the configure utility proceeds to make changes to the source tree via the xmkmf. xmkmf is a utility that creates makefiles for X Window and creates a makefile from an imakefile, taking into account the peculiarities of different X Window installations across UNIX-like platforms.

To build Wine, simply type

make

You're done with the hard part of configuring Wine. However, building Wine seems like the longest part. To build Wine from scratch takes approximately eight minutes on a 90MHz Pentium. You will also need the -lXext libraries for the final link to work, so install it from your CD-ROM first.

Using Wine can be as simple as typing wine filename. Wine can be configured and used with a number of different options--including a debugger for tracking down internal errors in Wine itself.

Wine's global configuration file is typically /usr/local/etc/wine.conf. The configuration pa-rameters match mostly with the above questions and are organized in the format of MS-Windows .ini files. A sample file follows, with some comments on the usage of each section.

The following statements map MS-DOS drive letters to the matching subdirectory under Linux:

[drives]

A=/a

C=/c

These parameters tell Wine where to find Windows- and Wine-specific DLLs and directories:

[wine]

Windows=c:\windows

System=c:\windows\system

Temp=c:\temp

Path=c:\windows;c:\windows\system

SystemResources=/users/wine/wine950122/sysres.dll

The following section applies to the mapping of MS-Windows fonts to X font (note that the * is used for wildcard matching of X fonts):

[fonts]

system=*-helvetica

mssansserif=*-helvetica

msserif=*-times

fixedsys=*-fixed

arial=*-helvetica

helv=*-helvetica

roman=*-times

default=*-*

The following section maps serial ports available under Wine with corresponding Linux serial port identifiers:

[serialports]

Com1=/dev/cua0

Com2=/dev/cua1

The following section maps printer ports available under Wine with the corresponding printer port under Linux:

[parallelports]

Lpt1=/dev/lp0

These parameters determine the amount of logging and the destination:

[spy]

File=CON

Exclude=WM_SIZE;WM_TIMER

The Wine command line has the following format: wine wine_options program program_options. For example:

bash# /usr/wine/wine -debugmsg +all /c/windows/winmine.exe

Table 63.1 shows command-line options available with Wine.

Wine has a built-in debugger that is useful for uncovering problems within the program. When an MS-Windows program exits due to a problem, the debugger starts in the xterm from which Wine was started. If you are not interested in troubleshooting Wine, you need only type quit at the prompt and skip to the next section of this chapter.

The Wine debugger is similar to the GNU debugger gdb. Breakpoints can be set; examination and modification of registers as well as memory locations are possible. However, this is a minimal debugger that includes only the commands listed in Table 63.2.

In order to benefit from using the Wine debugger, an understanding of debugging i386 assembly is essential. If you are serious about debugging Wine, an assembly language output from GCC is essential.

Wine is composed of an MS-Windows program loader and a library of MS-Windows functions.

Wine's first duty is to load an MS-Windows executable image into memory. This also includes any DLL files and other resources that the application needs. MS-Windows uses a different executable image type than does DOS called NE, or new executable. DLLs and font files also use this NE format, which makes Wine's job easier.

Individual segments of the NE image must be load into memory, and references to other DLL and Windows calls need to be resolved. Calls to functions outside an image are referred to by the module name and function number. A call to Ellipse is actually stored as GDI.24.

After an executable image is loaded into memory, Wine simply jumps to the WinMain() function defined in the image. A call to MS-Windows graphics function Ellipse is stored as GDI.24. GDI is the name of the MS-Windows graphics library, and 24 is the position in that DLL where Ellipse starts. Wine does not need to do any instruction emulation, because both Linux and MS-Windows use the i386 instruction set. When an MS-Windows primitive function is called, Wine intercepts that call and passes it to a matching library routine.

Wine converts the MS-Windows API to the matching X or UNIX API calls. A call to the MS-Windows Ellipse function to draw an ellipse in a window has the following format:

Ellipse (hdc, xLeft, yTop, xRight, yBottom);

The definitions of xLeft, yTop, xRight, and yBottom are a bounding box for an ellipse, as shown in Figure 63.2.

The same ellipse is drawn under the X API XDrawArc function:

XDrawArc(display, d, gc, x, y, width, height, angle1, angle2);

The definitions of x, y, width, height, angle1, and angle2 are shown in Figure 63.3.

As Wine currently requires parts of MS-Windows to operate, it is a bit confusing to know where Wine ends and MS-Windows begins. Wine currently provides API calls for the following parts of a typical MS-Windows installation:

commdlg	Common Windows Dialogs
gdi	Graphics Device Interface
kernel	Kernel Interface
keyboard	Keyboard Interface
mmsystem	Multimedia System Interface
mouse	Mouse Interface
shell	Windows 3.1 Shell API Library
sound	Windows sound system
toolhelp	Debugging and tools helper calls
user	Microsoft Windows User Interface
win87em	Coprocessor/Emulator Library
winsock	Windows Socket interface (TCP/IP)

Wine requires access to some parts of MS-Windows to use features that are not implemented by Wine. One example is the MS-Windows dynamic link library OLECLI, which implements the OLE client. The Wine team has made significant headway in reducing the number of files needed. The Wine project charter includes removing any dependency on MS-Windows files. This includes utilities and file organizations to install MS-Windows applications.

Some of the simplest MS-Windows applications run today under Wine without need of any MS-Windows code or access to any MS-Windows directories. WINMINE.EXE and SOL.EXE are examples of such applications. Although no suggested directory organization exists to support this, a quick example of doing this is the following:

1. Copy winmine.exe and win.ini to a Linux directory such as /users/windows.

2. Change the Windows path options in wine.conf, such as to /users/windows.

3. Dismount your MS-DOS partition.

4. Run Wine.

Only a few MS-Windows software packages run correctly under Wine. Luckily, it is possible to estimate how likely a program is to run correctly without actually running it. Unfortunately, there are some classes of applications that are unlikely to ever run under Wine.

Recent versions of Wine support a good number of the MS-Windows applets and games included with the stock MS-Windows 3.1. There are considerable variations between each release of Wine. Changes that help some applications often break others. But here are just a few of the accessories and games that work well under Wine:

• calc.exe

• clock.exe

• cruel.exe

• golf.exe

• notepad.exe

• pipe.exe

• pegged.exe

• reversi.exe

• winmine.exe

Part of Wine is the winestat utility. This is actually the same program as Wine, but instead of running an MS-Windows executable, winestat simply attempts to load a Windows executable and reports on how successful the load was. In loading an executable, winestat also loads any DLLs necessary, and reports if any are missing. winestat looks for Windows API calls that are used by either the executable or any DLL, and verifies their existence. A sample winestat run on the MS-Windows Paintbrush applet pbrush yields the following:

KERNEL.1 not implemented

KERNEL.54 not implemented

KERNEL.113 not implemented

KERNEL.114 not implemented

KERNEL.121 not implemented

KERNEL.154 not implemented

KERNEL.178 not implemented

KERNEL.207 not implemented

KERNEL: 52 of 60 (86.7 %)

USER: 150 of 150 (100.0 %)

GDI.151 not implemented

GDI.307 not implemented

GDI.366 not implemented

GDI.439 not implemented

GDI: 80 of 84 (95.2 %)

SHELL: 9 of 9 (100.0 %)

KEYBOARD: 2 of 2 (100.0 %)

TOTAL: 293 of 305 winapi functions implemented (96.1 %)

winestat calls out by number and module the individual functions that are not implemented by Wine. If you are curious as to the function name, rather than number, look at the Wine sources in the if1632 directory for the given module name's spec file. A sample kernel.spec file is as follows:

#1 FATALEXIT

#2 EXITKERNEL

3   pascal GetVersion() GetVersion()

...

...

...

#54 pascal16 GETINSTANCEDATA

Any line in a .spec file that starts with a # is considered a comment, not an implemented function. In this example, both 1 and 54 are commented, with the respective names of FATALEXIT, and GETINSTANCEDATA. FATALEXIT is used for debugging MS-Windows programs under error conditions and is not important for most MS-Windows users. GETINSTANCEDATA copies configuration data from a previous instance of an application. If you are running only one instance of an application, this does not apply.

The final percentage shows which MS-Windows API calls are implemented. This is often a good measure of how much of an application could work under Wine. Unfortunately, if a single, unimplemented API call is needed to initialize your MS-Windows application, anything less than 100 percent is not good enough.

MS-Windows applications to which winestat gives an overall implementation rating over 95 percent are worth a try. Unlike DOSemu, Wine is not as prone to leaving Linux in an unusable state. However, it is not always a trivial matter to kill an errant Wine session. The easiest thing to do is to start Wine with a separate desktop: wine -desktop 800x600 filename. Normal methods of killing a Windows process from your window manager should work.

Perhaps the most obvious omission from Wine is the lack of a printer interface. As this is a complex process, work on a printer interface is little more than a few ideas. It would be a huge task to support all of the types of printers supported under MS-Windows. Wine will likely implement only a PostScript driver. Existing Linux utilities such as GhostScript are already capable of converting PostScript to other printer types, such as HP laser and inkjet printers.

The Wine project has no plans to support Windows Virtual Device Drivers. (VDDs). VDDs use a different image format, called LE for linear executable, that the Wine loader is unable to handle. Because VDDs do things like direct hardware manipulation, coexistence of a VDD with Linux device drivers would be a tough problem indeed. One of the uses of VDDs in commercial MS-Windows is for TCP/IP stacks. Wine supports TCP/IP through the winsock DLL, which uses the TCP/IP inherent in the Linux kernel.

The first parts of Wine were made available in July 1993. The first versions had problems running the MS-Windows Solitaire game, and were quite limited. Notably missing was support for menus. Since then a huge number of changes have been made by many dedicated people. Following are just a few of the notable milestones:

• Dec 1993 Communications port support

• Feb 1994 Winsock interface added

• May 1994 clock.exe working, backingstore optimizations added

• Aug 1994 Win 32 resource loading support started

• Oct 1994 commdlg.dll support started

• Nov 1994 Multiple language support added

• Jul 1995 ipc, DDE, shared memory support