rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

2 files changed, 2259 insertions, 0 deletions

diff --git a/recipes/opencvs/files/linux.patch b/recipes/opencvs/files/linux.patch
new file mode 100644
index 0000000000..5230c1bb91
--- /dev/null
+++ b/recipes/opencvs/files/linux.patch
@@ -0,0 +1,2239 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- /dev/null
++++ cvs/bsd-md5.h
+@@ -0,0 +1,36 @@
++#include <openssl/md5.h>
++#include <stdio.h>
++
++/* fscking linux boxen doesnt have MD5File in a crypto lib*/
++
++void 
++MDPrint (unsigned char digest[16], char buf[])
++{ 
++   unsigned int i;
++
++   for (i = 0; i < 16; i++) {
++      sprintf((char *)(buf+2*i),"%02x", digest[i]);
++   }
++}  
++  
++char *
++MD5File(const char *fname, char *buf)
++{
++   FILE *f;
++   char mybuf[100];
++   int i;
++   MD5_CTX c;
++
++   if( (f=fopen(fname, "r")) == NULL ) 
++      return NULL;
++   else {
++      MD5_Init(&c);
++      while( (i=fread(mybuf, sizeof(char), 100, f) ) > 0) {
++         MD5_Update(&c, mybuf, i);   
++      }
++      fclose(f);
++      MD5_Final(mybuf, &c);
++      MDPrint(mybuf, buf);
++      return buf; 
++   }
++}
+--- /dev/null
++++ cvs/bsd-queue.h
+@@ -0,0 +1,584 @@
++/*	$OpenBSD: queue.h,v 1.22 2001/06/23 04:39:35 angelos Exp $	*/
++/*	$NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $	*/
++
++/*
++ * Copyright (c) 1991, 1993
++ *	The Regents of the University of California.  All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ * 3. All advertising materials mentioning features or use of this software
++ *    must display the following acknowledgement:
++ *	This product includes software developed by the University of
++ *	California, Berkeley and its contributors.
++ * 4. Neither the name of the University nor the names of its contributors
++ *    may be used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ *
++ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
++ */
++
++#ifndef	_FAKE_QUEUE_H_
++#define	_FAKE_QUEUE_H_
++
++/*
++ * Ignore all <sys/queue.h> since older platforms have broken/incomplete
++ * <sys/queue.h> that are too hard to work around.
++ */
++#undef SLIST_HEAD
++#undef SLIST_HEAD_INITIALIZER
++#undef SLIST_ENTRY
++#undef SLIST_FIRST
++#undef SLIST_END
++#undef SLIST_EMPTY
++#undef SLIST_NEXT
++#undef SLIST_FOREACH
++#undef SLIST_INIT
++#undef SLIST_INSERT_AFTER
++#undef SLIST_INSERT_HEAD
++#undef SLIST_REMOVE_HEAD
++#undef SLIST_REMOVE
++#undef LIST_HEAD
++#undef LIST_HEAD_INITIALIZER
++#undef LIST_ENTRY
++#undef LIST_FIRST
++#undef LIST_END
++#undef LIST_EMPTY
++#undef LIST_NEXT
++#undef LIST_FOREACH
++#undef LIST_INIT
++#undef LIST_INSERT_AFTER
++#undef LIST_INSERT_BEFORE
++#undef LIST_INSERT_HEAD
++#undef LIST_REMOVE
++#undef LIST_REPLACE
++#undef SIMPLEQ_HEAD
++#undef SIMPLEQ_HEAD_INITIALIZER
++#undef SIMPLEQ_ENTRY
++#undef SIMPLEQ_FIRST
++#undef SIMPLEQ_END
++#undef SIMPLEQ_EMPTY
++#undef SIMPLEQ_NEXT
++#undef SIMPLEQ_FOREACH
++#undef SIMPLEQ_INIT
++#undef SIMPLEQ_INSERT_HEAD
++#undef SIMPLEQ_INSERT_TAIL
++#undef SIMPLEQ_INSERT_AFTER
++#undef SIMPLEQ_REMOVE_HEAD
++#undef TAILQ_HEAD
++#undef TAILQ_HEAD_INITIALIZER
++#undef TAILQ_ENTRY
++#undef TAILQ_FIRST
++#undef TAILQ_END
++#undef TAILQ_NEXT
++#undef TAILQ_LAST
++#undef TAILQ_PREV
++#undef TAILQ_EMPTY
++#undef TAILQ_FOREACH
++#undef TAILQ_FOREACH_REVERSE
++#undef TAILQ_INIT
++#undef TAILQ_INSERT_HEAD
++#undef TAILQ_INSERT_TAIL
++#undef TAILQ_INSERT_AFTER
++#undef TAILQ_INSERT_BEFORE
++#undef TAILQ_REMOVE
++#undef TAILQ_REPLACE
++#undef CIRCLEQ_HEAD
++#undef CIRCLEQ_HEAD_INITIALIZER
++#undef CIRCLEQ_ENTRY
++#undef CIRCLEQ_FIRST
++#undef CIRCLEQ_LAST
++#undef CIRCLEQ_END
++#undef CIRCLEQ_NEXT
++#undef CIRCLEQ_PREV
++#undef CIRCLEQ_EMPTY
++#undef CIRCLEQ_FOREACH
++#undef CIRCLEQ_FOREACH_REVERSE
++#undef CIRCLEQ_INIT
++#undef CIRCLEQ_INSERT_AFTER
++#undef CIRCLEQ_INSERT_BEFORE
++#undef CIRCLEQ_INSERT_HEAD
++#undef CIRCLEQ_INSERT_TAIL
++#undef CIRCLEQ_REMOVE
++#undef CIRCLEQ_REPLACE
++
++/*
++ * This file defines five types of data structures: singly-linked lists, 
++ * lists, simple queues, tail queues, and circular queues.
++ *
++ *
++ * A singly-linked list is headed by a single forward pointer. The elements
++ * are singly linked for minimum space and pointer manipulation overhead at
++ * the expense of O(n) removal for arbitrary elements. New elements can be
++ * added to the list after an existing element or at the head of the list.
++ * Elements being removed from the head of the list should use the explicit
++ * macro for this purpose for optimum efficiency. A singly-linked list may
++ * only be traversed in the forward direction.  Singly-linked lists are ideal
++ * for applications with large datasets and few or no removals or for
++ * implementing a LIFO queue.
++ *
++ * A list is headed by a single forward pointer (or an array of forward
++ * pointers for a hash table header). The elements are doubly linked
++ * so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before
++ * or after an existing element or at the head of the list. A list
++ * may only be traversed in the forward direction.
++ *
++ * A simple queue is headed by a pair of pointers, one the head of the
++ * list and the other to the tail of the list. The elements are singly
++ * linked to save space, so elements can only be removed from the
++ * head of the list. New elements can be added to the list before or after
++ * an existing element, at the head of the list, or at the end of the
++ * list. A simple queue may only be traversed in the forward direction.
++ *
++ * A tail queue is headed by a pair of pointers, one to the head of the
++ * list and the other to the tail of the list. The elements are doubly
++ * linked so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before or
++ * after an existing element, at the head of the list, or at the end of
++ * the list. A tail queue may be traversed in either direction.
++ *
++ * A circle queue is headed by a pair of pointers, one to the head of the
++ * list and the other to the tail of the list. The elements are doubly
++ * linked so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before or after
++ * an existing element, at the head of the list, or at the end of the list.
++ * A circle queue may be traversed in either direction, but has a more
++ * complex end of list detection.
++ *
++ * For details on the use of these macros, see the queue(3) manual page.
++ */
++
++/*
++ * Singly-linked List definitions.
++ */
++#define SLIST_HEAD(name, type)						\
++struct name {								\
++	struct type *slh_first;	/* first element */			\
++}
++ 
++#define	SLIST_HEAD_INITIALIZER(head)					\
++	{ NULL }
++ 
++#define SLIST_ENTRY(type)						\
++struct {								\
++	struct type *sle_next;	/* next element */			\
++}
++ 
++/*
++ * Singly-linked List access methods.
++ */
++#define	SLIST_FIRST(head)	((head)->slh_first)
++#define	SLIST_END(head)		NULL
++#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
++#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
++
++#define	SLIST_FOREACH(var, head, field)					\
++	for((var) = SLIST_FIRST(head);					\
++	    (var) != SLIST_END(head);					\
++	    (var) = SLIST_NEXT(var, field))
++
++/*
++ * Singly-linked List functions.
++ */
++#define	SLIST_INIT(head) {						\
++	SLIST_FIRST(head) = SLIST_END(head);				\
++}
++
++#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
++	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
++	(slistelm)->field.sle_next = (elm);				\
++} while (0)
++
++#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
++	(elm)->field.sle_next = (head)->slh_first;			\
++	(head)->slh_first = (elm);					\
++} while (0)
++
++#define	SLIST_REMOVE_HEAD(head, field) do {				\
++	(head)->slh_first = (head)->slh_first->field.sle_next;		\
++} while (0)
++
++#define SLIST_REMOVE(head, elm, type, field) do {			\
++	if ((head)->slh_first == (elm)) {				\
++		SLIST_REMOVE_HEAD((head), field);			\
++	}								\
++	else {								\
++		struct type *curelm = (head)->slh_first;		\
++		while( curelm->field.sle_next != (elm) )		\
++			curelm = curelm->field.sle_next;		\
++		curelm->field.sle_next =				\
++		    curelm->field.sle_next->field.sle_next;		\
++	}								\
++} while (0)
++
++/*
++ * List definitions.
++ */
++#define LIST_HEAD(name, type)						\
++struct name {								\
++	struct type *lh_first;	/* first element */			\
++}
++
++#define LIST_HEAD_INITIALIZER(head)					\
++	{ NULL }
++
++#define LIST_ENTRY(type)						\
++struct {								\
++	struct type *le_next;	/* next element */			\
++	struct type **le_prev;	/* address of previous next element */	\
++}
++
++/*
++ * List access methods
++ */
++#define	LIST_FIRST(head)		((head)->lh_first)
++#define	LIST_END(head)			NULL
++#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
++#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
++
++#define LIST_FOREACH(var, head, field)					\
++	for((var) = LIST_FIRST(head);					\
++	    (var)!= LIST_END(head);					\
++	    (var) = LIST_NEXT(var, field))
++
++/*
++ * List functions.
++ */
++#define	LIST_INIT(head) do {						\
++	LIST_FIRST(head) = LIST_END(head);				\
++} while (0)
++
++#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
++	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
++		(listelm)->field.le_next->field.le_prev =		\
++		    &(elm)->field.le_next;				\
++	(listelm)->field.le_next = (elm);				\
++	(elm)->field.le_prev = &(listelm)->field.le_next;		\
++} while (0)
++
++#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
++	(elm)->field.le_prev = (listelm)->field.le_prev;		\
++	(elm)->field.le_next = (listelm);				\
++	*(listelm)->field.le_prev = (elm);				\
++	(listelm)->field.le_prev = &(elm)->field.le_next;		\
++} while (0)
++
++#define LIST_INSERT_HEAD(head, elm, field) do {				\
++	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
++		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
++	(head)->lh_first = (elm);					\
++	(elm)->field.le_prev = &(head)->lh_first;			\
++} while (0)
++
++#define LIST_REMOVE(elm, field) do {					\
++	if ((elm)->field.le_next != NULL)				\
++		(elm)->field.le_next->field.le_prev =			\
++		    (elm)->field.le_prev;				\
++	*(elm)->field.le_prev = (elm)->field.le_next;			\
++} while (0)
++
++#define LIST_REPLACE(elm, elm2, field) do {				\
++	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
++		(elm2)->field.le_next->field.le_prev =			\
++		    &(elm2)->field.le_next;				\
++	(elm2)->field.le_prev = (elm)->field.le_prev;			\
++	*(elm2)->field.le_prev = (elm2);				\
++} while (0)
++
++/*
++ * Simple queue definitions.
++ */
++#define SIMPLEQ_HEAD(name, type)					\
++struct name {								\
++	struct type *sqh_first;	/* first element */			\
++	struct type **sqh_last;	/* addr of last next element */		\
++}
++
++#define SIMPLEQ_HEAD_INITIALIZER(head)					\
++	{ NULL, &(head).sqh_first }
++
++#define SIMPLEQ_ENTRY(type)						\
++struct {								\
++	struct type *sqe_next;	/* next element */			\
++}
++
++/*
++ * Simple queue access methods.
++ */
++#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
++#define	SIMPLEQ_END(head)	    NULL
++#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
++#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)
++
++#define SIMPLEQ_FOREACH(var, head, field)				\
++	for((var) = SIMPLEQ_FIRST(head);				\
++	    (var) != SIMPLEQ_END(head);					\
++	    (var) = SIMPLEQ_NEXT(var, field))
++
++/*
++ * Simple queue functions.
++ */
++#define	SIMPLEQ_INIT(head) do {						\
++	(head)->sqh_first = NULL;					\
++	(head)->sqh_last = &(head)->sqh_first;				\
++} while (0)
++
++#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
++	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
++		(head)->sqh_last = &(elm)->field.sqe_next;		\
++	(head)->sqh_first = (elm);					\
++} while (0)
++
++#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
++	(elm)->field.sqe_next = NULL;					\
++	*(head)->sqh_last = (elm);					\
++	(head)->sqh_last = &(elm)->field.sqe_next;			\
++} while (0)
++
++#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
++	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
++		(head)->sqh_last = &(elm)->field.sqe_next;		\
++	(listelm)->field.sqe_next = (elm);				\
++} while (0)
++
++#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do {			\
++	if (((head)->sqh_first = (elm)->field.sqe_next) == NULL)	\
++		(head)->sqh_last = &(head)->sqh_first;			\
++} while (0)
++
++/*
++ * Tail queue definitions.
++ */
++#define TAILQ_HEAD(name, type)						\
++struct name {								\
++	struct type *tqh_first;	/* first element */			\
++	struct type **tqh_last;	/* addr of last next element */		\
++}
++
++#define TAILQ_HEAD_INITIALIZER(head)					\
++	{ NULL, &(head).tqh_first }
++
++#define TAILQ_ENTRY(type)						\
++struct {								\
++	struct type *tqe_next;	/* next element */			\
++	struct type **tqe_prev;	/* address of previous next element */	\
++}
++
++/* 
++ * tail queue access methods 
++ */
++#define	TAILQ_FIRST(head)		((head)->tqh_first)
++#define	TAILQ_END(head)			NULL
++#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
++#define TAILQ_LAST(head, headname)					\
++	(*(((struct headname *)((head)->tqh_last))->tqh_last))
++/* XXX */
++#define TAILQ_PREV(elm, headname, field)				\
++	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
++#define	TAILQ_EMPTY(head)						\
++	(TAILQ_FIRST(head) == TAILQ_END(head))
++
++#define TAILQ_FOREACH(var, head, field)					\
++	for((var) = TAILQ_FIRST(head);					\
++	    (var) != TAILQ_END(head);					\
++	    (var) = TAILQ_NEXT(var, field))
++
++#define TAILQ_FOREACH_REVERSE(var, head, field, headname)		\
++	for((var) = TAILQ_LAST(head, headname);				\
++	    (var) != TAILQ_END(head);					\
++	    (var) = TAILQ_PREV(var, headname, field))
++
++/*
++ * Tail queue functions.
++ */
++#define	TAILQ_INIT(head) do {						\
++	(head)->tqh_first = NULL;					\
++	(head)->tqh_last = &(head)->tqh_first;				\
++} while (0)
++
++#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
++	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
++		(head)->tqh_first->field.tqe_prev =			\
++		    &(elm)->field.tqe_next;				\
++	else								\
++		(head)->tqh_last = &(elm)->field.tqe_next;		\
++	(head)->tqh_first = (elm);					\
++	(elm)->field.tqe_prev = &(head)->tqh_first;			\
++} while (0)
++
++#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
++	(elm)->field.tqe_next = NULL;					\
++	(elm)->field.tqe_prev = (head)->tqh_last;			\
++	*(head)->tqh_last = (elm);					\
++	(head)->tqh_last = &(elm)->field.tqe_next;			\
++} while (0)
++
++#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
++	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
++		(elm)->field.tqe_next->field.tqe_prev =			\
++		    &(elm)->field.tqe_next;				\
++	else								\
++		(head)->tqh_last = &(elm)->field.tqe_next;		\
++	(listelm)->field.tqe_next = (elm);				\
++	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
++} while (0)
++
++#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
++	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
++	(elm)->field.tqe_next = (listelm);				\
++	*(listelm)->field.tqe_prev = (elm);				\
++	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
++} while (0)
++
++#define TAILQ_REMOVE(head, elm, field) do {				\
++	if (((elm)->field.tqe_next) != NULL)				\
++		(elm)->field.tqe_next->field.tqe_prev =			\
++		    (elm)->field.tqe_prev;				\
++	else								\
++		(head)->tqh_last = (elm)->field.tqe_prev;		\
++	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
++} while (0)
++
++#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
++	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
++		(elm2)->field.tqe_next->field.tqe_prev =		\
++		    &(elm2)->field.tqe_next;				\
++	else								\
++		(head)->tqh_last = &(elm2)->field.tqe_next;		\
++	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
++	*(elm2)->field.tqe_prev = (elm2);				\
++} while (0)
++
++/*
++ * Circular queue definitions.
++ */
++#define CIRCLEQ_HEAD(name, type)					\
++struct name {								\
++	struct type *cqh_first;		/* first element */		\
++	struct type *cqh_last;		/* last element */		\
++}
++
++#define CIRCLEQ_HEAD_INITIALIZER(head)					\
++	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
++
++#define CIRCLEQ_ENTRY(type)						\
++struct {								\
++	struct type *cqe_next;		/* next element */		\
++	struct type *cqe_prev;		/* previous element */		\
++}
++
++/*
++ * Circular queue access methods 
++ */
++#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
++#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
++#define	CIRCLEQ_END(head)		((void *)(head))
++#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
++#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
++#define	CIRCLEQ_EMPTY(head)						\
++	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
++
++#define CIRCLEQ_FOREACH(var, head, field)				\
++	for((var) = CIRCLEQ_FIRST(head);				\
++	    (var) != CIRCLEQ_END(head);					\
++	    (var) = CIRCLEQ_NEXT(var, field))
++
++#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
++	for((var) = CIRCLEQ_LAST(head);					\
++	    (var) != CIRCLEQ_END(head);					\
++	    (var) = CIRCLEQ_PREV(var, field))
++
++/*
++ * Circular queue functions.
++ */
++#define	CIRCLEQ_INIT(head) do {						\
++	(head)->cqh_first = CIRCLEQ_END(head);				\
++	(head)->cqh_last = CIRCLEQ_END(head);				\
++} while (0)
++
++#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
++	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
++	(elm)->field.cqe_prev = (listelm);				\
++	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
++		(head)->cqh_last = (elm);				\
++	else								\
++		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
++	(listelm)->field.cqe_next = (elm);				\
++} while (0)
++
++#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
++	(elm)->field.cqe_next = (listelm);				\
++	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
++	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
++		(head)->cqh_first = (elm);				\
++	else								\
++		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
++	(listelm)->field.cqe_prev = (elm);				\
++} while (0)
++
++#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
++	(elm)->field.cqe_next = (head)->cqh_first;			\
++	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
++	if ((head)->cqh_last == CIRCLEQ_END(head))			\
++		(head)->cqh_last = (elm);				\
++	else								\
++		(head)->cqh_first->field.cqe_prev = (elm);		\
++	(head)->cqh_first = (elm);					\
++} while (0)
++
++#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
++	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
++	(elm)->field.cqe_prev = (head)->cqh_last;			\
++	if ((head)->cqh_first == CIRCLEQ_END(head))			\
++		(head)->cqh_first = (elm);				\
++	else								\
++		(head)->cqh_last->field.cqe_next = (elm);		\
++	(head)->cqh_last = (elm);					\
++} while (0)
++
++#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
++	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
++		(head)->cqh_last = (elm)->field.cqe_prev;		\
++	else								\
++		(elm)->field.cqe_next->field.cqe_prev =			\
++		    (elm)->field.cqe_prev;				\
++	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
++		(head)->cqh_first = (elm)->field.cqe_next;		\
++	else								\
++		(elm)->field.cqe_prev->field.cqe_next =			\
++		    (elm)->field.cqe_next;				\
++} while (0)
++
++#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
++	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
++	    CIRCLEQ_END(head))						\
++		(head).cqh_last = (elm2);				\
++	else								\
++		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
++	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
++	    CIRCLEQ_END(head))						\
++		(head).cqh_first = (elm2);				\
++	else								\
++		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
++} while (0)
++
++#endif	/* !_FAKE_QUEUE_H_ */
+--- cvs/buf.h~linux.patch
++++ cvs/buf.h
+@@ -39,6 +39,7 @@
+ #define BUF_H
+ 
+ #include <sys/types.h>
++#include "config.h"
+ 
+ 
+ /* flags */
+--- cvs/cache.c~linux.patch
++++ cvs/cache.c
+@@ -25,7 +25,11 @@
+  */
+ 
+ #include <sys/param.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ #include <sys/time.h>
+ 
+ #include <stdlib.h>
+--- cvs/commit.c~linux.patch
++++ cvs/commit.c
+@@ -25,7 +25,11 @@
+  */
+ 
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ #include <sys/stat.h>
+ 
+ #include <errno.h>
+--- /dev/null
++++ cvs/configure.ac
+@@ -0,0 +1,72 @@
++#                                               -*- Autoconf -*-
++# Process this file with autoconf to produce a configure script.
++
++AC_PREREQ(2.59)
++AC_INIT(OpenCVS, 1.0, unknown@unknown.com)
++AC_CONFIG_SRCDIR([remove.c])
++AM_CONFIG_HEADER([config.h])
++AM_INIT_AUTOMAKE
++
++# Checks for programs.
++AC_PROG_CC
++
++# Checks for libraries.
++AC_CHECK_HEADER([md5.h], [], [
++	AC_CHECK_LIB([ssl], [MD5_Final], MD5_LIBS="-lssl", AC_MSG_ERROR([Unable to find an appropriate lib for the MD5 functions]))
++])
++AC_SUBST([MD5_LIBS])
++
++# Checks for header files.
++AC_HEADER_DIRENT
++AC_HEADER_STDC
++AC_HEADER_SYS_WAIT
++AC_CHECK_HEADERS([fcntl.h netinet/in.h paths.h stddef.h stdlib.h string.h sys/param.h sys/socket.h sys/time.h syslog.h unistd.h])
++AC_CHECK_HEADERS([stdint.h])
++AC_CHECK_HEADERS([md5.h])
++
++# Checks for typedefs, structures, and compiler characteristics.
++AC_C_CONST
++AC_TYPE_UID_T
++AC_TYPE_MODE_T
++AC_TYPE_OFF_T
++AC_TYPE_PID_T
++AC_TYPE_SIZE_T
++AC_HEADER_TIME
++AC_STRUCT_TM
++AC_C_VOLATILE
++AC_CHECK_DECL([LIST_FOREACH], [], [], [[
++#if HAVE_SYS_QUEUE_H
++# include <sys/queue.h>
++#endif
++]])
++AC_CHECK_TYPES([ptrdiff_t])
++AC_CHECK_DECL([optreset])
++AC_CHECK_FUNC([syslog_r])
++AC_CHECK_DECL([u_int], [], [AC_DEFINE([u_int], [unsigned int], [u_int isnt defined for Linux platforms])])
++AC_CHECK_DECL([u_char], [], [AC_DEFINE([u_char], [unsigned char], [u_char isnt defined for Linux platforms])])
++
++# NOTE: strn* is not as safe as strl*, due to the fact that if
++# the src is larger than the dest, strn* do not NULL terminate.
++# FIXME: replace these with inline functions that call strn* and
++# then NULL terminate the dest.
++AC_CHECK_FUNCS([strlcpy], [], [AC_DEFINE([strlcpy], [strncpy], [strlcpy isnt portable])])
++AC_CHECK_FUNCS([strlcat], [], [AC_DEFINE([strlcat], [strncat], [strlcat isnt portable])])
++AC_CHECK_FUNCS([heapsort], [], [AC_DEFINE([heapsort], [qsort], [heapsrt isnt portable, and according to the man page, the only advantage over qsort is memory])])
++
++# Checks for library functions.
++AC_FUNC_CHOWN
++AC_REPLACE_FNMATCH
++AC_FUNC_FORK
++AC_FUNC_MALLOC
++AC_FUNC_MEMCMP
++AC_FUNC_MKTIME
++AC_FUNC_REALLOC
++AC_FUNC_SETVBUF_REVERSED
++AC_TYPE_SIGNAL
++AC_FUNC_STAT
++AC_FUNC_VPRINTF
++AC_CHECK_FUNCS([dup2 gettimeofday localtime_r memchr memset mkdir realpath socket strcasecmp strchr strdup strerror strrchr strtol])
++AC_CHECK_FUNCS([getdirentries], [], [AC_MSG_ERROR([getdirentries not found])])
++
++AC_CONFIG_FILES([Makefile])
++AC_OUTPUT
+--- cvs/conf.y~linux.patch
++++ cvs/conf.y
+@@ -33,7 +33,11 @@
+ 
+ %{
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ 
+ #include <errno.h>
+ #include <ctype.h>
+--- cvs/cvs/Makefile
++++ /dev/null
+--- cvs/cvs.c~linux.patch
++++ cvs/cvs.c
+@@ -41,6 +41,7 @@
+ #include "cvs.h"
+ #include "log.h"
+ #include "file.h"
++#include "config.h"
+ 
+ 
+ extern char *__progname;
+@@ -518,7 +519,9 @@
+ 
+ 	ret = optind;
+ 	optind = 1;
++#if HAVE_DECL_OPTRESET
+ 	optreset = 1;	/* for next call */
++#endif
+ 
+ 	return (ret);
+ }
+--- cvs/cvsd/Makefile
++++ /dev/null
+--- cvs/cvsd.h~linux.patch
++++ cvs/cvsd.h
+@@ -28,7 +28,11 @@
+ #define CVSD_H
+ 
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ #include <sys/stat.h>
+ #include <sys/socket.h>
+ 
+--- cvs/cvs.h~linux.patch
++++ cvs/cvs.h
+@@ -33,6 +33,7 @@
+ 
+ #include "rcs.h"
+ #include "file.h"
++#include "config.h"
+ 
+ #define CVS_VERSION_MAJOR 0
+ #define CVS_VERSION_MINOR 2
+--- cvs/diff.c~linux.patch
++++ cvs/diff.c
+@@ -126,6 +126,8 @@
+  *	6n words for files of length n.
+  */
+ 
++#include "config.h"
++
+ #include <sys/param.h>
+ #include <sys/stat.h>
+ #include <sys/wait.h>
+@@ -142,6 +144,9 @@
+ #include <unistd.h>
+ #include <string.h>
+ #include <sysexits.h>
++#if HAVE_STDINT_H
++# include <stdint.h>
++#endif
+ 
+ #include "cvs.h"
+ #include "log.h"
+--- cvs/event.h~linux.patch
++++ cvs/event.h
+@@ -28,7 +28,11 @@
+ #define EVENT_H
+ 
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ #include <sys/time.h>
+ 
+ #include <pwd.h>
+--- cvs/file.c~linux.patch
++++ cvs/file.c
+@@ -25,7 +25,11 @@
+  */
+ 
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ #include <sys/stat.h>
+ 
+ #include <pwd.h>
+--- cvs/import.c~linux.patch
++++ cvs/import.c
+@@ -25,7 +25,11 @@
+  */
+ 
+ #include <sys/types.h>
+-#include <sys/queue.h>
++#if HAVE_DECL_LIST_FOREACH
++# include <sys/queue.h>
++#else
++# include <bsd-queue.h>
++#endif
+ 
+ #include <err.h>
+ #include <dirent.h>
+--- cvs/log.c~linux.patch
++++ cvs/log.c
+@@ -73,7 +73,9 @@
+ #define NB_FILTERS  sizeof(cvs_log_filters)/sizeof(cvs_log_filters[0])
+ 
+ 
++#if HAVE_SYSLOG_R
+ static struct syslog_data cvs_sl;
++#endif
+ 
+ 
+ /*
+@@ -106,7 +108,11 @@
+ 		if (flags & LF_PID)
+ 			slopt |= LOG_PID;
+ 
++#if HAVE_SYSLOG_R
+ 		openlog_r(__progname, slopt, LOG_DAEMON, &cvs_sl);
++#else
++		openlog(__progname, slopt, LOG_DAEMON);
++#endif
+ 	}
+ 
+ 	return (0);
+@@ -122,7 +128,11 @@
+ cvs_log_cleanup(void)
+ {
+ 
++#if HAVE_SYSLOG_R
+ 	closelog_r(&cvs_sl);
++#else
++	closelog();
++#endif
+ }
+ 
+ 
+@@ -276,7 +286,11 @@
+ 	}
+ 
+ 	if (cvs_log_dest & LD_SYSLOG)
++#if HAVE_SYSLOG_R
+ 		syslog_r(cvs_slpriomap[level], &cvs_sl, "%s", buf);
++#else
++		syslog(cvs_slpriomap[level], "%s", buf);
++#endif
+ 
+ 	/* preserve it just in case we changed it? */
+ 	if (level == LP_ERRNO)
+--- cvs/Makefile~linux.patch
++++ cvs/Makefile
+@@ -1,7 +1,1227 @@
+-#	$OpenBSD: Makefile,v 1.2 2004/07/26 17:29:49 jfb Exp $
++# Makefile.in generated by automake 1.8.4 from Makefile.am.
++# Makefile.  Generated from Makefile.in by configure.
+ 
+-.include <bsd.own.mk>
++# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
++# 2003, 2004  Free Software Foundation, Inc.
++# This Makefile.in is free software; the Free Software Foundation
++# gives unlimited permission to copy and/or distribute it,
++# with or without modifications, as long as this notice is preserved.
+ 
+-SUBDIR= cvs cvsd
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
++# PARTICULAR PURPOSE.
+ 
+-.include <bsd.subdir.mk>
++
++
++SOURCES = $(cvs_SOURCES)
++
++srcdir = /home/kergoth/code/user/oe/build-omap/tmp/work/opencvs-0.0cvs20050111-r0/cvs
++top_srcdir = /home/kergoth/code/user/oe/build-omap/tmp/work/opencvs-0.0cvs20050111-r0/cvs
++VPATH = /home/kergoth/code/user/oe/build-omap/tmp/work/opencvs-0.0cvs20050111-r0/cvs
++pkgdatadir = $(datadir)/
++pkglibdir = $(libdir)/
++pkgincludedir = $(includedir)/
++top_builddir = .
++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
++INSTALL = /usr/bin/install -c
++install_sh_DATA = $(install_sh) -c -m 644
++install_sh_PROGRAM = $(install_sh) -c
++install_sh_SCRIPT = $(install_sh) -c
++INSTALL_HEADER = $(INSTALL_DATA)
++transform = $(program_transform_name)
++NORMAL_INSTALL = :
++PRE_INSTALL = :
++POST_INSTALL = :
++NORMAL_UNINSTALL = :
++PRE_UNINSTALL = :
++POST_UNINSTALL = :
++bin_PROGRAMS = cvs$(EXEEXT)
++subdir = .
++DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \
++	$(srcdir)/Makefile.in $(srcdir)/config.h.in \
++	$(top_srcdir)/configure TODO compile depcomp install-sh \
++	missing
++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
++am__aclocal_m4_deps = $(top_srcdir)/configure.ac
++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
++	$(ACLOCAL_M4)
++am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
++ configure.lineno configure.status.lineno
++mkinstalldirs = $(mkdir_p)
++CONFIG_HEADER = config.h
++CONFIG_CLEAN_FILES =
++am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" "$(DESTDIR)$(man5dir)" "$(DESTDIR)$(man7dir)"
++binPROGRAMS_INSTALL = $(INSTALL_PROGRAM)
++PROGRAMS = $(bin_PROGRAMS)
++am_cvs_OBJECTS = cvs-cvs.$(OBJEXT) cvs-add.$(OBJEXT) \
++	cvs-annotate.$(OBJEXT) cvs-buf.$(OBJEXT) \
++	cvs-checkout.$(OBJEXT) cvs-commit.$(OBJEXT) cvs-diff.$(OBJEXT) \
++	cvs-entries.$(OBJEXT) cvs-file.$(OBJEXT) cvs-getlog.$(OBJEXT) \
++	cvs-history.$(OBJEXT) cvs-hist.$(OBJEXT) cvs-import.$(OBJEXT) \
++	cvs-init.$(OBJEXT) cvs-log.$(OBJEXT) cvs-logmsg.$(OBJEXT) \
++	cvs-proto.$(OBJEXT) cvs-rcs.$(OBJEXT) cvs-rcsnum.$(OBJEXT) \
++	cvs-remove.$(OBJEXT) cvs-req.$(OBJEXT) cvs-resp.$(OBJEXT) \
++	cvs-root.$(OBJEXT) cvs-server.$(OBJEXT) cvs-sock.$(OBJEXT) \
++	cvs-status.$(OBJEXT) cvs-tag.$(OBJEXT) cvs-update.$(OBJEXT) \
++	cvs-util.$(OBJEXT) cvs-version.$(OBJEXT)
++cvs_OBJECTS = $(am_cvs_OBJECTS)
++am__DEPENDENCIES_1 =
++cvs_DEPENDENCIES = $(am__DEPENDENCIES_1)
++DEFAULT_INCLUDES = -I. -I$(srcdir) -I.
++depcomp = $(SHELL) $(top_srcdir)/depcomp
++am__depfiles_maybe = depfiles
++@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/cvs-add.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-annotate.Po ./$(DEPDIR)/cvs-buf.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-checkout.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-commit.Po ./$(DEPDIR)/cvs-cvs.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-diff.Po ./$(DEPDIR)/cvs-entries.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-file.Po ./$(DEPDIR)/cvs-getlog.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-hist.Po ./$(DEPDIR)/cvs-history.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-import.Po ./$(DEPDIR)/cvs-init.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-log.Po ./$(DEPDIR)/cvs-logmsg.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-proto.Po ./$(DEPDIR)/cvs-rcs.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-rcsnum.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-remove.Po ./$(DEPDIR)/cvs-req.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-resp.Po ./$(DEPDIR)/cvs-root.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-server.Po ./$(DEPDIR)/cvs-sock.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-status.Po ./$(DEPDIR)/cvs-tag.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-update.Po ./$(DEPDIR)/cvs-util.Po \
++@AMDEP_TRUE@	./$(DEPDIR)/cvs-version.Po
++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
++	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
++CCLD = $(CC)
++LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
++SOURCES = $(cvs_SOURCES)
++DIST_SOURCES = $(cvs_SOURCES)
++man1dir = $(mandir)/man1
++man5dir = $(mandir)/man5
++man7dir = $(mandir)/man7
++NROFF = nroff
++MANS = $(man1_MANS) $(man5_MANS) $(man7_MANS)
++ETAGS = etags
++CTAGS = ctags
++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
++distdir = $(PACKAGE)-$(VERSION)
++top_distdir = $(distdir)
++am__remove_distdir = \
++  { test ! -d $(distdir) \
++    || { find $(distdir) -type d ! -perm -200 -exec chmod u+w {} ';' \
++         && rm -fr $(distdir); }; }
++DIST_ARCH