Forgot your password?
typodupeerror
Caldera Unix Linux

Claimed Proof That UNIX Code Was Copied Into Linux 578

Posted by kdawson
from the copied-by-a-spider-on-lsd dept.
walterbyrd writes "SCO's ex-CEO's brother, a lawyer named Kevin McBride, has finally revealed some of the UNIX code that SCO claimed was copied into Linux. Scroll down to the comments where it reads: 'SCO submitted a very material amount of literal copying from UNIX to Linux in the SCO v. IBM case. For example, see the following excerpts from SCO's evidence submission in Dec. 2005 in the SCO v. IBM case:' There are a number of links to PDF files containing UNIX code that SCO claimed was copied into Linux (until they lost the battle by losing ownership of UNIX)." Many of the snippets I looked at are pretty generic. Others, like this one (PDF), would require an extremely liberal view of the term "copy and paste."
This discussion has been archived. No new comments can be posted.

Claimed Proof That UNIX Code Was Copied Into Linux

Comments Filter:
  • More details, and a downloadable archive here - because there's no telling how long those files will remain on McBride's blog,

    Also, we find out more about streams, and how SCOsource was bogus.

  • For those not logged in who don't see the download url in my sig [slushdot.com]

    "In a blog post dated July 10th, 2010, Kevin McBride has leaked almost 50 of the code comparisons that were submitted in evidence in SCO vs Novell. You can download the archive. [slushdot.com]

    Read on to view individual files if you don't want to download the whole thing.

    Linux STREAMS

    We also learned that the whole STREAMS fuss was not about linux, but about a product distributed by gcom, a provider of legacy solutions.

    Their Linux STREAMS (LiS) product provides a couple of loadable drivers that would intercept calls to the old streams api and convert them. In other words, far from the allegations that the linux kernel contained code that infringed streams, it's evident from the need of an add-on loadable module that the linux kernel does not contain any STREAMS code.

    Of particular note, and probably a source of much consternation to SCO and their proponents, is that LiS itself doesn't implement streams either, just does protocol translation. So neither linux nor LiS contains infringing code.

    The whole end-user $699 license was a scam

    In my view, contract violations by IBM would not result in liabilities by other Linux users.

    So according to Kevin McBride, one of the lawyers who worked on the case, there was no reason for end users to take out a license. It's logical to conclude that SCOsource was a protection scam. So what happened? To me, it looks like SCO lawyer-shopped until they found attorneys who were willing to go along with the scheme for a price - everyone has their price, and in this case, it was $30,000,000.00.

    The Appeal of SCO's loss to Novell - Novell will probably win.

    Will Novell win the current SCO appeal? Probably. Will Novell donate the UNIX copyrights to the Linux community if it wins the current appeal? Probably-although Novell's Linux activities have been difficult to predict in recent years.

    So it's pretty much as we suspected all along.

  • libelf!?! (Score:5, Informative)

    by Dahamma (304068) on Sunday July 11, 2010 @10:39PM (#32870926)

    I actually find it ironic that libelf was picked as an example of infringement. I can tell you first hand that the (more standard) UNIX/Solaris libelf is NOT compatible with the Linux/libc libelf. And I can also tell you that after pointing this out to Ulrich Drepper he really didn't give a shit... (I think his approximate words were "It's been like that for a while, too late, I won't change it").

    Their only mistake was actually naming it "libelf"... since it is most definitely NOT the same library...

  • by Anonymous Coward on Sunday July 11, 2010 @10:40PM (#32870934)

    Not if you go through the details. Look at the ElfData structure, for example. Also the fact that it is a header file.

  • by tsalmark (1265778) on Sunday July 11, 2010 @10:41PM (#32870940) Homepage
    You're not a programmer are you. The header files are pretty much just a bunch of definitions. there is no programming to speak of in either of those files. From reading the Posix standards you will end up with the same code but with your own comments. The header files are a lot like the ingredients section of a recipe. So it's like looking at two recipes for omelets then complaining that both have eggs listed in the ingredients section.
  • by mewyn (663989) on Sunday July 11, 2010 @10:42PM (#32870948) Homepage
    It's a header file for a standardized interface. All this stuff needs to be the same for any *NIX-like operating system to be *NIX-like, otherwise, you're making an incompatible operating system. To make source-compatible operating systems you need to have common interfaces, and those interfaces lie in the header files. Saying that this is copyright infringement is like saying that they patented a hole in the wall as a way of getting in and out of a room.
  • by Anonymous Coward on Sunday July 11, 2010 @10:43PM (#32870960)

    In case you are not trolling, virtually all of the allegedly copied code is boilerplate stuff defining types and structs or function interfaces. These have to be the same for Linux to be posix compatible. The little actual code there is, it isn't similar at all. Copyright can't keep you from writing a function that acts like another, that is for software patents, there should be actual copying and for such tiny functions it would be pretty hard to demonstrate (!s) was copied from (s==NULL).

    I still think the jury, knowing nothing about computers, would have ruled against Linux, but the claims were ridiculous.

  • by Anonymous Coward on Sunday July 11, 2010 @10:45PM (#32870972)

    If that's the one I'm looking at it's a header file for handling ELF executables.
    All that's in there are the names, arguments and return types of ELF functions, and constants used.

    All the names, values and return types of those functions are defined in the ELF standard, as are the constants. Of course they're going to be the same, they HAVE to be, and the ELF standard wasn't a proprietary Unix thing.

    Note that the actual implementation of these functions is not in question, because it's not the same code

  • by DrJimbo (594231) on Sunday July 11, 2010 @10:48PM (#32870992)
    From Sega v. Accolade [digital-law-online.info]:

    Computer programs pose unique problems for the application of the "idea/expression distinction" that determines the extent of copyright protection. To the extent that there are many possible ways of accomplishing a given task or fulfilling a particular market demand, the programmer's choice of program structure and design may be highly creative and idiosyncratic. However, computer programs are, in essence, utilitarian articles -- articles that accomplish tasks. As such, they contain many logical, structural, and visual display elements that are dictated by external factors such as compatibility requirements and industry demands... In some circumstances, even the exact set of commands used by the programmer is deemed functional rather than creative for the purposes of copyright. When specific instructions, even though previously copyrighted, are the only and essential means of accomplishing a given task, their later use by another will not amount to infringement.

    It is nearly impossible to win a copyright suit over a header file. The only chance you would have would be if it was a straight copy-and-paste which this was clearly not. The reason for this is that there is just not much room for creative expression in header files. Likewise, you can't copyright a word or a short sentence.

    There are a very limited number of ways to declare functions. If someone was allowed to copyright certain function declarations then they would have control over a large segment of the software industry. Likewise, if someone was allowed to copyright particular words, they would have control over a segment of the publishing industry.

  • by SpazmodeusG (1334705) on Sunday July 11, 2010 @10:49PM (#32871004)

    No, read the POSIX interface standard (or in this case specifically the ELF executable standard).
    You have to give your functions certain names to be compliant to the specification. The code shown is interface code, the implementation is somewhere else. Interface code simply names the functions, parameters and variables. As the functions must have certain names and parameters to fit the standard you will get the exact same line that declares a function. Any C programmer could recreate that same block of code with just a list of functions names and parameters that must be declared.

    eg. If you have to have a global function called elf_version with return of unsigned int and parameter of the version you'll get the line
    extern unsigned in elf_version( unsigned int __version );

    We see that same line of code in both files as they both implement the same specification. I'm sure there's a ton of other UNIXes out there that have the same line of code.

  • Re:Cheat Detection (Score:1, Informative)

    by Anonymous Coward on Sunday July 11, 2010 @10:56PM (#32871034)

    I'm not sure if you are aware of this but there are cheat detectors for code. At my university they would run all assignments through to check for cheaters. Once you go beyond trivial programs you can detect if someone copied and just renamed variables and moved code blocks around.

  • I've never done that (replaced a url with another) in my life - nice try. Next time, try to be at least a bit more credible by not posting as a lying A.C.

  • by DrJimbo (594231) on Sunday July 11, 2010 @11:13PM (#32871158)
    This code was the last big unknown in this long sorry saga. Even if SCO owned the copyrights, (and hadn't distributed it under the GPL, and hadn't signed the UnitedLinux agreement, etc.) it is now crystal clear that SCO's Microsoft-funded anti-Linux campaign was based on a stack of frivolous law suits.

    I think Darl's brother is scrambling to cover his backside so that when the disbarments and criminal charges come down, he has a chance to escape.

    Groklaw (of course) has IBM's response [groklaw.net] to SCO's claims that these paltry examples are worth BILLIONS of dollars in copyright damages. None of the code they offered is protectable under copyright law. Some of it is BSD code that everyone is free to use however they want (if they include the copyright notice). A lot of it is header files that were not copy-and-pasted which are nearly impossible to protect under copyright law. Then they have some snippets of generic code. Given the size of the source code for Linux, it would be astounding if there weren't some similar snippets. The idea that this is proof that Linux violated any Unix copyrights is totally absurd. The idea that these generic snippets are what made Linux enterprise-ready is beyond insane.

    The recent SCO v. Novell case decided that SCO never even owned the copyrights it was suing about. And then instead of the millions of lines of code they claimed were infringing, they presented this meager collection of totally unprotectable snippets. I sure hope SCO's lawyers get severely punished for perpetrating this fraud on the court for the past seven years.
  • by johnmoe (103704) on Sunday July 11, 2010 @11:19PM (#32871180)
  • by tomhudson (43916) <barbara.hudson@NoSPam.barbara-hudson.com> on Sunday July 11, 2010 @11:20PM (#32871188) Journal

    re 331: It's from BSD [gsp.com]

    Man Pages
    Manual Reference Pages - ELF (5)

    NAME
    elf - format of ELF executable binary files CONTENTS

    Synopsis
    Description
    See Also
    History
    Authors

    SYNOPSIS

    .In elf.h

    DESCRIPTION

    The header file
    .In elf.h defines the format of ELF executable binary files. Amongst these files are normal executable files, relocatable object files, core files and shared libraries.

    An executable file using the ELF file format consists of an ELF header, followed by a program header table or a section header table, or both. The ELF header is always at offset zero of the file. The program header table and the section header table's offset in the file are defined in the ELF header. The two tables describe the rest of the particularities of the file.

    Applications which wish to process ELF binary files for their native architecture only should include .In elf.h in their source code. These applications should need to refer to all the types and structures by their generic names "Elf_xxx" and to the macros by "ELF_xxx". Applications written this way can be compiled on any architecture, regardless whether the host is 32-bit or 64-bit.

    Should an application need to process ELF files of an unknown architecture then the application needs to include both .In sys/elf32.h and .In sys/elf64.h instead of .In elf.h . Furthermore, all types and structures need to be identified by either "Elf32_xxx" or "Elf64_xxx". The macros need to be identified by "ELF32_xxx" or "ELF64_xxx".

    Whatever the system's architecture is, it will always include .In sys/elf_common.h as well as .In sys/elf_generic.h .

    These header files describe the above mentioned headers as C structures and also include structures for dynamic sections, relocation sections and symbol tables.

    ...

    [snippage]

    ...

    HISTORY

    The ELF header files made their appearance in Fx 2.2.6 . ELF in itself first appeared in AT&T V . The ELF format is an adopted standard.

    This is the problem with SCO's case - OldSCO/Caldera only could have gotten what Novell originally had to give, if Novell HAD assigned copyrights to OldSCO. A lot of the stuff was from BSD.

  • by SpazmodeusG (1334705) on Sunday July 11, 2010 @11:20PM (#32871194)

    It's not even that. It's plain old rewriting a library to remain compatible.
    Here's an example of some end-user programs that use those very enumerations. The ELF_Type enumeration is used on page 37 in an end user application and ELF_T_WORD value is assigned to it on page 45.
    http://elftoolchain.sourceforge.net/for-review/libelf-by-example-20100112.pdf [sourceforge.net]

    There's no coincidence involved. If you write applications that use the ELF_Type enumeration and you decided to write a new elf library to support that app you'd end up having the same enumeration names to maintain compatibility.

    Copyright allows you to recreate something that's compatible as long as it isn't copied directly.

  • by tofubeer (1746800) on Sunday July 11, 2010 @11:58PM (#32871388)

    Ell given that everything in a header file is public if you want source compatibility they have to have the same names.

    I, admittedly, didn't read 100% of all of the links, but the slightly more then skimming I did do did not show me anything that was the same that couldn't have been for achieving source compatibility.

    It would be like complaining that glibc defines EXIT_SUCCESS...

  • Slashdot tends to eat anything that looks like an HTML tag. I'm sure when he put it in, it said:

    #include <stdio.h>

  • Re:Shocking (Score:4, Informative)

    by physicsdot (530505) on Monday July 12, 2010 @12:07AM (#32871436)

    How dare they copy/paste those blank lines!

    Just in case you thought you were kidding: http://www.mcbride-law.com/wp-content/uploads/2010/07/Tab-422.pdf [mcbride-law.com]

    Line 22 is blank, and is indicated as being copied.

  • by DrJimbo (594231) on Monday July 12, 2010 @12:26AM (#32871526)
    The courts have established that in order to determine software copyright infringement (for non-literal copying, which is what we have here but filtration is required even for literal copying), one must perform what is called the Abstraction, Filtration, Comparison Test [ladas.com]. In court documents related to the code in question, SCO admitted the did not perform this test on this code. They claimed that that was IBM's job. The article linked to above explains the test:

    1. break down the plaintiff’s program into its constituent structural parts (“abstraction”);

    2. examine each part for incorporated “ideas,” elements taken from the public domain, methods of operation, processes or procedures, or otherwise unprotected material (“filtration”); and

    3. compare the remaining kernel of creative expression, if any, to the work alleged to infringe at each level of abstraction (“comparison”).

    They further explain:

    The scenes à faire doctrine is often applied in software cases because it is frequently impossible to write a program in a particular computing environment without employing certain standard programming techniques and design elements. This is because certain functions, data elements, and the order of operation of a program can be dictated by such things as the type of computer on which the program will run, the programming language used, the operating system environment, governmental requirements, industry demands and standards, and widely accepted programming practices.

    I suspect the reason SCO didn't filter this code is because if they did, there would be nothing at all left to present to the court as their fig leaf to avoid being charged with perpetrating a fraud on the court.

  • by UnknowingFool (672806) on Monday July 12, 2010 @01:20AM (#32871758)
    In Gates v Bando [groklaw.net] the Tenth Circuit established the abstraction-filtration-comparison test that would become the standard in software copyright infringement. Specifically in the filtration step, all elements which are not protected by copyright must be removed from consideration. In this case, most of the code falls under scenes a faire: "expressions that are standard, stock, or common to a particular topic or that necessarily follow from a common theme or setting . .these external factors may include: hardware standards and mechanical specifications." Most of the code were simply declarations needed for compatibility and cannot be copyrighted.
  • by http (589131) on Monday July 12, 2010 @01:40AM (#32871866) Homepage Journal

    ipX [slashdot.org], for the win:

    "In the ten years that we have worked together, I can recall only one case of miscoordination of work. On that occasion, I discovered that we both had written the same 20-line assembly language program. I compared the sources and was astounded to find that they matched character-for-character."

    http://cm.bell-labs.com/who/ken/trust.html [bell-labs.com]

  • by sg_oneill (159032) on Monday July 12, 2010 @02:08AM (#32871962)

    And heres the Magic. Linus learned his style by closely reading Andrew Tanenbaum's books, and reading the Minix code. Which of course is what your supposed to do with Minix. So have most OS coders who had their education back then.

    The end result of course is that everyones code ends up looking like Tanenbaums , which is not a bad thing, the guy is up there with the gods in terms of importance to O/S theory.

  • by pandrijeczko (588093) on Monday July 12, 2010 @02:49AM (#32872154)

    Kill -9 all | sort > /dev/null

    I don't wish to be pedantic but there are all sorts of problems with the above command string:

    1. "kill -9" requires a process ID number, it doesn't accept a process name or "all". "killall" will accept process names or do some string matching.

    2. Since "kill -9 all" would generate an error, it is that error that would be sorted and sent to /dev/null. It's therefore no surprise to me that you never spotted the problems with this command string since you would never have seen any errors.

    My advice is always see what's in STDOUT and STDERR before sending anything to /dev/null.

  • by Anne Thwacks (531696) on Monday July 12, 2010 @02:51AM (#32872164)
    Because I, J, K, L, M, or variable names beginnning with them, are integers in Fortran. Otherwise variables are floating point, and floating point loop variables is a bad idea especially in Fortran.

    Foobar is a WW2 acronym for F*%&'d up beyond all recognition. (Typically referring to the military situation (See "The Longest Day").

    Now get off my lawn.

  • by lordholm (649770) on Monday July 12, 2010 @02:53AM (#32872170) Homepage

    Reverse engineering for compatibility is allowed (at least where I live). Thus, headers cannot be considered code, since they are only expressing an interface, essential for compatibility.

    If you want to be compatible with say int foo(int, float), then you actually need to write that exact sequence in your own headers, since the header define the symbol name and the calling convention for the functions. You do also, by the way need to name the header the same as in the system you are emulating for compatibility reasons, as otherwise the programs that you want to run on your system will not compile.

  • Missed verdict (Score:4, Informative)

    by The Cornishman (592143) on Monday July 12, 2010 @04:04AM (#32872418)
    You only missed a verdict if you haven't looked up for seven years! Recently a jury in Utah confirmed what a judge found in a bench trial: Caldera (later SCO Group) did not get, and was not entitled to get, the UNIX copyrights in the 1995 deal they did with Novell. Unless you think that the jury was unreasonable in that finding (and guess what, SCOG and its lawyers do), SCOG does not 'own' UNIX in any useful sense.
  • Re:First post (Score:4, Informative)

    by Richard_at_work (517087) <<richardprice> <at> <gmail.com>> on Monday July 12, 2010 @04:13AM (#32872436)

    Since we have to rely on this PDF , and there is no way to prove that that code was actually in UNIX at the moment ( as it's closed , there's no way to check ) .

    I am left to conclude that it's much easier to copy from Linux (which is open ) , than from UNIX ( which is closed ). In other words , using this PDF , i could also claim to SCO stole from Linux , and then implemented it in their commercial product , thus violating the GPL .

    While I disagree with the SCO case, your assertion that its impossible to check is wrong - UNIX may be 'closed' but that doesn't mean that the code base is impossible to get hold of. One of the licenses you could buy was full source code access, and many companies and academic institutes took this license (I for example have seen the code base to AIX and HPUX several times at different places).

    'Closed' doesn't always mean 'you can never have the source code', it can just mean 'you can't do what you want with the source code'. UNIX is one of these cases.

  • by Jaydee23 (1741316) on Monday July 12, 2010 @04:28AM (#32872504)
    I think that this is part of the ELF code. See analysis here: http://www.groklaw.net/articlebasic.php?story=20040722135616439 [groklaw.net]
  • by Anonymous Coward on Monday July 12, 2010 @04:53AM (#32872578)

    Barratry.

    SCO is in possession of Unix and BSD source code and stuff older than that.
    Rather than make comparisons using their older pre-copyright notice code, they selectivity chose to compare it with stuff after attaching copyright? notices.

    They chose not to apply abstraction-filtration-comparison tests to their own code.

    I think the Judge did not ask the right questions for this fraud to go on for as long as it has. Hard jail time is needed for the 'players' who made this possible.

  • These are not small words like "kissing" that are under dispute, this is not about reusing some very common routines that everyone uses, that's just silly. Rather it's about companies wanting to maintain compatibility with legacy versions of UNIX and doing so by referring directly to the legacy UNIX at best, and plagiarizing their code at worst.

    Except it's not about that at all. It's about implementing standard interfaces that are defined by POSIX. POSIX defines things down to the variable type so it's natural that the resulting header files will look similar. In fact, some of the differences I'm seeing in these files are from SCO not implementing POSIX properly ex return type int where it should be size_t.

    You also need to keep in mind that SCO's predecessor (AT&T) was itself caught copying code from Berkely.

    There was exactly one case where there was copying shown between SCO and Linux. In that case the code was from Berkely (licensed open source) copied into SCO and copied into Linux by SGI as one of their internal filesystem driver headers. The code was determined to be non infringing due to it's history but deleted because it was old and reimplemented in a better way elsewhere.

    From working with the Linux kernel maintainers I know they take copyright very seriously and investigate even the possibility that code was copied and you owe them an huge apology for that uninformed set of accusations.

  • Palin (Score:3, Informative)

    by gd2shoe (747932) on Monday July 12, 2010 @05:01AM (#32872610) Journal

    Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???

    An even better question would be: What does Sarah Palin really have to do with the "tea party" movement?

    (Besides the fact that she wants as much air time as possible, I mean...)
    ("Tea Party Express" sort-of has something to do with the "tea party" movement, but not strongly. Largely, it's a degenerate Republican cheer squad. The rest of the movement embraces fiscal responsibility, not blind adherence to a political party.)

  • Re:First post (Score:5, Informative)

    by joss (1346) on Monday July 12, 2010 @05:05AM (#32872624) Homepage

    > The similarities in code flow, layout, variable names, filenames, etc. are conclusive.

    I did look at the code on the linked site and what I saw looked entirely like a clean room implementation to me. The similarities were superficial and much less impressive than similarities I have seen in code that I know was written independently (because I wrote it). Two programmers working on the same problem can easily come up with strikingly similar looking solutions which a non-programmer (or an inexperienced programmer) would never believe was independent. I was astounded at how pathetic the supposed similarities were.

  • Re:First post (Score:3, Informative)

    by shentino (1139071) on Monday July 12, 2010 @05:20AM (#32872670)

    In theory, having a problem that only accepts a single solution by definition would preclude the creativity inherent in a copyrightable work.

  • Re:First post (Score:3, Informative)

    by shentino (1139071) on Monday July 12, 2010 @05:22AM (#32872678)

    Which doesn't even address the fact that SCO made contributions to the kernel under the GPL.

    Any so-called infringement is fully licensed.

  • by Eunuchswear (210685) on Monday July 12, 2010 @06:28AM (#32872916) Journal

    Of particular note, and probably a source of much consternation to SCO and their proponents, is that LiS itself doesn't implement streams either, just does protocol translation. So neither linux nor LiS contains infringing code.

    From http://email.gcom.com/home/linux/lis/ [gcom.com]

    What is LiS

    LiS is a software package that comprises an implementation of SVR4 compatible STREAMS for Linux.

    Of course LiS does protocol translation - that's what STREAMS is, a framework for doing protocol translation.

    As to whether LiS is infringing I couldn't say - I've never seen the SVR4 code to STREAMS.

  • by silentcoder (1241496) on Monday July 12, 2010 @07:30AM (#32873084) Homepage

    >But we're talking about a structured programming language - with far more structure and rules than the English language

    Not to mention a far smaller vocabulary, the complete absense of abstract forms of speech (no metaphors, similes)and in fact of even fundemental sentences.
    The vast majority of sentences in a programming language are verb(subject); THAT'S it, a rare few have an "object" (e.g. substr(S1,S2)) but at heart, that's 99% of the lines in a program. Simple commands. There are identifiers, control concepts (loops and conditionals) and structural stuff (classes, functions and the like) but these make up very little of the bulk. The implementation section consists of commands and variables for them to act on.
    Thus for the same algorythmic task, barring minor changes in indentation and identifier naming (which will be minor because both are matters on whic standards exist and within organisations some or other standard is usually enforced) the statistical likelihood of two programmers writing and identical solution to the problem is very high. After all, programming is maths and there is only so many ways you can calculate the same equation - which is basically all any algorithm does.

    You need a lot more than a few functions with identical structures to prove copyright violation when the scope for individual change is that much more limited. Creativity in programming is VERY rarely coming up with a NEW algorythm for an old task. Nearly always it lies in how we combine algorythms with one another to solve the bigger problems. The bits and pieces of code are like nuts and bolts, every engine has a million of them and they all look pretty much the same.

  • by Stumbles (602007) on Monday July 12, 2010 @07:36AM (#32873104)
    Software rot is immaterial to the issue. I think IBM summed it up nicely about the supposed amount of "their code" that is in Linux this way:

    Even if (contrary to fact) all of the System V Code were protectable by copyright, it could not render the Linux kernel substantially similar to the System V Works because the Disputed Code represents a trivial portion -- less than five one-thousandths of one percent (.005%) -- of the most cited of the System V Works and is qualitatively insignificant.

  • by kspirov (1853986) on Monday July 12, 2010 @07:59AM (#32873184)
    About libelf - 6 years ago Groklaw closed this "issue": http://www.groklaw.net/articlebasic.php?story=20040722135616439 [groklaw.net] The varable names are the same in both headers, because they correspond to Tool Interface Standard (TIS) 1.1 (Oct 1993). http://webster.cs.ucr.edu/Page_TechDocs/pfmt11.pdf [ucr.edu]
  • Re:First post (Score:3, Informative)

    by Score Whore (32328) on Monday July 12, 2010 @08:00AM (#32873188)

    They both had a common parent which was public with those structures.

    No they didn't. ELF originated in AT&T SysV Unix.

  • A year of discovery (Score:4, Informative)

    by Lorien_the_first_one (1178397) on Monday July 12, 2010 @08:01AM (#32873190)
    I read the part in Groklaw about discovery in SCO v. IBM. They spent a year in discovery to see if there was similar code and once the infringing code was revealed, the response from the judge was "Is that all ya got?" After some pretty detailed analysis and dissection of the code in court, I think the result amounted to 230 lines of code out of several million.

    Since they couldn't find examples of literal copying, SCO really wanted to go after methods and concepts as if that was protected by copyright. And they might have done it if they had been more forthcoming. But they were always late, delaying discovery as much as possible out of fear that any code revealed would be code removed from Linux. In a sense, they wanted a permanent tax on Linux without revealing the code so that it couldn't be removed.

    Since you write code and you appear to have greater ethics than SCO, you wouldn't do what SCO did in order to recoup your investment in your code. What SCO did was try to reach something far beyond copyright enforcement in any reasonable sense of what the law actually says. And that was without owning the copyrights.

    Having said all that, I can say that I am too, opposed to plagiarism in Linux. But I am also fairly confident that plagiarism isn't a problem in Linux since the code is open for anyone to see, and vetted by hundreds if not thousands of other programmers.

    The far more compelling case of copyright infringement will come out in the counterclaims that IBM has against SCO. Right now, that giant is sleeping, but when it wakes, it's going to keep Boise Schiller very busy.
  • by Xtifr (1323) on Monday July 12, 2010 @09:03AM (#32873550) Homepage

    The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.

    The truth is that SCO does not own the copyrights to UNIX code, as ruled by a judge, a jury and a second judge in Utah.

    Beyond that, SCO already turned over all their evidence to IBM several years ago, where it was analyzed by an expert named Dr. Brian W. Kernighan (if the name doesn't ring a bell, you're not qualifed to be commenting on this topic), and he examined the comparisons and came to the conclusion that no illegal copying had taken place. Note, that's not "no copying", but "no illegal copying". UNIX is based on a number of sources. Most famously, they stole (and I use that word advisedly, since they removed copyright notices, which was illegal) from BSD. They also contributed parts of UNIX to public standards, including the ELF standard which is one of the examples shown here.

    The problem is that you seem to think there's a single copyright to UNIX. There isn't. The three biggest stakeholders are Novell (inherited from AT&T), the University of Cal. regents (all the BSD code in UNIX), and Sun, but IBM and SGI also own largish chunks. The people you're accusing of being "lazy and careless" actually own parts of the code you're claiming they illegally copied. Do you know who actually owns the parts in question? I don't, but no evidence of illegal copying has been shown in court!

    Releasing this thoroughly debunked information at this late date can only be a desperate attempt to spread FUD. Don't fall for it. I'm sorry that you once had your code plagiarized, but this case is nothing like yours.

  • Re:First post (Score:3, Informative)

    by Anonymous Coward on Monday July 12, 2010 @09:56AM (#32874046)

    It must have been during the "fascist totalitarianism" days of Reaganism when it was completely impossible to get hold of books which weren't in some specific location on some specially designated shelf.

    The books were rather obscure and very pricey. They most likely weren't in libraries, and the only way for a typical 20-something developer to get one would be to buy it. I don't know anybody who would plunk down a huge chunk of change to buy their own copy of one of those books, especially when reverse engineering was plenty fun work anyway. It was like solving a puzzle.

    At any rate, I have no doubt that IBM had their lawyers pore over every byte of the Compaq BIOS looking for evidence of copying. If there had been any, they would have stomped Compaq off the map.

    You seem pretty unappreciative for someone who benefits greatly from reverse engineering efforts. If none of that had happened anywhere, all systems from different vendors would still be totally incompatible and proprietary, and you might still be shelling out the equivalent of $10,000 in 2010 dollars for a crappy midrange personal computer.

  • by LWATCDR (28044) on Monday July 12, 2010 @10:57AM (#32874628) Homepage Journal

    Actually it is even simpler than that. The code in the PDF I saw for for ELF.
    They where all typedefs. Elf is a well documented format and not of the code that shows copying was actual functional code.
    As I was reading the code I was thinking just how trivial the example was but also how well written both .h files where. You could tell exactly what each variable in the type def did. It also looked like a lot of my own code when I am having a good day.
    Also these are .h files! they are not functional code blocks just definitions. Of course the definitions for the typedefs of a well documented file format will look a lot alike!
    It is a huge duh but an attorney that knows nothing about programing might not understand that.
    If this was an example of the infringement I would say the court did a great job when they tossed it out.

  • Re:First post (Score:1, Informative)

    by Anonymous Coward on Monday July 12, 2010 @10:57AM (#32874630)

    Look. You read the original code. You admit to reading the original code.

    I said *disassembled*, with a debugger. That's not reading the source code in the books, which I had no access to.

    Look, you're either a troll or know nothing about this topic. Go play with your "other architectures".

  • by butlerm (3112) on Monday July 12, 2010 @11:14AM (#32874808)

    Because I, J, K, L, M, or variable names beginnning with them, are integers in Fortran

    I am afraid the tradition is much older than that. "i", "j", and "k" are standard subscript variables in math and physics, almost as common as "x", "y", and "z".

  • Re:First post (Score:3, Informative)

    by Chris Burke (6130) on Monday July 12, 2010 @11:25AM (#32874938) Homepage

    Header files are public - but they seldom contains any advanced functionality. They are just a definition of the calls available, defined data types and constants.

    But of course - a lawyer wouldn't understand that, it's just a question of money.

    Any lawyer versed in the relevant law would understand that. A lawyer may be able to pretend they don't understand for the sake of their client; I'm not sure but wouldn't that run afoul of rules regarding legal practice? It's certainly possible Kevin really doesn't understand, and even avoided learning so he could in all sincerity advise his client with the bad advice they wanted.

    In any case, the judge understood, which is why back when they submitted this evidence, the judge correctly ruled that necessary API definitions didn't by themselves constitute copyright violation. Besides, what with them being necessary APIs, there's no way to say they were copied from UNIX versus any other implementation which would also have the same headers.

    This is a sad, pathetic attempt to claim that there really was something to the UNIX-code-in-Linux accusation. Especially sad because as they admit this evidence was already submitted, examined, and rejected as valid evidence of what they claim.

  • Re:First post (Score:4, Informative)

    by MikeBabcock (65886) <mtb-slashdot@mikebabcock.ca> on Monday July 12, 2010 @12:11PM (#32875390) Homepage Journal

    You're not a programmer, are you?

    Reading the man pages for (random example) memcpy tells you how to define it. It also describes what it does. Tell me how you'd re-implement this function without your header definition being identical to SCO's (and yes, the definition is included verbatim right there):


    NAME
                  memcpy - copy memory area

    SYNOPSIS
                  #include <string.h>

                  void *memcpy(void *dest, const void *src, size_t n);

    DESCRIPTION
                  The memcpy() function copies n bytes from memory area src to memory area
                  dest. The memory areas should not overlap. Use memmove(3) if the memory
                  areas do overlap.

  • The code was first copied, correctly.

    The copyright notices in the comments, etc were then replaced with AT&T ones, replacing the Berkeley ones (also replacing the earlier AT&T ones, btw.) I can vouch for this personally, having worked on the "vi" source code both at Purdue (original BSD 4.3 code) and at AT&T (System Vr4 code) -- all of the BSD copyrights, as well as the (bad) poetry, had been removed from the comments in the vi sources.

    The Folks from the UCB law school took advantage of this in the counter suit, since the AT&T folks, having changed the copyright notices in the troff sources, ended up doing this this then in the printed manuals. So while AT&T was suing about vague things like including code derived from code derived from code they wrote; UC Berkeley countersued about printed, published, paper manuals, where AT&T was clearly publishing them without the UCB copyright and license info. Clear, obvious, game-set-match, paper copyright violations.

    So rather than have to find and "Destroy all Copies" of SystemVr4 manuals (including those published in turn by licencees like HP, IBM, etc.) AT&T agreed to drop their initial suit and make the countersuit go away.

  • by Anonymous Coward on Monday July 12, 2010 @01:05PM (#32875958)

    Usually, the system is using the same structure when it builds the packet. That's why it matches the actual packet. In a technical sense you could put the structure members in whatever order you wanted, but then you'd need to go write code that put them into the order that's in the actual packet ... and that code would be all overhead. It's much simpler to just have the structure match the packet and build it in the right order to begin with.

  • Re:First post (Score:3, Informative)

    by dgatwood (11270) on Monday July 12, 2010 @01:32PM (#32876280) Journal

    It doesn't really matter. Headers almost certainly cannot be copyrighted anyway. A header file is really no different than a phone book. It is a purely factual description of an interface. Phone books were held to not be copyrightable in Feist Publications v. Rural Telephone Service [wikipedia.org]. In that case, the court ruled that although creative aspects of a collection of facts can be copyrighted (which facts to include, the order and style of the information, etc.), the facts themselves are facts and cannot be copyrighted.

    An interface definition is a fact. There is only one interface definition that correctly describes a given interface. Change even one letter (not including comments) and code written against that interface will not compile without modification (unless you're doing something funky with C preprocessor macros, but even then, what the compiler eventually sees must be identical). Therefore a header is nothing more than a collection of facts. So long as the organization of the header is substantively different from the organization of the original header and the new header does not contain any non-paraphrased comments from the original, it is unlikely that copyright violation has occurred.

    And Sega v. Accolade [wikia.com] seems to support that assessment, along with several other reverse engineering cases.

  • by gwjgwj (727408) on Monday July 12, 2010 @03:01PM (#32877362)
    God is real, unless explicitly declared as integer.

Stupidity, like virtue, is its own reward.

Working...