|Groklaw Takes A Closer Look at the ABI Files, by Frank Sorenson et al|
|Friday, January 30 2004 @ 11:53 PM EST|
This article is the result of a group research project, compiled and primarily written by Frank Sorenson with Pamela Jones. The special footnoted article explaining some of the terms for nonprogrammers was written by Nick Richards. The research group was primarily composed of Frank Sorenson, Dr. Stupid, Harlan Wilkerson, Rand McNatt, Roland Buresund, and Pamela Jones, all of whom contributed both research and writing, with input from some Linux kernel contributors. Everyone worked on editing, including an invited group of Groklaw regulars. However, Frank carried the load more than anyone else, so his name is on the finished article.
We are now publishing the article and welcome Groklaw readers' further contributions, corrections, improvements, and comments. This is an ongoing project. This article is the first in a series where we'll discuss the System V UNIX ABI, or Application Binary Interface. We approached the research as, What if Linus Torvalds had not already claimed paternity of most of the header files? Then what?
The article will first explain what the ABI is and what it does, then discuss whether the code was released under the GPL and if so whether management at SCO knew and approved, and finally show how the Linux files that pertain to this do not appear to be infringing files that SCO can claim.
For those who are not programmers, such as myself, there is a footnoted section to explain in greater detail and in plain English what ABIs and APIs and shared libraries are and how they work. If you read it first, it will clarify the terminology for you and you will be able to follow the thread in the article more easily. At least, it helped me tremendously.
I think you will see from this article alone that if SCO is planning to sue anyone over the ABI files, unless there are facts we haven't unearthed, they seem to be leaning on a rickety bamboo reed.
GROKLAW TAKES A CLOSER LOOK AT THE ABI FILES
Back in January 2003, word leaked out that SCO was planning to charge Linux users for "System V Intellectual Property" in Linux. SCO created a new business division called SCOSource to come up with new ways to make money from this "intellectual property". The original SCOSource Presentation (PowerPoint version) talks of licensing SCO's shared UNIX Libraries from OpenServer and UnixWare for use in Linux.
A Little Background: What Are ABI Files? 
As background information, shared libraries are files containing information to be loaded when an application is run. They usually implement common routines, and their inclusion simplifies programming, reduces file size, and standardizes interfaces. A simple example of this would be the "copy file" and "move file" commands: both commands check file permissions and manipulate the file system. When applications have a great deal of functionality in common, this functionality is often placed into shared libraries.
Shared libraries are architecture, operating-system, and version specific. Executables for different systems follow various standard formats, such as a.out, ELF, and COFF. To load an application, the system must do several things: the system interprets the format of the executable (or binary), loads any shared libraries referenced, and begins executing the code found in the binary.
If the executable is in a different format from those the system supports, or if the library files are for the wrong architecture or operating system version, the binary normally will not run. In 1991, Intel announced the availability of the iBCS-2 (Intel Binary Compatibility Specification), a specification designed by Intel, SCO, and Unix System Laboratories (USL) to enable binary compatibility and migration capabilities between systems. SCO's Tim Ruckle said this to encourage support:
'The goal of 'shrink wrap' software for the open systems marketplace will not be possible without the commitment of the entire industry to achieve full binary compatibility. This requires more than just the ability for binaries to run on a given kernel--it must address system installation scripts, I/O control instructions to devices, and the availability of standard system commands.
Say that you are building yourself a house. In order to make this construction project something that you can reasonably do within your lifetime, you choose to use pre-made construction materials, such as windows, doors, lumber, bricks, and plumbing supplies that you can get at the local Home Depot. By doing this, you don't need to cut down your own trees, fire bricks, or make glass. Someone else has gone to the trouble of building these components, and you can just build on what they've done.
This can save a lot of time and energy when building your house, but it does require that you conform to certain standards, such as 16-inch centers on studs, 3-foot-wide doors, specific diameters on the plumbing and electrical pipes, and vanities 18- or 24-inches deep. If you don't conform to these building standards, ductwork will not fit between the floor joists, and your pre-built and pre-hung doors will have gaps around them, may stick, or will require you to shave a couple of inches off them. If you don't follow the standards, either something isn't going to work, or you'll have to build it from scratch.
By conforming to these standards, you can just buy a window and install it. You can find 2-inch drain pipes that fit the 2-inch pipe coming out of the drain in your sink. You don't have to custom build a door to fit whatever space you left. You can just choose where to put doors, windows, sinks, and other things in your house, purchase the components, and build it.
It's somewhat comparable in programming. Someone has built some useful functions already, but to use them, you need to know and use the interface provided so as to put these building blocks into the right places. The components of the programs all behave the same, because they're the same library functions.
How ABIs Are Used
SCO UnixWare or OpenServer executables have a different binary format from Linux, and reference different versions of different shared library files, and therefore will not normally run under Linux. However, with iBCS-2 it is possible to execute a UnixWare or OpenServer program on a Linux machine. First the Linux machine must understand how to interpret the foreign executable file. This functionality of executing foreign binaries in the Linux 2.4 kernel is provided by an addon called "linux-abi." On that linked page, you will find a list of SCO software that can be run with linux-abi, as well as this information:
"The Linux abi is a patch to the linux kernel that allows a linux system to run foreign binaries. This was developed and written by Christoph Hellwig and Joerg Ahrens as a follow on to the iBCS/iBCS2 project written for the older 2.2.x kernel by Mike Jagdis."More on Christoph Hellwig later, but most of you remember his name from earlier Groklaw articles as a Caldera employee who contributed code to the Linux kernel.
When a SCO binary requires a given shared library, the correct version of this library must be present in the appropriate location on the system. Copying SCO's shared libraries from a UnixWare or OpenServer system to the Linux system makes it possible to run a SCO Unix application. One example of this (from the SCOSource Presentation) is a Red Hat Documentation page where the author explains how to run WordPerfect 6.0 for SCO under Linux. The instructions include this caution:
"SCO Shared Libraries
SCO's Shifting Claims on ABIs
When SCO's allegations against Linux first surfaced, there was concern over the ABI code, but Blake Stowell reassured everyone in a MozillaQuest interview that the linux-abi add-on was "clean", although the libraries themselves were SCO's IP:
Blake Stowell: No, none of the code in the Linux ABI modules contains SCO IP. This code is under the GPL and it re-implements publicly documented interfaces. We do not have an issue with the Linux ABI modules. The IP that we are licensing is all in the shared libraries - these libraries are needed by many OpenServer applications *in addition* to the Linux ABI.
47. Linux offers a "SCO emulation module," originally called "iBCS" and now known as "linux-abi" which enables applications which were originally developed to run on SCO OpenServer to be run on Linux. ... SCO does not give permission for copying of the Shared Libraries for use outside OpenServer without payment of separate licensing fees.
A significant expansion of SCO's claims occurred in a December 2003 letter to Unix Licensees. The SCO Group claimed ownership of not just the libraries, but over the ABI code itself:
"Certain copyrighted application binary interfaces ('ABI Code') have been copied verbatim from the UNIX System V code base and contributed to Linux for distribution under the General Public License ('GPL') without proper authorization and without copyright attribution. While some application programming interfaces ('API Code') have been made available over the years through POSIX and other open standards, the UNIX System V ABI Code has only been made available under copyright restriction."
History of the Publicly Documented Standards
Stowell was correct when he said that the Linux ABI modules implement publicly documented interfaces. In September 1993, over 75 companies, including Novell and SCO, agreed to adopt a single set of 1170 API calls. This standard was known as Spec 1170, and is now called the Single UNIX Specification, or SuS for short. In January of 1994, that Byte article linked to described the purpose of the standard adopted by SCO and the 75 other companies:
"Novell has transferred the Unix trademark to the international X/Open standards organization. The transfer, which was announced last October, when combined with other standards efforts, may yet result in multiple implementations of Unix that conform to a single specification. . . .
The System V ABI information has been known for decades, and the specifications are even now available from SCO's web site. The specifications are spelled out in several parts, a generic part (gABI) and a processor specific part (psABI), which together form the specification:
"The System V ABI is composed of two basic parts: A generic part of the specification describes those parts of the interface that remain constant across all hardware implementations of System V, and a processor-specific part of the specification describes the parts of the specification that are specific to a particular processor architecture. Together, the generic ABI (or gABI) and the processor specific supplement (or psABI) provide a complete interface specification for compiled application programs on systems that share a common hardware architecture.. . .
"We acknowledge the contributions of the 88OPEN Consortium Ltd., portions of whose System V ABI Implementation Guide for the M88000 Processor and the System V ABI M88000 Processor Networking Supplement have been incorporated in this section of the ABI with permission."
The entire Intel® Itanium® Processor-specific Application Binary Interface (ABI) carries an 2001 Intel copyright, calls the System V ABI the "prime reference document," and says that the ABI was developed as the result of "consensus among operating system vendors...[including] Intel, Sun Microsystems, SCO, IBM, SGI, Cygnus Solutions, VA Linux Systems, HP, and Compaq."
SCO's web site touts the benefits of ABI Conformance, and encourages system and application developers to "seriously consider the benefits of building [their] products in conformance with the binary compatibility specification".
In the SCOSource Presentation, The SCO Group admitted that "Because ibcs2 [the Intel Binary Compatibility Standard] is an open specification, the Linux community was able to freely copy this and rename it Linux ABI or Linux Application Binary Interface." These interfaces are also documented in a number of other places, including IEEE Std 1003.1.
Did SCO Release the ABI Code Under the GPL?
The evidence indicates they not only did, they still are.
Let's follow the evidence trail. By SCO's own admission, the Linux ABI modules do not infringe on SCO IP, since they implement public standards. So how could any code implementing those standards infringe? You can read them but not use them? Moreover, though they claim they never made their own "ABI code" available outside of OpenServer, does the evidence support that claim?
In SCO's December 2003 letter, they named a number of Linux files, including errno.h, ctype.h, and signal.h, that they said they believe contain their copyrighted source code implementing the ABI. In the SCOSource FAQ, SCO claims "SCO has obviously never placed a notice indicating that our UNIX source code can be distributed under the terms of the GPL license." Is this a true statement? Has SCO ever released these particular files (or the information contained therein) under the GPL, or have they just been used without their knowledge and permission?
These Linux files can be found inside libc packages from the various versions of OpenLinux that SCO/Caldera produced, and many of the packages may still be found on their FTP site to this day. Here are just a few examples:
There can be no question that the LGPL files were present on the OpenLinux CDs that Caldera was producing and distributing. The SCO Group would have us believe that they were not aware of what they were distributing, but were only passing along packages created by someone else. Did Caldera know that the errno.h and other files existed inside those packages on their CDs and were they put there intentionally by Caldera? SCO says obviously not, but the evidence speaks loudly otherwise. At this point, we encounter Christoph Hellwig once again.
As we have already seen, according to the Linux A.B.I. homepage, Christoph Hellwig, working for Caldera, developed and wrote the linux-abi patches to allow the Linux kernel to run UnixWare and other foreign binaries. The entries in the ChangeLog show Christoph Hellwig as the principal maintainer of the patches, and the patch releases were announced by him as well (for example, 2.4.14 kernel and 2.4.15 kernel). Here are two one brief snips from the changelog to show you what we mean:
"2002-01-03 Christoph Hellwig (email@example.com)
This work by Caldera provided the linux-abi package add-ons for Linux, enabling programs compiled for UnixWare (and other systems) to run on a Linux system. However, as we have explained earlier, having the linux-abi package alone is not enough to run a UnixWare program. The program would need to make use of libraries compatible with the right SCO system.
To run binaries from older versions of SCO's operating systems, it is possible to use shared libraries from the Coherent Operating System. Created by Mark Williams Company, in Northbrook, Illinois, Coherent was a multi-tasking, multi-user operating system similar to System V Unix, but it did not require either an AT&T or SCO license. Coherent had implemented their Unix so closely to SCO UNIX (in fact, more closely than Linux has ever been) that they could run SCO binaries directly, as they explain in the introduction to the Coherent FAQ:
"Coherent is a multi-tasking, multi-user operating system for IBM PC's and compatibles. Versions will run on most systems with a 286, 386, or 486 CPU. Coherent appears to be very similar to Version 7 Unix, or for those of you that have not had the pleasure, close to System 5 Unix. Coherent includes uucp (Coherent to Coherent Copy) :) and many more functions you would expect with Unix. Coherent is small and simple, easy to maintain, and does not require extensive CPU resources to operate well. It has serial networking, V4.2 has X Window support. It does not require an AT&T license for Unix. It is as advertised, a quick, elegant Unix-like multi-tasking, multi-user Operating System, with good documentation. The newest version is very much like SCO Unix, and version 4.2 will actually run out of the box applications."
Coherent's system and libraries were implemented by following the Intel386 Architecture BCS Supplement, and were therefore Intel BCS-compliant. AT&T examined Coherent's code and found that while it had been written by someone with in-depth knowledge of Unix, nothing could be found that was copied or wasn't reproducible by using the manual. Coherent and other non-UNIX operating systems have used these System V ABI's for years with AT&T's knowledge. Neither AT&T, Novell, nor SCO ever had any problems with this, but then why would they, since iBCS was the defacto open standard?
If you wanted the official UnixWare shared libraries, one way to get them was to purchase UnixWare and to copy the libraries onto the Linux machine. However in the SCOSource Presentation, SCO claims that the SCO Unix shared libraries have never been licensed outside of the SCO products. The SCO Group's amended complaint also asserts that SCO did not give permission for copying of the shared libraries for use outside of SCO's products, and the SCOSource Q&A claimed "the UNIX shared libraries, owned by SCO, are not Linux products. They are not open source software and they are not covered by the GPL."
While this may be true for other UNIX shared libraries, SCO did in fact provide some Unix shared libraries, as products for Linux, under the GPL. The evidence shows that SCO packaged and provided a set of Unix shared libraries, with a System V ABI, as a GPLed product, to Linux users.
The library set released implemented the basic functions needed for simple (non-graphical) programs. Rather than require customers who only wanted to run these programs to purchase an expensive UnixWare license, SCO released an add-on with these basic libraries. This add-on was released by Caldera under the GPL and was packaged by then-Caldera employee Tim Riker. Want some proof? The source code (including the Unix shared libraries) is still available from SCO. Here are just a few examples:
How do we know that these packages were, in fact, created and distributed by SCO/Caldera and that they were not packaged by someone else and just passed along unwittingly by SCO/Caldera? The process of verifying the file signatures will prove that the packages were actually provided by someone at SCO/Caldera with the authority to sign, something only a trusted representative would have authority to do.
By checking the file signatures, we can see that these packages have been signed by SCO/Caldera's Key. The keys can be found here and here. To verify the rpms, download and import the keys, then download the packages and check the package signature like this:
$ rpm --import PGP-KEY-*` $ rpm -qp --checksig iBCS-*`
The license for the package can be verified as GPL with this:
$ rpm -qip iBCS-*
While these GPL'd source files contain 'lite' versions of SCO's shared libraries, which are significant in their own right, a closer look reveals the presence of source code files of great importance. Among the files contained in these packages are:
ctype.h ctype.c ipc.h errno.h signal.h stat.h
In other words, SCO's GPL'd packages contain many of the very same files that constitute the ABI code SCO recently identified as allegedly infringing. A close look at these files shows that none contain any copyright notice whatsoever and that they implement the majority of the ABI code in dispute. The errno.h file, for example, lists all of the error codes from System V, with the same numbering that System V uses. The same is true for the signal.h and the ioctl numbering.
This indicates that representatives of SCO/Caldera were the ones who collected, developed, tested, and maintained the source code to implement the ABI functionality, then placed the GPL notice on it, packaged it, and provided it to the entire Linux community. Given that SCO themselves did so much of the work to provide this functionality, and placed the GPL notice on it themselves, judging from these files, it seems hard to avoid concluding that SCO explicitly released the System V ABI under the GPL and that they did so knowingly and because they wanted to. Distributing code under the GPL under those circumstances is like losing your virginity. Even if you regret it later, there is no turning back to the way things were and no way to undo the consequences. SCO's claims are a little like a woman falsely claiming rape after she willingly consented to sexual relations. Worse, from their standpoint. The evidence of the GPL distribution is there for the world to see, so it's not a He Said, She Said situation where you might have at least a 50% chance of being believed.
Moreover, as this ABI code was released under the GPL with no copyright management information, it is difficult to understand how SCO could now view it as infringing their copyrights. SCO worked side-by-side with IBM, Linux distributors, and others in defining and publishing the specifications and actively developed and distributed the material that they now wish to claim is infringing.
Did Management Know?
While we have shown that at least some employees at SCO were actively developing and releasing GPL code and libraries to support the linux-abi project, the question could be asked whether Hellwig or Riker were working on their own, without authorization. Let's see.
Not only was SCO involved with the linux-abi work, but SCO employees were involved in additional low-level coding activities. Both (old) SCO and Caldera were also heavily involved with the Linux Standards Base (LSB), which had - and still has - this as their mission statement:
"To develop and promote a set of standards that will increase compatibility among Linux distributions and enable software applications to run on any compliant system. In addition, the LSB will help coordinate efforts to recruit software vendors to port and write products for Linux."
The LSB was formed in 1998, with Caldera supporting it from day one. Notice the purpose and the top signatories to the proposal for formation of the LSB:
"The Linux(R) Operating System's rapid adoption by millions of computer users everywhere is direct recognition of the quality of the software and success of the freely distributable software development model. In order to ensure that large software application programs, from binary-only tools sold by the largest software companies, to freely distributable desktop environments built cooperatively over the net, run smoothly on as many Linux-based computers as possible - the Linux Standard Base (LSB) Project is an attempt to define the common core of components that can be expected to be found in any "Linux" system. . . .
In May 2000, both (old) SCO and Caldera became charter members of the Free Standards Group to "accelerate the use and acceptance of open source technologies through the application, development and promotion of standards for open source development." Obviously, this was a company decision, not something a rogue employee arranged.
Both (old) SCO and Caldera participated in LSB Conference Calls, including at least one in which the header files in question were discussed, and Caldera presented about the LSB at SCOForum 2001. The participation was constant, beginning with the very first conference in 1999, which Caldera's Ralf Flaxa attended, to one on July 19, 2000 with SCO's Dave Prosser participating, and included this April 23, 2002 conference, where both Flaxa and SCO's Doug Beattie were participants, to the LSB Workgroup meeting on June 26, 2002, where Flaxa is listed as the LSB Implementation Lead in charge of the LSB Sample Implementation project. On January 17, 2001, Beattie and Prosser and Caldera's John Terpstra participated in the LSB telephone conference and on the agenda that day, you find these tasks:
Dave Prosser, a senior engineer for (old) SCO, then Caldera, worked for AT&T back when Unix was younger. When the C programming language was being standardized, Dave Prosser served as chief editor for the ANSI C standard. He stayed on as Unix was passed through Unix System Laboratories and Novell.
Since the gABI was a changing standard, Prosser maintained it and kept it up to date. Updates (such as this one where Linux gets e_machine numbers for the PDP-10 and PDP-11) were sent to Prosser at firstname.lastname@example.org (later, email@example.com). Prosser coordinated the approvals for the release of the updated gABI specifications at sco.com.
Not only did Dave Prosser contribute ABI information to the LSB, but he also contributed other "valuable" SCO IP on the LSB email lists. Here, he is seen sharing UnixWare source code as an example of how tmpfile.c was programmed. As you see, he shared source code without mention of confidentiality or other restriction on use or adoption.
Doug Beattie, another senior SCO engineer, was involved with the Free Standards Group beginning in the fall of 2000, and was actively working with the LSB to disseminate information and keep everyone updated. Beattie indicated that he was cooperating to make sure that the LSB and ABI could work together, as can be seen in this post to the LSB working group, where he is listed as having the title Linux Test Architect for SCO:
"As before, these are just starting points and there is much work to be done in various areas to make these workable for the LSB."
In August 2000, Flaxa presented Caldera's Linux Technology Preview to the LSB, and it subsequently became the LSB sample implementation. Here's the revealing exchange of email between Flaxa and IBM's George Kraft, just after the Caldera acquisition of UnixWare from SCO, regarding the LSB sample implementation. A little piece of history. First Flaxa lets it be known that it's about ready, it's under the GPL, and it includes the 2.4 Linux kernel, and most LSB ABIs, with the rest to be added. He wonders if he should release now or wait:
"It has been extremely busy times for me the last weeks, and with the Linux Technology Preview product (announced last week) and us aquiring big parts of SCO (announcement went out today) you may now understand why.
"Let's run with it. Can you get the LSB sample implementation web page to point to ftp://ftp.caldera.com/pub/LTP/ or copy the images to the LSB's download area on SourceForge?
Caldera must have been proud of their LSB work, because in March 2001, Caldera jumped the gun by announcing Project 42, their beta version of OpenLinux, as having an LSB 1.0 implementation, even before the standard was finalized and a certification program in place. The next day, an updated press release replaced the first, and (appropriately) made no mention of LSB compliance.
It would have been difficult to achieve point-by-point compliance with the LSB while completely missing the concept that the LSB implemented both the general and platform-unique ABI specifications. In order to achieve compliance, someone would have been knee-deep in the code and couldn't have ignored the ABI specification staring them in the face. If there was anything protectable about the code, that was the time to say so.
Both (old) SCO and Caldera made many public statements about their support for Linux and the LSB. David McCrabb, who was president of (old) SCO's server software division, then president and chief operating officer of Caldera, gave a presentation before the Hong Kong Computer Society on the "Future of Linux," and listed five critical success factors in the adoption of Linux, including the LSB. While he fell short of giving his full support for the Linux development process and the GPL, it cannot be argued that he didn't know about the LSB or what it was.
Since the fundamentals of the Linux ABI have not changed between then and now, if Linux is now infringing on SCO's rights, it was back then as well. Yet Doug Michels, (old) SCO CEO, who felt that Linux could provide free research and development, and who had been trying to put a Linux personality on UnixWare, essentially going in the other direction from ABIs, so as to run Linux programs in UnixWare, presented a "Lifetime Achievement Award" to Linus Torvalds at UniForum '97. Here's an account of what he said:
"Linus received the UniForum "Lifetime Achievement Award" presented by Doug Michels, co-founder of SCO. Doug said that many people expected him to turn down the opportunity to present the award, or to say little when he did. He said that these people had him all wrong, that this was a special opportunity. Doug said he has been amazed at the success that Linux has had. Linux has rekindled the spirit and energy that first got him excited about Unix 20 years ago. The work of Linus and the greater Linux community has brought back a source base for real experimentation and innovation, something the computer industry badly needs again. Doug is proud of the selfless and true commitment that Linus and the Linux community have towards improvement of computing. Linus has brought the fun back in an otherwise static industry. He said that he thinks Linux is just what the world needs now."
Ransom Love, Manager of the OpenLinux Division at Caldera, then CEO of Caldera Systems made public statements in support of the LSB, and when Caldera purchased SCO's divisions, he became CEO of the new company.
Here's a fascinating segment from an article on Love and his GPL plans for Unix:
"According to Ransom Love, Caldera Systems' CEO and soon to be CEO of the combined SCO divisions and Caldera Systems, 'Caldera has a proven track record of releasing the most important stuff to the open community. We haven't decided on which license to use yet. For standards, GPL makes a lot of sense and every product we'll ship with source code.' Some code, however, can't be open sourced because other companies own it.
So, IBM's porting of JFS was known back then, without a word of complaint from Caldera's Love, who was, according to this article, trying to do the same kind of thing with Unix code, the only blockage being that some of the code didn't belong to Caldera.
"In conjunction with the announcement of the transaction, Love said, 'This acquisition is an industry-changing event that puts Caldera front and center as the answer to the enterprise question. Caldera will further broaden and validate both the Linux and UNIX industries and communities by providing open access to its unified Linux and UNIX technologies and by offering support, training, and professional services to customers worldwide. Caldera is fully committed to supporting and servicing the SCO OpenServer and UnixWare communities.'"
In January 2002, Caldera/SCO released older versions of the Unix source code under a BSD-style license. Some of these versions, such as 32V, contain the ABI files in question, and in fact, have no copyright notices in the files. Even if the Linux versions of these files had come from these older versions of Unix, which Linus says they didn't, no 'copyright management' information would have been removed in the copying.
This isn't even a case where the old management was aware and participating but the new management (McBride) didn't know what was happening. Darl McBride knew about the LSB work, and publicly touted SCO's involvement. When OpenLinux 3.1.1 achieved LSB Certification in September 2002, he said:
"This is an important milestone for SCO. SCO is very dedicated to the development and promotion of standards. We see standards adherence as central to the growth and progression of the Linux industry, and are committed to again being LSB certified when we release SCO Linux, powered by UnitedLinux, this fall."
We have seen that both SCO and Caldera were involved in writing the LSB standard, and they made contributions of gABI information. Executives and programmers were actively involved. Does that not indicate that they approved of and intended to facilitate the use of the ABI files in the specification? The Free Standards Group specifications are licensed under the GNU Free Documentation License version 1.1, and require that copyrights be assigned to the Free Standards Group before being included in the specifications.
Why does the LSB matter? Because the LSB specifications contain the errno.h and signal.h files. How, then, can The SCO Group claim them now as their proprietary property and threaten to sue end users for using them? Caldera, when they were working with the LSB, helped to define what the mapping of error numbers to names was to be Linux. So an analogy for that would be someone sending in an article submission to the local newspaper and then suing the newspaper for copyright infringement when the article was published. Another way to look at it would be if a company suggested everyone use a certain symbol any time referring to a concept. Every other company agrees to follow the suggestion, and for many years everyone uses the symbol when discussing that particular concept. Then the original suggester claims that now that everyone is using the symbol, everyone needs to pay them because they never gave anyone the right to freely use the symbol. A separate question is what you can and can't copyright, but we'll leave that for a later article.
If someone tells you that SCO didn't participate or was unaware that the System V ABI was being made available to Linux, or that Linux programmers "stole" it without authorization, what do you think? And if SCO goes forward, as they say they will, and sues an end user for "copyright infringement" of "their" ABI files, will they prevail? If you were on the jury, after reviewing this history, how would you vote?
To Be Continued
[Footnote 1] APIs and ABIs -- What are they and what does it all mean?
~By Nick Richards
API stands for Application Programming Interface and ABI stands for Application Binary Interface. Let's break this down.
What is an interface?
An interface is just a means or mechanism that allows two parties to connect or communicate with each other. When you flip on a light switch, you are using that particular interface (the light switch) to connect with the wiring of your home. The switch allows an abstraction of what is actually going on in your walls.
Another example is the way you communicate with a computer. How do you connect to a computer? You give it a command. How do you accomplish that? You have to use the mouse to click on a program, and then use the keyboard to type some parameters. Your desktop setup, the way the screen is painted, the way the mouse interacts with icons, the way the keyboard allows input, all of that is an interface, commonly called a graphical user interface, or GUI, since there are icons and the like. If you are using the Linux command line, your user interface leaves out the graphics part and the interface is primarily the keyboard alone.
So an interface allows one party or entity to connect or communicate with another party or entity.
The same thing happens behind the scenes with your computer. Programs have to connect and communicate with each other, and the way they do that is by means of interfaces.
When a programmer finds him or herself constantly having to reinvent the wheel by writing the same code over and over, it gets annoying. Not only is this time-consuming, but it can increase the number of times you make an error. So what programmers came up with long ago is the idea of putting commonly called functions or procedures into shared libraries. A library file contains source code just like a regular program, but this source code is generalized for use by multiple programs. For example, if you create an absurdly simple function that returns the sum of two integers, you can put that Add function in a shared library and reuse it across multiple programs or applications. All you have to do is tell the compiler to link that library into the project. That allows you to then just write Add (3, 4) in your code instead of also defining just what it is you mean by "Add." That definition has already been laid out in that shared library.
That's programming: when you tell the compiler what to do by writing near-English commands, you are creating a program. What the compiler does is take that human-readable programming code and turn it into computer-readable programming code. This is commonly called creating a binary file. Computers actually work with binary code, so programs have to be translated into that format before the computer can actually know what to do with your commands. Compilers are the translators of the computer world. More than that, they are the gatherers and translators, because at compile time they look through your code and find all the references to outside libraries and then go find those libraries. It doesn't matter if your instructions are found inside your main program or inside one of the libraries you referenced in your program. Wherever its location, that "Add" function will be found by the compiler and then translated into binary for the computer.
API vs ABI
We can define the difference between an API and an ABI like this:
An Application Programming Interface (API) is something that communicates with the programmer as code is written. It contains the near-English code that a human can read. A typical API will list all the functions the programmer can use, along with all the types of data the fuctions can be used to manipulate.
It is an interface, so it connects the program with information that program needs to compile properly. This connection occurs at compile time.
An Application Binary Interface (ABI), in contrast, is something that speaks to the computer. It contains binary information that a computer can read that talks about how the binary file is structured, how the program should be linked and loaded, and so on. It is also an interface, so it connects the program on that computer system with information that program needs to actually run properly. This connection occurs at run time.
It is possible for two computer systems to have the same APIs but have the associated ABIs be different. Compilers are programs that are specific to operating systems and computer chip sets. You can have the same source code on two different machines, but if you compile the source code on one machine with compiler A and on the other machine with compiler B, the ABIs could be different.
Header Files in Shared Libraries
So with all that in mind, what do we know about files claimed by SCO such as errno.h? That file is a header file, which is a type of library file spoken of earlier. Header files contain commonly defined variables that get used in many programs. Again, there's no point in reinventing the wheel every time you want to use one of these common variables, so you tell the compiler to gather in that header file instead at compile time.
Header Files Define Interfaces
The errno.h header file defines an interface, a way for the programmer to communicate with the end user by means of error messages. It is not, however, an implementation. Since this header file will be used by multiple programs, it is generalized, and that's why it's an interface but not an implementation. The light switch is how you turn on the light, the interface. When you actually flip the switch, you implement the interface. You have gone from the general to the specific and the light goes on. So too with errno.h. It is generalized in that it contains the error messages and the accompanying error abbreviations, but not the actual error numbers. Each system can define their own error numbers (1, 2, 17, 238, whatever) to those error abbreviations (E2BIG, EACCES, whatever). When you give it the actual error numbers, you are creating a specific implementation of that error interface.
Everyone agrees to use these particular error abbreviations and messages. It's a standard. All you have to do in your particular implementation is to assign numbers to each abbreviation. When your function returns an error number, the system can look up the number, find the associated error abbreviation, and print out the corresponding error message.
Keep in mind that the abbreviations, such as E2BIG, are defined as integer (int) types. That means the computer sees E2BIG and thinks of it as a number, not a string of letters. Which number? The one you assign to it. Let's say you define E2BIG as being equivalent to the integer 23. Now when you have a function return the error E2BIG, the computer at compile time sees that as returning 23. That's what it compiles into. Then at run time, when that error occurs, a 23 gets returned from the function, the 23 gets looked up in the errno.h and the appropriate error message is displayed.
Had you defined E2BIG as being 218 instead, that would be fine, the same process would occur. The error abbreviations and messages are standards; the numbers assigned to the abbreviations are not and are part of the actual implementation.
The source code that makes up errno.h and the error numbers you assign as part of your implementation of errno.h in your particular program are part of the API. It's part of that near-English listing of words and numbers that humans can read. Once it gets complied to binary code, it forms part of the ABI that tells the computer how to actually run the program on your system.