#include <security_utilities/errors.h>
#include <security_utilities/debugging.h>
#include <typeinfo>
#include <stdio.h>
#include <Security/SecBase.h>
#define errSecErrnoBase 100000
#define errSecErrnoLimit 100255
CommonError::CommonError()
{
}
CommonError::CommonError(const CommonError &source)
{
SECURITY_EXCEPTION_COPY(this, &source);
}
CommonError::~CommonError() throw ()
{
SECURITY_EXCEPTION_HANDLED(this);
}
UnixError::UnixError() : error(errno)
{
SECURITY_EXCEPTION_THROW_UNIX(this, errno);
}
UnixError::UnixError(int err) : error(err)
{
SECURITY_EXCEPTION_THROW_UNIX(this, err);
}
const char *UnixError::what() const throw ()
{ return "UNIX error exception"; }
OSStatus UnixError::osStatus() const
{
return error + errSecErrnoBase;
}
int UnixError::unixError() const
{ return error; }
void UnixError::throwMe(int err) { throw UnixError(err); }
UnixError UnixError::make(int err) { return UnixError(err); }
MacOSError::MacOSError(int err) : error(err)
{
SECURITY_EXCEPTION_THROW_OSSTATUS(this, err);
}
const char *MacOSError::what() const throw ()
{ return "MacOS error"; }
OSStatus MacOSError::osStatus() const
{ return error; }
int MacOSError::unixError() const
{
if (error >= errSecErrnoBase && error <= errSecErrnoLimit)
return error - errSecErrnoBase;
switch (error) {
default:
return -1;
}
}
void MacOSError::throwMe(int error)
{ throw MacOSError(error); }
MacOSError MacOSError::make(int error)
{ return MacOSError(error); }
CFError::CFError()
{
SECURITY_EXCEPTION_THROW_CF(this);
}
const char *CFError::what() const throw ()
{ return "CoreFoundation error"; }
OSStatus CFError::osStatus() const
{ return errSecCoreFoundationUnknown; }
int CFError::unixError() const
{
return EFAULT; }
void CFError::throwMe()
{ throw CFError(); }
void ModuleNexusError::throwMe()
{
throw ModuleNexusError();
}
OSStatus ModuleNexusError::osStatus() const
{
return errSecParam;
}
int ModuleNexusError::unixError() const
{
return EINVAL;
}