generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

More upstream NetBSD upgrades.

Browse Source 
Change-Id: Idb781d37de3b05585271d7d258ecffd5ba87d0b8
This commit is contained in:
Elliott Hughes
2012-10-23 16:05:09 -07:00
parent e3dbe1e382
commit ab44f52202
20 changed files with 330 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
libc/upstream-netbsd/libc/gen/setjmperr.c Normal file
View File

@@ -0,0 +1,56 @@
/* $NetBSD: setjmperr.c,v 1.8 2012/06/24 15:26:03 christos Exp $ */
/*
* Copyright (c) 1980, 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)setjmperr.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: setjmperr.c,v 1.8 2012/06/24 15:26:03 christos Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
/*
* This routine is called from longjmp() when an error occurs.
* Programs that wish to exit gracefully from this error may
* write their own versions.
* If this routine returns, the program is aborted.
*/
#include <setjmp.h>
#include <unistd.h>
void
longjmperror(void)
{
#define ERRMSG "longjmp botch.\n"
(void)write(STDERR_FILENO, ERRMSG, sizeof(ERRMSG) - 1);
}

132
libc/upstream-netbsd/libc/include/isc/assertions.h Normal file
View File

@@ -0,0 +1,132 @@
/* $NetBSD: assertions.h,v 1.5 2009/04/12 17:07:16 christos Exp $ */
/*
* Copyright (C) 2004, 2005, 2008 Internet Systems Consortium, Inc. ("ISC")
* Copyright (C) 1997-2001 Internet Software Consortium.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Id: assertions.h,v 1.5 2008/11/14 02:36:51 marka Exp
*/
#ifndef ASSERTIONS_H
#define ASSERTIONS_H 1
typedef enum {
assert_require, assert_ensure, assert_insist, assert_invariant
} assertion_type;
typedef void (*assertion_failure_callback)(const char *, int, assertion_type,
const char *, int);
/* coverity[+kill] */
extern assertion_failure_callback __assertion_failed;
void set_assertion_failure_callback(assertion_failure_callback f);
const char *assertion_type_to_text(assertion_type type);
#if defined(CHECK_ALL) || defined(__COVERITY__)
#define CHECK_REQUIRE 1
#define CHECK_ENSURE 1
#define CHECK_INSIST 1
#define CHECK_INVARIANT 1
#endif
#if defined(CHECK_NONE) && !defined(__COVERITY__)
#define CHECK_REQUIRE 0
#define CHECK_ENSURE 0
#define CHECK_INSIST 0
#define CHECK_INVARIANT 0
#endif
#ifdef _DIAGNOSTIC
#ifndef CHECK_REQUIRE
#define CHECK_REQUIRE 1
#endif
#ifndef CHECK_ENSURE
#define CHECK_ENSURE 1
#endif
#ifndef CHECK_INSIST
#define CHECK_INSIST 1
#endif
#ifndef CHECK_INVARIANT
#define CHECK_INVARIANT 1
#endif
#endif /* _DIAGNOSTIC */
#if CHECK_REQUIRE != 0
#define REQUIRE(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_require, \
#cond, 0), 0)))
#define REQUIRE_ERR(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_require, \
#cond, 1), 0)))
#else
#define REQUIRE(cond) ((void) (cond))
#define REQUIRE_ERR(cond) ((void) (cond))
#endif /* CHECK_REQUIRE */
#if CHECK_ENSURE != 0
#define ENSURE(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_ensure, \
#cond, 0), 0)))
#define ENSURE_ERR(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_ensure, \
#cond, 1), 0)))
#else
#define ENSURE(cond) ((void) (cond))
#define ENSURE_ERR(cond) ((void) (cond))
#endif /* CHECK_ENSURE */
#if CHECK_INSIST != 0
#define INSIST(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_insist, \
#cond, 0), 0)))
#define INSIST_ERR(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_insist, \
#cond, 1), 0)))
#else
#if !defined(__lint__)
#define INSIST(cond) ((void) (cond))
#define INSIST_ERR(cond) ((void) (cond))
#else /* !__lint__ */
#define INSIST(cond)
#define INSIST_ERR(cond)
#endif /* !__lint__ */
#endif /* CHECK_INSIST */
#if CHECK_INVARIANT != 0
#define INVARIANT(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_invariant, \
#cond, 0), 0)))
#define INVARIANT_ERR(cond) \
((void) ((cond) || \
((__assertion_failed)(__FILE__, __LINE__, assert_invariant, \
#cond, 1), 0)))
#else
#define INVARIANT(cond) ((void) (cond))
#define INVARIANT_ERR(cond) ((void) (cond))
#endif /* CHECK_INVARIANT */
#endif /* ASSERTIONS_H */
/*! \file */

170
libc/upstream-netbsd/libc/include/isc/dst.h Normal file
View File

@@ -0,0 +1,170 @@
/* $NetBSD: dst.h,v 1.1.1.4 2009/04/12 16:35:44 christos Exp $ */
#ifndef DST_H
#define DST_H
#ifndef HAS_DST_KEY
typedef struct dst_key {
char *dk_key_name; /*%< name of the key */
int dk_key_size; /*%< this is the size of the key in bits */
int dk_proto; /*%< what protocols this key can be used for */
int dk_alg; /*%< algorithm number from key record */
u_int32_t dk_flags; /*%< and the flags of the public key */
u_int16_t dk_id; /*%< identifier of the key */
} DST_KEY;
#endif /* HAS_DST_KEY */
/*
* do not taint namespace
*/
#define dst_bsafe_init __dst_bsafe_init
#define dst_buffer_to_key __dst_buffer_to_key
#define dst_check_algorithm __dst_check_algorithm
#define dst_compare_keys __dst_compare_keys
#define dst_cylink_init __dst_cylink_init
#define dst_dnskey_to_key __dst_dnskey_to_key
#define dst_eay_dss_init __dst_eay_dss_init
#define dst_free_key __dst_free_key
#define dst_generate_key __dst_generate_key
#define dst_hmac_md5_init __dst_hmac_md5_init
#define dst_init __dst_init
#define dst_key_to_buffer __dst_key_to_buffer
#define dst_key_to_dnskey __dst_key_to_dnskey
#define dst_read_key __dst_read_key
#define dst_rsaref_init __dst_rsaref_init
#define dst_s_build_filename __dst_s_build_filename
#define dst_s_calculate_bits __dst_s_calculate_bits
#define dst_s_conv_bignum_b64_to_u8 __dst_s_conv_bignum_b64_to_u8
#define dst_s_conv_bignum_u8_to_b64 __dst_s_conv_bignum_u8_to_b64
#define dst_s_dns_key_id __dst_s_dns_key_id
#define dst_s_dump __dst_s_dump
#define dst_s_filename_length __dst_s_filename_length
#define dst_s_fopen __dst_s_fopen
#define dst_s_get_int16 __dst_s_get_int16
#define dst_s_get_int32 __dst_s_get_int32
#define dst_s_id_calc __dst_s_id_calc
#define dst_s_put_int16 __dst_s_put_int16
#define dst_s_put_int32 __dst_s_put_int32
#define dst_s_quick_random __dst_s_quick_random
#define dst_s_quick_random_set __dst_s_quick_random_set
#define dst_s_random __dst_s_random
#define dst_s_semi_random __dst_s_semi_random
#define dst_s_verify_str __dst_s_verify_str
#define dst_sig_size __dst_sig_size
#define dst_sign_data __dst_sign_data
#define dst_verify_data __dst_verify_data
#define dst_write_key __dst_write_key
/*
* DST Crypto API defintions
*/
void dst_init(void);
int dst_check_algorithm(const int);
int dst_sign_data(const int, /*!< specifies INIT/UPDATE/FINAL/ALL */
DST_KEY *, /*!< the key to use */
void **, /*!< pointer to state structure */
const u_char *, /*!< data to be signed */
const int, /*!< length of input data */
u_char *, /*!< buffer to write signature to */
const int); /*!< size of output buffer */
int dst_verify_data(const int, /*!< specifies INIT/UPDATE/FINAL/ALL */
DST_KEY *, /*!< the key to use */
void **, /*!< pointer to state structure */
const u_char *, /*!< data to be verified */
const int, /*!< length of input data */
const u_char *, /*!< buffer containing signature */
const int); /*!< length of signature */
DST_KEY *dst_read_key(const char *, /*!< name of key */
const u_int16_t, /*!< key tag identifier */
const int, /*!< key algorithm */
const int); /*!< Private/PublicKey wanted */
int dst_write_key(const DST_KEY *, /*!< key to write out */
const int); /*!< Public/Private */
DST_KEY *dst_dnskey_to_key(const char *, /*!< KEY record name */
const u_char *, /*!< KEY RDATA */
const int); /*!< size of input buffer */
int dst_key_to_dnskey(const DST_KEY *, /*!< key to translate */
u_char *, /*!< output buffer */
const int); /*!< size of out_storage */
DST_KEY *dst_buffer_to_key(const char *, /*!< name of the key */
const int, /*!< algorithm */
const int, /*!< dns flags */
const int, /*!< dns protocol */
const u_char *, /*!< key in dns wire fmt */
const int); /*!< size of key */
int dst_key_to_buffer(DST_KEY *, u_char *, int);
DST_KEY *dst_generate_key(const char *, /*!< name of new key */
const int, /*!< key algorithm to generate */
const int, /*!< size of new key */
const int, /*!< alg dependent parameter */
const int, /*!< key DNS flags */
const int); /*!< key DNS protocol */
DST_KEY *dst_free_key(DST_KEY *);
int dst_compare_keys(const DST_KEY *, const DST_KEY *);
int dst_sig_size(DST_KEY *);
/* support for dns key tags/ids */
u_int16_t dst_s_dns_key_id(const u_char *, const int);
u_int16_t dst_s_id_calc(const u_char *, const int);
/* Used by callers as well as by the library. */
#define RAW_KEY_SIZE 8192 /*%< large enough to store any key */
/* DST_API control flags */
/* These are used used in functions dst_sign_data and dst_verify_data */
#define SIG_MODE_INIT 1 /*%< initialize digest */
#define SIG_MODE_UPDATE 2 /*%< add data to digest */
#define SIG_MODE_FINAL 4 /*%< generate/verify signature */
#define SIG_MODE_ALL (SIG_MODE_INIT|SIG_MODE_UPDATE|SIG_MODE_FINAL)
/* Flags for dst_read_private_key() */
#define DST_FORCE_READ 0x1000000
#define DST_CAN_SIGN 0x010F
#define DST_NO_AUTHEN 0x8000
#define DST_EXTEND_FLAG 0x1000
#define DST_STANDARD 0
#define DST_PRIVATE 0x2000000
#define DST_PUBLIC 0x4000000
#define DST_RAND_SEMI 1
#define DST_RAND_STD 2
#define DST_RAND_KEY 3
#define DST_RAND_DSS 4
/* DST algorithm codes */
#define KEY_RSA 1
#define KEY_DH 2
#define KEY_DSA 3
#define KEY_PRIVATE 254
#define KEY_EXPAND 255
#define KEY_HMAC_MD5 157
#define KEY_HMAC_SHA1 158
#define UNKNOWN_KEYALG 0
#define DST_MAX_ALGS KEY_HMAC_SHA1
/* DST constants to locations in KEY record changes in new KEY record */
#define DST_FLAGS_SIZE 2
#define DST_KEY_PROT 2
#define DST_KEY_ALG 3
#define DST_EXT_FLAG 4
#define DST_KEY_START 4
#ifndef SIGN_F_NOKEY
#define SIGN_F_NOKEY 0xC000
#endif
/* error codes from dst routines */
#define SIGN_INIT_FAILURE (-23)
#define SIGN_UPDATE_FAILURE (-24)
#define SIGN_FINAL_FAILURE (-25)
#define VERIFY_INIT_FAILURE (-26)
#define VERIFY_UPDATE_FAILURE (-27)
#define VERIFY_FINAL_FAILURE (-28)
#define MISSING_KEY_OR_SIGNATURE (-30)
#define UNSUPPORTED_KEYALG (-31)
#endif /* DST_H */
/*! \file */

206
libc/upstream-netbsd/libc/include/isc/eventlib.h Normal file
View File

@@ -0,0 +1,206 @@
/* $NetBSD: eventlib.h,v 1.3 2009/04/12 17:07:16 christos Exp $ */
/*
* Copyright (C) 2004, 2005, 2008 Internet Systems Consortium, Inc. ("ISC")
* Copyright (C) 1995-1999, 2001, 2003 Internet Software Consortium.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/* eventlib.h - exported interfaces for eventlib
* vix 09sep95 [initial]
*
* Id: eventlib.h,v 1.7 2008/11/14 02:36:51 marka Exp
*/
#ifndef _EVENTLIB_H
#define _EVENTLIB_H
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/time.h>
#include <stdio.h>
#ifndef __P
# define __EVENTLIB_P_DEFINED
# ifdef __STDC__
# define __P(x) x
# else
# define __P(x) ()
# endif
#endif
/* In the absence of branded types... */
typedef struct { void *opaque; } evConnID;
typedef struct { void *opaque; } evFileID;
typedef struct { void *opaque; } evStreamID;
typedef struct { void *opaque; } evTimerID;
typedef struct { void *opaque; } evWaitID;
typedef struct { void *opaque; } evContext;
typedef struct { void *opaque; } evEvent;
#define evInitID(id) ((id)->opaque = NULL)
#define evTestID(id) ((id).opaque != NULL)
typedef void (*evConnFunc)__P((evContext, void *, int, const void *, int,
const void *, int));
typedef void (*evFileFunc)__P((evContext, void *, int, int));
typedef void (*evStreamFunc)__P((evContext, void *, int, int));
typedef void (*evTimerFunc)__P((evContext, void *,
struct timespec, struct timespec));
typedef void (*evWaitFunc)__P((evContext, void *, const void *));
typedef struct { unsigned char mask[256/8]; } evByteMask;
#define EV_BYTEMASK_BYTE(b) ((b) / 8)
#define EV_BYTEMASK_MASK(b) (1 << ((b) % 8))
#define EV_BYTEMASK_SET(bm, b) \
((bm).mask[EV_BYTEMASK_BYTE(b)] |= EV_BYTEMASK_MASK(b))
#define EV_BYTEMASK_CLR(bm, b) \
((bm).mask[EV_BYTEMASK_BYTE(b)] &= ~EV_BYTEMASK_MASK(b))
#define EV_BYTEMASK_TST(bm, b) \
((bm).mask[EV_BYTEMASK_BYTE(b)] & EV_BYTEMASK_MASK(b))
#define EV_POLL 1
#define EV_WAIT 2
#define EV_NULL 4
#define EV_READ 1
#define EV_WRITE 2
#define EV_EXCEPT 4
#define EV_WASNONBLOCKING 8 /* Internal library use. */
/* eventlib.c */
#define evCreate __evCreate
#define evSetDebug __evSetDebug
#define evDestroy __evDestroy
#define evGetNext __evGetNext
#define evDispatch __evDispatch
#define evDrop __evDrop
#define evMainLoop __evMainLoop
#define evHighestFD __evHighestFD
#define evGetOption __evGetOption
#define evSetOption __evSetOption
int evCreate __P((evContext *));
void evSetDebug __P((evContext, int, FILE *));
int evDestroy __P((evContext));
int evGetNext __P((evContext, evEvent *, int));
int evDispatch __P((evContext, evEvent));
void evDrop __P((evContext, evEvent));
int evMainLoop __P((evContext));
int evHighestFD __P((evContext));
int evGetOption __P((evContext *, const char *, int *));
int evSetOption __P((evContext *, const char *, int));
/* ev_connects.c */
#define evListen __evListen
#define evConnect __evConnect
#define evCancelConn __evCancelConn
#define evHold __evHold
#define evUnhold __evUnhold
#define evTryAccept __evTryAccept
int evListen __P((evContext, int, int, evConnFunc, void *, evConnID *));
int evConnect __P((evContext, int, const void *, int,
evConnFunc, void *, evConnID *));
int evCancelConn __P((evContext, evConnID));
int evHold __P((evContext, evConnID));
int evUnhold __P((evContext, evConnID));
int evTryAccept __P((evContext, evConnID, int *));
/* ev_files.c */
#define evSelectFD __evSelectFD
#define evDeselectFD __evDeselectFD
int evSelectFD __P((evContext, int, int, evFileFunc, void *, evFileID *));
int evDeselectFD __P((evContext, evFileID));
/* ev_streams.c */
#define evConsIovec __evConsIovec
#define evWrite __evWrite
#define evRead __evRead
#define evTimeRW __evTimeRW
#define evUntimeRW __evUntimeRW
#define evCancelRW __evCancelRW
struct iovec evConsIovec __P((void *, size_t));
int evWrite __P((evContext, int, const struct iovec *, int,
evStreamFunc func, void *, evStreamID *));
int evRead __P((evContext, int, const struct iovec *, int,
evStreamFunc func, void *, evStreamID *));
int evTimeRW __P((evContext, evStreamID, evTimerID timer));
int evUntimeRW __P((evContext, evStreamID));
int evCancelRW __P((evContext, evStreamID));
/* ev_timers.c */
#define evConsTime __evConsTime
#define evAddTime __evAddTime
#define evSubTime __evSubTime
#define evCmpTime __evCmpTime
#define evTimeSpec __evTimeSpec
#define evTimeVal __evTimeVal
#define evNowTime __evNowTime
#define evUTCTime __evUTCTime
#define evLastEventTime __evLastEventTime
#define evSetTimer __evSetTimer
#define evClearTimer __evClearTimer
#define evConfigTimer __evConfigTimer
#define evResetTimer __evResetTimer
#define evSetIdleTimer __evSetIdleTimer
#define evClearIdleTimer __evClearIdleTimer
#define evResetIdleTimer __evResetIdleTimer
#define evTouchIdleTimer __evTouchIdleTimer
struct timespec evConsTime __P((time_t sec, long nsec));
struct timespec evAddTime __P((struct timespec, struct timespec));
struct timespec evSubTime __P((struct timespec, struct timespec));
struct timespec evNowTime __P((void));
struct timespec evUTCTime __P((void));
struct timespec evLastEventTime __P((evContext));
struct timespec evTimeSpec __P((struct timeval));
struct timeval evTimeVal __P((struct timespec));
int evCmpTime __P((struct timespec, struct timespec));
int evSetTimer __P((evContext, evTimerFunc, void *, struct timespec,
struct timespec, evTimerID *));
int evClearTimer __P((evContext, evTimerID));
int evConfigTimer __P((evContext, evTimerID, const char *param,
int value));
int evResetTimer __P((evContext, evTimerID, evTimerFunc, void *,
struct timespec, struct timespec));
int evSetIdleTimer __P((evContext, evTimerFunc, void *, struct timespec,
evTimerID *));
int evClearIdleTimer __P((evContext, evTimerID));
int evResetIdleTimer __P((evContext, evTimerID, evTimerFunc, void *,
struct timespec));
int evTouchIdleTimer __P((evContext, evTimerID));
/* ev_waits.c */
#define evWaitFor __evWaitFor
#define evDo __evDo
#define evUnwait __evUnwait
#define evDefer __evDefer
int evWaitFor __P((evContext, const void *, evWaitFunc, void *, evWaitID *));
int evDo __P((evContext, const void *));
int evUnwait __P((evContext, evWaitID));
int evDefer __P((evContext, evWaitFunc, void *));
#ifdef __EVENTLIB_P_DEFINED
# undef __P
#endif
#endif /*_EVENTLIB_H*/
/*! \file */

51
libc/upstream-netbsd/libc/include/isc/heap.h Normal file
View File

@@ -0,0 +1,51 @@
/* $NetBSD: heap.h,v 1.1.1.4 2009/04/12 16:35:44 christos Exp $ */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1997,1999 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
typedef int (*heap_higher_priority_func)(void *, void *);
typedef void (*heap_index_func)(void *, int);
typedef void (*heap_for_each_func)(void *, void *);
typedef struct heap_context {
int array_size;
int array_size_increment;
int heap_size;
void **heap;
heap_higher_priority_func higher_priority;
heap_index_func index;
} *heap_context;
#define heap_new __heap_new
#define heap_free __heap_free
#define heap_insert __heap_insert
#define heap_delete __heap_delete
#define heap_increased __heap_increased
#define heap_decreased __heap_decreased
#define heap_element __heap_element
#define heap_for_each __heap_for_each
heap_context heap_new(heap_higher_priority_func, heap_index_func, int);
int heap_free(heap_context);
int heap_insert(heap_context, void *);
int heap_delete(heap_context, int);
int heap_increased(heap_context, int);
int heap_decreased(heap_context, int);
void * heap_element(heap_context, int);
int heap_for_each(heap_context, heap_for_each_func, void *);
/*! \file */

120
libc/upstream-netbsd/libc/include/isc/list.h Normal file
View File

@@ -0,0 +1,120 @@
/* $NetBSD: list.h,v 1.5 2009/04/12 17:07:16 christos Exp $ */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1997,1999 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef LIST_H
#define LIST_H 1
#include <isc/assertions.h>
#define LIST(type) struct { type *head, *tail; }
#define INIT_LIST(list) \
do { (list).head = NULL; (list).tail = NULL; } while (/*CONSTCOND*/0)
#define LINK(type) struct { type *prev, *next; }
#define INIT_LINK_TYPE(elt, link, type) \
do { \
(elt)->link.prev = (type *)(-1); \
(elt)->link.next = (type *)(-1); \
} while (/*CONSTCOND*/0)
#define INIT_LINK(elt, link) \
INIT_LINK_TYPE(elt, link, void)
#define LINKED(elt, link) ((void *)((elt)->link.prev) != (void *)(-1) && \
(void *)((elt)->link.next) != (void *)(-1))
#define HEAD(list) ((list).head)
#define TAIL(list) ((list).tail)
#define EMPTY(list) ((list).head == NULL)
#define PREPEND(list, elt, link) \
do { \
INSIST(!LINKED(elt, link));\
if ((list).head != NULL) \
(list).head->link.prev = (elt); \
else \
(list).tail = (elt); \
(elt)->link.prev = NULL; \
(elt)->link.next = (list).head; \
(list).head = (elt); \
} while (/*CONSTCOND*/0)
#define APPEND(list, elt, link) \
do { \
INSIST(!LINKED(elt, link));\
if ((list).tail != NULL) \
(list).tail->link.next = (elt); \
else \
(list).head = (elt); \
(elt)->link.prev = (list).tail; \
(elt)->link.next = NULL; \
(list).tail = (elt); \
} while (/*CONSTCOND*/0)
#define UNLINK_TYPE(list, elt, link, type) \
do { \
INSIST(LINKED(elt, link));\
if ((elt)->link.next != NULL) \
(elt)->link.next->link.prev = (elt)->link.prev; \
else { \
INSIST((list).tail == (elt)); \
(list).tail = (elt)->link.prev; \
} \
if ((elt)->link.prev != NULL) \
(elt)->link.prev->link.next = (elt)->link.next; \
else { \
INSIST((list).head == (elt)); \
(list).head = (elt)->link.next; \
} \
INIT_LINK_TYPE(elt, link, type); \
} while (/*CONSTCOND*/0)
#define UNLINK(list, elt, link) \
UNLINK_TYPE(list, elt, link, void)
#define PREV(elt, link) ((elt)->link.prev)
#define NEXT(elt, link) ((elt)->link.next)
#define INSERT_BEFORE(list, before, elt, link) \
do { \
INSIST(!LINKED(elt, link));\
if ((before)->link.prev == NULL) \
PREPEND(list, elt, link); \
else { \
(elt)->link.prev = (before)->link.prev; \
(before)->link.prev = (elt); \
(elt)->link.prev->link.next = (elt); \
(elt)->link.next = (before); \
} \
} while (/*CONSTCOND*/0)
#define INSERT_AFTER(list, after, elt, link) \
do { \
INSIST(!LINKED(elt, link));\
if ((after)->link.next == NULL) \
APPEND(list, elt, link); \
else { \
(elt)->link.next = (after)->link.next; \
(after)->link.next = (elt); \
(elt)->link.next->link.prev = (elt); \
(elt)->link.prev = (after); \
} \
} while (/*CONSTCOND*/0)
#define ENQUEUE(list, elt, link) APPEND(list, elt, link)
#define DEQUEUE(list, elt, link) UNLINK(list, elt, link)
#endif /* LIST_H */
/*! \file */

52
libc/upstream-netbsd/libc/include/isc/memcluster.h Normal file
View File

@@ -0,0 +1,52 @@
/* $NetBSD: memcluster.h,v 1.1.1.4 2009/04/12 16:35:44 christos Exp $ */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1997,1999 by Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef MEMCLUSTER_H
#define MEMCLUSTER_H
#include <stdio.h>
#define meminit __meminit
#ifdef MEMCLUSTER_DEBUG
#define memget(s) __memget_debug(s, __FILE__, __LINE__)
#define memput(p, s) __memput_debug(p, s, __FILE__, __LINE__)
#else /*MEMCLUSTER_DEBUG*/
#ifdef MEMCLUSTER_RECORD
#define memget(s) __memget_record(s, __FILE__, __LINE__)
#define memput(p, s) __memput_record(p, s, __FILE__, __LINE__)
#else /*MEMCLUSTER_RECORD*/
#define memget __memget
#define memput __memput
#endif /*MEMCLUSTER_RECORD*/
#endif /*MEMCLUSTER_DEBUG*/
#define memstats __memstats
#define memactive __memactive
int meminit(size_t, size_t);
void * __memget(size_t);
void __memput(void *, size_t);
void * __memget_debug(size_t, const char *, int);
void __memput_debug(void *, size_t, const char *, int);
void * __memget_record(size_t, const char *, int);
void __memput_record(void *, size_t, const char *, int);
void memstats(FILE *);
int memactive(void);
#endif /* MEMCLUSTER_H */
/*! \file */

319
libc/upstream-netbsd/libc/isc/ev_streams.c Normal file
View File

@@ -0,0 +1,319 @@
/* $NetBSD: ev_streams.c,v 1.6 2009/04/12 17:07:17 christos Exp $ */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1996-1999 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* ev_streams.c - implement asynch stream file IO for the eventlib
* vix 04mar96 [initial]
*/
#include <sys/cdefs.h>
#if !defined(LINT) && !defined(CODECENTER) && !defined(lint)
#ifdef notdef
static const char rcsid[] = "Id: ev_streams.c,v 1.5 2005/04/27 04:56:36 sra Exp";
#else
__RCSID("$NetBSD: ev_streams.c,v 1.6 2009/04/12 17:07:17 christos Exp $");
#endif
#endif
#include "port_before.h"
#include "fd_setsize.h"
#include <sys/types.h>
#include <sys/uio.h>
#include <errno.h>
#include <isc/eventlib.h>
#include <isc/assertions.h>
#include "eventlib_p.h"
#include "port_after.h"
#ifndef _LIBC
static int copyvec(evStream *str, const struct iovec *iov, int iocnt);
static void consume(evStream *str, size_t bytes);
static void done(evContext opaqueCtx, evStream *str);
static void writable(evContext opaqueCtx, void *uap, int fd, int evmask);
static void readable(evContext opaqueCtx, void *uap, int fd, int evmask);
#endif
struct iovec
evConsIovec(void *buf, size_t cnt) {
struct iovec ret;
memset(&ret, 0xf5, sizeof ret);
ret.iov_base = buf;
ret.iov_len = cnt;
return (ret);
}
#ifndef _LIBC
int
evWrite(evContext opaqueCtx, int fd, const struct iovec *iov, int iocnt,
evStreamFunc func, void *uap, evStreamID *id)
{
evContext_p *ctx = opaqueCtx.opaque;
evStream *new;
int save;
OKNEW(new);
new->func = func;
new->uap = uap;
new->fd = fd;
new->flags = 0;
if (evSelectFD(opaqueCtx, fd, EV_WRITE, writable, new, &new->file) < 0)
goto free;
if (copyvec(new, iov, iocnt) < 0)
goto free;
new->prevDone = NULL;
new->nextDone = NULL;
if (ctx->streams != NULL)
ctx->streams->prev = new;
new->prev = NULL;
new->next = ctx->streams;
ctx->streams = new;
if (id != NULL)
id->opaque = new;
return (0);
free:
save = errno;
FREE(new);
errno = save;
return (-1);
}
int
evRead(evContext opaqueCtx, int fd, const struct iovec *iov, int iocnt,
evStreamFunc func, void *uap, evStreamID *id)
{
evContext_p *ctx = opaqueCtx.opaque;
evStream *new;
int save;
OKNEW(new);
new->func = func;
new->uap = uap;
new->fd = fd;
new->flags = 0;
if (evSelectFD(opaqueCtx, fd, EV_READ, readable, new, &new->file) < 0)
goto free;
if (copyvec(new, iov, iocnt) < 0)
goto free;
new->prevDone = NULL;
new->nextDone = NULL;
if (ctx->streams != NULL)
ctx->streams->prev = new;
new->prev = NULL;
new->next = ctx->streams;
ctx->streams = new;
if (id)
id->opaque = new;
return (0);
free:
save = errno;
FREE(new);
errno = save;
return (-1);
}
int
evTimeRW(evContext opaqueCtx, evStreamID id, evTimerID timer) /*ARGSUSED*/ {
evStream *str = id.opaque;
UNUSED(opaqueCtx);
str->timer = timer;
str->flags |= EV_STR_TIMEROK;
return (0);
}
int
evUntimeRW(evContext opaqueCtx, evStreamID id) /*ARGSUSED*/ {
evStream *str = id.opaque;
UNUSED(opaqueCtx);
str->flags &= ~EV_STR_TIMEROK;
return (0);
}
int
evCancelRW(evContext opaqueCtx, evStreamID id) {
evContext_p *ctx = opaqueCtx.opaque;
evStream *old = id.opaque;
/*
* The streams list is doubly threaded. First, there's ctx->streams
* that's used by evDestroy() to find and cancel all streams. Second,
* there's ctx->strDone (head) and ctx->strLast (tail) which thread
* through the potentially smaller number of "IO completed" streams,
* used in evGetNext() to avoid scanning the entire list.
*/
/* Unlink from ctx->streams. */
if (old->prev != NULL)
old->prev->next = old->next;
else
ctx->streams = old->next;
if (old->next != NULL)
old->next->prev = old->prev;
/*
* If 'old' is on the ctx->strDone list, remove it. Update
* ctx->strLast if necessary.
*/
if (old->prevDone == NULL && old->nextDone == NULL) {
/*
* Either 'old' is the only item on the done list, or it's
* not on the done list. If the former, then we unlink it
* from the list. If the latter, we leave the list alone.
*/
if (ctx->strDone == old) {
ctx->strDone = NULL;
ctx->strLast = NULL;
}
} else {
if (old->prevDone != NULL)
old->prevDone->nextDone = old->nextDone;
else
ctx->strDone = old->nextDone;
if (old->nextDone != NULL)
old->nextDone->prevDone = old->prevDone;
else
ctx->strLast = old->prevDone;
}
/* Deallocate the stream. */
if (old->file.opaque)
evDeselectFD(opaqueCtx, old->file);
memput(old->iovOrig, sizeof (struct iovec) * old->iovOrigCount);
FREE(old);
return (0);
}
/* Copy a scatter/gather vector and initialize a stream handler's IO. */
static int
copyvec(evStream *str, const struct iovec *iov, int iocnt) {
int i;
str->iovOrig = (struct iovec *)memget(sizeof(struct iovec) * iocnt);
if (str->iovOrig == NULL) {
errno = ENOMEM;
return (-1);
}
str->ioTotal = 0;
for (i = 0; i < iocnt; i++) {
str->iovOrig[i] = iov[i];
str->ioTotal += iov[i].iov_len;
}
str->iovOrigCount = iocnt;
str->iovCur = str->iovOrig;
str->iovCurCount = str->iovOrigCount;
str->ioDone = 0;
return (0);
}
/* Pull off or truncate lead iovec(s). */
static void
consume(evStream *str, size_t bytes) {
while (bytes > 0U) {
if (bytes < (size_t)str->iovCur->iov_len) {
str->iovCur->iov_len -= bytes;
str->iovCur->iov_base = (void *)
((u_char *)str->iovCur->iov_base + bytes);
str->ioDone += bytes;
bytes = 0;
} else {
bytes -= str->iovCur->iov_len;
str->ioDone += str->iovCur->iov_len;
str->iovCur++;
str->iovCurCount--;
}
}
}
/* Add a stream to Done list and deselect the FD. */
static void
done(evContext opaqueCtx, evStream *str) {
evContext_p *ctx = opaqueCtx.opaque;
if (ctx->strLast != NULL) {
str->prevDone = ctx->strLast;
ctx->strLast->nextDone = str;
ctx->strLast = str;
} else {
INSIST(ctx->strDone == NULL);
ctx->strDone = ctx->strLast = str;
}
evDeselectFD(opaqueCtx, str->file);
str->file.opaque = NULL;
/* evDrop() will call evCancelRW() on us. */
}
/* Dribble out some bytes on the stream. (Called by evDispatch().) */
static void
writable(evContext opaqueCtx, void *uap, int fd, int evmask) {
evStream *str = uap;
int bytes;
UNUSED(evmask);
bytes = writev(fd, str->iovCur, str->iovCurCount);
if (bytes > 0) {
if ((str->flags & EV_STR_TIMEROK) != 0)
evTouchIdleTimer(opaqueCtx, str->timer);
consume(str, bytes);
} else {
if (bytes < 0 && errno != EINTR) {
str->ioDone = -1;
str->ioErrno = errno;
}
}
if (str->ioDone == -1 || str->ioDone == str->ioTotal)
done(opaqueCtx, str);
}
/* Scoop up some bytes from the stream. (Called by evDispatch().) */
static void
readable(evContext opaqueCtx, void *uap, int fd, int evmask) {
evStream *str = uap;
int bytes;
UNUSED(evmask);
bytes = readv(fd, str->iovCur, str->iovCurCount);
if (bytes > 0) {
if ((str->flags & EV_STR_TIMEROK) != 0)
evTouchIdleTimer(opaqueCtx, str->timer);
consume(str, bytes);
} else {
if (bytes == 0)
str->ioDone = 0;
else {
if (errno != EINTR) {
str->ioDone = -1;
str->ioErrno = errno;
}
}
}
if (str->ioDone <= 0 || str->ioDone == str->ioTotal)
done(opaqueCtx, str);
}
#endif
/*! \file */

519
libc/upstream-netbsd/libc/isc/ev_timers.c Normal file
View File

@@ -0,0 +1,519 @@
/* $NetBSD: ev_timers.c,v 1.11 2012/03/21 00:34:54 christos Exp $ */
/*
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1995-1999 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* ev_timers.c - implement timers for the eventlib
* vix 09sep95 [initial]
*/
#include <sys/cdefs.h>
#if !defined(LINT) && !defined(CODECENTER) && !defined(lint)
#ifdef notdef
static const char rcsid[] = "Id: ev_timers.c,v 1.6 2005/04/27 04:56:36 sra Exp";
#else
__RCSID("$NetBSD: ev_timers.c,v 1.11 2012/03/21 00:34:54 christos Exp $");
#endif
#endif
/* Import. */
#include "port_before.h"
#include "fd_setsize.h"
#include <errno.h>
#include <isc/assertions.h>
#include <isc/eventlib.h>
#include "eventlib_p.h"
#include "port_after.h"
/* Constants. */
#define MILLION 1000000
#define BILLION 1000000000
/* Forward. */
#ifndef _LIBC
static int due_sooner(void *, void *);
static void set_index(void *, int);
static void free_timer(void *, void *);
static void print_timer(void *, void *);
static void idle_timeout(evContext, void *, struct timespec, struct timespec);
/* Private type. */
typedef struct {
evTimerFunc func;
void * uap;
struct timespec lastTouched;
struct timespec max_idle;
evTimer * timer;
} idle_timer;
#endif
/* Public. */
struct timespec
evConsTime(time_t sec, long nsec) {
struct timespec x;
x.tv_sec = sec;
x.tv_nsec = nsec;
return (x);
}
struct timespec
evAddTime(struct timespec addend1, struct timespec addend2) {
struct timespec x;
x.tv_sec = addend1.tv_sec + addend2.tv_sec;
x.tv_nsec = addend1.tv_nsec + addend2.tv_nsec;
if (x.tv_nsec >= BILLION) {
x.tv_sec++;
x.tv_nsec -= BILLION;
}
return (x);
}
struct timespec
evSubTime(struct timespec minuend, struct timespec subtrahend) {
struct timespec x;
x.tv_sec = minuend.tv_sec - subtrahend.tv_sec;
if (minuend.tv_nsec >= subtrahend.tv_nsec)
x.tv_nsec = minuend.tv_nsec - subtrahend.tv_nsec;
else {
x.tv_nsec = BILLION - subtrahend.tv_nsec + minuend.tv_nsec;
x.tv_sec--;
}
return (x);
}
int
evCmpTime(struct timespec a, struct timespec b) {
#define SGN(x) ((x) < 0 ? (-1) : (x) > 0 ? (1) : (0));
time_t s = a.tv_sec - b.tv_sec;
long n;
if (s != 0)
return SGN(s);
n = a.tv_nsec - b.tv_nsec;
return SGN(n);
}
struct timespec
evNowTime(void)
{
struct timeval now;
#ifdef CLOCK_REALTIME
struct timespec tsnow;
int m = CLOCK_REALTIME;
#ifdef CLOCK_MONOTONIC
#ifndef _LIBC
if (__evOptMonoTime)
m = CLOCK_MONOTONIC;
#endif
#endif
if (clock_gettime(m, &tsnow) == 0)
return (tsnow);
#endif
if (gettimeofday(&now, NULL) < 0)
return (evConsTime((time_t)0, 0L));
return (evTimeSpec(now));
}
struct timespec
evUTCTime(void) {
struct timeval now;
#ifdef CLOCK_REALTIME
struct timespec tsnow;
if (clock_gettime(CLOCK_REALTIME, &tsnow) == 0)
return (tsnow);
#endif
if (gettimeofday(&now, NULL) < 0)
return (evConsTime((time_t)0, 0L));
return (evTimeSpec(now));
}
#ifndef _LIBC
struct timespec
evLastEventTime(evContext opaqueCtx) {
evContext_p *ctx = opaqueCtx.opaque;
return (ctx->lastEventTime);
}
#endif
struct timespec
evTimeSpec(struct timeval tv) {
struct timespec ts;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
return (ts);
}
struct timeval
evTimeVal(struct timespec ts) {
struct timeval tv;
tv.tv_sec = ts.tv_sec;
tv.tv_usec = (suseconds_t)(ts.tv_nsec / 1000);
return (tv);
}
#ifndef _LIBC
int
evSetTimer(evContext opaqueCtx,
evTimerFunc func,
void *uap,
struct timespec due,
struct timespec inter,
evTimerID *opaqueID
) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *id;
evPrintf(ctx, 1,
"evSetTimer(ctx %p, func %p, uap %p, due %ld.%09ld, inter %ld.%09ld)\n",
ctx, func, uap,
(long)due.tv_sec, due.tv_nsec,
(long)inter.tv_sec, inter.tv_nsec);
#ifdef __hpux
/*
* tv_sec and tv_nsec are unsigned.
*/
if (due.tv_nsec >= BILLION)
EV_ERR(EINVAL);
if (inter.tv_nsec >= BILLION)
EV_ERR(EINVAL);
#else
if (due.tv_sec < 0 || due.tv_nsec < 0 || due.tv_nsec >= BILLION)
EV_ERR(EINVAL);
if (inter.tv_sec < 0 || inter.tv_nsec < 0 || inter.tv_nsec >= BILLION)
EV_ERR(EINVAL);
#endif
/* due={0,0} is a magic cookie meaning "now." */
if (due.tv_sec == (time_t)0 && due.tv_nsec == 0L)
due = evNowTime();
/* Allocate and fill. */
OKNEW(id);
id->func = func;
id->uap = uap;
id->due = due;
id->inter = inter;
if (heap_insert(ctx->timers, id) < 0)
return (-1);
/* Remember the ID if the caller provided us a place for it. */
if (opaqueID)
opaqueID->opaque = id;
if (ctx->debug > 7) {
evPrintf(ctx, 7, "timers after evSetTimer:\n");
(void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
}
return (0);
}
int
evClearTimer(evContext opaqueCtx, evTimerID id) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *del = id.opaque;
if (ctx->cur != NULL &&
ctx->cur->type == Timer &&
ctx->cur->u.timer.this == del) {
evPrintf(ctx, 8, "deferring delete of timer (executing)\n");
/*
* Setting the interval to zero ensures that evDrop() will
* clean up the timer.
*/
del->inter = evConsTime(0, 0);
return (0);
}
if (heap_element(ctx->timers, del->index) != del)
EV_ERR(ENOENT);
if (heap_delete(ctx->timers, del->index) < 0)
return (-1);
FREE(del);
if (ctx->debug > 7) {
evPrintf(ctx, 7, "timers after evClearTimer:\n");
(void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
}
return (0);
}
int
evConfigTimer(evContext opaqueCtx,
evTimerID id,
const char *param,
int value
) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *timer = id.opaque;
int result=0;
UNUSED(value);
if (heap_element(ctx->timers, timer->index) != timer)
EV_ERR(ENOENT);
if (strcmp(param, "rate") == 0)
timer->mode |= EV_TMR_RATE;
else if (strcmp(param, "interval") == 0)
timer->mode &= ~EV_TMR_RATE;
else
EV_ERR(EINVAL);
return (result);
}
int
evResetTimer(evContext opaqueCtx,
evTimerID id,
evTimerFunc func,
void *uap,
struct timespec due,
struct timespec inter
) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *timer = id.opaque;
struct timespec old_due;
int result=0;
if (heap_element(ctx->timers, timer->index) != timer)
EV_ERR(ENOENT);
#ifdef __hpux
/*
* tv_sec and tv_nsec are unsigned.
*/
if (due.tv_nsec >= BILLION)
EV_ERR(EINVAL);
if (inter.tv_nsec >= BILLION)
EV_ERR(EINVAL);
#else
if (due.tv_sec < 0 || due.tv_nsec < 0 || due.tv_nsec >= BILLION)
EV_ERR(EINVAL);
if (inter.tv_sec < 0 || inter.tv_nsec < 0 || inter.tv_nsec >= BILLION)
EV_ERR(EINVAL);
#endif
old_due = timer->due;
timer->func = func;
timer->uap = uap;
timer->due = due;
timer->inter = inter;
switch (evCmpTime(due, old_due)) {
case -1:
result = heap_increased(ctx->timers, timer->index);
break;
case 0:
result = 0;
break;
case 1:
result = heap_decreased(ctx->timers, timer->index);
break;
}
if (ctx->debug > 7) {
evPrintf(ctx, 7, "timers after evResetTimer:\n");
(void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
}
return (result);
}
int
evSetIdleTimer(evContext opaqueCtx,
evTimerFunc func,
void *uap,
struct timespec max_idle,
evTimerID *opaqueID
) {
evContext_p *ctx = opaqueCtx.opaque;
idle_timer *tt;
/* Allocate and fill. */
OKNEW(tt);
tt->func = func;
tt->uap = uap;
tt->lastTouched = ctx->lastEventTime;
tt->max_idle = max_idle;
if (evSetTimer(opaqueCtx, idle_timeout, tt,
evAddTime(ctx->lastEventTime, max_idle),
max_idle, opaqueID) < 0) {
FREE(tt);
return (-1);
}
tt->timer = opaqueID->opaque;
return (0);
}
int
evClearIdleTimer(evContext opaqueCtx, evTimerID id) {
evTimer *del = id.opaque;
idle_timer *tt = del->uap;
FREE(tt);
return (evClearTimer(opaqueCtx, id));
}
int
evResetIdleTimer(evContext opaqueCtx,
evTimerID opaqueID,
evTimerFunc func,
void *uap,
struct timespec max_idle
) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *timer = opaqueID.opaque;
idle_timer *tt = timer->uap;
tt->func = func;
tt->uap = uap;
tt->lastTouched = ctx->lastEventTime;
tt->max_idle = max_idle;
return (evResetTimer(opaqueCtx, opaqueID, idle_timeout, tt,
evAddTime(ctx->lastEventTime, max_idle),
max_idle));
}
int
evTouchIdleTimer(evContext opaqueCtx, evTimerID id) {
evContext_p *ctx = opaqueCtx.opaque;
evTimer *t = id.opaque;
idle_timer *tt = t->uap;
tt->lastTouched = ctx->lastEventTime;
return (0);
}
/* Public to the rest of eventlib. */
heap_context
evCreateTimers(const evContext_p *ctx) {
UNUSED(ctx);
return (heap_new(due_sooner, set_index, 2048));
}
void
evDestroyTimers(const evContext_p *ctx) {
(void) heap_for_each(ctx->timers, free_timer, NULL);
(void) heap_free(ctx->timers);
}
/* Private. */
static int
due_sooner(void *a, void *b) {
evTimer *a_timer, *b_timer;
a_timer = a;
b_timer = b;
return (evCmpTime(a_timer->due, b_timer->due) < 0);
}
static void
set_index(void *what, int idx) {
evTimer *timer;
timer = what;
timer->index = idx;
}
static void
free_timer(void *what, void *uap) {
evTimer *t = what;
UNUSED(uap);
FREE(t);
}
static void
print_timer(void *what, void *uap) {
evTimer *cur = what;
evContext_p *ctx = uap;
cur = what;
evPrintf(ctx, 7,
" func %p, uap %p, due %ld.%09ld, inter %ld.%09ld\n",
cur->func, cur->uap,
(long)cur->due.tv_sec, cur->due.tv_nsec,
(long)cur->inter.tv_sec, cur->inter.tv_nsec);
}
static void
idle_timeout(evContext opaqueCtx,
void *uap,
struct timespec due,
struct timespec inter
) {
evContext_p *ctx = opaqueCtx.opaque;
idle_timer *this = uap;
struct timespec idle;
UNUSED(due);
UNUSED(inter);
idle = evSubTime(ctx->lastEventTime, this->lastTouched);
if (evCmpTime(idle, this->max_idle) >= 0) {
(this->func)(opaqueCtx, this->uap, this->timer->due,
this->max_idle);
/*
* Setting the interval to zero will cause the timer to
* be cleaned up in evDrop().
*/
this->timer->inter = evConsTime(0L, 0L);
FREE(this);
} else {
/* evDrop() will reschedule the timer. */
this->timer->inter = evSubTime(this->max_idle, idle);
}
}
#endif
/*! \file */

283
libc/upstream-netbsd/libc/isc/eventlib_p.h Normal file
View File

@@ -0,0 +1,283 @@
/* $NetBSD: eventlib_p.h,v 1.3 2009/04/12 17:07:17 christos Exp $ */
/*
* Copyright (c) 2005 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1995-1999 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*! \file
* \brief private interfaces for eventlib
* \author vix 09sep95 [initial]
*
* Id: eventlib_p.h,v 1.9 2006/03/09 23:57:56 marka Exp
*/
#ifndef _EVENTLIB_P_H
#define _EVENTLIB_P_H
#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#define EVENTLIB_DEBUG 1
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <isc/heap.h>
#include <isc/list.h>
#include <isc/memcluster.h>
#define EV_MASK_ALL (EV_READ | EV_WRITE | EV_EXCEPT)
#define EV_ERR(e) return (errno = (e), -1)
#define OK(x) if ((x) < 0) EV_ERR(errno); else (void)NULL
#define OKFREE(x, y) if ((x) < 0) { FREE((y)); EV_ERR(errno); } \
else (void)NULL
#define NEW(p) if (((p) = memget(sizeof *(p))) != NULL) \
FILL(p); \
else \
(void)NULL;
#define OKNEW(p) if (!((p) = memget(sizeof *(p)))) { \
errno = ENOMEM; \
return (-1); \
} else \
FILL(p)
#define FREE(p) memput((p), sizeof *(p))
#if EVENTLIB_DEBUG
#define FILL(p) memset((p), 0xF5, sizeof *(p))
#else
#define FILL(p)
#endif
#ifdef USE_POLL
#ifdef HAVE_STROPTS_H
#include <stropts.h>
#endif
#include <poll.h>
#endif /* USE_POLL */
typedef struct evConn {
evConnFunc func;
void * uap;
int fd;
int flags;
#define EV_CONN_LISTEN 0x0001 /*%< Connection is a listener. */
#define EV_CONN_SELECTED 0x0002 /*%< evSelectFD(conn->file). */
#define EV_CONN_BLOCK 0x0004 /*%< Listener fd was blocking. */
evFileID file;
struct evConn * prev;
struct evConn * next;
} evConn;
typedef struct evAccept {
int fd;
union {
struct sockaddr sa;
struct sockaddr_in in;
#ifndef NO_SOCKADDR_UN
struct sockaddr_un un;
#endif
} la;
ISC_SOCKLEN_T lalen;
union {
struct sockaddr sa;
struct sockaddr_in in;
#ifndef NO_SOCKADDR_UN
struct sockaddr_un un;
#endif
} ra;
ISC_SOCKLEN_T ralen;
int ioErrno;
evConn * conn;
LINK(struct evAccept) link;
} evAccept;
typedef struct evFile {
evFileFunc func;
void * uap;
int fd;
int eventmask;
int preemptive;
struct evFile * prev;
struct evFile * next;
struct evFile * fdprev;
struct evFile * fdnext;
} evFile;
typedef struct evStream {
evStreamFunc func;
void * uap;
evFileID file;
evTimerID timer;
int flags;
#define EV_STR_TIMEROK 0x0001 /*%< IFF timer valid. */
int fd;
struct iovec * iovOrig;
int iovOrigCount;
struct iovec * iovCur;
int iovCurCount;
int ioTotal;
int ioDone;
int ioErrno;
struct evStream *prevDone, *nextDone;
struct evStream *prev, *next;
} evStream;
typedef struct evTimer {
evTimerFunc func;
void * uap;
struct timespec due, inter;
int index;
int mode;
#define EV_TMR_RATE 1
} evTimer;
typedef struct evWait {
evWaitFunc func;
void * uap;
const void * tag;
struct evWait * next;
} evWait;
typedef struct evWaitList {
evWait * first;
evWait * last;
struct evWaitList * prev;
struct evWaitList * next;
} evWaitList;
typedef struct evEvent_p {
enum { Accept, File, Stream, Timer, Wait, Free, Null } type;
union {
struct { evAccept *this; } accept;
struct { evFile *this; int eventmask; } file;
struct { evStream *this; } stream;
struct { evTimer *this; } timer;
struct { evWait *this; } wait;
struct { struct evEvent_p *next; } free;
struct { const void *placeholder; } null;
} u;
} evEvent_p;
#ifdef USE_POLL
typedef struct {
void *ctx; /* pointer to the evContext_p */
uint32_t type; /* READ, WRITE, EXCEPT, nonblk */
uint32_t result; /* 1 => revents, 0 => events */
} __evEmulMask;
#define emulMaskInit(ctx, field, ev, lastnext) \
ctx->field.ctx = ctx; \
ctx->field.type = ev; \
ctx->field.result = lastnext;
extern short *__fd_eventfield(int fd, __evEmulMask *maskp);
extern short __poll_event(__evEmulMask *maskp);
extern void __fd_clr(int fd, __evEmulMask *maskp);
extern void __fd_set(int fd, __evEmulMask *maskp);
#undef FD_ZERO
#define FD_ZERO(maskp)
#undef FD_SET
#define FD_SET(fd, maskp) \
__fd_set(fd, maskp)
#undef FD_CLR
#define FD_CLR(fd, maskp) \
__fd_clr(fd, maskp)
#undef FD_ISSET
#define FD_ISSET(fd, maskp) \
((*__fd_eventfield(fd, maskp) & __poll_event(maskp)) != 0)
#endif /* USE_POLL */
typedef struct {
/* Global. */
const evEvent_p *cur;
/* Debugging. */
int debug;
FILE *output;
/* Connections. */
evConn *conns;
LIST(evAccept) accepts;
/* Files. */
evFile *files, *fdNext;
#ifndef USE_POLL
fd_set rdLast, rdNext;
fd_set wrLast, wrNext;
fd_set exLast, exNext;
fd_set nonblockBefore;
int fdMax, fdCount, highestFD;
evFile *fdTable[FD_SETSIZE];
#else
struct pollfd *pollfds; /* Allocated as needed */
evFile **fdTable; /* Ditto */
int maxnfds; /* # elements in above */
int firstfd; /* First active fd */
int fdMax; /* Last active fd */
int fdCount; /* # fd:s with I/O */
int highestFD; /* max fd allowed by OS */
__evEmulMask rdLast, rdNext;
__evEmulMask wrLast, wrNext;
__evEmulMask exLast, exNext;
__evEmulMask nonblockBefore;
#endif /* USE_POLL */
#ifdef EVENTLIB_TIME_CHECKS
struct timespec lastSelectTime;
int lastFdCount;
#endif
/* Streams. */
evStream *streams;
evStream *strDone, *strLast;
/* Timers. */
struct timespec lastEventTime;
heap_context timers;
/* Waits. */
evWaitList *waitLists;
evWaitList waitDone;
} evContext_p;
/* eventlib.c */
#define evPrintf __evPrintf
void evPrintf(const evContext_p *ctx, int level, const char *fmt, ...)
ISC_FORMAT_PRINTF(3, 4);
#ifdef USE_POLL
extern int evPollfdRealloc(evContext_p *ctx, int pollfd_chunk_size, int fd);
#endif /* USE_POLL */
/* ev_timers.c */
#define evCreateTimers __evCreateTimers
heap_context evCreateTimers(const evContext_p *);
#define evDestroyTimers __evDestroyTimers
void evDestroyTimers(const evContext_p *);
/* ev_waits.c */
#define evFreeWait __evFreeWait
evWait *evFreeWait(evContext_p *ctx, evWait *old);
/* Global options */
extern int __evOptMonoTime;
#endif /*_EVENTLIB_P_H*/

85
libc/upstream-netbsd/libc/stdlib/bsearch.c Normal file
View File

@@ -0,0 +1,85 @@
/* $NetBSD: bsearch.c,v 1.15 2012/03/04 20:01:45 christos Exp $ */
/*
* Copyright (c) 1990, 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)bsearch.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: bsearch.c,v 1.15 2012/03/04 20:01:45 christos Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
/*
* Perform a binary search.
*
* The code below is a bit sneaky. After a comparison fails, we
* divide the work in half by moving either left or right. If lim
* is odd, moving left simply involves halving lim: e.g., when lim
* is 5 we look at item 2, so we change lim to 2 so that we will
* look at items 0 & 1. If lim is even, the same applies. If lim
* is odd, moving right again involes halving lim, this time moving
* the base up one item past p: e.g., when lim is 5 we change base
* to item 3 and make lim 2 so that we will look at items 3 and 4.
* If lim is even, however, we have to shrink it by one before
* halving: e.g., when lim is 4, we still looked at item 2, so we
* have to make lim 3, then halve, obtaining 1, so that we will only
* look at item 3.
*/
void *
bsearch(const void *key, const void *base0, size_t nmemb, size_t size,
int (*compar)(const void *, const void *))
{
const char *base = base0;
size_t lim;
int cmp;
const void *p;
_DIAGASSERT(key != NULL);
_DIAGASSERT(base0 != NULL || nmemb == 0);
_DIAGASSERT(compar != NULL);
for (lim = nmemb; lim != 0; lim >>= 1) {
p = base + (lim >> 1) * size;
cmp = (*compar)(key, p);
if (cmp == 0)
return __UNCONST(p);
if (cmp > 0) { /* key > p: move right */
base = (const char *)p + size;
lim--;
} /* else move left */
}
return (NULL);
}

81
libc/upstream-netbsd/libc/stdlib/div.c Normal file
View File

@@ -0,0 +1,81 @@
/* $NetBSD: div.c,v 1.8 2012/06/25 22:32:45 abs Exp $ */
/*
* Copyright (c) 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Chris Torek.
*
* 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)div.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: div.c,v 1.8 2012/06/25 22:32:45 abs Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include <stdlib.h> /* div_t */
div_t
div(int num, int denom)
{
div_t r;
r.quot = num / denom;
r.rem = num % denom;
/*
* The ANSI standard says that |r.quot| <= |n/d|, where
* n/d is to be computed in infinite precision. In other
* words, we should always truncate the quotient towards
* 0, never -infinity.
*
* Machine division and remainer may work either way when
* one or both of n or d is negative. If only one is
* negative and r.quot has been truncated towards -inf,
* r.rem will have the same sign as denom and the opposite
* sign of num; if both are negative and r.quot has been
* truncated towards -inf, r.rem will be positive (will
* have the opposite sign of num). These are considered
* `wrong'.
*
* If both are num and denom are positive, r will always
* be positive.
*
* This all boils down to:
* if num >= 0, but r.rem < 0, we got the wrong answer.
* In that case, to get the right answer, add 1 to r.quot and
* subtract denom from r.rem.
*/
if (num >= 0 && r.rem < 0) {
r.quot++;
r.rem -= denom;
}
return (r);
}

60
libc/upstream-netbsd/libc/stdlib/ldiv.c Normal file
View File

@@ -0,0 +1,60 @@
/* $NetBSD: ldiv.c,v 1.8 2012/06/25 22:32:45 abs Exp $ */
/*
* Copyright (c) 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Chris Torek.
*
* 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)ldiv.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: ldiv.c,v 1.8 2012/06/25 22:32:45 abs Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include <stdlib.h> /* ldiv_t */
ldiv_t
ldiv(long num, long denom)
{
ldiv_t r;
/* see div.c for comments */
r.quot = num / denom;
r.rem = num % denom;
if (num >= 0 && r.rem < 0) {
r.quot++;
r.rem -= denom;
}
return (r);
}

66
libc/upstream-netbsd/libc/stdlib/lldiv.c Normal file
View File

@@ -0,0 +1,66 @@
/* $NetBSD: lldiv.c,v 1.4 2012/06/25 22:32:45 abs Exp $ */
/*
* Copyright (c) 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Chris Torek.
*
* 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "from: @(#)ldiv.c 8.1 (Berkeley) 6/4/93";
#else
__RCSID("$NetBSD: lldiv.c,v 1.4 2012/06/25 22:32:45 abs Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include "namespace.h"
#include <stdlib.h> /* lldiv_t */
#ifdef __weak_alias
__weak_alias(lldiv, _lldiv)
#endif
/* LONGLONG */
lldiv_t
lldiv(long long int num, long long int denom)
{
lldiv_t r;
/* see div.c for comments */
r.quot = num / denom;
r.rem = num % denom;
if (num >= 0 && r.rem < 0) {
r.quot++;
r.rem -= denom;
}
return (r);
}

56
libc/upstream-netbsd/libc/unistd/killpg.c Normal file
View File

@@ -0,0 +1,56 @@
/* $NetBSD: killpg.c,v 1.8 2003/08/07 16:42:39 agc Exp $ */
/*
* Copyright (c) 1989, 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. 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.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)killpg.c 8.1 (Berkeley) 6/2/93";
#else
__RCSID("$NetBSD: killpg.c,v 1.8 2003/08/07 16:42:39 agc Exp $");
#endif
#endif /* LIBC_SCCS and not lint */
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
/*
* Backwards-compatible killpg().
*/
int
killpg(pid_t pgid, int sig)
{
if (pgid == 1) {
errno = ESRCH;
return (-1);
}
return (kill(-pgid, sig));
}