diff --git a/duct/src/CMakeLists.txt b/duct/src/CMakeLists.txt index 8f9dc9ceb..0964e722b 100644 --- a/duct/src/CMakeLists.txt +++ b/duct/src/CMakeLists.txt @@ -19,5 +19,5 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -nostdinc -D__DARWIN_UNIX03 -fPIC -w") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -nostdlib -Wl,--unresolved-symbols=ignore-all") -add_library(system_duct SHARED commpage.c libnotify.c numcpus.c CRGetCrashLogMessage.c acl.c) +add_library(system_duct SHARED commpage.c libnotify.c numcpus.c CRGetCrashLogMessage.c acl.c bootstrap.c dyld.c dirhelper.c) diff --git a/duct/src/bootstrap.c b/duct/src/bootstrap.c new file mode 100644 index 000000000..cdb3bafca --- /dev/null +++ b/duct/src/bootstrap.c @@ -0,0 +1,13 @@ +int bootstrap_parent() +{ + return 0; +} + +void bootstrap_init(void) +{ +} + +void _libxpc_initializer(void) +{ +} + diff --git a/duct/src/dirhelper.c b/duct/src/dirhelper.c new file mode 100644 index 000000000..5a2bfaf51 --- /dev/null +++ b/duct/src/dirhelper.c @@ -0,0 +1,12 @@ +#include + +void _dirhelper_fork_child(void) +{ +} + +int _dirhelper() +{ + errno = ENOSYS; + return -1; +} + diff --git a/duct/src/dyld.c b/duct/src/dyld.c new file mode 100644 index 000000000..ace270941 --- /dev/null +++ b/duct/src/dyld.c @@ -0,0 +1,4 @@ +void _dyld_initializer(void) +{ +} + diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt index 990f6b009..0948cc580 100644 --- a/kernel/CMakeLists.txt +++ b/kernel/CMakeLists.txt @@ -79,9 +79,11 @@ add_definitions(-DHAVE_STDINT_H=1) add_definitions(-D__APPLE__ -D__DYNAMIC__) add_subdirectory(libsyscall) +add_subdirectory(mach_server/client) add_library(system_kernel SHARED - $) + $ + $) target_link_libraries(system_kernel system_duct) add_dependencies(system_kernel migcom) diff --git a/kernel/libsyscall/CMakeLists.txt b/kernel/libsyscall/CMakeLists.txt index 588695b04..7218db467 100644 --- a/kernel/libsyscall/CMakeLists.txt +++ b/kernel/libsyscall/CMakeLists.txt @@ -120,6 +120,7 @@ set(syscall_sources ${CMAKE_CURRENT_BINARY_DIR}/mach/taskUser.c ${CMAKE_CURRENT_BINARY_DIR}/mach/thread_actUser.c ${CMAKE_CURRENT_BINARY_DIR}/mach/vm_mapUser.c + ${CMAKE_CURRENT_BINARY_DIR}/mach/clockUser.c mach/mach_init.c mach/clock_sleep.c @@ -539,6 +540,7 @@ set(syscall_sources sys/writev.S ) +mig(mach/clock.defs) mig(mach/host_priv.defs) mig(mach/host_security.defs) mig(mach/ledger.defs) diff --git a/kernel/mach_server/client/CMakeLists.txt b/kernel/mach_server/client/CMakeLists.txt new file mode 100644 index 000000000..bbd43eb4b --- /dev/null +++ b/kernel/mach_server/client/CMakeLists.txt @@ -0,0 +1,12 @@ +project(mach_server_client) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -nostdinc") +include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../../platform-include") +include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../../libc/include") + +set(mach_server_client_sources + mach_traps.c + mach_time.c +) + +add_library(mach_server_client OBJECT ${mach_server_client_sources}) diff --git a/kernel/mach_server/client/mach_time.c b/kernel/mach_server/client/mach_time.c new file mode 100644 index 000000000..327ecc7fe --- /dev/null +++ b/kernel/mach_server/client/mach_time.c @@ -0,0 +1,20 @@ +#include +#include + +kern_return_t mach_timebase_info( + mach_timebase_info_t info) +{ + return KERN_FAILURE; +} + +kern_return_t mach_wait_until( + uint64_t deadline) +{ + return KERN_FAILURE; +} + + +uint64_t mach_absolute_time(void) +{ + return 0; +} diff --git a/kernel/mach_server/client/mach_traps.c b/kernel/mach_server/client/mach_traps.c new file mode 100644 index 000000000..283903322 --- /dev/null +++ b/kernel/mach_server/client/mach_traps.c @@ -0,0 +1,344 @@ +#define PRIVATE +#include +#include + +mach_port_name_t mach_reply_port(void) +{ + return 0; +} + +mach_port_name_t thread_self_trap(void) +{ + return 0; +} + +mach_port_name_t host_self_trap(void) +{ + return 0; +} + +mach_msg_return_t mach_msg_trap( + mach_msg_header_t *msg, + mach_msg_option_t option, + mach_msg_size_t send_size, + mach_msg_size_t rcv_size, + mach_port_name_t rcv_name, + mach_msg_timeout_t timeout, + mach_port_name_t notify) +{ + return KERN_FAILURE; +} + +mach_msg_return_t mach_msg_overwrite_trap( + mach_msg_header_t *msg, + mach_msg_option_t option, + mach_msg_size_t send_size, + mach_msg_size_t rcv_size, + mach_port_name_t rcv_name, + mach_msg_timeout_t timeout, + mach_port_name_t notify, + mach_msg_header_t *rcv_msg, + mach_msg_size_t rcv_limit) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_signal_trap( + mach_port_name_t signal_name) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_signal_all_trap( + mach_port_name_t signal_name) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_signal_thread_trap( + mach_port_name_t signal_name, + mach_port_name_t thread_name) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_wait_trap( + mach_port_name_t wait_name) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_wait_signal_trap( + mach_port_name_t wait_name, + mach_port_name_t signal_name) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_timedwait_trap( + mach_port_name_t wait_name, + unsigned int sec, + clock_res_t nsec) +{ + return KERN_FAILURE; +} + +kern_return_t semaphore_timedwait_signal_trap( + mach_port_name_t wait_name, + mach_port_name_t signal_name, + unsigned int sec, + clock_res_t nsec) +{ + return KERN_FAILURE; +} + +kern_return_t clock_sleep_trap( + mach_port_name_t clock_name, + sleep_type_t sleep_type, + int sleep_sec, + int sleep_nsec, + mach_timespec_t *wakeup_time) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_vm_allocate_trap( + mach_port_name_t target, + mach_vm_offset_t *addr, + mach_vm_size_t size, + int flags) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_vm_deallocate_trap( + mach_port_name_t target, + mach_vm_address_t address, + mach_vm_size_t size +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_vm_protect_trap( + mach_port_name_t target, + mach_vm_address_t address, + mach_vm_size_t size, + boolean_t set_maximum, + vm_prot_t new_protection +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_vm_map_trap( + mach_port_name_t target, + mach_vm_offset_t *address, + mach_vm_size_t size, + mach_vm_offset_t mask, + int flags, + vm_prot_t cur_protection +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_allocate_trap( + mach_port_name_t target, + mach_port_right_t right, + mach_port_name_t *name +) +{ + return KERN_FAILURE; +} + + +kern_return_t _kernelrpc_mach_port_destroy_trap( + mach_port_name_t target, + mach_port_name_t name +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_deallocate_trap( + mach_port_name_t target, + mach_port_name_t name +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_mod_refs_trap( + mach_port_name_t target, + mach_port_name_t name, + mach_port_right_t right, + mach_port_delta_t delta +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_move_member_trap( + mach_port_name_t target, + mach_port_name_t member, + mach_port_name_t after +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_insert_right_trap( + mach_port_name_t target, + mach_port_name_t name, + mach_port_name_t poly, + mach_msg_type_name_t polyPoly +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_insert_member_trap( + mach_port_name_t target, + mach_port_name_t name, + mach_port_name_t pset +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_extract_member_trap( + mach_port_name_t target, + mach_port_name_t name, + mach_port_name_t pset +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_construct_trap( + mach_port_name_t target, + mach_port_options_t *options, + uint64_t context, + mach_port_name_t *name +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_destruct_trap( + mach_port_name_t target, + mach_port_name_t name, + mach_port_delta_t srdelta, + uint64_t guard +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_guard_trap( + mach_port_name_t target, + mach_port_name_t name, + uint64_t guard, + boolean_t strict +) +{ + return KERN_FAILURE; +} + +kern_return_t _kernelrpc_mach_port_unguard_trap( + mach_port_name_t target, + mach_port_name_t name, + uint64_t guard +) +{ + return KERN_FAILURE; +} + +kern_return_t macx_swapon( + uint64_t filename, + int flags, + int size, + int priority) +{ + return KERN_FAILURE; +} + +kern_return_t macx_swapoff( + uint64_t filename, + int flags) +{ + return KERN_FAILURE; +} + +kern_return_t macx_triggers( + int hi_water, + int low_water, + int flags, + mach_port_t alert_port) +{ + return KERN_FAILURE; +} + +kern_return_t macx_backing_store_suspend( + boolean_t suspend) +{ + return KERN_FAILURE; +} + +kern_return_t macx_backing_store_recovery( + int pid) +{ + return KERN_FAILURE; +} + +boolean_t swtch_pri(int pri) +{ + return 0; +} + +boolean_t swtch(void) +{ + return 0; +} + +kern_return_t syscall_thread_switch( + mach_port_name_t thread_name, + int option, + mach_msg_timeout_t option_time) +{ + return KERN_FAILURE; +} + +mach_port_name_t task_self_trap(void) +{ + return 0; +} + +/* + * Obsolete interfaces. + */ + +kern_return_t task_for_pid( + mach_port_name_t target_tport, + int pid, + mach_port_name_t *t) +{ + return KERN_FAILURE; +} + +kern_return_t task_name_for_pid( + mach_port_name_t target_tport, + int pid, + mach_port_name_t *tn) +{ + return KERN_FAILURE; +} + +kern_return_t pid_for_task( + mach_port_name_t t, + int *x) +{ + return KERN_FAILURE; +} + diff --git a/libc/CMakeLists.txt b/libc/CMakeLists.txt index 7f8b17da1..72886bc8f 100644 --- a/libc/CMakeLists.txt +++ b/libc/CMakeLists.txt @@ -19,6 +19,7 @@ add_definitions(-D__LIBC__ -D__DARWIN_UNIX03=1 -D__DARWIN_64_BIT_INO_T=1 -D__DAR #add_definitions("'-D__weak_reference(sym,alias)=__asm__(\".weak \" \\\#alias );__asm__(\".equ \" \\\#alias \", \" \\\#sym)'") #add_definitions("'-D__weak_reference(sym,alias)='") add_definitions("'-D__warn_references(name,warning)='") +add_definitions(-Ddladdr=__darwin_dladdr) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -nostdinc -D__DARWIN_UNIX03 -fPIC -w ") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -include ${CMAKE_CURRENT_SOURCE_DIR}/weak_reference.h") @@ -55,6 +56,7 @@ add_subdirectory(posix1e) add_subdirectory(nls) add_subdirectory(net) add_subdirectory(locale) +add_subdirectory(threads) # The following generate libc-hwplat if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "i686") @@ -94,6 +96,7 @@ add_library(system_c SHARED $ $ $ + $ $) # TODO: see ./xcodescripts/variants.xcconfig diff --git a/libc/net/CMakeLists.txt b/libc/net/CMakeLists.txt index d12f097dc..5d4895bbd 100644 --- a/libc/net/CMakeLists.txt +++ b/libc/net/CMakeLists.txt @@ -25,6 +25,8 @@ set(net_sources FreeBSD/send.c FreeBSD/sockatmark.c FreeBSD/sourcefilter.c + inet_ntop.c + inet_pton.c ) add_library(libc-net OBJECT ${net_sources}) diff --git a/libc/net/inet_ntop.c b/libc/net/inet_ntop.c new file mode 100644 index 000000000..a4c977d73 --- /dev/null +++ b/libc/net/inet_ntop.c @@ -0,0 +1,206 @@ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define MAX_V4_ADDR_LEN 16 +#define MAX_V6_ADDR_LEN 64 + +static const char *hexchars = "0123456789abcdef"; + +const char * +inet_ntop6(const struct in6_addr *addr, char *dst, socklen_t size) +{ + char hexa[8][5], tmp[MAX_V6_ADDR_LEN]; + int zr[8]; + socklen_t len; + int32_t i, j, k, skip; + uint8_t x8, hx8; + uint16_t x16; + struct in_addr a4; + + if (addr == NULL) + { + errno = EAFNOSUPPORT; + return NULL; + } + + if (dst == NULL) + { + errno = ENOSPC; + return NULL; + } + + memset(tmp, 0, MAX_V6_ADDR_LEN); + + /* check for mapped or compat addresses */ + i = IN6_IS_ADDR_V4MAPPED(addr); + j = IN6_IS_ADDR_V4COMPAT(addr); + if ((i != 0) || (j != 0)) + { + a4.s_addr = addr->__u6_addr.__u6_addr32[3]; + sprintf(tmp, "::%s%s", (i != 0) ? "ffff:" : "", inet_ntoa(a4)); + len = strlen(tmp) + 1; + if (len > size) + { + errno = ENOSPC; + return NULL; + } + + memcpy(dst, tmp, len); + return dst; + } + + k = 0; + for (i = 0; i < 16; i += 2) + { + j = 0; + skip = 1; + + memset(hexa[k], 0, 5); + + x8 = addr->__u6_addr.__u6_addr8[i]; + + hx8 = x8 >> 4; + if (hx8 != 0) + { + skip = 0; + hexa[k][j++] = hexchars[hx8]; + } + + hx8 = x8 & 0x0f; + if ((skip == 0) || ((skip == 1) && (hx8 != 0))) + { + skip = 0; + hexa[k][j++] = hexchars[hx8]; + } + + x8 = addr->__u6_addr.__u6_addr8[i + 1]; + + hx8 = x8 >> 4; + if ((skip == 0) || ((skip == 1) && (hx8 != 0))) + { + hexa[k][j++] = hexchars[hx8]; + } + + hx8 = x8 & 0x0f; + hexa[k][j++] = hexchars[hx8]; + + k++; + } + + /* find runs of zeros for :: convention */ + j = 0; + for (i = 7; i >= 0; i--) + { + zr[i] = j; + x16 = addr->__u6_addr.__u6_addr16[i]; + if (x16 == 0) j++; + else j = 0; + zr[i] = j; + } + + /* find longest run of zeros */ + k = -1; + j = 0; + for(i = 0; i < 8; i++) + { + if (zr[i] > j) + { + k = i; + j = zr[i]; + } + } + + for(i = 0; i < 8; i++) + { + if (i != k) zr[i] = 0; + } + + len = 0; + for (i = 0; i < 8; i++) + { + if (zr[i] != 0) + { + /* check for leading zero */ + if (i == 0) tmp[len++] = ':'; + tmp[len++] = ':'; + i += (zr[i] - 1); + continue; + } + for (j = 0; hexa[i][j] != '\0'; j++) tmp[len++] = hexa[i][j]; + if (i != 7) tmp[len++] = ':'; + } + + /* trailing NULL */ + len++; + + if (len > size) + { + errno = ENOSPC; + return NULL; + } + + memcpy(dst, tmp, len); + return dst; +} + +const char * +inet_ntop4(const struct in_addr *addr, char *dst, socklen_t size) +{ + char tmp[MAX_V4_ADDR_LEN], *p; + const u_int8_t *ap = (u_int8_t *)&addr->s_addr; + int i, ql, len; + + if (addr == NULL) + { + errno = EAFNOSUPPORT; + return NULL; + } + + if (dst == NULL) + { + errno = ENOSPC; + return NULL; + } + + memset(tmp, 0, MAX_V4_ADDR_LEN); + + /* 3 dots, trailing nul */ + len = 4; + + p = tmp; + + for (i = 0; i < 4; i++, ap++) + { + snprintf(p, 4, "%d", *ap); + ql = strlen(p); + len += ql; + p += ql; + if (i < 3) *p++ = '.'; + } + + if (len > size) + { + errno = ENOSPC; + return NULL; + } + + memcpy(dst, tmp, len); + return dst; +} + +const char * +inet_ntop(int af, const void *addr, char *buf, socklen_t len) +{ + if (af == AF_INET6) return inet_ntop6(addr, buf, len); + if (af == AF_INET) return inet_ntop4(addr, buf, len); + + errno = EAFNOSUPPORT; + return NULL; +} diff --git a/libc/net/inet_pton.c b/libc/net/inet_pton.c new file mode 100644 index 000000000..9989548dc --- /dev/null +++ b/libc/net/inet_pton.c @@ -0,0 +1,292 @@ +/* + * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS + * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE + * CONSORTIUM 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. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char rcsid[] = "$Id: inet_pton.c,v 1.3 2003/04/10 18:53:29 majka Exp $"; +#endif /* LIBC_SCCS and not lint */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define INET6 1 + +#define IN6ADDRSZ 16 + +#if 0 +#ifndef HAVE_PORTABLE_PROTOTYPE +#include "cdecl_ext.h" +#endif + +#ifndef HAVE_U_INT16_T +#include "bittypes.h" +#endif +#if !(defined(HAVE_INADDRSZ) && defined(HAVE_IN6ADDRSZ)) +#include "addrsize.h" +#endif +#endif +#ifndef NS_INADDRSZ +#define NS_INADDRSZ INADDRSZ +#endif +#ifndef NS_IN6ADDRSZ +#define NS_IN6ADDRSZ IN6ADDRSZ +#endif +#ifndef NS_INT16SZ +#define NS_INT16SZ sizeof(u_int16_t) +#endif + +/* + * WARNING: Don't even consider trying to compile this on a system where + * sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX. + */ + +static int inet_pton4 __P((const char *src, u_char *dst)); +#ifdef INET6 +static int inet_pton6 __P((const char *src, u_char *dst)); +#endif + +/* int + * inet_pton(af, src, dst) + * convert from presentation format (which usually means ASCII printable) + * to network format (which is usually some kind of binary format). + * return: + * 1 if the address was valid for the specified address family + * 0 if the address wasn't valid (`dst' is untouched in this case) + * -1 if some other error occurred (`dst' is untouched in this case, too) + * author: + * Paul Vixie, 1996. + */ +int +inet_pton(int af, const char *src, void *dst) +{ + int status; + unsigned short ifnum; + char *p, *s; + + switch (af) + { + case AF_INET: + { + return (inet_pton4(src, dst)); + } + +#ifdef INET6 + case AF_INET6: + { + ifnum = 0; + p = NULL; + s = (char *)src; + + if (src != NULL) p = strrchr(src, '%'); + if (p != NULL) + { + s = strdup(src); + if (s == NULL) + { + errno = ENOMEM; + return -1; + } + + s[p - src] = '\0'; + } + + status = inet_pton6(s, dst); + if (p != NULL) free(s); + if (status != 1) return status; + + if ((p != NULL) && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)dst)) + { + ifnum = if_nametoindex(++p); + ifnum = htons(ifnum); + ((struct in6_addr *)dst)->__u6_addr.__u6_addr16[1] = ifnum; + } + + return 1; + } +#endif + + default: + { + errno = EAFNOSUPPORT; + return -1; + } + } + + /* NOTREACHED */ + return -1; +} + +/* int + * inet_pton4(src, dst) + * like inet_aton() but without all the hexadecimal and shorthand. + * return: + * 1 if `src' is a valid dotted quad, else 0. + * notice: + * does not touch `dst' unless it's returning 1. + * author: + * Paul Vixie, 1996. + */ +static int +inet_pton4(const char *src, u_char *dst) +{ + static const char digits[] = "0123456789"; + int saw_digit, octets, ch; + u_char tmp[NS_INADDRSZ], *tp; + + saw_digit = 0; + octets = 0; + *(tp = tmp) = 0; + while ((ch = *src++) != '\0') { + const char *pch; + + if ((pch = strchr(digits, ch)) != NULL) { + u_int new = *tp * 10 + (pch - digits); + + if (new > 255) + return (0); + *tp = new; + if (! saw_digit) { + if (++octets > 4) + return (0); + saw_digit = 1; + } + } else if (ch == '.' && saw_digit) { + if (octets == 4) + return (0); + *++tp = 0; + saw_digit = 0; + } else + return (0); + } + if (octets < 4) + return (0); + memcpy(dst, tmp, NS_INADDRSZ); + return (1); +} + +#ifdef INET6 +/* int + * inet_pton6(src, dst) + * convert presentation level address to network order binary form. + * return: + * 1 if `src' is a valid [RFC1884 2.2] address, else 0. + * notice: + * (1) does not touch `dst' unless it's returning 1. + * (2) :: in a full address is silently ignored. + * credit: + * inspired by Mark Andrews. + * author: + * Paul Vixie, 1996. + */ +static int +inet_pton6(const char *src, u_char *dst) +{ + static const char xdigits_l[] = "0123456789abcdef", + xdigits_u[] = "0123456789ABCDEF"; + u_char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp; + const char *xdigits, *curtok; + int ch, saw_xdigit; + u_int val; + + memset((tp = tmp), '\0', NS_IN6ADDRSZ); + endp = tp + NS_IN6ADDRSZ; + colonp = NULL; + /* Leading :: requires some special handling. */ + if (*src == ':') + if (*++src != ':') + return (0); + curtok = src; + saw_xdigit = 0; + val = 0; + while ((ch = *src++) != '\0') { + const char *pch; + + if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL) + pch = strchr((xdigits = xdigits_u), ch); + if (pch != NULL) { + val <<= 4; + val |= (pch - xdigits); + if (val > 0xffff) + return (0); + saw_xdigit = 1; + continue; + } + if (ch == ':') { + curtok = src; + if (!saw_xdigit) { + if (colonp) + return (0); + colonp = tp; + continue; + } else if (*src == '\0') { + return (0); + } + if (tp + NS_INT16SZ > endp) + return (0); + *tp++ = (u_char) (val >> 8) & 0xff; + *tp++ = (u_char) val & 0xff; + saw_xdigit = 0; + val = 0; + continue; + } + if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) && + inet_pton4(curtok, tp) > 0) { + tp += NS_INADDRSZ; + saw_xdigit = 0; + break; /* '\0' was seen by inet_pton4(). */ + } + return (0); + } + if (saw_xdigit) { + if (tp + NS_INT16SZ > endp) + return (0); + *tp++ = (u_char) (val >> 8) & 0xff; + *tp++ = (u_char) val & 0xff; + } + if (colonp != NULL) { + /* + * Since some memmove()'s erroneously fail to handle + * overlapping regions, we'll do the shift by hand. + */ + const int n = tp - colonp; + int i; + + if (tp == endp) + return (0); + for (i = 1; i <= n; i++) { + endp[- i] = colonp[n - i]; + colonp[n - i] = 0; + } + tp = endp; + } + if (tp != endp) + return (0); + memcpy(dst, tmp, NS_IN6ADDRSZ); + return (1); +} +#endif /*INET6*/ diff --git a/libc/pthreads/pthread.c b/libc/pthreads/pthread.c index d6d116c3e..cf784d3db 100644 --- a/libc/pthreads/pthread.c +++ b/libc/pthreads/pthread.c @@ -1,3 +1,4 @@ +// Modified by Lubos Dolezel for Darling /* * Copyright (c) 2000-2008 Apple Inc. All rights reserved. * @@ -2055,7 +2056,7 @@ pthread_once(pthread_once_t *once_control, /* * Insert a cancellation point in a thread. */ -__private_extern__ void +/*__private_extern__*/ void // accessed by libsystem.dylib _pthread_testcancel(pthread_t thread, int isconforming) { LOCK(thread->lock); diff --git a/libc/sys/gettimeofday.c b/libc/sys/gettimeofday.c index 56d931267..75830eabf 100644 --- a/libc/sys/gettimeofday.c +++ b/libc/sys/gettimeofday.c @@ -1,3 +1,4 @@ +// Modified by Lubos Dolezel for Darling /* * Copyright (c) 2003-2005 Apple Computer, Inc. All rights reserved. * @@ -52,11 +53,11 @@ int gettimeofday (struct timeval *tp, void *vtzp) tp = &atv; } - if (__commpage_gettimeofday(tp)) { /* first try commpage */ + //if (__commpage_gettimeofday(tp)) { /* first try commpage */ if (__gettimeofday(tp, NULL) < 0) { /* if it fails, use syscall */ return (-1); } - } + //} if (tzp) { if (validtz == 0) { diff --git a/libc/threads/CMakeLists.txt b/libc/threads/CMakeLists.txt new file mode 100644 index 000000000..db4ee3c49 --- /dev/null +++ b/libc/threads/CMakeLists.txt @@ -0,0 +1,13 @@ +project(libc-threads) + +cmake_minimum_required(VERSION 2.4.0) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -include ${CMAKE_CURRENT_SOURCE_DIR}/../fbsdcompat/_fbsd_compat_.h") + +set(threads_sources + cprocs.c + cthreads.c + mig_support.c +) + +add_library(libc-threads OBJECT ${threads_sources}) diff --git a/libsystem/CMakeLists.txt b/libsystem/CMakeLists.txt index 7d10c6191..264c975a2 100644 --- a/libsystem/CMakeLists.txt +++ b/libsystem/CMakeLists.txt @@ -19,6 +19,7 @@ endif(CMAKE_SIZEOF_VOID_P EQUAL 4 OR CMAKE_INSTALL_LIBDIR STREQUAL "lib32") add_definitions(-DTARGET_OS_MAC=1) add_definitions(-DHAVE_STDINT_H=1) add_definitions(-D__APPLE__ -D__DYNAMIC__) +add_definitions(-Ddlsym=__darwin_dlsym) set(libsystem_sources init.c diff --git a/libsystem/init.c b/libsystem/init.c index 91f07b74f..d2819454a 100644 --- a/libsystem/init.c +++ b/libsystem/init.c @@ -92,7 +92,7 @@ void libSystem_initializer(int argc, const char* argv[], const char* envp[], con ._pthread_exit_if_canceled = _pthread_exit_if_canceled, }; - _libkernel_init(libkernel_funcs); + __libkernel_init(&libkernel_funcs, envp, apple, vars); bootstrap_init(); mach_init(); diff --git a/platform-include/mach/mach_traps.h b/platform-include/mach/mach_traps.h index 604ebea73..c33a308f4 100644 --- a/platform-include/mach/mach_traps.h +++ b/platform-include/mach/mach_traps.h @@ -81,7 +81,65 @@ __BEGIN_DECLS - +#ifndef KERNEL + +#ifdef PRIVATE + +extern mach_port_name_t mach_reply_port(void); + +extern mach_port_name_t thread_self_trap(void); + +extern mach_port_name_t host_self_trap(void); + +extern mach_msg_return_t mach_msg_trap( + mach_msg_header_t *msg, + mach_msg_option_t option, + mach_msg_size_t send_size, + mach_msg_size_t rcv_size, + mach_port_name_t rcv_name, + mach_msg_timeout_t timeout, + mach_port_name_t notify); + +extern mach_msg_return_t mach_msg_overwrite_trap( + mach_msg_header_t *msg, + mach_msg_option_t option, + mach_msg_size_t send_size, + mach_msg_size_t rcv_size, + mach_port_name_t rcv_name, + mach_msg_timeout_t timeout, + mach_port_name_t notify, + mach_msg_header_t *rcv_msg, + mach_msg_size_t rcv_limit); + +extern kern_return_t semaphore_signal_trap( + mach_port_name_t signal_name); + +extern kern_return_t semaphore_signal_all_trap( + mach_port_name_t signal_name); + +extern kern_return_t semaphore_signal_thread_trap( + mach_port_name_t signal_name, + mach_port_name_t thread_name); + +extern kern_return_t semaphore_wait_trap( + mach_port_name_t wait_name); + +extern kern_return_t semaphore_wait_signal_trap( + mach_port_name_t wait_name, + mach_port_name_t signal_name); + +extern kern_return_t semaphore_timedwait_trap( + mach_port_name_t wait_name, + unsigned int sec, + clock_res_t nsec); + +extern kern_return_t semaphore_timedwait_signal_trap( + mach_port_name_t wait_name, + mach_port_name_t signal_name, + unsigned int sec, + clock_res_t nsec); + +#endif /* PRIVATE */ extern kern_return_t clock_sleep_trap( mach_port_name_t clock_name, @@ -246,6 +304,437 @@ extern kern_return_t pid_for_task( mach_port_name_t t, int *x); +#else /* KERNEL */ + +#ifdef XNU_KERNEL_PRIVATE + +/* Syscall data translations routines + * + * The kernel may support multiple userspace ABIs, and must use + * argument structures with elements large enough for any of them. + */ +#if CONFIG_REQUIRES_U32_MUNGING +#define PAD_(t) (sizeof(uint64_t) <= sizeof(t) \ + ? 0 : sizeof(uint64_t) - sizeof(t)) +#define PAD_ARG_8 +#else +#define PAD_(t) (sizeof(uint32_t) <= sizeof(t) \ + ? 0 : sizeof(uint32_t) - sizeof(t)) +#define PAD_ARG_8 char arg8_pad_[sizeof(uint32_t)]; +#endif + +#if BYTE_ORDER == LITTLE_ENDIAN +#define PADL_(t) 0 +#define PADR_(t) PAD_(t) +#else +#define PADL_(t) PAD_(t) +#define PADR_(t) 0 +#endif + +#define PAD_ARG_(arg_type, arg_name) \ + char arg_name##_l_[PADL_(arg_type)]; arg_type arg_name; char arg_name##_r_[PADR_(arg_type)]; + +/* + * To support 32-bit clients as well as 64-bit clients, argument + * structures may need to be munged to repack the arguments. All + * active architectures do this inline in the code to dispatch Mach + * traps, without calling out to the BSD system call mungers. + */ + +struct kern_invalid_args { + int32_t dummy; +}; +extern kern_return_t kern_invalid( + struct kern_invalid_args *args); + +struct mach_reply_port_args { + int32_t dummy; +}; +extern mach_port_name_t mach_reply_port( + struct mach_reply_port_args *args); + +struct thread_self_trap_args { + int32_t dummy; +}; +extern mach_port_name_t thread_self_trap( + struct thread_self_trap_args *args); + +struct task_self_trap_args { + int32_t dummy; +}; +extern mach_port_name_t task_self_trap( + struct task_self_trap_args *args); + +struct host_self_trap_args { + int32_t dummy; +}; +extern mach_port_name_t host_self_trap( + struct host_self_trap_args *args); + +struct mach_msg_overwrite_trap_args { + PAD_ARG_(user_addr_t, msg); + PAD_ARG_(mach_msg_option_t, option); + PAD_ARG_(mach_msg_size_t, send_size); + PAD_ARG_(mach_msg_size_t, rcv_size); + PAD_ARG_(mach_port_name_t, rcv_name); + PAD_ARG_(mach_msg_timeout_t, timeout); + PAD_ARG_(mach_port_name_t, notify); + PAD_ARG_8 + PAD_ARG_(user_addr_t, rcv_msg); /* Unused on mach_msg_trap */ +}; +extern mach_msg_return_t mach_msg_trap( + struct mach_msg_overwrite_trap_args *args); +extern mach_msg_return_t mach_msg_overwrite_trap( + struct mach_msg_overwrite_trap_args *args); + +struct semaphore_signal_trap_args { + PAD_ARG_(mach_port_name_t, signal_name); +}; +extern kern_return_t semaphore_signal_trap( + struct semaphore_signal_trap_args *args); + +struct semaphore_signal_all_trap_args { + PAD_ARG_(mach_port_name_t, signal_name); +}; +extern kern_return_t semaphore_signal_all_trap( + struct semaphore_signal_all_trap_args *args); + +struct semaphore_signal_thread_trap_args { + PAD_ARG_(mach_port_name_t, signal_name); + PAD_ARG_(mach_port_name_t, thread_name); +}; +extern kern_return_t semaphore_signal_thread_trap( + struct semaphore_signal_thread_trap_args *args); + +struct semaphore_wait_trap_args { + PAD_ARG_(mach_port_name_t, wait_name); +}; +extern kern_return_t semaphore_wait_trap( + struct semaphore_wait_trap_args *args); + +struct semaphore_wait_signal_trap_args { + PAD_ARG_(mach_port_name_t, wait_name); + PAD_ARG_(mach_port_name_t, signal_name); +}; +extern kern_return_t semaphore_wait_signal_trap( + struct semaphore_wait_signal_trap_args *args); + +struct semaphore_timedwait_trap_args { + PAD_ARG_(mach_port_name_t, wait_name); + PAD_ARG_(unsigned int, sec); + PAD_ARG_(clock_res_t, nsec); +}; +extern kern_return_t semaphore_timedwait_trap( + struct semaphore_timedwait_trap_args *args); + +struct semaphore_timedwait_signal_trap_args { + PAD_ARG_(mach_port_name_t, wait_name); + PAD_ARG_(mach_port_name_t, signal_name); + PAD_ARG_(unsigned int, sec); + PAD_ARG_(clock_res_t, nsec); +}; +extern kern_return_t semaphore_timedwait_signal_trap( + struct semaphore_timedwait_signal_trap_args *args); + +struct task_for_pid_args { + PAD_ARG_(mach_port_name_t, target_tport); + PAD_ARG_(int, pid); + PAD_ARG_(user_addr_t, t); +}; +extern kern_return_t task_for_pid( + struct task_for_pid_args *args); + +struct task_name_for_pid_args { + PAD_ARG_(mach_port_name_t, target_tport); + PAD_ARG_(int, pid); + PAD_ARG_(user_addr_t, t); +}; +extern kern_return_t task_name_for_pid( + struct task_name_for_pid_args *args); + +struct pid_for_task_args { + PAD_ARG_(mach_port_name_t, t); + PAD_ARG_(user_addr_t, pid); +}; +extern kern_return_t pid_for_task( + struct pid_for_task_args *args); + +struct macx_swapon_args { + PAD_ARG_(uint64_t, filename); + PAD_ARG_(int, flags); + PAD_ARG_(int, size); + PAD_ARG_(int, priority); +}; +extern kern_return_t macx_swapon( + struct macx_swapon_args *args); + +struct macx_swapoff_args { + PAD_ARG_(uint64_t, filename); + PAD_ARG_(int, flags); +}; +extern kern_return_t macx_swapoff( + struct macx_swapoff_args *args); + +struct macx_triggers_args { + PAD_ARG_(int, hi_water); + PAD_ARG_(int, low_water); + PAD_ARG_(int, flags); + PAD_ARG_(mach_port_t, alert_port); +}; +extern kern_return_t macx_triggers( + struct macx_triggers_args *args); + +struct macx_backing_store_suspend_args { + PAD_ARG_(boolean_t, suspend); +}; +extern kern_return_t macx_backing_store_suspend( + struct macx_backing_store_suspend_args *args); + +struct macx_backing_store_recovery_args { + PAD_ARG_(int, pid); +}; +extern kern_return_t macx_backing_store_recovery( + struct macx_backing_store_recovery_args *args); + +struct swtch_pri_args { + PAD_ARG_(int, pri); +}; +extern boolean_t swtch_pri( + struct swtch_pri_args *args); + +struct pfz_exit_args { + int32_t dummy; +}; +extern kern_return_t pfz_exit( + struct pfz_exit_args *args); + +struct swtch_args { + int32_t dummy; +}; +extern boolean_t swtch( + struct swtch_args *args); + +struct clock_sleep_trap_args{ + PAD_ARG_(mach_port_name_t, clock_name); + PAD_ARG_(sleep_type_t, sleep_type); + PAD_ARG_(int, sleep_sec); + PAD_ARG_(int, sleep_nsec); + PAD_ARG_(user_addr_t, wakeup_time); +}; +extern kern_return_t clock_sleep_trap( + struct clock_sleep_trap_args *args); + +struct thread_switch_args { + PAD_ARG_(mach_port_name_t, thread_name); + PAD_ARG_(int, option); + PAD_ARG_(mach_msg_timeout_t, option_time); +}; +extern kern_return_t thread_switch( + struct thread_switch_args *args); + +struct mach_timebase_info_trap_args { + PAD_ARG_(user_addr_t, info); +}; +extern kern_return_t mach_timebase_info_trap( + struct mach_timebase_info_trap_args *args); + +struct mach_wait_until_trap_args { + PAD_ARG_(uint64_t, deadline); +}; +extern kern_return_t mach_wait_until_trap( + struct mach_wait_until_trap_args *args); + +struct mk_timer_create_trap_args { + int32_t dummy; +}; +extern mach_port_name_t mk_timer_create_trap( + struct mk_timer_create_trap_args *args); + +struct mk_timer_destroy_trap_args { + PAD_ARG_(mach_port_name_t, name); +}; +extern kern_return_t mk_timer_destroy_trap( + struct mk_timer_destroy_trap_args *args); + +struct mk_timer_arm_trap_args { + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(uint64_t, expire_time); +}; +extern kern_return_t mk_timer_arm_trap( + struct mk_timer_arm_trap_args *args); + +struct mk_timer_cancel_trap_args { + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(user_addr_t, result_time); +}; +extern kern_return_t mk_timer_cancel_trap( + struct mk_timer_cancel_trap_args *args); + +struct _kernelrpc_mach_vm_allocate_trap_args { + PAD_ARG_(mach_port_name_t, target); /* 1 word */ + PAD_ARG_(user_addr_t, addr); /* 1 word */ + PAD_ARG_(mach_vm_size_t, size); /* 2 words */ + PAD_ARG_(int, flags); /* 1 word */ +}; /* Total: 5 */ + +extern kern_return_t _kernelrpc_mach_vm_allocate_trap( + struct _kernelrpc_mach_vm_allocate_trap_args *args); + +struct _kernelrpc_mach_vm_deallocate_args { + PAD_ARG_(mach_port_name_t, target); /* 1 word */ + PAD_ARG_(mach_vm_address_t, address); /* 2 words */ + PAD_ARG_(mach_vm_size_t, size); /* 2 words */ +}; /* Total: 5 */ +extern kern_return_t _kernelrpc_mach_vm_deallocate_trap( + struct _kernelrpc_mach_vm_deallocate_args *args); + +struct _kernelrpc_mach_vm_protect_args { + PAD_ARG_(mach_port_name_t, target); /* 1 word */ + PAD_ARG_(mach_vm_address_t, address); /* 2 words */ + PAD_ARG_(mach_vm_size_t, size); /* 2 words */ + PAD_ARG_(boolean_t, set_maximum); /* 1 word */ + PAD_ARG_(vm_prot_t, new_protection); /* 1 word */ +}; /* Total: 7 */ +extern kern_return_t _kernelrpc_mach_vm_protect_trap( + struct _kernelrpc_mach_vm_protect_args *args); + +struct _kernelrpc_mach_vm_map_trap_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(user_addr_t, addr); + PAD_ARG_(mach_vm_size_t, size); + PAD_ARG_(mach_vm_offset_t, mask); + PAD_ARG_(int, flags); + PAD_ARG_8 + PAD_ARG_(vm_prot_t, cur_protection); +}; +extern kern_return_t _kernelrpc_mach_vm_map_trap( + struct _kernelrpc_mach_vm_map_trap_args *args); + +struct _kernelrpc_mach_port_allocate_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_right_t, right); + PAD_ARG_(user_addr_t, name); +}; +extern kern_return_t _kernelrpc_mach_port_allocate_trap( + struct _kernelrpc_mach_port_allocate_args *args); + + +struct _kernelrpc_mach_port_destroy_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); +}; +extern kern_return_t _kernelrpc_mach_port_destroy_trap( + struct _kernelrpc_mach_port_destroy_args *args); + +struct _kernelrpc_mach_port_deallocate_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); +}; +extern kern_return_t _kernelrpc_mach_port_deallocate_trap( + struct _kernelrpc_mach_port_deallocate_args *args); + +struct _kernelrpc_mach_port_mod_refs_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(mach_port_right_t, right); + PAD_ARG_(mach_port_delta_t, delta); +}; +extern kern_return_t _kernelrpc_mach_port_mod_refs_trap( + struct _kernelrpc_mach_port_mod_refs_args *args); + +struct _kernelrpc_mach_port_move_member_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, member); + PAD_ARG_(mach_port_name_t, after); +}; +extern kern_return_t _kernelrpc_mach_port_move_member_trap( + struct _kernelrpc_mach_port_move_member_args *args); + +struct _kernelrpc_mach_port_insert_right_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(mach_port_name_t, poly); + PAD_ARG_(mach_msg_type_name_t, polyPoly); +}; +extern kern_return_t _kernelrpc_mach_port_insert_right_trap( + struct _kernelrpc_mach_port_insert_right_args *args); + +struct _kernelrpc_mach_port_insert_member_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(mach_port_name_t, pset); +}; +extern kern_return_t _kernelrpc_mach_port_insert_member_trap( + struct _kernelrpc_mach_port_insert_member_args *args); + +struct _kernelrpc_mach_port_extract_member_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(mach_port_name_t, pset); +}; +extern kern_return_t _kernelrpc_mach_port_extract_member_trap( + struct _kernelrpc_mach_port_extract_member_args *args); + +struct _kernelrpc_mach_port_construct_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(user_addr_t, options); + PAD_ARG_(uint64_t, context); + PAD_ARG_(user_addr_t, name); +}; +extern kern_return_t _kernelrpc_mach_port_construct_trap( + struct _kernelrpc_mach_port_construct_args *args); + +struct _kernelrpc_mach_port_destruct_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(mach_port_delta_t, srdelta); + PAD_ARG_(uint64_t, guard); +}; +extern kern_return_t _kernelrpc_mach_port_destruct_trap( + struct _kernelrpc_mach_port_destruct_args *args); + +struct _kernelrpc_mach_port_guard_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(uint64_t, guard); + PAD_ARG_(boolean_t, strict); +}; +extern kern_return_t _kernelrpc_mach_port_guard_trap( + struct _kernelrpc_mach_port_guard_args *args); + +struct _kernelrpc_mach_port_unguard_args { + PAD_ARG_(mach_port_name_t, target); + PAD_ARG_(mach_port_name_t, name); + PAD_ARG_(uint64_t, guard); +}; +extern kern_return_t _kernelrpc_mach_port_unguard_trap( + struct _kernelrpc_mach_port_unguard_args *args); + + +/* not published to LP64 clients yet */ +struct iokit_user_client_trap_args { + PAD_ARG_(void *, userClientRef); + PAD_ARG_(uint32_t, index); + PAD_ARG_(void *, p1); + PAD_ARG_(void *, p2); + PAD_ARG_(void *, p3); + PAD_ARG_(void *, p4); + PAD_ARG_(void *, p5); + PAD_ARG_8 + PAD_ARG_(void *, p6); +}; +kern_return_t iokit_user_client_trap( + struct iokit_user_client_trap_args *args); + +#undef PAD_ +#undef PADL_ +#undef PADR_ +#undef PAD_ARG_ +#undef PAD_ARG_8 + +#endif /* XNU_KERNEL_PRIVATE */ + +#endif /* KERNEL */ __END_DECLS