Posted on 08/19/2003 11:00:12 AM PDT by shadowman99
On August 18 at their trade show in Las Vegas, SCO showed code that they claim was copied into Linux in violation of their copyright or trade secrets. The German publisher Heise photographed two slides of SCO's code show and made them public on their news ticker. Heise publishes c't, a popular German computer magazine. These are the slides:
This slide has some of the "System V" source code comments deliberately obfuscated using Greek characters in a Symbol font. You can remove the obfuscation by typing in the Greek text and changing back to a Latin font. The result is:
* As part of the kernel evolution toward modular naming, the * functions malloc and mfree are being renamed to rmalloc and rmfree. * Compatibility will be maintained by the following assembly code: * (Also see mfree/rmfree below)We haven't yet located the original source of this code, the next slide is more telling.
We've found the malloc() function this slide refers to. It is included in code copyrighed by ATT and twice released under the BSD license: once by Unix Systems Labs (ATT), and again by Caldera, the company that now calls itself SCO. The Linux developers have a legal right to make use of the code under that license. No violation of SCO's copyright or trade secrets is taking place.
The ATT source code is here on the net, from a version released around 1979, although we believe that earlier versions exist. The Caldera license letter releasing this code is here. Caldera is, of course, the company that now calls itself SCO. The license very clearly permits the Linux developers to use the code in question. Historical information on why Caldera released the Unix source code to the public is here, and contains some information relevant to the SCO court cases.
The malloc() code also appears in Lions Commentary on Unix, in this form:
Lions' book was first published in the 1980's under non-disclosure and was used as a textbook by universities that had licensed the Unix source. ATT vended a copy of this book to Unix licensees for some time, and a photocopy version was widely circulated among Unix licensees. The original SCO, before its purchase by Caldera, allowed the book to be published without any non-disclosure terms in 1996./* * Allocate size units from the given * map. Return the base of the allocated * space. * Algorithm is first fit. */ malloc(mp, size) struct map *mp; { register int a; register struct map *bp;for (bp = mp; bp->m_size; bp++) { if (bp->m_size >= size) { a = bp->m_addr; bp->m_addr =+ size; if ((bp->m_size =- size) == 0) do { bp++; (bp-1)->m_addr = bp->m_addr; while((bp-1)->m_size = bp->m_size); return(a); } } return(0); }
Another version of the algorithm was published in Kernighan & Ritchie's The C Programming Language, Prentice Hall 1978, apparently without restrictions.
Another version of the code is copyrighted by the University of California as part of the BSD Unix system that they produced for the U.S. Army and released as Open Source. That code is also under the BSD license, and appears here in this file released in 1984.
In the early 1990s, ATT's Unix Systems Labs (USL) sued BSDI, a company vending the BSD system, and the University of California, over this and other code in the BSD system. The claims that SCO is making are very similar to the ATT claims. ATT lost. It was found that ATT had copied heavily from the university without attribution, and thus ATT settled the case. In the settlement, the University agreed to add an ATT copyright notice to some files and continue to distribute them under the BSD license. ATT agreed to pay the University's court costs. Some details of the lawsuit are here.
The ATT code that was subject of this lawsuit survives into SCO's current system. SCO's "pattern analysis team" found this code and correctly concluded that it was identical to code in Unix. But they didn't take the additional step of checking whether or not the code had been released for others to copy legally.
Actually, you don't need a "pattern-analysis team" - you can just type lines of the allegedly copied program text into google.com, and google will show you where that code has been posted to the net.
My sources in this analysis are some very helpful members of the Linux community who posted information on the Linux Weekly News web site, and on this page of very useful information on the SCO cases.
http://www.freerepublic.com/focus/f-news/966610/posts?page=70#70
The origin of the code in question goes back even further than was known when Bruce wrote this.
The mainstream media will probably pick this up tomorrow. Apparently, the financial markets haven't figured it out yet, because SCO's stock price is down less than 1%. If I were a gambler, I'd be shorting them right now.
SCO has been very publicly discredited. They will have to respond with something that supports their claim -- the question is how diligent their research will be. They won't be able to survive another bogus claim: another slip like this will ruin their credibility.
So SCO is trying to lay claim to the malloc() function? From Lion's no less... why don't I just go patent the fork.
We haven't yet located the original source of this code...
I don't think the Mormon's would ever do that, but I did see a comment from Linus Torvald's email where he talked about doing that. Did you ever see it?
/* * Copyright (c) 1986 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * @(#)subr_rmap.c 1.2 (2.11BSD GTE) 12/24/92 */ #include "param.h" #include "systm.h" #include "map.h" #include "vm.h" /* * Resource map handling routines. * * A resource map is an array of structures each of which describes a * segment of the address space of an available resource. The segments * are described by their base address and length, and sorted in address * order. Each resource map has a fixed maximum number of segments * allowed. Resources are allocated by taking part or all of one of the * segments of the map. * * Returning of resources will require another segment if the returned * resources are not adjacent in the address space to an existing segment. * If the return of a segment would require a slot which is not available, * then one of the resource map segments is discarded after a warning is * printed. * * Returning of resources may also cause the map to collapse by coalescing * two existing segments and the returned space into a single segment. In * this case the resource map is made smaller by copying together to fill * the resultant gap. * * N.B.: the current implementation uses a dense array and does not admit * the value ``0'' as a legal address or size, since that is used as a * delimiter. */ /* * Allocate 'size' units from the given map. Return the base of the * allocated space. In a map, the addresses are increasing and the * list is terminated by a 0 size. * * Algorithm is first-fit. */ memaddr malloc(mp, size) struct map *mp; register size_t size; { register struct mapent *bp, *ep; memaddr addr; int retry; if (!size) panic("malloc: size = 0"); /* * Search for a piece of the resource map which has enough * free space to accomodate the request. */ retry = 0; again: for (bp = mp->m_map; bp->m_size; ++bp) if (bp->m_size >= size) { /* * Allocate from the map. If we allocated the entire * piece, move the rest of the map to the left. */ addr = bp->m_addr; bp->m_size -= size; if (bp->m_size) bp->m_addr += size; else for (ep = bp;; ++ep) { *ep = *++bp; if (!bp->m_size) break; } #ifdef UCB_METER if (mp == coremap) freemem -= size; #endif return(addr); } /* no entries big enough */ if (!retry++) { if (mp == swapmap) { printf("short of swap\n"); xumount(NODEV); goto again; } else if (mp == coremap) { xuncore(size); goto again; } } return((memaddr)NULL); }
...snip...
/* * Copyright (c) 1986 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * @(#)subr_rmap.c 1.2 (2.11BSD GTE) 12/24/92 */ #include "param.h" #include "systm.h" #include "map.h" #include "vm.h" /* * Resource map handling routines. * * A resource map is an array of structures each of which describes a * segment of the address space of an available resource. The segments * are described by their base address and length, and sorted in address * order. Each resource map has a fixed maximum number of segments * allowed. Resources are allocated by taking part or all of one of the * segments of the map. * * Returning of resources will require another segment if the returned * resources are not adjacent in the address space to an existing segment. * If the return of a segment would require a slot which is not available, * then one of the resource map segments is discarded after a warning is * printed. * * Returning of resources may also cause the map to collapse by coalescing * two existing segments and the returned space into a single segment. In * this case the resource map is made smaller by copying together to fill * the resultant gap. * * N.B.: the current implementation uses a dense array and does not admit * the value ``0'' as a legal address or size, since that is used as a * delimiter. */ /* * Allocate 'size' units from the given map. Return the base of the * allocated space. In a map, the addresses are increasing and the * list is terminated by a 0 size. * * Algorithm is first-fit. */ memaddr malloc(mp, size) struct map *mp; register size_t size; { register struct mapent *bp, *ep; memaddr addr; int retry; if (!size) panic("malloc: size = 0"); /* * Search for a piece of the resource map which has enough * free space to accomodate the request. */ retry = 0; again: for (bp = mp->m_map; bp->m_size; ++bp) if (bp->m_size >= size) { /* * Allocate from the map. If we allocated the entire * piece, move the rest of the map to the left. */ addr = bp->m_addr; bp->m_size -= size; if (bp->m_size) bp->m_addr += size; else for (ep = bp;; ++ep) { *ep = *++bp; if (!bp->m_size) break; } #ifdef UCB_METER if (mp == coremap) freemem -= size; #endif return(addr); } /* no entries big enough */ if (!retry++) { if (mp == swapmap) { printf("short of swap\n"); xumount(NODEV); goto again; } else if (mp == coremap) { xuncore(size); goto again; } } return((memaddr)NULL); }
...snip...
>>We haven't yet located the original source of this code...
"The ATT source code is here on the net, from a version released around 1979, although we believe that earlier versions exist."
He is referring to the obfuscated code. Whoever created the Powerpoint slide changed the font to "Symbol".
The consensus elsewhere is that it is a comment from SCO's kernel. Since it can't be found elsewhere, it is probably proprietary. But, SCO is not claiming that it is duplicated in Linux.
Disclaimer: Opinions posted on Free Republic are those of the individual posters and do not necessarily represent the opinion of Free Republic or its management. All materials posted herein are protected by copyright law and the exemption for fair use of copyrighted works.