void SHash_grow(SHash *self)
{
unsigned int oldTableSize = self->tableSize;
SHashRecord* oldRecords = self->records;
self->records = NULL;
while (self->records == NULL)
{
unsigned int i;
SHash_tableInit_(self, self->log2tableSize + 1);
// enumerate old records
i = 0;
while (i < oldTableSize*2)
{
SHashRecord thisRecord = oldRecords[i];
i++;
if (thisRecord.key)
{
SHashRecord *record = SHash_cuckoo_(self, &thisRecord);
if (!record) // collision
{
io_free(self->records);
self->records = NULL;
break; // grow & rehash
}
*record = thisRecord;
}
}
}
io_free(oldRecords);
}
kern_return_t
ipc_object_alloc_name(
ipc_space_t space,
ipc_object_type_t otype,
mach_port_type_t type,
mach_port_urefs_t urefs,
mach_port_name_t name,
ipc_object_t *objectp)
{
ipc_object_t object;
ipc_entry_t entry;
kern_return_t kr;
assert(otype < IOT_NUMBER);
assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
assert(type != MACH_PORT_TYPE_NONE);
assert(urefs <= MACH_PORT_UREFS_MAX);
object = io_alloc(otype);
if (object == IO_NULL)
return KERN_RESOURCE_SHORTAGE;
if (otype == IOT_PORT) {
ipc_port_t port = (ipc_port_t)object;
bzero((char *)port, sizeof(*port));
#if CONFIG_MACF_MACH
mac_port_label_init(&port->ip_label);
#endif
} else if (otype == IOT_PORT_SET) {
ipc_pset_t pset = (ipc_pset_t)object;
bzero((char *)pset, sizeof(*pset));
}
io_lock_init(object);
kr = ipc_entry_alloc_name(space, name, &entry);
if (kr != KERN_SUCCESS) {
io_free(otype, object);
return kr;
}
/* space is write-locked */
if (ipc_right_inuse(space, name, entry)) {
io_free(otype, object);
return KERN_NAME_EXISTS;
}
entry->ie_bits |= type | urefs;
entry->ie_object = object;
io_lock(object);
is_write_unlock(space);
object->io_references = 1; /* for entry, not caller */
object->io_bits = io_makebits(TRUE, otype, 0);
*objectp = object;
return KERN_SUCCESS;
}
int CHash_resizeTo_(CHash *self, size_t newSize)
{
unsigned char *oldRecords = self->records;
size_t oldSize = self->size;
self->isResizing = 1;
//printf("%p resizeTo %i/%i %i%%\n", (void *)self, self->keyCount, self->size, (int)(100.0*CHash_density(self)));
do
{
self->size = newSize;
self->records = io_calloc(1, sizeof(CHashRecord) * self->size);
self->keyCount = 0;
CHash_updateMask(self);
if(CHash_insertRecords(self, oldRecords, oldSize) == 0)
{
self->isResizing = 0;
}
else
{
//printf("%p grow collision %i/%i\n", (void *)self, self->keyCount, self->size);
newSize *= 2;
io_free(self->records);
}
} while(self->isResizing);
io_free(oldRecords);
return 0;
}
void BStream_free(BStream *self)
{
if (self->ownsUArray) UArray_free(self->ba);
UArray_free(self->tmp);
UArray_free(self->errorBa);
io_free(self->typeBuf);
io_free(self);
}
void DynLib_free(DynLib *self)
{
//DynLib_close(self);
if (self->path) io_free(self->path);
if (self->initFuncName) io_free(self->initFuncName);
if (self->freeFuncName) io_free(self->freeFuncName);
if (self->error) io_free(self->error);
io_free(self);
}
void IoLexer_free(IoLexer *self)
{
IoLexer_clear(self);
io_free(self->s);
Stack_free(self->posStack);
Stack_free(self->tokenStack);
List_free(self->tokenStream);
List_free(self->charLineIndex);
if(self->errorDescription) io_free(self->errorDescription);
io_free(self);
}
struct fsm *fsm_read_binary_file(char *filename) {
char *net_name;
struct fsm *net;
struct io_buf_handle *iobh;
iobh = io_init();
if (io_gz_file_to_mem(iobh, filename) == 0) {
io_free(iobh);
return NULL;
}
net = io_net_read(iobh, &net_name);
io_free(iobh);
return(net);
}
static int print_var_definition(parser_t *p, int comp, const char *varname,
const char *buf, size_t bufsz)
{
codec_t *zip = NULL;
io_t *ios = NULL;
int rc, i;
unsigned char c;
dbg_err_if(p == NULL);
dbg_err_if(varname == NULL);
dbg_err_if(buf == NULL);
/* create an io_t around the HTML block */
dbg_err_if(io_mem_create((char*)buf, bufsz, 0, &ios));
#ifdef HAVE_LIBZ
/* if compression is enabled zip the data block */
if(comp)
{
/* apply a gzip codec */
dbg_err_if(codec_gzip_create(GZIP_COMPRESS, &zip));
dbg_err_if(io_codec_add_tail(ios, zip));
zip = NULL; /* io_free() will free the codec */
}
#endif
io_printf(p->out, "static const char %s[] = {\n", varname);
for(i = 1; (rc = io_getc(ios, (char*)&c)) > 0; ++i)
{
io_printf(p->out, "0x%02X, ", c);
if(i % 12 == 0)
io_printf(p->out, "\n");
}
dbg_err_if(rc < 0); /* input stream error */
io_printf(p->out, "};\n");
io_free(ios);
return 0;
err:
if(zip)
codec_free(zip);
if(ios)
io_free(ios);
return ~0;
}
void IoCoroutine_free(IoCoroutine *self)
{
Coro *coro = DATA(self)->cid;
if (coro) Coro_free(coro);
Stack_free(DATA(self)->ioStack);
io_free(DATA(self));
}
void PHash_copy_(PHash *self, const PHash *other)
{
io_free(self->records);
memcpy(self, other, sizeof(PHash));
self->records = malloc(self->size * sizeof(PHashRecord));
memcpy(self->records, other->records, self->size * sizeof(PHashRecord));
}
void IoFile_free(IoFile *self)
{
if (NULL == IoObject_dataPointer(self))
{
return;
}
IoFile_justClose(self);
if (DATA(self)->info)
{
io_free(DATA(self)->info);
}
io_free(IoObject_dataPointer(self));
}
IoDynLib *IoDynLib_callPluginInitFunc(IoDynLib *self, IoObject *locals, IoMessage *m)
{
/*doc DynLib callPluginInit(functionName)
Call's the dll function of the specified name.
Returns the result as a Number or raises an exception on error.
*/
intptr_t rc = 0;
intptr_t *params = NULL;
void *f = DynLib_pointerForSymbolName_(DATA(self),
CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0)));
if (f == NULL)
{
IoState_error_(IOSTATE, m, "Error resolving call '%s'.",
CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0)));
return IONIL(self);
}
if (IoMessage_argCount(m) < 1)
{
IoState_error_(IOSTATE, m, "Error, you must give an init function name to check for.");
return IONIL(self);
}
params = io_calloc(1, sizeof(intptr_t) * 2);
params[0] = (intptr_t)IOSTATE;
params[1] = (intptr_t)IOSTATE->lobby;
rc = ((intptr_t (*)(intptr_t, intptr_t))f)(params[0], params[1]);
io_free(params);
return IONUMBER(rc);
}
int io_mem_create(char *buf, size_t size, int flags, io_t **pio)
{
io_mem_t *im = NULL;
dbg_err_if (buf == NULL);
dbg_err_if (pio == NULL);
dbg_err_if(io_create(io_mem_t, (io_t**)&im));
im->io.type = IO_TYPE_MEM;
im->buf = buf;
im->size = size;
im->flags = flags;
im->off = 0;
im->io.read = (io_read_op) io_mem_read;
im->io.write = (io_write_op) io_mem_write;
im->io.seek = (io_seek_op) io_mem_seek;
im->io.tell = (io_tell_op) io_mem_tell;
im->io.close = (io_close_op) io_mem_close;
im->io.free = (io_free_op) io_mem_free;
*pio = (io_t*)im;
return 0;
err:
if(im)
io_free((io_t *)im);
return ~0;
}
BOOL io_init(io_struct *ps, uint32 size, BOOL io)
{
io_free(ps);
ps->io = io;
ps->bigendian_data = False;
ps->is_dynamic = False;
ps->data_offset = 0;
ps->buffer_size = 0;
ps->data_p = NULL;
ps->format_string = NULL;
ps->format_offset = 0;
ps->entry_count = NULL;
ps->receive_buf = NULL;
ps->receive_len = NULL;
ps->ctx = NULL;
if (size != 0) {
ps->buffer_size = size;
if((ps->data_p = (char *)talloc(get_ctx(ps), (size_t)size)) == NULL) {
DEBUG(0,("io_init: malloc fail for %u bytes.\n", (unsigned int)size));
return False;
}
ps->is_dynamic = True; /* We own this memory. */
}
return True;
}
static void setenv(const char *varName, const char* value, int force)
{
const char *safeValue;
char *buf;
if (!varName)
{
return;
}
if (!value)
{
safeValue = "";
}
else
{
safeValue = value;
}
// buffer for var and value plus '=' and the \0
buf = (char*)io_calloc(1, strlen(varName) + strlen(safeValue) + 2);
if (!buf)
{
return;
}
strcpy(buf, varName);
strcat(buf, "=");
strcat(buf, safeValue);
_putenv(buf);
io_free(buf);
}
gboolean
io_close_and_free (IOStream *io, GError **err)
{
gboolean retval = FALSE;
if (io == NULL)
return FALSE;
if (io->fd >= 0) {
if (io->mode == IO_MODE_WRITE) {
/* Any pending writes to flush? */
if (io->s.write.curpos != 0) {
if (_io_fd_write (io->fd, io->s.write.buf, io->s.write.curpos, err))
retval = TRUE;
}
}
if (close (io->fd)) {
IO_ERRNO_ERR (err, errno, "Failed to close stream");
retval = TRUE;
}
}
io_free (io);
return retval;
}
void IoCFFIArray_free(IoCFFIArray *self)
{
IoCFFIArrayData *data;
data = DATA(self);
if ( data->needToFreeBuffer ) {
io_free(data->buffer);
data->buffer = NULL;
}
if ( DATA(self)->needToFreeFFIType ) {
io_free(DATA(self)->ffiType.elements);
}
io_free(data);
}
IO_METHOD(IoNumber, justAsString)
{
IoSymbol *string;
char *s = IoNumber_asAllocedCString(self);
string = IoSeq_newWithCString_((IoState *)IOSTATE, s);
io_free(s);
return string;
}
void Image_free(Image *self)
{
if (self->ownsUArray)
{
UArray_free(self->byteArray);
}
if (self->error)
{
io_free(self->error);
}
io_free(self->fileType);
io_free(self->path);
io_free(self);
}
void IoCoroutine_free(IoCoroutine *self)
{
//printf("IoCoroutine_free %p\n", (void *)self);
Coro *coro = DATA(self)->cid;
if (coro) Coro_free(coro);
Stack_free(DATA(self)->ioStack);
io_free(DATA(self));
}
int load_defined(struct defined_networks *def, char *filename) {
struct fsm *net;
char *net_name;
struct io_buf_handle *iobh;
iobh = io_init();
printf("Loading definitions from %s.\n",filename);
if (io_gz_file_to_mem(iobh, filename) == 0) {
fprintf(stderr, "File error.\n");
io_free(iobh);
return 0;
}
while ((net = io_net_read(iobh, &net_name)) != NULL) {
add_defined(def, net, net_name);
}
io_free(iobh);
return(1);
}
static void closedir(DIR * pDir)
{
if (pDir->hFind != INVALID_HANDLE_VALUE)
{
FindClose(pDir->hFind);
}
io_free(pDir);
}
/* Close connection. */
void
fetch_pop3_disconnect(struct account *a)
{
struct fetch_pop3_data *data = a->data;
if (data->io != NULL) {
io_close(data->io);
io_free(data->io);
data->io = NULL;
}
}
IO_METHOD(IoNumber, printNumber)
{
/*doc Number print
Prints the number.
*/
char *s = IoNumber_asAllocedCString(self);
IoState_print_((IoState *)IOSTATE, s);
io_free(s);
return self;
}
void PHash_resizeTo_(PHash *self, size_t newSize)
{
unsigned char *oldRecords = self->records;
size_t oldSize = self->size;
self->size = newSize;
self->records = io_calloc(1, sizeof(PHashRecord) * self->size);
self->keyCount = 0;
PHash_updateMask(self);
PHash_insertRecords(self, oldRecords, oldSize);
io_free(oldRecords);
}
void IoMessage_free(IoMessage *self)
{
//IoMessageData *d = (IoMessageData *)IoObject_dataPointer(self);
if (DATA(self)->args)
{
List_free(DATA(self)->args);
}
io_free(IoObject_dataPointer(self));
}
void DynLib_setError_(DynLib *self,const char *error)
{
if (error)
{
self->error = strcpy((char *)io_realloc(self->error, strlen(error)+1), error);
}
else
{
if (self->error) io_free(self->error);
self->error = NULL;
}
}
void Coro_free(Coro *self)
{
#ifdef USE_FIBERS
// If this coro has a fiber, delete it.
// Don't delete the main fiber. We don't want to commit suicide.
if (self->fiber && !self->isMain)
{
DeleteFiber(self->fiber);
}
#else
STACK_DEREGISTER(self);
#endif
if (self->stack)
{
io_free(self->stack);
}
//printf("Coro_%p io_free\n", (void *)self);
io_free(self);
}
kern_return_t
ipc_object_alloc(
ipc_space_t space,
ipc_object_type_t otype,
mach_port_type_t type,
mach_port_urefs_t urefs,
mach_port_name_t *namep,
ipc_object_t *objectp)
{
ipc_object_t object;
ipc_entry_t entry;
kern_return_t kr;
assert(otype < IOT_NUMBER);
assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
assert(type != MACH_PORT_TYPE_NONE);
assert(urefs <= MACH_PORT_UREFS_MAX);
object = io_alloc(otype);
if (object == IO_NULL)
return KERN_RESOURCE_SHORTAGE;
if (otype == IOT_PORT) {
ipc_port_t port = (ipc_port_t)object;
bzero((char *)port, sizeof(*port));
} else if (otype == IOT_PORT_SET) {
ipc_pset_t pset = (ipc_pset_t)object;
bzero((char *)pset, sizeof(*pset));
}
io_lock_init(object);
*namep = CAST_MACH_PORT_TO_NAME(object);
kr = ipc_entry_alloc(space, namep, &entry);
if (kr != KERN_SUCCESS) {
io_free(otype, object);
return kr;
}
/* space is write-locked */
entry->ie_bits |= type | urefs;
entry->ie_object = object;
ipc_entry_modified(space, *namep, entry);
io_lock(object);
object->io_references = 1; /* for entry, not caller */
object->io_bits = io_makebits(TRUE, otype, 0);
*objectp = object;
return KERN_SUCCESS;
}
void IoTag_free(IoTag *self)
{
//printf("io_free tag %p\n", (void *)self);
//printf("%s\n", self->name ? self->name : "NULL");
if (--self->referenceCount > 0) {
return;
}
if (self->tagCleanupFunc)
{
(self->tagCleanupFunc)(self);
}
if (self->name)
{
io_free(self->name);
self->name = NULL;
}
//Stack_free(self->recyclableInstances);
io_free(self);
}
