ObjFW  Check-in [67066be692]

/*
 * Copyright (c) 2008 - 2009
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of libobjfw. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE included in
 * the packaging of this file.
 */

#import "OFObject.h"
#import "OFString.h"

/**
 * An exception indicating an object could not be allocated.
 *
 * This exception is preallocated, as if there's no memory, no exception can
 * be allocated of course. That's why you shouldn't and even can't deallocate
 *it.

{
	Class isa;
}

+ (Class)class;

/**
 * \return An error message for the exception as a C string
 * \return An error message for the exception as a string
 */
- (const char*)cString;
- (OFString*)string;
@end

/**
 * The OFException class is the base class for all exceptions in ObjFW.
 *
 * IMPORTANT: Exceptions do NOT use OFAutoreleasePools!!
 */
@interface OFException: OFObject
{
	Class class;
	char  *string;
	Class	 class;
	OFString *string;
}

/**
 * Creates a new exception.
 *
 * \param class The class of the object which caused the exception
 * \return A new exception

/**
 * \return The class of the object in which the exception happened
 */
- (Class)inClass;

/**
 * \return An error message for the exception as a C string
 * \return An error message for the exception as a string
 */
- (const char*)cString;
- (OFString*)string;
@end

/**
 * An OFException indicating there is not enough memory available.
 */
@interface OFNoMemException: OFException
{

@end

/**
 * An OFException indicating the file couldn't be opened.
 */
@interface OFOpenFileFailedException: OFException
{
	char *path;
	char *mode;
	OFString *path;
	OFString *mode;
	int  err;
}

/**
 * \param class The class of the object which caused the exception
 * \param path A C string of the path to the file tried to open
 * \param mode A C string of the mode in which the file should have been opened
 * \param path A string of the path to the file tried to open
 * \param mode A string of the mode in which the file should have been opened
 * \return A new open file failed exception
 */
+ newWithClass: (Class)class
       andPath: (const char*)path
       andMode: (const char*)mode;
       andPath: (OFString*)path
       andMode: (OFString*)mode;

/**
 * Initializes an already allocated open file failed exception.
 *
 * \param class The class of the object which caused the exception
 * \param path A C string of the path to the file which couldn't be opened
 * \param mode A C string of the mode in which the file should have been opened
 * \param path A string of the path to the file which couldn't be opened
 * \param mode A string of the mode in which the file should have been opened
 * \return An initialized open file failed exception
 */
- initWithClass: (Class)class
	andPath: (const char*)path
	andMode: (const char*)mode;
	andPath: (OFString*)path
	andMode: (OFString*)mode;

/**
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \return A C string of the path to the file which couldn't be opened
 * \return A string of the path to the file which couldn't be opened
 */
- (char*)path;
- (OFString*)path;

/**
 * \return A C string of the mode in which the file should have been opened
 * \return A string of the mode in which the file should have been opened
 */
- (char*)mode;
- (OFString*)mode;
@end

/**
 * An OFException indicating a read or write to the file failed.
 */
@interface OFReadOrWriteFailedException: OFException
{

/**
 * An OFException indicating an attempt to connect or bind an already connected
 * or bound socket.
 */
@interface OFAlreadyConnectedException: OFException {}
@end

/**
 * An OFException indicating that the specified port is invalid.
 */
@interface OFInvalidPortException: OFException {}
@end

/**
 * An OFException indicating the translation of an address failed.
 */
@interface OFAddressTranslationFailedException: OFException
{
	char *node;
	char *service;
	int  err;
	OFString *node;
	OFString *service;
	int	 err;
}

/**
 * \param class The class of the object which caused the exception
 * \param node The node for which translation was requested
 * \param service The service of the node for which translation was requested
 * \return A new address translation failed exception
 */
+ newWithClass: (Class)class
       andNode: (const char*)node
    andService: (const char*)service;
       andNode: (OFString*)node
    andService: (OFString*)service;

/**
 * Initializes an already allocated address translation failed exception.
 *
 * \param class The class of the object which caused the exception
 * \param node The node for which translation was requested
 * \param service The service of the node for which translation was requested
 * \return An initialized address translation failed exception
 */
- initWithClass: (Class)class
	andNode: (const char*)node
     andService: (const char*)service;
	andNode: (OFString*)node
     andService: (OFString*)service;

/**
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * /return The node for which translation was requested
 */
- (const char*)node;
- (OFString*)node;

/**
 * \return The service of the node for which translation was requested
 */
- (const char*)service;
- (OFString*)service;
@end

/**
 * An OFException indicating that the connection could not be established.
 */
@interface OFConnectionFailedException: OFException
{
	char	 *host;
	uint16_t port;
	OFString *node;
	OFString *service;
	int	 err;
}

/**
 * \param class The class of the object which caused the exception
 * \param host The host to which the connection failed
 * \param port The port on the host to which the connection failed
 * \param node The node to which the connection failed
 * \param service The service on the node to which the connection failed
 * \return A new connection failed exception
 */
+ newWithClass: (Class)class
       andHost: (const char*)host
       andPort: (uint16_t)port;
       andNode: (OFString*)node
    andService: (OFString*)service;

/**
 * Initializes an already allocated connection failed exception.
 *
 * \param class The class of the object which caused the exception
 * \param host The host to which the connection failed
 * \param port The port on the host to which the connection failed
 * \param node The node to which the connection failed
 * \param service The service on the node to which the connection failed
 * \return An initialized connection failed exception
 */
- initWithClass: (Class)class
	andHost: (const char*)host
	andPort: (uint16_t)port;
	andNode: (OFString*)node
     andService: (OFString*)service;

/**
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \return The host to which the connection failed
 * \return The node to which the connection failed
 */
- (const char*)host;
- (OFString*)node;

/**
 * \return The port on the host to which the connection failed
 * \return The service on the node to which the connection failed
 */
- (uint16_t)port;
- (OFString*)service;
@end

/**
 * An OFException indicating that binding the socket failed.
 */
@interface OFBindFailedException: OFException
{
	char	 *host;
	uint16_t port;
	OFString *node;
	OFString *service;
	int	 family;
	int	 err;
}

/**
 * \param class The class of the object which caused the exception
 * \param host The host on which binding failed
 * \param port The port on which binding failed
 * \param node The node on which binding failed
 * \param service The service on which binding failed
 * \param family The family for which binnding failed
 * \return A new bind failed exception
 */
+ newWithClass: (Class)class
       andHost: (const char*)host
       andPort: (uint16_t)port
       andNode: (OFString*)node
    andService: (OFString*)service
     andFamily: (int)family;

/**
 * Initializes an already allocated bind failed exception.
 *
 * \param class The class of the object which caused the exception
 * \param host The host on which binding failed
 * \param port The port on which binding failed
 * \param node The node on which binding failed
 * \param service The service on which binding failed
 * \param family The family for which binnding failed
 * \return An initialized bind failed exception
 */
- initWithClass: (Class)class
	andHost: (const char*)host
	andPort: (uint16_t)port
	andNode: (OFString*)node
     andService: (OFString*)service
      andFamily: (int)family;

/**
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \return The host on which binding failed
 * \return The node on which binding failed
 */
- (const char*)host;
- (OFString*)node;

/**
 * \return The port on which binding failed
 * \return The service on which binding failed
 */
- (uint16_t)port;
- (OFString*)service;

/**
 * \return The family for which binding failed
 */
- (int)family;
@end

@implementation OFAllocFailedException
+ (Class)class
{
	return self;
}

- (const char*)cString
- (OFString*)string
{
	return "Allocating an object failed!";
	return @"Allocating an object failed!";
}
@end

@implementation OFException
+ newWithClass: (Class)class_
{
	return [[self alloc] initWithClass: class_];
}

- initWithClass: (Class)class_
{
	self = [super init];

	class = class_;
	string = NULL;
	string = nil;

	return self;
}

- (void)dealloc
{
	if (string != NULL)
		free(string);
	[string release];

	[super dealloc];
}

- (Class)inClass
{
	return class;
}

- (const char*)cString
- (OFString*)string
{
	return string;
}
@end

@implementation OFNoMemException
+ newWithClass: (Class)class_

	self = [super initWithClass: class_];

	req_size = size;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Could not allocate %zu bytes in class %s!",
		req_size, [class name]);
	    initWithFormat: @"Could not allocate %zu bytes in class %s!",
			    req_size, [class name]];

	return string;
}

- (size_t)requestedSize
{
	return req_size;

	self = [super initWithClass: class_];

	pointer = ptr;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Memory at %p was not allocated as part of object "
	    "of class %s, thus the memory allocation was not changed! It is "
	    "also possible that there was an attempt to free the same memory "
	    "twice.", pointer, [class name]);
	    initWithFormat: @"Memory at %p was not allocated as part of object "
			    @"of class %s, thus the memory allocation was not "
			    @"changed! It is also possible that there was an "
			    @"attempt to free the same memory twice.",
			    pointer, [class name]];

	return string;
}

- (void*)pointer
{
	return pointer;

	self = [super initWithClass: class_];

	selector = selector_;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The method %s of class %s is not or not fully "
	    "implemented!", SEL_NAME(selector), [class name]);
	    initWithFormat: @"The method %s of class %s is not or not fully "
			    @"implemented!",
			    SEL_NAME(selector), [class name]];

	return string;
}
@end

@implementation OFOutOfRangeException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Value out of range in class %s!", [class name]);
	    initWithFormat: @"Value out of range in class %s!",
			    [class name]];

	return string;
}
@end

@implementation OFInvalidArgumentException
+ newWithClass: (Class)class_

	self = [super initWithClass: class_];

	selector = selector_;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The argument for method %s of class %s is invalid!",
	    SEL_NAME(selector), [class name]);
	    initWithFormat: @"The argument for method %s of class %s is "
	    		    @"invalid!",
			    SEL_NAME(selector), [class name]];

	return string;
}
@end

@implementation OFInvalidEncodingException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The encoding is invalid for class %s!",
	    [class name]);
	    initWithFormat: @"The encoding is invalid for class %s!",
			    [class name]];

	return string;
}
@end

@implementation OFInvalidFormatException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The format is invalid for class %s!", [class name]);
	    initWithFormat: @"The format is invalid for class %s!",
			    [class name]];

	return string;
}
@end

@implementation OFInitializationFailedException
- (const char*)cString
- (OFString*)cString
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Initialization failed for class %s!", [class name]);
	    initWithFormat: @"Initialization failed for class %s!",
			    [class name]];

	return string;
}
@end

@implementation OFOpenFileFailedException
+ newWithClass: (Class)class_
       andPath: (const char*)path_
       andMode: (const char*)mode_
       andPath: (OFString*)path_
       andMode: (OFString*)mode_
{
	return [[self alloc] initWithClass: class_
				   andPath: path_
				   andMode: mode_];
}

- initWithClass: (Class)class_
	andPath: (const char*)path_
	andMode: (const char*)mode_
	andPath: (OFString*)path_
	andMode: (OFString*)mode_
{
	self = [super initWithClass: class_];

	path = (path_ != NULL ? strdup(path_) : NULL);
	mode = (mode_ != NULL ? strdup(mode_) : NULL);
	path = [path_ retain];
	mode = [mode_ retain];
	err = GET_ERR;

	return self;
}

- (void)dealloc
{
	if (path != NULL)
	[path release];
		free(path);
	if (mode != NULL)
	[mode release];
		free(mode);

	[super dealloc];
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Failed to open file %s with mode %s in class %s! "
	    ERRFMT, path, mode, [self name], ERRPARAM);
	    initWithFormat: @"Failed to open file %s with mode %s in class %s! "
			    ERRFMT,
			    [path cString], [mode cString], [self name],
			    ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;
}

- (char*)path
- (OFString*)path
{
	return path;
}

- (char*)mode
- (OFString*)mode
{
	return mode;
}
@end

@implementation OFReadOrWriteFailedException
+ newWithClass: (Class)class_

- (BOOL)hasNItems
{
	return has_items;
}
@end

@implementation OFReadFailedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;;

	if (has_items)
		string = [[OFMutableString alloc]
		asprintf(&string, "Failed to read %zu items of size %zu in "
		    "class %s! " ERRFMT, req_items, req_size, [class name],
		    ERRPARAM);
		    initWithFormat: @"Failed to read %zu items of size %zu in "
				    @"class %s! " ERRFMT,
				    req_items, req_size, [class name],
				    ERRPARAM];
	else
		string = [[OFMutableString alloc]
		asprintf(&string, "Failed to read %zu bytes in class %s! "
		    ERRFMT, req_size, [class name], ERRPARAM);
		    initWithFormat: @"Failed to read %zu bytes in class %s! "
				    ERRFMT,
				    req_size, [class name], ERRPARAM];

	return string;
}
@end

@implementation OFWriteFailedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	if (has_items)
		string = [[OFMutableString alloc]
		asprintf(&string, "Failed to write %zu items of size %zu in "
		    "class %s! " ERRFMT, req_items, req_size, [class name],
		    ERRPARAM);
		    initWithFormat: @"Failed to write %zu items of size %zu in "
				    @"class %s! " ERRFMT,
				    req_items, req_size, [class name],
				    ERRPARAM];
	else
		string = [[OFMutableString alloc]
		asprintf(&string, "Failed to write %zu bytes in class %s! "
		    ERRFMT, req_size, [class name], ERRFMT);
		    initWithFormat: @"Failed to write %zu bytes in class %s! "
				    ERRFMT,
				    req_size, [class name], ERRPARAM];

	return string;
}
@end

@implementation OFSetOptionFailedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Setting an option in class %s failed!",
	    [class name]);
	    initWithFormat: @"Setting an option in class %s failed!",
			    [class name]];

	return string;
}
@end

@implementation OFNotConnectedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The socket of type %s is not connected or bound!",
	    [class name]);
	    initWithFormat: @"The socket of type %s is not connected or bound!",
			    [class name]];

	return string;
}
@end

@implementation OFAlreadyConnectedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The socket of type %s is already connected or bound "
	    "and thus can't be connected or bound again!", [class name]);

	    initWithFormat: @"The socket of type %s is already connected or "
			    @"bound and thus can't be connected or bound "
			    @"again!",
	return string;
}
@end

@implementation OFInvalidPortException
- (const char*)cString
{
	if (string != NULL)
		return string;

	asprintf(&string, "The port specified is not valid for a socket of "
	    "type %s! This usually means you tried to use port 0, which is an "
	    "invalid port.", [class name]);
			    [class name]];

	return string;
}
@end

@implementation OFAddressTranslationFailedException
+ newWithClass: (Class)class_
       andNode: (const char*)node_
    andService: (const char*)service_
       andNode: (OFString*)node_
    andService: (OFString*)service_
{
	return [[self alloc] initWithClass: class_
				   andNode: node_
				andService: service_];
}

- initWithClass: (Class)class_
	andNode: (const char*)node_
     andService: (const char*)service_
	andNode: (OFString*)node_
     andService: (OFString*)service_
{
	self = [super initWithClass: class_];

	node = (node_ != NULL ? strdup(node_) : NULL);
	service = (service_ != NULL ? strdup(service_) : NULL);
	node = [node_ retain];
	service = [service_ retain];
	err = GET_SOCK_ERR;

	return self;
}

- (void)dealloc
{
	[node release];
	[service release];
	if (node != NULL)
		free(node);
	if (service != NULL)
		free(node);

	[super dealloc];
}

- (OFString*)string
{
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	    initWithFormat: @"The service %s on %s could not be translated to "
			    @"an address in class %s. This means that either "
			    @"the node was not found, there is no such service "
			    @"on the node, there was a problem with the name "
			    @"server, there was a problem with your network "
			    @"connection or you specified an invalid node or "
			    @"service. " ERRFMT,
			    [service cString], [node cString], [class name],
			    ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;
}

- (OFString*)node
{
	return node;
}

- (OFString*)service
{
	return service;
}
@end

@implementation OFConnectionFailedException
+ newWithClass: (Class)class_
       andNode: (OFString*)node_
    andService: (OFString*)service_
{
	return [[self alloc] initWithClass: class_
				   andNode: node_
				andService: service_];
}

- initWithClass: (Class)class_
	andNode: (OFString*)node_
     andService: (OFString*)service_
{
	self = [super initWithClass: class_];

	node	= [node_ retain];
	service	= [service_ retain];
	err	= GET_SOCK_ERR;

	return self;
}

- (void)dealloc
{
	[node release];
	[service release];

	[super dealloc];
}

- (OFString*)string
{
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	    initWithFormat: @"A connection to service %s on node %s could not "
			    @"be established in class %s! " ERRFMT,
			    [node cString], [service cString], [class name],
			    ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;
}

- (OFString*)node
{
	return node;
}

- (OFString*)service
{
	return service;
}
@end

@implementation OFBindFailedException
+ newWithClass: (Class)class_
       andNode: (OFString*)node_
    andService: (OFString*)service_
     andFamily: (int)family_
{
	return [[self alloc] initWithClass: class_
				   andNode: node_
				andService: service_
				 andFamily: family_];
}

- initWithClass: (Class)class_
	andNode: (OFString*)node_
     andService: (OFString*)service_
      andFamily: (int)family_
{
	self = [super initWithClass: class_];

	node	= [node_ retain];
	service	= [service_ retain];
	family	= family_;
	err	= GET_SOCK_ERR;

	return self;
}

- (void)dealloc
{
	[node release];
	[service release];

	[super dealloc];
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The service %s on %s could not be translated to an "
	    "address in class %s. This means that either the node was not "
	    "found, there is no such service on the node, there was a problem "
	    initWithFormat: @"Binding service %s on node %s using family %d "
			    @"failed in class %s! " ERRFMT,
			    [service cString], [node cString], family,
	    "with the name server, there was a problem with your network "
	    "connection or you specified an invalid node or service. " ERRFMT,
	    service, node, [class name], ERRPARAM);
			    [class name], ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;
}

- (const char*)node
- (OFString*)node
{
	return node;
}

- (const char*)service
- (OFString*)service
{
	return service;
}
@end

@implementation OFConnectionFailedException
+ newWithClass: (Class)class_
       andHost: (const char*)host_
       andPort: (uint16_t)port_
{
	return [[self alloc] initWithClass: class_
				   andHost: host_
				   andPort: port_];
}

- initWithClass: (Class)class_
	andHost: (const char*)host_
	andPort: (uint16_t)port_
{
	self = [super initWithClass: class_];

	host = (host_ != NULL ? strdup(host_) : NULL);
	port = port_;
	err = GET_SOCK_ERR;

	return self;
}

- (void)dealloc
{
	if (host != NULL)
		free(host);

	[super dealloc];
}

- (const char*)cString
{
	if (string != NULL)
		return string;

	asprintf(&string, "A connection to %s:%d could not be established in "
	    "class %s! " ERRFMT, host, port, [class name], ERRPARAM);

	return string;
}

- (int)errNo
{
	return err;
}

- (const char*)host
{
	return host;
}

- (uint16_t)port
{
	return port;
}
@end

@implementation OFBindFailedException
+ newWithClass: (Class)class_
       andHost: (const char*)host_
       andPort: (uint16_t)port_
     andFamily: (int)family_
{
	return [[self alloc] initWithClass: class_
				   andHost: host_
				   andPort: port_
				 andFamily: family_];
}

- initWithClass: (Class)class_
	andHost: (const char*)host_
	andPort: (uint16_t)port_
      andFamily: (int)family_
{
	self = [super initWithClass: class_];

	host = (host_ != NULL ? strdup(host_) : NULL);
	port = port_;
	family = family_;
	err = GET_SOCK_ERR;

	return self;
}

- (void)dealloc
{
	if (host != NULL)
		free(host);

	[super dealloc];
}

- (const char*)cString
{
	if (string != NULL)
		return string;

	asprintf(&string, "Binding to port %d on %s using family %d failed in "
	    "class %s! " ERRFMT, port, host, family, [class name], ERRPARAM);

	return string;
}

- (int)errNo
{
	return err;
}

- (const char*)host
{
	return host;
}

- (uint16_t)port
{
	return port;
}

- (int)family
{
	return family;
}
@end

	backlog = backlog_;
	err = GET_SOCK_ERR;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Failed to listen in socket of type %s with a back "
	    "log of %d! "ERRFMT, [class name], backlog, ERRPARAM);
	    initWithFormat: @"Failed to listen in socket of type %s with a "
			    @"back log of %d! " ERRFMT,
			    [class name], backlog, ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;

	self = [super initWithClass: class_];

	err = GET_SOCK_ERR;

	return self;
}

- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Failed to accept connection in socket of type %s! "
	    ERRFMT, [class name], ERRPARAM);
	    initWithFormat: @"Failed to accept connection in socket of type "
			    @"%s! " ERRFMT,
			    [class name], ERRPARAM];

	return string;
}

- (int)errNo
{
	return err;
}
@end

@implementation OFThreadJoinFailedException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "Joining a thread of class %s failed! Most likely, "
	    "another thread already waits for the thread to join.",
	    [class name]);
	    initWithFormat: @"Joining a thread of class %s failed! Most "
			    @"likely, another thread already waits for the "
			    @"thread to join.",
			    [class name]];

	return string;
}
@end

@implementation OFThreadCanceledException
- (const char*)cString
- (OFString*)string
{
	if (string != NULL)
	if (string != nil)
		return string;

	string = [[OFMutableString alloc]
	asprintf(&string, "The requested action cannot be performed because "
	    "the thread of class %s was canceled!", [class name]);
	    initWithFormat: @"The requested action cannot be performed because "
			    @"the thread of class %s was canceled!",
			    [class name]];

	return string;
}
@end

#include <sys/types.h>
#else
typedef int uid_t;
typedef int gid_t;
#endif

#import "OFStream.h"
#import "OFString.h"

/**
 * The OFFile class provides functions to read, write and manipulate files.
 */
@interface OFFile: OFStream
{
	FILE *fp;
}

/**
 * \param path The path to the file to open as a C string
 * \param mode The mode in which the file should be opened as a C string
 * \param path The path to the file to open as a string
 * \param mode The mode in which the file should be opened as a string
 * \return A new autoreleased OFFile
 */
+ fileWithPath: (const char*)path
       andMode: (const char*)mode;
+ fileWithPath: (OFString*)path
       andMode: (OFString*)mode;
/**
 * Changes the mode of a file.
 *
 * Not available on Windows.
 *
 * \param path The path to the file of which the mode should be changed as a
 *	  C string
 *	       string
 * \param mode The new mode for the file
 * \return A boolean whether the operation succeeded
 */
+ (void)changeModeOfFile: (const char*)path
+ (void)changeModeOfFile: (OFString*)path
		  toMode: (mode_t)mode;

/**
 * Changes the owner of a file.
 *
 * Not available on Windows.
 *
 * \param path The path to the file of which the owner should be changed as a
 *	  C string
 *	       string
 * \param owner The new owner for the file
 * \param group The new group for the file
 * \return A boolean whether the operation succeeded
 */
+ (void)changeOwnerOfFile: (const char*)path
+ (void)changeOwnerOfFile: (OFString*)path
		  toOwner: (uid_t)owner
		 andGroup: (gid_t)group;

/**
 * Deletes a file.
 *
 * \param path The path to the file of which should be deleted as a C string
 * \param path The path to the file of which should be deleted as a string
 * \return A boolean whether the operation succeeded
 */
+ (void)delete: (const char*)path;
+ (void)delete: (OFString*)path;

/**
 * Hardlinks a file.
 *
 * Not available on Windows.
 *
 * \param src The path to the file of which should be linked as a C string
 * \param dest The path to where the file should be linked as a C string
 * \param src The path to the file of which should be linked as a string
 * \param dest The path to where the file should be linked as a string
 * \return A boolean whether the operation succeeded
 */
+ (void)link: (const char*)src
	  to: (const char*)dest;
+ (void)link: (OFString*)src
	  to: (OFString*)dest;

/**
 * Symlinks a file.
 *
 * Not available on Windows.
 *
 * \param src The path to the file of which should be symlinked as a C string
 * \param dest The path to where the file should be symlinked as a C string
 * \param src The path to the file of which should be symlinked as a string
 * \param dest The path to where the file should be symlinked as a string
 * \return A boolean whether the operation succeeded
 */
+ (void)symlink: (const char*)src
	     to: (const char*)dest;
+ (void)symlink: (OFString*)src
	     to: (OFString*)dest;

/**
 * Initializes an already allocated OFFile.
 *
 * \param path The path to the file to open as a C string
 * \param mode The mode in which the file should be opened as a C string
 * \param path The path to the file to open as a string
 * \param mode The mode in which the file should be opened as a string
 * \return An initialized OFFile
 */
- initWithPath: (const char*)path
       andMode: (const char*)mode;
- initWithPath: (OFString*)path
       andMode: (OFString*)mode;

/**
 * \return A boolean whether the end of the file has been reached
 */
- (BOOL)atEndOfFile;

/**

#include <sys/stat.h>
#endif

#import "OFFile.h"
#import "OFExceptions.h"

@implementation OFFile
+ fileWithPath: (const char*)path
       andMode: (const char*)mode
+ fileWithPath: (OFString*)path
       andMode: (OFString*)mode
{
	return [[[OFFile alloc] initWithPath: path
				   andMode: mode] autorelease];
}

+ (void)changeModeOfFile: (const char*)path
+ (void)changeModeOfFile: (OFString*)path
		  toMode: (mode_t)mode
{
	/*
	 * FIXME: On error, throw exception
	 * FIXME: On Win32, change write access
	 */
#ifndef _WIN32
	chmod(path, mode);
	chmod([path cString], mode);
#endif
}

+ (void)changeOwnerOfFile: (const char*)path
+ (void)changeOwnerOfFile: (OFString*)path
		  toOwner: (uid_t)owner
		 andGroup: (gid_t)group
{
	/* FIXME: On error, throw exception */
#ifndef _WIN32
	chown(path, owner, group);
	chown([path cString], owner, group);
#endif
}

+ (void)delete: (const char*)path
+ (void)delete: (OFString*)path
{
	/* FIXME: On error, throw exception */
	unlink(path);
	unlink([path cString]);
}

+ (void)link: (const char*)src
	  to: (const char*)dest
+ (void)link: (OFString*)src
	  to: (OFString*)dest
{
	/* FIXME: On error, throw exception */
#ifndef _WIN32
	link(src, dest);
	link([src cString], [dest cString]);
#endif
}

+ (void)symlink: (const char*)src
	     to: (const char*)dest
+ (void)symlink: (OFString*)src
	     to: (OFString*)dest
{
	/* FIXME: On error, throw exception */
#ifndef _WIN32
	symlink(src, dest);
	symlink([src cString], [dest cString]);
#endif
}

- initWithPath: (const char*)path
       andMode: (const char*)mode
- initWithPath: (OFString*)path
       andMode: (OFString*)mode
{
	Class c;

	self = [super init];

	if ((fp = fopen(path, mode)) == NULL) {
	if ((fp = fopen([path cString], [mode cString])) == NULL) {
		c = isa;
		[super dealloc];
		@throw [OFOpenFileFailedException newWithClass: c 
						       andPath: path
						       andMode: mode];
	}

 */
- initWithCString: (const char*)str;

/**
 * Initializes an already allocated OFMutableString from a format C string.
 * See printf for the format syntax.
 *
 * \param fmt A C string used as format to initialize the OFMutableString
 * \param fmt A string used as format to initialize the OFMutableString
 * \return An initialized OFMutableString
 */
- initWithFormat: (const char*)fmt, ...;
- initWithFormat: (OFString*)fmt, ...;

/**
 * Initializes an already allocated OFMutableString from a format C string.
 * See printf for the format syntax.
 *
 * \param fmt A C string used as format to initialize the OFMutableString
 * \param fmt A string used as format to initialize the OFMutableString
 * \param args The arguments used in the format string
 * \return An initialized OFMutableString
 */
- initWithFormat: (const char*)fmt
- initWithFormat: (OFString*)fmt
    andArguments: (va_list)args;
@end

		}
		memcpy(string, str, length + 1);
	}

	return self;
}

- initWithFormat: (const char*)fmt, ...
- initWithFormat: (OFString*)fmt, ...
{
	id ret;
	va_list args;

	va_start(args, fmt);
	ret = [self initWithFormat: fmt
		      andArguments: args];
	va_end(args);

	return ret;
}

- initWithFormat: (const char*)fmt
- initWithFormat: (OFString*)fmt
    andArguments: (va_list)args
{
	int t;
	Class c;

	self = [super init];

	if (fmt == NULL) {
		c = isa;
		[super dealloc];
		@throw [OFInvalidFormatException newWithClass: c];
	}

	if ((t = vasprintf(&string, fmt, args)) == -1) {
	if ((t = vasprintf(&string, [fmt cString], args)) == -1) {
		c = isa;
		[super dealloc];
		@throw [OFInitializationFailedException newWithClass: c];
	}
	length = t;

	switch (check_utf8(string, length)) {

			  toSize: length + strlength + 1];
	memcpy(string + length, str, strlength + 1);
	length += strlength;

	return self;
}

- appendWithFormatCString: (const char*)fmt, ...
- appendWithFormat: (OFString*)fmt, ...
{
	id ret;
	va_list args;

	va_start(args, fmt);
	ret = [self appendWithFormatCString: fmt
			       andArguments: args];
	ret = [self appendWithFormat: fmt
			andArguments: args];
	va_end(args);

	return ret;
}

- appendWithFormatCString: (const char*)fmt
	     andArguments: (va_list)args
- appendWithFormat: (OFString*)fmt
      andArguments: (va_list)args
{
	char *t;

	if (fmt == NULL)
		@throw [OFInvalidFormatException newWithClass: isa];

	if ((vasprintf(&t, fmt, args)) == -1)
	if ((vasprintf(&t, [fmt cString], args)) == -1)
		/*
		 * This is only the most likely error to happen.
		 * Unfortunately, as errno isn't always thread-safe, there's
		 * no good way for us to find out what really happened.
		 */
		@throw [OFNoMemException newWithClass: isa];

/*
 * Copyright (c) 2008 - 2009
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of libobjfw. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE included in
 * the packaging of this file.
 */

#import "OFObject.h"
#import "OFString.h"

/**
 * The OFPlugin class provides a system for loading plugins at runtime.
 */
@interface OFPlugin: OFObject
{
	void *handle;
}

/**
 * Loads an OFPlugin from a file.
 *
 * \param path Path to the OFPlugin file. The suffix is appended automatically.
 * \return The loaded OFPlugin
 */
+ pluginFromFile: (const char*)path;
+ pluginFromFile: (OFString*)path;
@end

#include <string.h>
#include <dlfcn.h>

#import "OFPlugin.h"
#import "OFExceptions.h"

@implementation OFPlugin
+ pluginFromFile: (const char*)path
+ pluginFromFile: (OFString*)path
{
	char *file;
	size_t pathlen, suffixlen;
	void *handle;
	OFPlugin *(*init_plugin)();
	OFPlugin *plugin;

	pathlen = strlen(path);
	pathlen = [path length];
	suffixlen = strlen(PLUGIN_SUFFIX);

	if ((file = malloc(pathlen + suffixlen + 1)) == NULL) {
		@throw [OFNoMemException newWithClass: self
					      andSize: pathlen +
					      suffixlen + 1];
	}
	memcpy(file, path, pathlen);
	memcpy(file, [path cString], pathlen);
	memcpy(file + pathlen, PLUGIN_SUFFIX, suffixlen);
	file[pathlen + suffixlen] = 0;

	if ((handle = dlopen(file, RTLD_NOW)) == NULL) {
		free(file);
		@throw [OFInitializationFailedException newWithClass: self];
	}

/*
 * Copyright (c) 2008 - 2009
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of libobjfw. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE included in
 * the packaging of this file.
 */

#import "OFObject.h"
#import "OFString.h"

/**
 * The OFStream class provides a base class for different types of streams.
 */
@interface OFStream: OFObject
{
	char   *cache;

/**
 * Read until a newline or \0 occurs.
 *
 * If you want to use readNBytes afterwards again, you have to clear the cache
 * before and optionally get the cache before clearing it!
 *
 * \return The line that was read. Use freeMem: to free it!
 * \return The line that was read, autoreleased.
 */
- (char*)readLine;
- (OFString*)readLine;

/**
 * Writes from a buffer into the stream.
 *
 * \param buf The buffer from which the data is written to the stream
 * \param size The size of the data that should be written
 * \return The number of bytes written
 */
- (size_t)writeNBytes: (size_t)size
	   fromBuffer: (const char*)buf;

/**
 * Writes a C string into the stream, without the trailing zero.
 * Writes a string into the stream, without the trailing zero.
 *
 * \param str The C string from which the data is written to the stream
 * \param str The string from which the data is written to the stream
 * \return The number of bytes written
 */
- (size_t)writeCString: (const char*)str;
- (size_t)writeString: (OFString*)str;

/**
 * Sets a specified pointer to the cache and returns the length of the cache.
 *
 * \param ptr A pointer to a pointer. It will be set to the cache.
 *	      If it is NULL, only the number of bytes in the cache is returned.
 * \return The number of bytes in the cache.

- (size_t)readNBytes: (size_t)size
	  intoBuffer: (char*)buf
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- (char*)readLine
- (OFString*)readLine
{
	size_t i, len;
	char *ret, *tmp, *tmp2;
	char *ret_c, *tmp, *tmp2;
	OFString *ret;

	/* Look if there's a line or \0 in our cache */
	if (cache != NULL) {
		for (i = 0; i < cache_len; i++) {
			if (OF_UNLIKELY(cache[i] == '\n' ||
			    cache[i] == '\0')) {
				ret = [self allocWithSize: i + 1];
				memcpy(ret, cache, i);
				ret[i] = '\0';
				ret_c = [self allocWithSize: i + 1];
				memcpy(ret_c, cache, i);
				ret_c[i] = '\0';

				@try {
					tmp = [self allocWithSize: cache_len -
								   i - 1];
				} @catch (OFException *e) {
					[self freeMem: ret];
					[self freeMem: ret_c];
					@throw e;
				}
				memcpy(tmp, cache + i + 1, cache_len - i - 1);

				[self freeMem: cache];
				cache = tmp;
				cache_len = cache_len - i - 1;

				@try {
					ret = [OFString
					    stringWithCString: ret_c];
				} @finally {
					[self freeMem: ret_c];
				}
				return ret;
			}
		}
	}

	/* Read until we get a newline or \0 */
	tmp = [self allocWithSize: getpagesize()];

			@throw e;
		}

		/* Look if there's a newline or \0 */
		for (i = 0; i < len; i++) {
			if (OF_UNLIKELY(tmp[i] == '\n' || tmp[i] == '\0')) {
				@try {
					ret = [self
					ret_c = [self
					    allocWithSize: cache_len + i + 1];
				} @catch (OFException *e) {
					[self freeMem: tmp];
					@throw e;
				}
				if (cache != NULL)
					memcpy(ret, cache, cache_len);
				memcpy(ret + cache_len, tmp, i);
				ret[i] = '\0';
					memcpy(ret_c, cache, cache_len);
				memcpy(ret_c + cache_len, tmp, i);
				ret_c[i] = '\0';

				if (i < len) {
					@try {
						tmp2 = [self
						    allocWithSize: len - i - 1];
					} @catch (OFException *e) {
						[self freeMem: ret];
						[self freeMem: ret_c];
						[self freeMem: tmp];
						@throw e;
					}
					memcpy(tmp2, tmp + i + 1, len - i - 1);

					if (cache != NULL)
						[self freeMem: cache];
					cache = tmp2;
					cache_len = len - i - 1;
				} else {
					if (cache != NULL)
						[self freeMem: cache];
					cache = NULL;
					cache_len = 0;
				}

				[self freeMem: tmp];
				@try {
					ret = [OFString
					    stringWithCString: ret_c];
				} @finally {
					[self freeMem: ret_c];
				}
				return ret;
			}
		}

		/* There was no newline or \0 */
		@try {
			cache = [self resizeMem: cache

- (size_t)writeNBytes: (size_t)size
	   fromBuffer: (const char*)buf
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- (size_t)writeCString: (const char*)str
- (size_t)writeString: (OFString*)str
{
	return [self writeNBytes: strlen(str)
		      fromBuffer: str];
	return [self writeNBytes: [str length]
		      fromBuffer: [str cString]];
}

- (size_t)getCache: (char**)ptr
{
	if (ptr != NULL)
		*ptr = cache;

 */
+ stringWithCString: (const char*)str;

/**
 * Creates a new OFMutableString from a format C string.
 * See printf for the format syntax.
 *
 * \param fmt A C string used as format to initialize the OFMutableString
 * \param fmt A string used as format to initialize the OFMutableString
 * \return A new autoreleased OFMutableString
 */
+ stringWithFormat: (const char*)fmt, ...;
+ stringWithFormat: (OFString*)fmt, ...;

/**
 * Creates a new OFMutableString from a format C string.
 * See printf for the format syntax.
 *
 * \param fmt A C string used as format to initialize the OFMutableString
 * \param fmt A string used as format to initialize the OFMutableString
 * \param args The arguments used in the format string
 * \return A new autoreleased OFMutableString
 */
+ stringWithFormat: (const char*)fmt
+ stringWithFormat: (OFString*)fmt
      andArguments: (va_list)args;

/**
 * Initializes an already allocated OFString.
 *
 * \return An initialized OFString
 */

 */
- appendCString: (const char*)str;

/**
 * Appends a formatted C string to the OFString.
 * See printf for the format syntax.
 *
 * \param fmt A format C string which generates the string to append
 * \param fmt A format string which generates the string to append
 */
- appendWithFormatCString: (const char*)fmt, ...;
- appendWithFormat: (OFString*)fmt, ...;

/**
 * Appends a formatted C string to the OFString.
 * See printf for the format syntax.
 *
 * \param fmt A format C string which generates the string to append
 * \param fmt A format string which generates the string to append
 * \param args The arguments used in the format string
 */
- appendWithFormatCString: (const char*)fmt
	     andArguments: (va_list)args;
- appendWithFormat: (OFString*)fmt
      andArguments: (va_list)args;

/**
 * Reverse the OFString.
 */
- reverse;

/**

/**
 * Splits an OFString into an OFArray of OFStrings.
 *
 * \param delimiter The delimiter for splitting
 * \return An autoreleased OFArray with the splitted string
 */
- (OFArray*)splitWithDelimiter: (const char*)delimiter;
- (OFArray*)splitWithDelimiter: (OFString*)delimiter;
@end

#import "OFConstString.h"
#import "OFMutableString.h"

#import "config.h"

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#import "OFString.h"
#import "OFMutableString.h"
#import "OFAutoreleasePool.h"
#import "OFExceptions.h"
#import "OFMacros.h"

@implementation OFString
+ string
{
	return [[[OFMutableString alloc] init] autorelease];
}

+ stringWithCString: (const char*)str
{
	return [[[OFMutableString alloc] initWithCString: str] autorelease];
}

+ stringWithFormat: (const char*)fmt, ...
+ stringWithFormat: (OFString*)fmt, ...
{
	id ret;
	va_list args;

	va_start(args, fmt);
	ret = [[[OFMutableString alloc] initWithFormat: fmt
					  andArguments: args] autorelease];
	va_end(args);

	return ret;
}

+ stringWithFormat: (const char*)fmt
+ stringWithFormat: (OFString*)fmt
      andArguments: (va_list)args
{
	return [[[OFMutableString alloc] initWithFormat: fmt
					   andArguments: args] autorelease];
}

- init

- appendCString: (const char*)str
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- appendWithFormatCString: (const char*)fmt, ...
- appendWithFormat: (OFString*)fmt, ...
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- appendWithFormatCString: (const char*)fmt
	     andArguments: (va_list)args
- appendWithFormat: (OFString*)fmt
      andArguments: (va_list)args
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- reverse
{

- lower
{
	@throw [OFNotImplementedException newWithClass: isa
					   andSelector: _cmd];
}

- (OFArray*)splitWithDelimiter: (const char*)delimiter
- (OFArray*)splitWithDelimiter: (OFString*)delimiter
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
	OFArray *array = nil;
	const char *delim = [delimiter cString];
	size_t delim_len = strlen(delimiter);
	size_t delim_len = [delimiter length];
	size_t i, last;

	array = [OFArray array];

	for (i = 0, last = 0; i <= length; i++) {
		if (OF_UNLIKELY(i == length ||
		    !memcmp(string + i, delimiter, delim_len))) {
		    !memcmp(string + i, delim, delim_len))) {
			OFString *str;
			char *tmp;

			/*
			 * We can't use [self allocWithSize:] here as
			 * self might be a @""-literal.
			 */

/*
 * Copyright (c) 2008 - 2009
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * All rights reserved.
 *
 * This file is part of libobjfw. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE included in
 * the packaging of this file.
 */

#import "OFSocket.h"
#import "OFString.h"

/**
 * The OFTCPSocket class provides functions to create and use sockets.
 */
@interface OFTCPSocket: OFSocket {}
/**
 * \return A new autoreleased OFTCPSocket
 */
+ tcpSocket;

/**
 * Initializes an already allocated OFTCPSocket.
 *
 * \return An initialized OFTCPSocket
 */
- init;

/**
 * Connect the OFTCPSocket to the specified destination.
 *
 * \param host The host or IP to connect to
 * \param port The port of the host to connect to
 * \param service The service on the node to connect to
 * \param node The node to connect to
 */
- connectTo: (const char*)host
     onPort: (uint16_t)port;
- connectToService: (OFString*)service
	    onNode: (OFString*)node;

/**
 * Bind socket to the specified address and port.
 * Bind socket on the specified node and service.
 *
 * \param host The host or IP to bind to
 * \param port The port to bind to
 * \param service The service to bind
 * \param node The node to bind to
 * \param protocol The protocol to use (AF_INET or AF_INET6)
 */
-    bindOn: (const char*)host
   withPort: (uint16_t)port
  andFamily: (int)family;
- bindService: (OFString*)service
       onNode: (OFString*)node
   withFamily: (int)family;

/**
 * Listen on the socket.
 *
 * \param backlog Maximum length for the queue of pending connections.
 */
- listenWithBackLog: (int)backlog;

{
	if (sock != INVALID_SOCKET)
		close(sock);

	[super dealloc];
}

- connectTo: (const char*)host
     onPort: (uint16_t)port
- connectToService: (OFString*)service
	    onNode: (OFString*)node
{
	struct addrinfo hints, *res, *res0;
	char portstr[6];

	if (!port)
		@throw [OFInvalidPortException newWithClass: isa];

	if (sock != INVALID_SOCKET)
		@throw [OFAlreadyConnectedException newWithClass: isa];

	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;

	snprintf(portstr, 6, "%d", port);

	if (getaddrinfo([node cString], [service cString], &hints, &res0))
	if (getaddrinfo(host, portstr, &hints, &res0))
		@throw [OFAddressTranslationFailedException
		    newWithClass: isa
			 andNode: host
		      andService: portstr];
			 andNode: node
		      andService: service];

	for (res = res0; res != NULL; res = res->ai_next) {
		if ((sock = socket(res->ai_family, res->ai_socktype,
		    res->ai_protocol)) == INVALID_SOCKET)
			continue;

		if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
			close(sock);
			sock = INVALID_SOCKET;
			continue;
		}

		break;
	}

	freeaddrinfo(res0);

	if (sock == INVALID_SOCKET)
		@throw [OFConnectionFailedException newWithClass: isa
							 andHost: host
							 andPort: port];
							 andNode: node
						      andService: service];

	return self;
}

-    bindOn: (const char*)host
   withPort: (uint16_t)port
  andFamily: (int)family
- bindService: (OFString*)service
       onNode: (OFString*)node
   withFamily: (int)family
{
	struct addrinfo hints, *res;
	char portstr[6];

	if (!port)
		@throw [OFInvalidPortException newWithClass: isa];

	if (sock != INVALID_SOCKET)
		@throw [OFAlreadyConnectedException newWithClass: isa];

	if ((sock = socket(family, SOCK_STREAM, 0)) == INVALID_SOCKET)
		@throw [OFBindFailedException newWithClass: isa
						   andHost: host
						   andPort: port
						   andNode: node
						andService: service
						 andFamily: family];

	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = family;
	hints.ai_socktype = SOCK_STREAM;

	snprintf(portstr, 6, "%d", port);

	if (getaddrinfo([node cString], [service cString], &hints, &res))
	if (getaddrinfo(host, portstr, &hints, &res))
		@throw [OFAddressTranslationFailedException
		    newWithClass: isa
			 andNode: host
		      andService: portstr];
			 andNode: node
		      andService: service];

	if (bind(sock, res->ai_addr, res->ai_addrlen) == -1) {
		freeaddrinfo(res);
		@throw [OFBindFailedException newWithClass: isa
						   andHost: host
						   andPort: port
						   andNode: node
						andService: service
						 andFamily: family];
	}

	freeaddrinfo(res);

	return self;
}

	@try {						\
		code;					\
							\
		puts("NOT CAUGHT!");			\
		return 1;				\
	} @catch (exception *e) {			\
		puts("CAUGHT! Error string was:");	\
		puts([e cString]);			\
		puts([[e string] cString]);		\
		puts("Resuming...");			\
	}

const char *str = "Hallo!";

#define TEST(type) \
	puts("Trying to add too much to an array...");			\

#include <stdio.h>
#include <string.h>

#import "OFAutoreleasePool.h"
#import "OFDictionary.h"
#import "OFIterator.h"
#import "OFConstString.h"
#import "OFString.h"
#import "OFExceptions.h"

int
main()
{
	OFDictionary *dict = [OFDictionary dictionaryWithHashSize: 16];

main()
{
	char   buf[64];
	size_t len;

	OFMD5Hash  *md5  = [OFMD5Hash md5Hash];
	OFSHA1Hash *sha1 = [OFSHA1Hash sha1Hash];
	OFFile *f = [OFFile fileWithPath: "testfile"
				 andMode: "rb"];
	OFFile *f = [OFFile fileWithPath: @"testfile"
				 andMode: @"rb"];

	while (![f atEndOfFile]) {
		len = [f readNBytes: 64
			 intoBuffer: buf];
		[md5 updateWithBuffer: buf
			       ofSize: len];
		[sha1 updateWithBuffer: buf

	@try {						\
		code;					\
							\
		puts("NOT CAUGHT!");			\
		return 1;				\
	} @catch (exception *e) {			\
		puts("CAUGHT! Error string was:");	\
		puts([e cString]);			\
		puts([[e string] cString]);		\
		puts("Resuming...");			\
	}

int
main()
{
	OFObject *obj = [[OFObject alloc] init];

#import "TestPlugin/TestPlugin.h"

int
main()
{
	TestPlugin *plugin;

	plugin = [OFPlugin pluginFromFile: "TestPlugin/TestPlugin"];
	plugin = [OFPlugin pluginFromFile: @"TestPlugin/TestPlugin"];
	if ([plugin test: 1234] != 2468) {
		puts("\033[K\033[1;31mTest 1/1 failed!\033[m");
		return 1;
	}

	puts("\033[1;32mTests successful: 1/1\033[0m");
	return 0;
}

#import "config.h"

#include <stdio.h>
#include <string.h>

#import "OFString.h"
#import "OFConstString.h"
#import "OFArray.h"
#import "OFAutoreleasePool.h"
#import "OFExceptions.h"

#ifndef _WIN32
#define ZD "%zd"
#else

	s3 = [s1 copy];

	CHECK([s1 isEqual: s3])
	CHECK(![s1 isEqual: [[OFObject alloc] init]])
	CHECK([s1 hash] == [s3 hash])

	[s2 appendCString: "123"];
	[s2 appendCString: "12"];
	[s2 append: @"3"];
	[s4 setTo: [s2 cString]];

	CHECK(![s2 compare: s4])
	CHECK(!strcmp([[s1 append: s2] cString], "test123"))
	CHECK([s1 hash] == 0xC44F49A4)
	CHECK(strlen([s1 cString]) == [s1 length] && [s1 length] == 7)
	CHECK(!strcmp([[s1 reverse] cString], "321tset"))

	    OFInvalidEncodingException)

	s1 = [OFString stringWithCString: "äöü€𝄞"];
	CHECK(!strcmp([[s1 reverse] cString], "𝄞€üöä"))
	[s1 dealloc];

	/* Format tests */
	s1 = [OFString stringWithFormat: "%s: %d", "test", 123];
	s1 = [OFString stringWithFormat: @"%s: %d", "test", 123];
	CHECK(!strcmp([s1 cString], "test: 123"))

	[s1 appendWithFormatCString: "%02X", 15];
	[s1 appendWithFormat: @"%02X", 15];
	CHECK(!strcmp([s1 cString], "test: 1230F"))

	a = [@"fooXXbarXXXXbazXXXX" splitWithDelimiter: "XX"];
	a = [@"fooXXbarXXXXbazXXXX" splitWithDelimiter: @"XX"];
	CHECK([[a object: j++] isEqual: @"foo"])
	CHECK([[a object: j++] isEqual: @"bar"])
	CHECK([[a object: j++] isEqual: @""])
	CHECK([[a object: j++] isEqual: @"baz"])
	CHECK([[a object: j++] isEqual: @""])
	CHECK([[a object: j++] isEqual: @""])

	puts("");

	return 0;
}

	return port;
}

int
main()
{
	uint16_t port;
	OFString *service;

	srand(time(NULL));

	@try {
		OFTCPSocket *server = [OFTCPSocket tcpSocket];
		OFTCPSocket *client = [OFTCPSocket tcpSocket];
		OFTCPSocket *accepted;
		char buf[7];

		puts("== IPv4 ==");
		port = get_port();
		service = [OFString stringWithFormat: @"%d", port];

		[server bindOn: "localhost"
		      withPort: port
		     andFamily: AF_INET];
		[server bindService: service
			     onNode: @"localhost"
			 withFamily: AF_INET];
		[server listen];

		[client connectTo: "localhost"
			   onPort: port];
		[client connectToService: service
				  onNode: @"localhost"];

		accepted = [server accept];

		[client writeCString: "Hallo!"];
		[client writeString: @"Hallo!"];
		[accepted readNBytes: 6
			  intoBuffer: buf];
		buf[6] = 0;

		if (!strcmp(buf, "Hallo!"))
			puts("Received correct string!");
		else {
			puts("Received INCORRECT string!");
			return 1;
		}

#ifdef HAVE_IPV6
		memset(buf, 0, 7);

		[accepted release];
		[client close];
		[server close];

		puts("== IPv6 ==");
		port = get_port();
		service = [OFString stringWithFormat: @"%d", port];

		[server bindOn: "::1"
		      withPort: port
		     andFamily: AF_INET6];
		[server bindService: service
			     onNode: @"::1"
			 withFamily: AF_INET6];
		[server listen];

		[client connectTo: "::1"
			   onPort: port];
		[client connectToService: service
				  onNode: @"::1"];

		accepted = [server accept];

		[client writeCString: "IPv6:)"];
		[client writeString: @"IPv6:)"];
		[accepted readNBytes: 6
			  intoBuffer: buf];
		buf[6] = 0;

		if (!strcmp(buf, "IPv6:)"))
			puts("Received correct string!");
		else {
			puts("Received INCORRECT string!");
			return 1;
		}
#endif

		[accepted release];
	} @catch (OFException *e) {
		printf("EXCEPTION: %s\n", [e cString]);
		printf("EXCEPTION: %s\n", [[e string] cString]);
		return 1;
	}

	return 0;
}

 */

#import "config.h"

#include <stdio.h>

#import "OFThread.h"
#import "OFConstString.h"
#import "OFString.h"

@interface MyThread: OFThread
@end

@implementation MyThread
- main
{