ObjFW  Changes On Branch efb4e2aa6c6d9bba

Legend:
 * Changes of existing features or bugfixes
 + New features

This file only contains the most significant changes.

ObjFW 1.0.5 -> ObjFW 1.0.6, 2024-01-15
 * Fixes compatibility with autoconf 2.72.
 * Fixes OFDNSResolver's handling of types, classes and lengths > 255.

ObjFW 1.0.4 -> ObjFW 1.0.5, 2023-11-05
 * Fixes the calculation of the extra alignment in OFAllocObject()
 * Fixes +[OFSystemInfo networkInterfaces] on OpenBSD and Windows 98
 * Fixes OFSocketAddressString() for AppleTalk addresses
 * Uses GetModuleHandle() instead of LoadLibrary() where possible on Windows
 * Disables tests for global blocks on Win64 due to broken compilers
 * Adds PGP keys to verify tarballs and commits in the code repository

ObjFW 1.0.3 -> ObjFW 1.0.4, 2023-10-08
 * Fixes OFFile closing fd 0 when initialization fails
 * Fixes -[stringByAppendingPathComponent:] on empty strings
 * Fixes +[OFSystemInfo operatingSystemName] and
   +[OFSystemInfo operatingSystemVersion] returning nil on some systems
 * Adds a license for localizations

  ObjFW is intentionally incompatible with Foundation. This has two reasons:

   * GNUstep already provides a reimplementation of Foundation, which is only
     compatible to a certain degree. This means that a developer still needs to
     care about differences between frameworks if they want to be portable. The
     idea behind ObjFW is that a developer does not need to concern themselves
     with portability and making sure their code works with multiple
     frameworks: Instead, if it works it ObjFW on one platform, they can
     reasonably expect it to also work with ObjFW on another platform. ObjFW
     behaving differently on different operating systems (unless inevitable
     because it is a platform-specific part, like the Windows Registry) is
     considered a bug and will be fixed.
   * Foundation predates a lot of modern Objective-C concepts. The most
     prominent one is exceptions, which are only used in Foundation as a

<h1 id="installation">Installation</h1>

  ObjFW packages are available for various operating systems and can be
  installed as following:

  Operating System           | Command
  ---------------------------|---------------------------------------------
  Alpine Linux               | `doas apk add objfw`
  CRUX                       | `sudo prt-get depinst objfw`
  Fedora                     | `sudo dnf install objfw`
  FreeBSD                    | `sudo pkg install objfw`
  Haiku                      | `pkgman install objfw`
  Haiku (gcc2h)              | `pkgman install objfw_x86`
  macOS (Homebrew)           | `brew install objfw`
  macOS (pkgsrc)             | `cd $PKGSRCDIR/devel/objfw && make install`
  NetBSD                     | `cd /usr/pkgsrc/devel/objfw && make install`
  OpenBSD                    | `doas pkg_add objfw`
  OpenIndiana                | `sudo pkg install developer/objfw`
  Windows (MSYS2/MINGW32)    | `pacman -S mingw-w64-i686-objfw`
  Windows (MSYS2/CLANG64)    | `pacman -S mingw-w64-clang-x86_64-objfw`
  Windows (MSYS2/CLANGARM64) | `pacman -S mingw-w64-clang-aarch64-objfw`

  If your operating system is not listed, you can
  <a href="#building-from-source">build ObjFW from source</a>.  


<h1 id="license">License</h1>

<h1 id="support">Support and community</h1>

  If you have any questions about ObjFW or would like to talk to other ObjFW
  users, the following venues are available:

   * The [forum](https://objfw.nil.im/forum)
   * A [Matrix room](https://matrix.to/#/%23objfw:nil.im)
   * A [Discord room](https://objfw.nil.im/discord), bridged to the Matrix
     room above
   * A [Telegram room](https://t.me/objfw), bridged to the Matrix room above
   * A [Slack room](https://objfw.nil.im/slack), bridged to the Matrix room
     above
   * An IRC channel named `#objfw` on `irc.oftc.net`
     ([Web chat](https://webchat.oftc.net/?channels=%23objfw)), bridged to the
     Matrix room above








  Please don't hesitate to join any or all of those!


<h1 id="donating">Donating</h1>

  If you want to donate to ObjFW, you can read about possible ways to do so

AC_INIT(ObjFW, 1.0.5, js@nil.im, objfw, https://objfw.nil.im/)
AC_CONFIG_SRCDIR(src)
AC_CONFIG_AUX_DIR(build-aux)
AC_CONFIG_MACRO_DIR(build-aux/m4)

AC_DEFINE(OBJFW_VERSION_MAJOR, 1, [The major version of ObjFW])
AC_DEFINE(OBJFW_VERSION_MINOR, 0, [The minor version of ObjFW])

AC_SUBST(BUNDLE_VERSION, 1.0.5)
AC_SUBST(BUNDLE_SHORT_VERSION, 1.0)

for i in configure.ac build-aux/m4/*; do
	AS_IF([test $i -nt configure], [
		AC_MSG_ERROR([$i is newer than configure! Run ./autogen.sh!])
	])
done

	;;
*)
	potential_compilers="clang egcc gcc"
	;;
esac
AC_PROG_OBJC($potential_compilers)
AC_PROG_OBJCPP
AC_PROG_EGREP
AC_PROG_LN_S

BUILDSYS_CHECK_IOS

AC_ARG_WITH(wii,
	AS_HELP_STRING([--with-wii], [build for Wii]))
AS_IF([test x"$with_wii" = x"yes"], [

	CPPFLAGS="-D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS $CPPFLAGS"
	;;
esac

objc_runtime="ObjFW runtime"
AC_CHECK_HEADER(objc/objc.h)
AC_MSG_CHECKING(which Objective C runtime to use)


AC_ARG_ENABLE(seluid24,
	AS_HELP_STRING([--enable-seluid24],
		[use 24 bit instead of 16 bit for selector UIDs]))

AS_IF([test x"$ac_cv_header_objc_objc_h" = x"yes"], [
	AC_EGREP_CPP(egrep_cpp_yes, [
		#import <objc/objc.h>

		#ifdef OBJC_BOOL_DEFINED
		egrep_cpp_yes
		#endif
	], [
		objc_runtime="Apple runtime"
	], [
		dnl We don't want the GNU runtime
		:

	])
])
AC_MSG_RESULT($objc_runtime)

case "$objc_runtime" in
"ObjFW runtime")
	AC_DEFINE(OF_OBJFW_RUNTIME, 1, [Whether we use the ObjFW runtime])

		AC_CHECK_LIB(socket, socket, LIBS="$LIBS -lsocket")
		;;
	esac

	AC_CHECK_HEADER(sys/socket.h, [
		AC_DEFINE(OF_HAVE_SYS_SOCKET_H, 1,
			[Whether we have sys/socket.h])
	])
	AC_CHECK_MEMBERS([struct sockaddr.sa_len], [], [], [
		#ifdef OF_HAVE_SYS_TYPES_H
		# include <sys/types.h>
		#endif
		#ifdef OF_HAVE_SYS_SOCKET_H
		# include <sys/socket.h>
		#endif
		#ifdef _WIN32
		# include <winsock2.h>
		#endif
	])
	AC_CHECK_TYPE([struct sockaddr_storage], [
		AC_DEFINE(OF_HAVE_SOCKADDR_STORAGE, 1,
			[Whether we have struct sockaddr_storage])
	], [], [
		#ifdef OF_HAVE_SYS_TYPES_H
		# include <sys/types.h>

			#endif

			#ifdef AF_INET6
			egrep_cpp_yes
			#endif
		], [
			AC_DEFINE(OF_HAVE_IPV6, 1, [Whether we have IPv6])


		])
	], [
		dnl Work around a bug in autoconf 2.61 that creates a broken
		dnl configure if this branch is empty.
		:
	], [
		#ifdef _WIN32

])

AS_IF([test x"$GOBJC" = x"yes"], [
	OBJCFLAGS="$OBJCFLAGS -Wwrite-strings -Wpointer-arith"

	AC_ARG_ENABLE(werror,
		AS_HELP_STRING([--disable-werror], [do not build with -Werror]))
	AS_IF([test x"$enable_werror" = x"yes"], [
		OBJCFLAGS="$OBJCFLAGS -Werror"
	])

	old_OBJCFLAGS="$OBJCFLAGS"
	OBJCFLAGS="$OBJCFLAGS -Werror"
	AC_MSG_CHECKING(whether we need -Wno-strict-aliasing due to GCC bugs)
	AC_COMPILE_IFELSE([

OBJFW_SHARED_LIB = @OBJFW_SHARED_LIB@
OBJFW_STATIC_LIB = @OBJFW_STATIC_LIB@
OBJFW_FRAMEWORK = @OBJFW_FRAMEWORK@
OBJFW_LIB_MAJOR = 1
OBJFW_LIB_MINOR = 0
OBJFW_LIB_PATCH = 4
OBJFW_LIB_MAJOR_MINOR = ${OBJFW_LIB_MAJOR}.${OBJFW_LIB_MINOR}

OBJFWRT_SHARED_LIB = @OBJFWRT_SHARED_LIB@
OBJFWRT_STATIC_LIB = @OBJFWRT_STATIC_LIB@
OBJFWRT_FRAMEWORK = @OBJFWRT_FRAMEWORK@
OBJFWRT_LIB_MAJOR = 1
OBJFWRT_LIB_MINOR = 0

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=21Qx
-----END PGP PUBLIC KEY BLOCK-----

		uint32_t TTL;
		uint16_t dataLength;
		OFDNSResourceRecord *record;

		if (*i + 10 > length)
			@throw [OFTruncatedDataException exception];

		recordType = (buffer[*i] << 8) | buffer[*i + 1];
		DNSClass = (buffer[*i + 2] << 8) | buffer[*i + 3];
		TTL = (buffer[*i + 4] << 24) | (buffer[*i + 5] << 16) |
		    (buffer[*i + 6] << 8) | buffer[*i + 7];
		dataLength = (buffer[*i + 8] << 8) | buffer[*i + 9];

		*i += 10;

		if (*i + dataLength > length)
			@throw [OFTruncatedDataException exception];

		record = parseResourceRecord(name, DNSClass, recordType, TTL,

#if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \
    defined(OF_HAVE_THREADS)
	mutex = [[OFMutex alloc] init];
	atexit(releaseMutex);
#endif

#ifdef OF_WINDOWS
	if ((module = GetModuleHandle("msvcrt.dll")) != NULL)
		_mktime64FuncPtr = (__time64_t (*)(struct tm *))
		    GetProcAddress(module, "_mktime64");
#endif
}

+ (instancetype)alloc
{

#endif
#if !defined(HAVE_READDIR_R) && !defined(OF_WINDOWS) && defined(OF_HAVE_THREADS)
	readdirMutex = [[OFMutex alloc] init];
	atexit(releaseReaddirMutex);
#endif

#ifdef OF_WINDOWS
	if ((module = GetModuleHandle("msvcrt.dll")) != NULL)
		_wutime64FuncPtr = (int (*)(const wchar_t *,
		    struct __utimbuf64 *))GetProcAddress(module, "_wutime64");

	if ((module = GetModuleHandleA("kernel32.dll")) != NULL) {
		createSymbolicLinkWFuncPtr =
		    (WINAPI BOOLEAN (*)(LPCWSTR, LPCWSTR, DWORD))
		    GetProcAddress(module, "CreateSymbolicLinkW");
		createHardLinkWFuncPtr =
		    (WINAPI BOOLEAN (*)(LPCWSTR, LPCWSTR,
		    LPSECURITY_ATTRIBUTES))
		    GetProcAddress(module, "CreateHardLinkW");

{
	OFObject *instance;
	size_t instanceSize;

	instanceSize = class_getInstanceSize(class);

	if OF_UNLIKELY (extraAlignment > 1)
		extraAlignment = OFRoundUpToPowerOf2(extraAlignment,
		    PRE_IVARS_ALIGN + instanceSize) -
		    PRE_IVARS_ALIGN - instanceSize;

	instance = calloc(1, PRE_IVARS_ALIGN + instanceSize +
	    extraAlignment + extraSize);

	if OF_UNLIKELY (instance == nil) {
		object_setClass((id)&allocFailedException,
		    [OFAllocFailedException class]);

extern unsigned long OFSocketAddressHash(
    const OFSocketAddress *_Nonnull address);

/**
 * @brief Converts the specified @ref OFSocketAddress to a string.
 *
 * @param address The address to convert to a string
 * @return The address as a string, without the port
 */
extern OFString *_Nonnull OFSocketAddressString(
    const OFSocketAddress *_Nonnull address);

/**
 * @brief Sets the IP port of the specified @ref OFSocketAddress.
 *

}

static OFString *
appleTalkString(const OFSocketAddress *address)
{
	const struct sockaddr_at *addrAT = &address->sockaddr.at;

	return [OFString stringWithFormat: @"%" PRIu8 ".%" PRIu8,
	    OFFromBigEndian16(addrAT->sat_net), addrAT->sat_node];
}

OFString *
OFSocketAddressString(const OFSocketAddress *address)
{
	switch (address->family) {

			    sockaddrSize);

#  if defined(OF_HAVE_IPV6) && defined(HAVE_IF_NAMETOINDEX)
			if (address.sockaddr.in6.sin6_family == AF_INET6 &&
			    address.sockaddr.in6.sin6_addr.s6_addr[0] == 0xFE &&
			    (address.sockaddr.in6.sin6_addr.s6_addr[1] & 0xC0)
			    == 0x80) {
#   if defined(__KAME__)
#    define addr6 address.sockaddr.in6.sin6_addr.s6_addr
				address.sockaddr.in6.sin6_scope_id =

				    (addr6[2] << 8) | addr6[3];
				addr6[2] = addr6[3] = 0;
#    undef addr6
#   elif defined(HAVE_IF_NAMETOINDEX)
				address.sockaddr.in6.sin6_scope_id =
				    if_nametoindex(
				    [name cStringWithEncoding: encoding]);
#   endif
			}
#  endif

			[addresses addItem: &address];

next:
#  ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
			if (current->ifr_addr.sa_len > sizeof(struct sockaddr))
				buffer += sizeof(struct ifreq) -
				    sizeof(struct sockaddr) +
				    current->ifr_addr.sa_len;
			else
#  endif
				buffer += sizeof(struct ifreq);

		}
	} @finally {
		free(ifrs);
		closesocket(sock);
	}
# endif

    PIP_ADAPTER_ADDRESSES, PULONG);

static void
init(void)
{
	HMODULE module;

	if ((module = GetModuleHandle("iphlpapi.dll")) != NULL)
		GetAdaptersAddressesFuncPtr = (WINAPI ULONG (*)(ULONG, ULONG,
		    PVOID, PIP_ADAPTER_ADDRESSES, PULONG))
		    GetProcAddress(module, "GetAdaptersAddresses");

}

static OFMutableDictionary OF_GENERIC(OFString *, OFNetworkInterface) *
networkInterfacesFromGetAdaptersAddresses(void)
{
	OFMutableDictionary *ret = [OFMutableDictionary dictionary];

	ULONG adapterAddressesSize = sizeof(IP_ADAPTER_ADDRESSES);
	PIP_ADAPTER_ADDRESSES adapterAddresses;

	if ((adapterAddresses = malloc(adapterAddressesSize)) == NULL)
		return nil;

	@try {

		for (PIP_ADAPTER_ADDRESSES iter = adapterAddresses;
		    iter != NULL; iter = iter->Next) {
			OFString *name;
			OFMutableDictionary *interface;
			OFNumber *index;

			name = [OFString stringWithFormat: @"%lu",
							   iter->IfIndex];

			if ((interface = [ret objectForKey: name]) == nil) {
				interface = [OFMutableDictionary dictionary];
				[ret setObject: interface forKey: name];
			}

			index = [OFNumber numberWithUnsignedInt: iter->IfIndex];

		    iter = iter->Next) {
			OFMutableDictionary *interface;
			OFString *name, *IPString;
			OFNumber *index;
			OFSocketAddress IPv4Address;
			OFData *addresses;

			name = [OFString stringWithFormat: @"%u", iter->Index];


			if ((interface = [ret objectForKey: name]) == nil) {
				interface = [OFMutableDictionary dictionary];
				[ret setObject: interface forKey: name];
			}

			index = [OFNumber numberWithUnsignedInt: iter->Index];

# elif defined(OF_MIPS)
#  include "lookup-asm-mips-elf.S"
# elif defined(OF_SPARC64)
#  include "lookup-asm-sparc64-elf.S"
# elif defined(OF_SPARC)
#  include "lookup-asm-sparc-elf.S"
# endif




#elif defined(OF_WINDOWS)
# if defined(OF_AMD64)
#  include "lookup-asm-amd64-win64.S"
# elif defined(OF_X86)
#  include "lookup-asm-x86-win32.S"
# endif
#endif

#if defined(OF_ELF)
# if defined(OF_AMD64) || defined(OF_X86) || \
    defined(OF_POWERPC64) || defined(OF_POWERPC) || \
    defined(OF_ARM64) || defined(OF_ARM) || \
    defined(OF_MIPS64_N64) || defined(OF_MIPS) || \
    defined(OF_SPARC64) || defined(OF_SPARC)




#  define OF_ASM_LOOKUP
# endif
#elif defined(OF_WINDOWS)
# if defined(OF_AMD64) || defined(OF_X86)
#  define OF_ASM_LOOKUP
# endif
#endif

#elif defined(OF_APPLE_RUNTIME)
extern void *_NSConcreteStackBlock;
extern void *_NSConcreteGlobalBlock;
extern void *_NSConcreteMallocBlock;
#endif

/* Clang on Win32 generates broken code that crashes for global blocks. */
#if !defined(OF_WINDOWS) || !defined(__clang__)
static void (^globalBlock)(void) = ^ {};
#endif

static int
(^returnStackBlock(void))(void)
{
	__block int i = 42;

	void (^mallocBlock)(void);
	int (^voidBlock)(void);

	TEST(@"Class of stack block",
	    (Class)&_NSConcreteStackBlock == objc_getClass("OFStackBlock") &&
	    [stackBlock isKindOfClass: [OFBlock class]])

#if !defined(OF_WINDOWS) || !defined(__clang__)
	TEST(@"Class of global block",
	    (Class)&_NSConcreteGlobalBlock == objc_getClass("OFGlobalBlock") &&
	    [globalBlock isKindOfClass: [OFBlock class]])
#endif

	TEST(@"Class of a malloc block",
	    (Class)&_NSConcreteMallocBlock == objc_getClass("OFMallocBlock"))

	TEST(@"Copying a stack block",
	    (mallocBlock = [[stackBlock copy] autorelease]) &&
	    [mallocBlock class] == objc_getClass("OFMallocBlock") &&
	    [mallocBlock isKindOfClass: [OFBlock class]])

	TEST(@"Copying a stack block and referencing its variable",
	    forwardTest() == 5)

	TEST(@"Copying a stack block and using its copied variable",
	    (voidBlock = returnStackBlock()) && voidBlock() == 43 &&
	    voidBlock() == 44 && voidBlock() == 45)

#if !defined(OF_WINDOWS) || !defined(__clang__)
	TEST(@"Copying a global block",
	    (id)globalBlock == [[globalBlock copy] autorelease])
#endif

#ifndef __clang_analyzer__
	TEST(@"Copying a malloc block",
	    (id)mallocBlock == [mallocBlock copy] &&
	    [mallocBlock retainCount] == 2)
#endif

	TEST(@"Autorelease a stack block", R([stackBlock autorelease]))

#if !defined(OF_WINDOWS) || !defined(__clang__)
	TEST(@"Autorelease a global block", R([globalBlock autorelease]))
#endif

#ifndef __clang_analyzer__
	TEST(@"Autorelease a malloc block", R([mallocBlock autorelease]))
#endif

	objc_autoreleasePoolPop(pool);
}
@end