BugTraq.Ru
 Русский BugTraq
http://www.bugtraq.ru/law/articles/sco.html

Обвиняет SCO: потрясая пшикающим стволом

Эрик Реймонд
(esr@thyrsus.com)

© перевод: Павел Протасов, 2003 г.

От переводчика: оригинал данного текста находится здесь: http://www.catb.org/~esr/writings/smoking-fizzle.html. Данный перевод вы можете свободно копировать и распространять, не уведомляя об этом ни меня, ни автора исходного текста, и не спрашивая разрешения. Готовый html-полуфабрикат для публикации вы можете взять здесь.

 

Версия 1.0 – впервые опубликована 20 августа 2003 г.

Версия 1.1 – отмечено значение отсутствия указания на копирайт 32V.

Версия 1.2 – исправленное описание блокировки вызовов, которая добавилась в SIII.

 

Краткое содержание: есть три хороших для SCO новости относительно тех доказательств, которые они обнародовали 18 августа 2003 года. Первая – это то, что они действительно подтверждают факт копирования кода; вторая – то, что GPL в данном случае непригодна для использования в качестве защиты; и третья – то, что лицензия BSD, вероятно, тоже нам не поможет. Но остальные новости для SCO – плохие: большинство спорного кода было выпущено (a) как "открытые исходники" самой SCO/Caldera в 2002 году, (b) не было предоставлено IBM или Sequent, (c) отсутствует в 90 % всех использующихся дистрибутивах Linux, и (d) было удалено из Linux 2.5 в июле 2003 года, поскольку оказалось слишком уродливым, чтобы жить. Если это же характерно для качества всех доказательств, которыми располагает SCO, их дело – мертворожденное.

Введение

 

В SCOforum 18 августа 2003 года SCO опубликовала часть того, что было названо доказательством ее собственности на огромные части исходных текстов Linux. Это – одно из центральных утверждений в ее судебном процессе века против IBM. "Доказательством" были две слайдовые презентации, показывающие рядом тексты, озаглавленные SCO "System V" и "Linux". Первая презентация носила название: "Копирование строка за строкой – один пример из многих".

Сейчас прошло только 24 часа с тех пор как презентации стали распространяться. Было проведено несколько исследований, уже опубликованных на Slashdot и Linux Weekly News. Этот текст я написал потому, что (a): ни одно из них не было рассчитано на широкую или журналистскую аудиторию, и (b): они пропускают или не заостряют внимание на некоторых интересных подробностях, на которые опирается дело SCO против IBM и законности ее политики лицензирования. Также я делаю то, на что другие не осмелились: я публикую, наряду с различающимися фрагментами, и код System V.

 

Доказательства

 

Давайте начнем с того, что фактически является доказательством. Первоначальные слайды – здесь и здесь. Вариант, показанный SCO, был неполон, и часть комментария текста "System V" было невозможно прочитать, поскольку он был транслитерирован в греческие символы. После устранения путаницы, мы получаем следующий комментарий в заголовке исходного текста, озаглавленного SCO "System V":

 

Слайд 1, левая сторона (текст "System V"):

/*
 * 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.
 * The swap map unit is 512 bytes
 * Algorithm is first-fit.
 *
 * 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)
 *
/

 

Слайд 1, правая сторона ("текст ядра Linux"):

/*
 * 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.
 */

ulong_t
atealloc(
	struct map *mp,
	size_t size)
{
	register unsigned int a;
	register struct map *bp;
	register unsigned long s;

 

Слайд 2 просто показывает часть текста ядра Linux:

	if (size == 0)
		return((ulong_t) NULL);

	s = mutex_spinlock(maplock(mp));

	for (bp = mapstart(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)));
				mapsize(mp)++;
			}

			ASSERT(bp-m_size < 0x80000000);
			mutex_spinunlock(maplock(mp), s);

 

Заметьте, что SCO фактически не показывает текст System V, ограничиваясь комментарием.

Текст, показанный со стороны Linux, находится в файле 2.4 arch/ia64/sn/io/ate_utils.c. Вот – полный текст соответствующей функции:

/*
 * 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.
 */

ulong_t
atealloc(
	struct map *mp,
	size_t size)
{
	register unsigned int a;
	register struct map *bp;
	register unsigned long s;

	ASSERT(size = 0);

	if (size == 0)
		return((ulong_t) NULL);

	s = mutex_spinlock(maplock(mp));

	for (bp = mapstart(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)));
				mapsize(mp)++;
			}

			ASSERT(bp-m_size < 0x80000000);
			mutex_spinunlock(maplock(mp), s);
			return(a);
		}
	}

	/*
	 * We did not get what we need .. we cannot sleep .. 
	 */
	mutex_spinunlock(maplock(mp), s);
	return(0);
}

 

Рассматриваемый код – подпрограмма управления распределением памяти, которая рассчитана на использование другим кодом ядра. Мы не можем видеть точно, на какой код в своей последовательности развития Unixware ссылается SCO, но, действительно, в нескольких Unix'ах есть очень похожая реализация.

 

Почти самая ранняя версия Unix, для которой исходники все еще существуют в настоящее время – Fifth Edition (она же Version 5 или V5), выпущеная 1974 году. Вот – версия рассматриваемого кода из Fifth Edition, с датой выпуска "1973".

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);
}

 

Вот версия из Sixth Edition, (или V6), от 1976 года. Добавленный комментарий выделен красным; в остальном текст идентичен версии из V5.


/*
 * 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);
}

 

Код из version 6 появляется в Lions Commentary on Unix, составленном в 1975-76 годах. Книга Lions (со включенным исходным текстом) была переиздана с благословения SCO в 1996 году.

Вот – код из Version 7 от 1979 года. Отличия от предыдущей версии (V6) снова выделены красным; они тривиальны и отражают незначительные изменения в синтаксисе и средствах объявления типов C.

/*

/*
 * 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.
 * The core map unit is 64 bytes; the swap map unit
 * is 512 bytes.
 * Algorithm is first-fit.
 */
malloc(mp, size)
struct map *mp;
{
	register unsigned 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);
}

 

Вот – версия текста из 32V, датированной позже 1979 годом. Отличия от предыдущей версии (V7) выделены красным; единственная незначительная поправка касается комментария в начале.


/*
 * 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.
 * The swap map unit is 512 bytes.
 * Algorithm is first-fit.
 */
malloc(mp, size)
struct map *mp;
{
	register unsigned 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);
}

 

Версия из System III от 1981 года идентична версии из 32V за исключением того, что есть незначительное изменение в расположении пробелов в комментарии.

 

С поправкой на пробелы в комментарии и незначительные изменения языка, версии кода из V5/V6/V7/32V/SIII идентичны. Это – очень устойчивый участок текста, в котором реализован простой алгоритм. Мы назовем это "старой" версией и возьмем вариант текста из 32V/SIII как типичный для нее.

Теперь – снова вариант из Linux. На сей раз красным выделены отличия от "старой версии". Незначительные различия в распределении пробелов игнорируются.


/*
 * 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.
 */

ulong_t
atealloc(
	struct map *mp,
	size_t size)
{
	register unsigned int a;
	register struct map *bp;
	register unsigned long s;

	ASSERT(size >= 0);

	if (size == 0)
		return((ulong_t) NULL);

	s = mutex_spinlock(maplock(mp));

	for (bp = mapstart(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)));
				mapsize(mp)++;
			}

			ASSERT(bp->m_size < 0x80000000);
			mutex_spinunlock(maplock(mp), s);
			return(a);
		}
	}

	/*
	 * We did not get what we need .. we cannot sleep .. 
	 */
	mutex_spinunlock(maplock(mp), s);
	return(0);
}

 

Различия незначительны. Чаще всего – тривиальны. Выражение в цикле с условием отличается только наличием двух дополнительных уровней круглых скобок. Параметр "size_t" объявлен вместо того, чтобы быть по умолчанию приведенным к типу "int". "mapstart" и "mapsize" – тривиальные макрокоманды. Единственные существенные изменения – добавление описания типов и обработки схемы блокировки процессов.

 

Другая версия того же самого кода находящаяся в системе 2.11 BSD Unix, является полезным контрастирующим примером. Версия 2.11 намного более обстоятельно прокомментирована и в ней устранены недостатки версии из 32V; они совершенно различны. Вот она:

/*
 * 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);
}

И теперь ... папам! ... Версия из System V Release 4, в uts/i386/os/malloc.c. Чтобы не использовать текст, формально защищенный авторским правом, я не собираюсь приводить непосредственно исходник SVr4. Вместо этого я собираюсь показать вам кое-что, фактически более информативное: разницу между версиями из SVr4 и Linux.

Любой юрист SCO, впавший в соблазн поднять шум вокруг публикации этих различий или моего доступа к текстам SVr4, должен сперва хорошо подумать о том, что может случиться с корпорациями, уже имеющими плохую репутацию, и преследующими журналистов, ставящих своей целью исключительно публикации, касающиеся спора, который затрагивает общественные интересы.

Фактически, можно было бы доказать, что сама публикация кода законна. В своем решении об отказе в иске, вынесенном в 1993 году, которое стало прецедентом, судья выразил сомнение в том, что AT&T является владельцем авторских прав на код Unix в целом (см. мою страницу "Никаких тайн" для посвященного этому обсуждения). Если бы я был адвокатом SCO, то последнее, чего я хотел бы – повторно открыть эту банку с червями. Остановил меня не риск юридического преследования, а этическая проблема: я уважаю права интеллектуальной собственности и не хочу нарушить права SCO, даже случайно, даже после явного игнорирования лично моих прав как программиста, выпускающего код на условиях GPL.

Различия есть. Знаком "<" в начале отмечены строки, удаленные в версии из Linux; строки начинающиеся с метки ">", добавлены. Такой формат был выбран, чтобы иллюстрировать тот факт, что различия между версиями SVr4 и Linux тривиальны и обусловлены главным образом синтаксисом. Но вот настоящее различие: тот факт, что функция из SystemV разбита на две ("rmalloc" и упаковщик для "malloc"), а также запросы к функциям блокирования/разблокировки.


6d5
<  * The swap map unit is 512 bytes.
8,12d6
<  *
<  * 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 assembler code:
<  * (also see mfree/rmfree below)
15,26c9,12
< unsigned long
< malloc(mp, size)
< register struct map *mp;
< register size_t size;
< {
<       return(rmalloc(mp, size));
< }
<
< unsigned long
< rmalloc(mp, size)
< register struct map *mp;
< register size_t size;
---
> ulong_t
> atealloc(
>       struct map *mp,
>       size_t size)
30c16,18
<       register int s;
---
>       register unsigned long s;
>
>       ASSERT(size >= 0);
33,35c21,24
<               return(NULL);
<       ASSERT(size > 0);
<       s = splhi();
---
>               return((ulong_t) NULL);
>
>       s = mutex_spinlock(maplock(mp));
>
44c33
<                               } while ((bp-1)->m_size = bp->m_size);
---
>                               } while ((((bp-1)->m_size) = (bp->m_size)));
47,48c36,38
<                       ASSERT(bp->m_size < (unsigned)0x80000000);
<                       splx(s);
---
>
>                       ASSERT(bp->m_size < 0x80000000);
>                       mutex_spinunlock(maplock(mp), s);
52c42,46
<       splx(s);
---
>
>       /*
>        * We did not get what we need .. we cannot sleep ..
>        */
>       mutex_spinunlock(maplock(mp), s);

 

Зная о функциональных изменениях в UnixWare до времен SVr4, я готов держать пари на хороший обед с бифштексом, что версия этого кода из UnixWare по функциям идентична версии из SVr4.

 

Подобия

 

Все эти части кода достаточно подобны друг другу для того, чтобы убедить меня (или любого другого компетентного программиста на C), что версии из Linux, 2.11BSD и System V Release 4, происходят от одной, более ранней, версии. Версии из System V и Linux действительно отличаются от общего предка только в том, что обе содержат нечто, напоминающее блокировку со взаимным исключением.

Фактически, вызовы SVr4 не блокируют запросы, а только прерывают запрещающие сигналы; различие – в том факте, что SVr4 не поддерживает многопроцессорность. Функция вызовов в SVr4 состоит в том, чтобы блокировать прерывания (способ гарантировать, что исполнение функции не будет прервано дисковыми событиями или импульсами таймера), а вызовы в Linux должны обеспечить симметричную мультипроцессорность без разрушения устройства памяти. Различие существенно.

"Старая", "System V" и Linux-версии более подобны друг другу, нежели любая из них напоминает код BSD. Различия среди них – точно сорта, которые были введены течением эволюции, по мере того, как скопированный код приспосабливался через какое-то время.

Оглянувшись назад, можно сказать, что в коде из Linux были признаки того, что он был скопирован из довольно старых исходников, а не написан заново: объявления "register". Они делают вручную оптимизацию, которую современные C компиляторы делают автоматически, и большинство программистов потеряло привычку к вставке их в новом коде добрые десять лет назад. Так что спросим честно: с чего был скопирован "atemalloc" Linux'a?

Чтобы разъяснять сущность вопроса: вот – примерное генеалогическое дерево версий этого участка кода. Каждая стрелка – отношение вероятного заимствования. Относительные расстояния указывают подобие кода; основная особенность – то, что код SVr4 и код Linux являются относительно близкими друг к другу, одинаково несходными с 32V, и более отличными от 2.11BSD.


                                      +------> SVr4
                                      |
                    старый Unix ----+-|
                                    | |
                                    | +------> Linux
                                    |
                                    | 
                                    +------> 2.11BSD

(Извините за псевдографику, я хотел, чтобы этот документ был одним HTML-файлом.)

Факт, который выступает в поддержку этой реконструкции эволюционного дерева – то, что оно соответствует хронологии выпусков, как она описана, например в Eric Levenez's history chart

Так что утверждения о копировании из старого кода Unix, сделанные SCO, фактически имеют под собой твердую основу. Что из этого следует о правах ИС или их нарушениях в данной ситуации? Это зависит от того, из какой версии системы был скопирован код.

 

Кто у кого скопировал?

 

Исходя из генеалогического дерева, можно сказать, что источником, с которого был скопирован код Linux, наименее вероятно была BSD.

В 1993 Лаборатория Unix (Unix Systems Labs, USL) компании AT&T предъявила иск к BSDI, компании, продающей операционную систему BSD, и Калифорнийскому университету, утверждая, что в BSD содержится незаконно присвоенный код. Их жалоба была весьма похожа на ту, что заявляет SCO. Спор был улажен после того как судья установил, что AT&T явно незаконно включила код из BSD в свое ядро. По мировому соглашению университет обязывался добавить уведомление об авторском праве AT&T в некоторые файлы, но получил право продолжить распространять операционную систему на условиях лицензии BSD. AT&T согласилась заплатить судебные издержки университета. Некоторые подробности судебного процесса – здесь.

Некоторые эксперты полагают, что существование версии кода в "открытой" BSD – достаточная защита против обвинений в том, что версия, содержащаяся в Linux была получена от SCO. В то же время я считаю, что это может оказаться оправданием для многих других предположительно существующих совпадающих участков кода (в действительности я был первым, кто предположил возможность этого в марте 2003 года), но, честно говоря, я не могу сказать, что думаю, будто это – действенная защита для такого случая. На самом деле вопрос состоит в том, был ли вариант из Linux первоначально скопирован из "старого" Unix либо System V прежде, чем был изменен для соответствия окружению Linux.

Перед попыткой определить это, мы должны рассмотреть различие между случайным и злонамеренным копированием. Случайное копирование и вставка имеет место тогда, когда вы уверены, что имеете разрешение повторно использовать код, или не думаете об этом. Злоднамеренное копирование – когда вы знаете, что не должны этого делать. Лицо, незаконно копирующее код, скорее всего, будет пытаться скрыть свои действия. Самый простой способ сделать это – изменить имена переменных, потому что такое изменение просто сделать без риска повредить код.

Причина, по которой мы должны ввести это различие – три версии кода напоминают друг друга настолько, что, если бы тот, кто скопировал его, попробовал скрыть это, мы не могли бы положиться ни на какие подсказки в тексте вообще.

К счастью, в нашем случае мы почти наверняка имеем дело с результатом непреднамеренного копирования. Все версии используют "bp" как основную локальную переменную. Ни одно из отличий между версиями из SVr4 и Linux, либо "старым" Unix и Linux, не выглядит как введенное для того, чтобы скрыть похожесть. Так что мы будем предполагать, что на самом деле можем доверять подсказкам из текстов.

Учитывая это, есть состоящее из двух частей доказательство, которое говорит в пользу "старого" кода. Первое – то, что функция разбита на две в SVr4, но одна в "старом" Unix и Linux. Менее заметный индикатор – что при обмене кодом между SVr4 и Linux было бы удалено приведение типа (во втором вызове "ASSERT"). Весьма маловероятно то, что программист, случайно копирующий код, делал бы усилия по удалению этого приведения; преднамеренно копирующий не будет делать этого, когда есть способы скрыть сходство, которые проще и менее вероятно породят неявные ошибки. Это кажется похожим на правду так как более эффективный метод маскировки состоял бы в том, чтобы удалить вызовы "ASSERT" полностью: они используются для отладки, и не нужны при работе, так что можно с легкостью обойтись без них.

С другой стороны, учитывая тот факт, что версии и из SVr4 и из Linux содержат, макроопределение "ASSERT" и код, который напоминает манипуляции с блокированием запросов, в то время как древний Unix этого не делает, может показаться что это является явным свидетельством того, будто код в Linux был скопирован с SVr4. Но здесь есть нечто, что сразу неразличимо. Первый вызов "ASSERT" фактически отличается, так как он не очевиден (версия из Linux исключает аргументы, равные нулю). И мы уже видели, что отличаются функции блокировки вызовов.

В первоначальной жалобе Caldera утверждала, что симметричная мультипроцессорная обработка (SMP) в Linux была скопирована из SVr4, но в их пересмотренной жалобе от этого требования она отказалась. Хорошо задокументировано то, что мультипроцессорная обработка в Linux была с нуля написана Аланом Коксом в 1996 году с использованием оборудования, предоставленного Caldera. В действительности, блокировка запросов неприменима как индикатор отличий от "древнего" Unix; она – плохой показатель копирования, потому что была обусловлена двумя различными наборами требований, которые не существовали в 32V.

Фактически, наиболее убедительным показателем того, что некий код в Linux был скопирован с SVr4, являются макроопределения "mapstart" и "mapsize". Они присутствуют в версиях из Linux и SVr4, но отсутствуют в "старом" коде. Они не вызваны требованиями поддержки SMP.

Ключ к пониманию ложности этого – в том факте, что их выполнение в Linux и SVr4 различно – они представляют собой макроопределения для доступа к различным структурам данных. Они, не могли быть скопированы с SVr4 и работать, потому что определяемые ими сдвиги были бы разными; скорее, кто-то, работавший над портироованием Linux под ia64 и видевший перед этим тексты SVr4, локально переопределил макросы для того, чтобы иметь знакомый удобный интерфейс. Это ни удивительно ни преступно.

В целом, картина, которую мы видим, предполагает, что код Linux был случайно скопирован со "старого" Unix, а не – злонамеренно и из System V. Теория о злонамеренном копировании, на которой основаны притязания SCO, не применима в данном случае не только из-за уголовно-правового принципа толкования неустранимых сомнений, но и гражданско-правовового принципа достаточности доказательств.

Значение прав интеллектуальной собственности

К сожалению для SCO, признание того, что "atemalloc" в Linux, возможно, был скопирован из 32V, нисколько не поможет их делу. Поскольку соответствующий файл из "старого" Unix версии 32V, законно доступен для копирования здесь.

Почему этот код выложен в сеть? Потому, что SCO/Caldera позволили распространять исходные тексты 5th Edition, 6th Edition, Version 7, 32V, и System III на условиях лицензии, основанной на лицензии BSD, с января 2002 года, задолго до того, как патч 2.4.19 ввел этот код в Linux.

Вот – копия письма, в котором Caldera официально объявила о выпуске ветвей исходников "старых Unix'ов". Дайон Джонсон, который подписал письмо, представился как "Руководитель разработки и один из многих энтузиастов открытых исходников в Caldera Intl". Письмо г-на Джонсона включает ссылку на одобренный руководством текст лицензии. В тексте лицензии невозможно было упомянуть о System III, но копия страницы, на которой SCO распространяла ее наряду с другими "старыми" версиями Unix, все еще существует на Wayback Machine.

Вообще, делу SCO, как минимум, несколько повредил тот факт, что она сама по "свободной" лицензии выпускала весь код доставшегося ей по наследству Unix. На условиях, содержащихся в лицензии на "старые" Unix'ы (Ancient Unix license), сформулированной непосредственно SCO/Caldera, разработчики ядра Linux могли полностью копировать исходники линии "старых" Unix'ов в ядро, и SCO/Caldera не может заявить никакого требования на результаты их работы вообще.

Тот факт, что очень похожий код появляется в System V, нисколько не поможет им. Чтобы выиграть дело, они должны будут показать, что существенные участки кода, которые не присутствовали ни в каком "открытом" ядре Unix, были скопированы в ядро Linux. Это будет, как минимум, трудно.

Происхождение и другие подробности

Но мы не закончили. Есть, как минимум, еще три более интересных подробности об этом коде. Вот они:

1. Код из Linux портирован на ia64, а не под i386, как в SVr4.

2. Он получен от SGI, а не IBM или Sequent.

3. Он был включен в версию 2.4.19 и удален в 2.5.

4. Тексты 32V не защищены никаким авторским правом.

Каждая из них имеет значения для дела SCO. Сейчас объясню.

Этот код портирован под ia64 для процессора Itanium, его нет в основной группе исходников, портированных для 32-разрядных процессоров Intel. Это означает, что более 90% всех пользователей Linux, включая корпоративных пользователей которым SCO сейчас грозит платой за лицензии, используют бинарный дистрибутив Linux, в который этот код не включен. Совершенно верно, SCO угрожает им из-за кода, который не откомпилирован в их ядрах и, вероятно, не присутствует в исходном виде нигде на их рабочих машинах!

 

Авторское право на архив Linux принадлежит Silicon Graphics, Inc – он состоит из находящихся в нем множестве файлов с исходниками. На большая часть кода NUMA (технологии доступа к неоднородной памяти, Non-Uniform Memory Access) SCO заявила свои требования, также часть кода создана SGI. Ничего из этого не поможет делу SCO о нарушении контракта, которое основано на утверждении, что код из System V был преднамеренно незаконно присвоен IBM и Sequent, которые сознательно пытаются уничтожить бизнес SCO, связанный с Unix.

Выбор времени введения кода и его удаления существенен по двум причинам, одна со знаком "минус" и одна "положительная". Сначала "минус": этот код "atemalloc" был введен в версии 2.4.19. Таким образом, GPL не была бы защитой против обвинений SCO в этом случае, потому что последнее ядро Linuz, которое распространяла SCO, было 2.4.13.

Теперь хорошее: код был удален из версии 2.5 в июле 2003 года, не из-за проблем с авторскими правами, а из-за своей уродливости. Так что в текущей версии Linux, этот код не присутствует даже в группе исходников, портированных под ia64!

Интересен обмен мнениями, связанный с этим удалением. В его рамках например, Манфред Спрол в списке рассылки, посвященном ядру, писал:

P.S.: я предложил бы сделать обязательным для выполнения существующее в GPL правило о том, что изменение должно быть отмечено именем человека, который изменяет (или добавляет) текст, – в "atealloc.c" написано только "SGI", так что я не знаю, кого расстрелять за то, что он написал это.

Трудно вообразить что – нибудь более нехарактерное для заговора (IBM или кого-либо еще), направленного на то, чтобы лишить SCO их интеллектуальной собственности или скрыть следы изменений в ядре. Прежде всего, Спрол отстаивает точку зрения, в соответствии с которой происхождение изменений в тексте ядра должно быть прослежено более четко, так, чтобы их авторы могут быть обнаружены. А во вторых, он это делает потому, что при этом импортировании код оказался загаженным.

 

Любопытный случай отсутствия указания на авторские права

Тексты 32V, выпущенные в 1979 году, не имеют никакого явного указания на обладателя авторского права на них. Это имеет значение потому что, согласно американскому законодательству об авторском праве, действовавшему до 1996 года, AT&T потерпела неудачу в попытках ограничить публикацию на основании явно не обозначенного авторского права на изданную работу. Это – причина того, что судья по делу "AT&T против BSD" вынес решение, выразив в нем сомнение относительно того, что AT&T может подтвердить свои притязания на авторские права, что, в свою очередь явилось причиной, по которой AT&T пошла на заключение мирового соглашения. Зная, что, если бы дело дошло до схватки в зале суда, они, вероятно, потеряли бы все права на код.

Закон был изменен в 1996 спосоом, который сделал защиту явно не обозначенных авторских прав намного более действенной и простой. (Нет, это не было гнусными интригами RIAA, это должно было привести американское законодательство в соответствие с международной Бернской конвенцией об авторском праве.)

SCO, как правопреемник AT&T, таким образом, унаследовала серьезную проблему. Было так много копий исходников "старых" Unix, существующих повсеместно так долго, что вообще неясно, имеет ли она авторские права на них. Тех из вас, кто, как и я, владеет исходниками System V, которые мы приобрели до 1996 года, нельзя преследовать за это, как из-за действующих до 1996 года правил, так и потому, что существует трехлетний срок давности на судебное преследование, связанное с авторскими правами, который истек. (Но нам все еще можно было бы предъявлять иск за их переиздание: это было бы новым нарушением.)

И, фактически, применительно к любому коду, копирование которого было сделано более чем три года назад, SCO не имеет никакой возможности возвратить убытки за нарушение авторского права на него, обнародованы ли исходники до или после 1996 года.

Заключение

Таким образом, в заключение отмечу: SCO права в том, что не имеет значения для дела и неправа в том, что имеет. Да, действительно кажется, что в данном случае код был скопирован в Linux из старых версий Unix. Но, поскольку соответствующий код, доставшийся ей по наследству, был выпущен как "открытые исходники", самой SCO/Caldera прежде, чем был включен в Linux, SCO/Caldera не имеет в данном случае никаких оснований для привлечения кого-либо к ответственности.

 

Вы можете также прочитать анализ этих текстов, сделанный Грэгом Лехи (Greg Lehey). Он отличается в некоторых частях, но приходит к тем же самым выводам.

Существует также анализ Брюса Перенса (Bruce Perens), который включает немного больше слайдов.





  Copyright © 2001-2024 Dmitry Leonov Design: Vadim Derkach