Getting WineThe Many Forms of Wine
The standard Wine distribution includes quite a few different
executables, libraries, and configuration files. All of these
must be set up properly for Wine to work well. This chapter
will guide you through the necessary steps to get Wine
installed on your system.
If you are running a distribution of Linux that uses packages
to keep track of installed software, you may be in luck: A
prepackaged version of Wine may already exist for your system.
The first three sections will tell you how to find the latest
Wine packages and get them installed. You should be careful,
though, about mixing packages between different distributions,
and even from different versions of the same distribution.
Often a package will only work on the distribution it's
compiled for. We'll cover Debian, Redhat, and other distributions.
If you're not lucky enough to have an available package for
your operating system, or if you'd prefer a newer version of
Wine than already exists as a package, you may have to
download the Wine source code and compile it yourself on your
own machine. Don't worry, it's not too hard to do this,
especially with the many helpful tools that come with Wine.
You don't need any programming experience to compile and
install Wine, although it might be nice to have some minor
UNIX administrative skill. We'll cover how to retrieve and
compile the official source releases from the FTP archives, and also how
to get the cutting edge up-to-the-minute fresh Wine source
code from CVS (Concurrent
Versions System). Both processes of source code
installation are similar, and once you master one, you should
have no trouble dealing with the other one.
Finally, you may someday need to know how to apply a source
code patch to your version of Wine. Perhaps you've uncovered
a bug in Wine, reported it to the Wine mailing list,
and received a patch from a developer to hopefully fix the
bug. The last section in this chapter will show you how to
safely apply the
patch and revert it if the patch doesn't work.
Getting Wine for a Debian System
In most cases on a Debian system, you can install Wine with a
single command, as root:
# apt-get install wine
apt-get will connect to a Debian archive
across the Internet (thus, you must be online), then download
the Wine package and install it on your system. End of story.
Of course, Debian's pre-packaged version of Wine may not be the
most recent release. If you are running the stable version of
Debian, you may be able to get a slightly newer version of Wine
by grabbing the package from the unstable distribution, although
this may be a little risky, depending on how far the unstable
distribution has diverged from the stable one. You can find a
list of Wine binary packages for the various Debian releases
using the
package search engine at
www.debian.org.
To install a package that's not part of your distribution, you
must use dpkg instead of
apt-get. Since dpkg
doesn't download the file for you, you must do it yourself.
Follow the link on the package search engine to the desired
package, then click on the Go To Download
Page button and follow the instructions. Save the
file to your hard drive, then run dpkg on it.
For example, if you saved the file to your home directory, you
might perform the following actions to install it:
$ su -
<Type in root password>
# cd /home/user
# dpkg -i wine_0.0.20000109-3.deb
You may also want to install the
wine-doc package, and if you are
using Wine from the 2.3 distribution (Woody), the
wine-utils package as well.
Getting Wine for a Redhat System
Redhat/RPM users can use
rpmfind.net to track down available Wine RPM binaries.
This
page contains a list of all rpmfind packages that start with
the letter "W", including a few Wine packages
Getting Wine for Other Distributions
The first place you should look if your system isn't Debian or
Redhat is the WineHQ Download
Page. This page lists many assorted archives of
binary (precompiled) Wine files.
Lycos FTPSearch is another useful resource for
tracking down miscellaneous distribution packages.
Getting Wine Source Code from the FTP Archive
If the version of Wine you want does not exist in package form,
you can download the source code yourself and compile it on your
machine. Although this might seem a little intimidating at
first if you've never done it, you'll find that it'll often go
quite smoothly, especially on the newer Linux distributions.
The safest way to grab the source is from one of the official
FTP archives. An up to date listing is in the ANNOUNCE
file in the Wine distribution (which you would have if you
already downloaded it). Here is a (possibly out of date) list
of FTP servers carrying Wine:
ftp://metalab.unc.edu/pub/Linux/ALPHA/wine/development/
ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/
ftp://ftp.infomagic.com/pub/mirrors/linux/sunsite/ALPHA/wine/development/
ftp://orcus.progsoc.uts.edu.au/pub/Wine/development/
The official releases are tagged by date with the format
"Wine-YYYYMMDD.tar.gz". Your best bet is to grab the latest
one.
FIXME: Explain how to un-tar, compile, and install Wine from a tarball.
Getting Wine Source Code from CVS
The official web page for Wine CVS is
http://www.winehq.com/dev.html.
First, you need to get a copy of the latest Wine sources
using CVS. You can tell it where to find the source tree by
setting the CVSROOT environment variable. You
also have to log in anonymously to the wine CVS server. In
bash, it might look something like this:
$ export CVSROOT=:pserver:cvs@cvs.winehq.com:/home/wine
$ cvs login
Password: cvs
$ cvs checkout wine
That'll pull down the entire Wine source tree from
winehq.com and place it in the current directory (actually
in the 'wine' subdirectory). CVS has a million command line
parameters, so there are many ways to pull down files, from
anywhere in the revision history. Later, you can grab just
the updates:
$ cvs -dP update
cvs update works from inside the source tree.
You don't need the CVSROOT environment variable
to run it either. You just have to be inside the source tree.
The -d and -P
options make sure your local Wine tree directory structure stays
in sync with the remote repository.
After you've made changes, you can create a patch with
cvs diff -u, which sends output to stdout
(the -u controls the format of the
patch). So, to create an my_patch.diff
file, you would do this:
$ cvs diff -u > my_patch.diff
You can call cvs diff from anywhere in the
tree (just like cvs update), and it will
always grab recursively from that point. You can also specify
single files or subdirectories:
$ cvs diff -u dlls/winaspi > my_aspi_patch.diff
Experiment around a little. It's fairly intuitive.
Upgrading Wine with a Patch
If you have the Wine source code, as opposed to a binary
distribution, you have the option of applying patches to the
source tree to fix bugs and add experimental features.
Perhaps you've found a bug, reported it to the Wine mailing list,
and received a patch file to fix the bug. You can apply the
patch with the patch command, which takes a
streamed patch from stdin:
$ cd wine
$ patch -p0 < ../patch_to_apply.diff
To remove the patch, use the -R option:
$ patch -p0 -R < ../patch_to_apply.diff
If you want to do a test run to see if the patch will apply
successfully (e.g., if the patch was created from an older or
newer version of the tree), you can use the
--dry-run parameter to run the patch
without writing to any files:
$ patch -p0 --dry-run < ../patch_to_apply.diff
patch is pretty smart about extracting
patches from the middle of a file, so if you save an email with
an inlined patch to a file on your hard drive, you can invoke
patch on it without stripping out the email headers and other
text. patch ignores everything that doesn't
look like a patch.
FIXME: Go into more depth about the -p0 option...