The Book of Webmin Or: How I Learned to Stop Worrying and Love UNIX

By Joe Cooper

Webmin is a web-based graphical UNIX system administration tool written by Jamie Cameron in the Perl programming language that is designed to be lightweight, functional, and easily extensible. Webmin has been translated to over 20 languages and dialects at the time of this writing, and has been embraced by a number of hardware and operating system vendors as their default system administration tool. It is extremely portable, offering support for more than 35 different UNIX-like Operating Systems and Linux distributions. And it is very easily extended to support new features and options, due to an open and well documented API.

Webmin also happens to be a fast and easy to use tool for general UNIX system administration. This document attempts to introduce to you many of the concepts you will need to maintain a UNIX system using Webmin. While no single volume can address every aspect of UNIX system administration, a real effort has been made to provide both a solid introduction to many important tasks, and a nearly comprehensive reference to a typical UNIX server and its parts. It is my hope that with nothing more than this book, a copy of Webmin, and the documentation that accompanies your server, you will be able to configure the system to provide the most popular services, create a reasonable security policy, and manage your users and normal system maintenence tasks. Advanced topics are often covered, but I hope that it will not be at the expense of preventing you from seeing the forest for the trees.

Click to Read More

Unix-the Bare Minimum

By Norman Matloff

Purpose - The information here is intended to be a review for those who have had a bit of prior exposure to Unix, and as a quick introduction to Unix for those who have never seen it before. (Some of the material may be new even to those with some prior exposure to Unix.)

Shells - A shell is a program that inputs Unix commands from the keyboard and relays them to the Unix system for execution. Shells typically include various shortcuts for users to use in stating their commands, and also a programming feature, in which users can make programs out of sets of their commands.

The first popular Unix shell was the Bourne shell, named sh. It still is in common use, though more often in a modernized version called the Bourne Again Shell, bash.

Click to Read More

XLib Manual

by The Labs.Com

The X Window System is a network-transparent window system that was designed at MIT. X display servers run on computers with either monochrome or color bitmap display hardware. The server distributes user input to and accepts output requests from various client programs located either on the same machine or elsewhere in the network. Xlib is a C subroutine library that application programs (clients) use to interface with the window system by means of a stream connection. Although a client usually runs on the same machine as the X server it is talking to, this need not be the case.

Xlib --- C Language X Interface is a reference guide to the low-level C language interface to the X Window System protocol. It is neither a tutorial nor a user's guide to programming the X Window System. Rather, it provides a detailed description of each function in the library as well as a discussion of the related background information. Xlib --- C Language X Interface assumes a basic understanding of a graphics window system and of the C programming language. Other higher-level abstractions (for example, those provided by the toolkits for X) are built on top of the Xlib library. For further information about these higher-level libraries, see the appropriate toolkit documentation. The X Window System Protocol provides the definitive word on the behavior of X. Although additional information appears here, the protocol document is the ruling document.

To provide an introduction to X programming, this chapter discusses:

Click to Read More

Documentation for XFree86[tm] version 4.3.0

The XFree86 Project, Inc

XFree86 is an Open Source version of the X Window System that supports many UNIX(R) and UNIX-like operating systems (such as Linux, FreeBSD, NetBSD, OpenBSD and Solaris x86) on Intel and other platforms. This version is compatible with X11R6.6.

XFree86 4.3.0 is the sixth full release in the XFree86 4.x series.

XFree86 4.x is the current XFree86 release series. The first release in this series was in early 2000. The core of XFree86 4.x is a modular X server. The 4.3.0 version is a new release that includes additional hardware support, functional enhancements and bug fixes. Specific release enhancements can be viewed in the Release Notes.

Most modern PC video hardware is supported in XFree86 4.3.0, and most PC video hardware that isn't supported explicitly can be used with the "vesa" driver. The Driver Status document has a summary of what hardware is supported in 4.3.0 compared with the old 3.3.x (3.3.6) series. It is a good idea to check there before upgrading if you are currently running 3.3.6 with older hardware.

XFree86 is produced by The XFree86 Project, Inc, which is a group of mostly volunteer independent developers. XFree86 is a non-commercial organisation, and would not be viable without the invaluable development contributions of volunteers. This release is dedicated to all who have supported and contributed to XFree86 over the last eleven years.

Click to Read More

The Makefile

opussoftware.com

Make reads its instructions from text files. An initialization file is read first, followed by the makefile. The initialization file holds instructions for all “makes” and is used to customize the operation of Make. Make automatically reads the initialization file whenever it starts up. Typically the initialization file is named make.ini and it resides in the directory of make.exe and mkmf.exe. The name and location of the initialization file is discussed in detail on Page .

The makefile has instructions for a specific project. The default name of the makefile is literally makefile, but the name can be specified with a command-line option.

With a few exceptions, the initialization file holds the same kind of information as does a makefile. Both the initialization file and the makefile are composed of the following components: comments, dependency lines, directives, macros, response files, rules and shell lines.

Click to Read More

Introduction to make

nersc.gov

The UNIX make utility facilitates the creation and maintenance of executable programs from source code. This tutorial will introduce the simple usage of the make utility with the goal of building an executable program from a series of source code files.

The UNIX make utility facilitates the creation and maintenance of executable programs from source code. make keeps track of the commands needed to build the code and when changes are made to a source file, recompiles only the necessary files. make creates and updates programs with a minimum of effort.

A small initial investment of time is needed to set up make for a given software project, but afterward, recompiling and linking is done consistently and quickly by typing one command: make, instead of issuing many complicated command lines that invoke the compiler and linker.
This tutorial will introduce the simple usage of the make utility with the goal of building an executable program from a series of source code files. Most of the varied, subtle, and complex features of make are the subject of entire books and are not covered here. See the NERSC UNIX Resources page for more information.

This tutorial assumes that you have some familiarity with UNIX, text editors and compiling programs from source code.

Click to Read More

A GNU Make Tutorial

By Byron Weber Becker

Make is a utility which uses a script, called a makefile to automatically determine which of a sequence of steps must be repeated because some files have changed. Two of the most common uses are

• Recompiling programs residing in several files, and
• Testing programs.

Since we are using Modula-3, which has its own make-like facility, this document will focus on using make for testing.

There are many versions of make in use. This tutorial assumes GNU Make, distributed freely by the Free Software Foundation. It has a number of features which make it more attractive than the standard Unix make.

Rules

Make uses instructions found in a file named makefile or Makefile to determine what actions to take in order to satisfy some requirement. A simple makefile consists of "rules" or "recipes" that describe how to create a particular target. Each rule has the following shape:

target... : dependencies ...
command
...
...

A target may be either a file to be generated by make or an identifier for an action to be carried out. Make determines that it needs to build a target if one or more dependencies have changed since the target was last built.

Click to Read More

Basic Introduction to UNIX/linux

By Claude Cantin

This course is intended for people not familiar with the UNIX/linux operating system, but familiar with other computer systems such as MS Windows, DOS or VMS. It is meant as an introduction for beginners to help them understand concepts behind the UNIX/linux operating system. Intermediate users may find the course useful as a refresher.

Up to 2003, most of the command examples used throughout the text were performed using a Silicon Graphics O, running IRIX 6.5. But since September 2003, the hands-on portion of the course is done using the linux (SuSE 8.2, then 9.0) operating system, which means most commands are now done with linux. SGI systems running IRIX, Sun systems running Solaris, Hewlett-Packards running HP/UX, IBM RS/6000s running AIX and most PCs (and other architectures) running linux use most of the commands described in this manual. They use the same basic commands, although some of the options used may vary slightly between the different architectures.

In specific cases, the book uses commands based on linux. The distribution used was SuSE version 7.3 and newer.

Notes:

• This book refers to various UNIX derivatives running on ``workstations".
• The author's definition of ``workstation" includes systems such as the Sun Microsystems SPARCstation family, the Silicon Graphics Personal IRIS, Indigo, Indigo, Power Series, Challenge, Power Challenge, Onyx, Power Onyx, Indy, O, Octane, Origin and Altix families, the IBM RS/6000 series, the HP 9000 model 700 and 800 families, the Compaq AXP families (systems running True UNIX), and 500+ MHz PCs running one of the linux distributions.
• Although most sections refer to UNIX in general, some refer to a specific architecture. Others may refer to NRC-specific topics. Those sections are generally clearly indicated.
• This book also refers to various linux distributions, notably SuSE 7.x and 8.x, and Red Hat 7.x and 8.x.

Click to Read More

Advanced Introduction to UNIX/linux

by Claude Cantin

The UNIX operating system has a number of ways to process a number of programs for the same user, simultaneously. Programs can be run in the background, they can be run by cron, they can be run at a specific time using at, they can be run in the background without interruption on logout, or they can simply be run in the foreground, as an interactive job.

This chapter describes ways of running programs in some kind of batch process.

&: Background

Programs can be sent to the background to be processed, while the user keeps doing interactive work in the foreground. Sending a job to the background is done by ending the command line with an ampersand (&).

When a job is sent to the background, the prompt immediately reappears, allowing the user to continue work in the foreground. At completion of the background job, a message will be displayed, announcing termination of the process.

NOTE: before leaving UNIX, all jobs running in the background mode should be allowed to complete; if the terminal used was connected to a serial port of the UNIX system and background jobs were still running, attempting to leave UNIX would potentially hang the port and stop other users from using it!!

If jobs are to be allowed to continue running upon exiting the interactive UNIX session, then the batch command should have been used instead of the & function.

Click to Read More