NOS 120 Linux/UNIX Single User
Compiling Linux Software from Source Code

Objectives

After reading this chapter and completing the exercises, you will be able to:

* Understand basic elements of C programming * Debug C programs * Create, compile, and test C programs

Text Reference: Chapter 10 – Developing UNIX/Linux Applications in C and C++

Programming Overview

A computer program is a list of instructions given to a computer to make it perform a specific task or series of tasks. A programmer communicates these instructions to the computer in a language the computer understands. Computers, however, can only operate using binary code (1’s and 0’s), which makes a computer’s language very difficult for humans to understand.

The solution to this problem is to create an intermediate language that both humans and computers can understand. These are called programming languages. Programmers create a list of instructions for the computer in a programming language such as C, C++, or Java.

The C Programming Language

The C programming language was released in 1973. C was created by Brian Kernighan, Dennis Ritchie and Ken Thompson working at Bell Labs. Both the UNIX and Linux operating systems are written in C. The C programming language is a high-level language because the code itself is written in relatively English-like statements. In 1978, Kernighan and Ritchie wrote "The C Programming Language," still one of the best C programming books available.

The list of programming instructions is known as source code. It is text-based in nature, and readable to humans (Figure 1). Programmers do all their work in this source code, changing the instructions to fix bugs, add features, or alter the appearance of a program.
Figure 1
C programming language source code for the “Hello, world!” program.

Compilers

Compiling is the process of translating source code (the human-readable description of a program written by a programmer) into the native language of the computer’s processor. While there are many popular programming languages, two predominate in Linux. Most programs written for Linux systems are written in either C or C++.

A special program called a compiler is used to translate human readable text instructions into computer readable format that correspond to the same instructions. The resulting file is usable by computers, but incomprehensible to humans. This is called object code. The resulting executable file is often called a binary, after the number system used by the computer. This translation from source code into binary object code is a one-way process. It is impossible to translate a binary executable back into the original source code.

The binary executable is what is needed to run the program. The source code is what you need if you want to understand how a program works internally, or if you want to change, add to, or improve a program. If you have the source code and an appropriate compiler, you can produce the binary executable, but the reverse is not true. The process is summarized below.

Compiling from source code can be an intimidating process if one is a non-programmer. Fortunately, the process is fairly straight forward if all the dependency programs are in place. Knowing how to compile source files is an indispensable skill in the Linux world. For this reason, every Linux user needs to become comfortable with the compilation process, as it truly is a necessary skill for anyone administering Linux systems.

As mentioned previously, programs written in programming languages such as C are converted into machine language by processing them with another program, called a “compiler”. The C compiler used almost universally in the Linux environment is called gcc (GNU C Compiler), originally written by Richard Stallman. Most distributions do not install gcc by default, but is easily installed using the package installer called yum.

Guided Exercise: GNU C/C++ Compiler Install

Compiling software from source code can become very complex and technical and is often well beyond the reach of many users. However, many compiling tasks are quite easy and involve only a few steps. It all depends on the package. In this exercise we will look at a very simple cases in order to provide an overview of the process and as a starting point for those of you who wish to undertake further study.

1. Install the C compiler and related tools

As root, use the following yum command to install GNU C/C++ compiler:

yum groupinstall 'Development Tools' -y

2. Verify installation

Type the following commands to display the version number and location of the compiler on Linux:

which gcc gcc --version

Sample output:

Compiling Programs with gcc

To compile a C program, use the following generic command:

gcc source_file.c -o program_name

The source files for gcc usually end in .c to indicate C program source code. If there is no error in the C program code then the compiler will successfully create an executable file called program_name in the current directory, otherwise the code syntax erorrs will have to be corrected. If you don’t specify an output file, gcc assumes the output filename a.out.

Guided Exercise: A First C Program

1. Login to your system a regular user.

2. Open your favorite text editor and enter the C code below. Save the file as hello.c in your home directory.

3. Open a terminal and compile hello.c with the following command:

gcc hello.c –o hello

Note that the file was automatically given execute permission during the successful compilation process.

Syntax errors may occur during the compile. Check the code for syntax errors if the code does not compile correctly. Save the file and recompile the program.

4. Once the code compiles correctly, execute the program as shown below.

Compiling C Programs from Existing Source Code

There is a lot of free software (e.g., http://sourceforge.net) that is written for Linux that is only available in source code format. This is the most efficient way for the developers to distribute their software. When you obtain the source code file(s) you compile them to generate an executable binary that's specific to the OS and hardware platform

Practically all source code comes in a compressed archive file. This will have the suffix .tgz or .tar.gz. It will also have a name and a version number, something like example-1.2.3.tar.gz.

While the exact process for compiling existing source code may vary, there are some general principles that can be followed, as outlined below.

1. Download the source code for the program from the Internet or other media.

The source code will most likely be in the form of a "tarball" and have a file extension of .tar, .tar.bz2, or .tar.gz.

2. Unpack the downloaded source code archive

Depending on the type of archive you have received, the command for unpacking it may differ slightly. The Linix tar (Tape ARchiver) command is used for working with file archives. Typical command switches are x to extract files, v for verbose mode so you can tell what’s going on, f indicating there will be a filename to follow. If the file name ends in .tar that is all you need, but usually the tar file has been compressed with another utility. Files ending in .gz were compressed with gzip. For those, add the z flag to the list of parameters. Files ending with .bz2 were compressed with the bzip2 utility. For those, add the j flag, or failing that, --bzip2.

For .tgz or .tar.gz use “tar –zxvf filename”; for .bz2 use “tar –jxvf filename”.

3. Once unpacked, the next step is to change into the newly created source code directory.

For example, if the archive name was source_code-1.2.3.tar.gz, cd into the directory named source_code-1.2.3.

Practically every source package contains some reading material, typically files with names in all caps, like README and INSTALL. Read these! They tell you how to proceed. There may also be documentation for your specific system, like README.linux. The documentation may also point you to other software that you need to install before you can install this package ("dependencies")

4. Run the “./configure” command

Execute “./configure” to configure the source code automatically. The primary job of the configure script is to detect information about your system and “configure” the source code to work with it. This checks that you have the correct compilation components and libraries installed.

5. Run the “make” command

Once configured, run "make" which does the actual compiling (this can take anything from a few seconds to many hours). When you run make, you'll once again see a bunch of strange messages filling the screen. The display looks quite technical and if someone is looking over your shoulder they will likely be impressed with your technical prowess on the computer. This is the actual compilation process occurring. This step may take some time, depending on how big the program is and the speed of the computer.

If all goes as it should, the binary executable is finished and ready to run after make has done its job. Now, the final step is to install the program.

6. To install the program run "make install".

Usually, this directory is /usr/local/bin, the traditional location for locally built software. Some distributions prefer to use the /opt (“optional”) software directory.

Sometimes you may not have root access to the system, and you would like to install the software into your home directory. You can do this in the configure step with “./configure --prefix=/home/username” (where username is your actual system user name).

7. Run the “make clean” command

Finally, most source code installations provide the option to clean up after themselves. Large programs often leave a substantial number of intermediate files lying about in their source directories, which can consume a significant amount of space. To make sure that these are cleaned up, or to clean up after a failed build of the program, try using the command “make clean.”

8. Execute the program

Depending on where the program was installed, either

./program_name

or

/path/to/program_name

Programming Assignment

1. For this exercise you will install the classic Rock-Paper-Scissors game from source code.

Login to your system as a regular user and do the following:

(a) Create a directory in your home directory name “src”.

mkdir ~/src

(b) Download the file papercut-0.1.1.tar.gz from Blackboard and save the file in your src directory.

(c) Change into the src directory.

(d) Extract the tarball.

tar zxvf papercut-0.1.1.tar.gz

(e) The tar command will extract the source code files into a directory (papercut-0.1.1) with the same name of the original tar.gz file.

(f) Now change into the source code directory and view the README file.:

(g) To begin the compilation process, execute the configuration command (replace username with your actual username):

./configure --prefix=/home/username

The dot-slash beforehand means you want to run the ./configure configuration tool in the current directory. This runs some diagnostic tests on your computer, figuring out whether the software has everything it needs to compile correctly.

The configuration process may take several minutes. When it's done, if it doesn't give you an error message, you're ready to compile.

(h) Execute the make command to compile the source code:

The make command “makes” the binary executable from the source code.

When it ends, if you still don't see an error message, you're ready for the last step. Note that you probably won't see a congratulations message either, but if there's no error, you've succeeded. The software has been compiled.

(i) All that remains to do is to put it where it belongs with “make install”.

This will install the papercut program in a directory named bin (short for “binary”) in your home directory.

(j) Now the program is ready to be used. Change back into your home directory, then execute “./bin/papercut 3”. This will run the Paper-Rock-Scissors game for three rounds. Give it a try. See if you can beat the computer!

(k) Execute the following command to view the actual source code for the program:

gedit ~/src/papercut-0.1.1/src/main.c

Next, click on “Edit” -> “Preferences”, then check “Display line numbers”.

You should now see the source code of the program with line numbers on the left side.

(l) Papercut is written in the C Programming language, as is most of Linux. Unless you have had a C programming class before the code will largely be unintelligible to you. That’s okay as our purpose is to learn how to compile and execute existing code.

We can, however, modify some easily recognizable code statements in the program. For example, look at line ~150.

printf("Youe lose. :-(\n\n");

The programmer misspelled “You” in the print statement. Correct that misspelling, please.

The “printf” statements simply print a line of text to the screen. There are numerous printf statements in the code. For example ~176, ~181, and ~193. Modify some of these printf with your own statements, but keep it professional.

(j) Change back into the source code directory once you have completed the code edits and save the file. Recompile the program by issuing the make and make install commands again.

(k) Execute the program and take a screenshot showing some of the changed text strings. Save the screenshot as papercut.png and upload to Blackboard.

2. Download the file vitetris-0.57.tar.gz from Blackboard and install the game from source code using the ./configure, make, make install process as outlined in the papercut example..

Play a game of Tetris (executable name is tetris). Take a screenshot of your game and save the image as tetris.png and upload to Bl