#include <sys/types.h>
#include <sys/socket.h>
#include <net/ethernet.h>
#include <libkern/OSAtomic.h>
#include <dlfcn.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
#include <mach/mach.h>
#include "si_module.h"
#define PLUGIN_DIR_PATH "/usr/lib/info"
#define PLUGIN_BUNDLE_SUFFIX "so"
#define WORKUNIT_CALL_ACTIVE 0x00000001
#define WORKUNIT_THREAD_ACTIVE 0x00000002
#define WORKUNIT_RETURNS_LIST 0x00000004
typedef struct si_async_workunit_s
{
si_mod_t *si;
uint32_t call;
char *str1;
char *str2;
char *str3;
uint32_t num1;
uint32_t num2;
uint32_t num3;
uint32_t num4;
uint32_t err;
uint32_t flags;
void *callback;
void *context;
mach_port_t port;
mach_port_t send;
si_item_t *resitem;
si_list_t *reslist;
struct si_async_workunit_s *next;
} si_async_workunit_t;
static si_mod_t **module_list = NULL;
static uint32_t module_count = 0;
static pthread_mutex_t module_mutex = PTHREAD_MUTEX_INITIALIZER;
static si_async_workunit_t *si_async_worklist = NULL;
__private_extern__ si_mod_t *si_module_static_search();
__private_extern__ si_mod_t *si_module_static_file();
__private_extern__ si_mod_t *si_module_static_cache();
__private_extern__ si_mod_t *si_module_static_mdns();
#ifdef DS_AVAILABLE
__private_extern__ si_mod_t *si_module_static_ds();
#endif
static void *
si_mod_dlsym(void *so, const char *name, const char *sym)
{
char *str;
void *out;
if ((so == NULL) || (name == NULL) || (sym == NULL)) return NULL;
str = NULL;
asprintf(&str, "%s_%s", name, sym);
if (str == NULL) return NULL;
out = dlsym(so, str);
free(str);
return out;
}
static si_mod_t *
si_mod_static(const char *name)
{
if (name == NULL) return NULL;
if (string_equal(name, "search")) return si_module_static_search();
if (string_equal(name, "file")) return si_module_static_file();
if (string_equal(name, "cache")) return si_module_static_cache();
if (string_equal(name, "mdns")) return si_module_static_mdns();
#ifdef DS_AVAILABLE
if (string_equal(name, "ds")) return si_module_static_ds();
#endif
return NULL;
}
__private_extern__ si_mod_t *
si_module_with_path(const char *path, const char *name)
{
void *so;
int (*si_sym_init)(si_mod_t *);
void (*si_sym_close)(si_mod_t *);
int status;
si_mod_t *out;
char *outname;
if ((path == NULL) || (name == NULL))
{
errno = EINVAL;
return NULL;
}
so = dlopen(path, RTLD_LOCAL);
if (so == NULL) return NULL;
si_sym_init = si_mod_dlsym(so, name, "init");
if (si_sym_init == NULL)
{
dlclose(so);
errno = ECONNREFUSED;
return NULL;
}
si_sym_close = si_mod_dlsym(so, name, "close");
if (si_sym_close == NULL)
{
dlclose(so);
errno = ECONNREFUSED;
return NULL;
}
out = (si_mod_t *)calloc(1, sizeof(si_mod_t));
outname = strdup(name);
if ((out == NULL) || (outname == NULL))
{
if (out != NULL) free(out);
if (outname != NULL) free(outname);
dlclose(so);
errno = ENOMEM;
return NULL;
}
out->name = outname;
out->refcount = 1;
out->bundle = so;
status = si_sym_init(out);
if (status != 0)
{
dlclose(so);
free(out);
free(outname);
errno = ECONNREFUSED;
return NULL;
}
return out;
}
si_mod_t *
si_module_with_name(const char *name)
{
uint32_t i;
char *path;
si_mod_t *out;
if (name == NULL)
{
errno = EINVAL;
return NULL;
}
pthread_mutex_lock(&module_mutex);
for (i = 0; i < module_count; i++)
{
if (string_equal(module_list[i]->name, name))
{
si_module_retain(module_list[i]);
pthread_mutex_unlock(&module_mutex);
return module_list[i];
}
}
pthread_mutex_unlock(&module_mutex);
out = si_mod_static(name);
pthread_mutex_lock(&module_mutex);
if (out == NULL)
{
path = NULL;
asprintf(&path, "%s/%s.%s", PLUGIN_DIR_PATH, name, PLUGIN_BUNDLE_SUFFIX);
if (path == NULL)
{
errno = ENOMEM;
pthread_mutex_unlock(&module_mutex);
return NULL;
}
out = si_module_with_path(path, name);
free(path);
}
if (out == NULL)
{
pthread_mutex_unlock(&module_mutex);
return NULL;
}
if (module_count == 0)
{
module_list = (si_mod_t **)calloc(1, sizeof(si_mod_t *));
}
else
{
module_list = (si_mod_t **)reallocf(module_list, (module_count + 1) * sizeof(si_mod_t *));
}
if (module_list == NULL)
{
pthread_mutex_unlock(&module_mutex);
return out;
}
module_list[module_count] = out;
module_count++;
pthread_mutex_unlock(&module_mutex);
return out;
}
__private_extern__ si_mod_t *
si_module_retain(si_mod_t *si)
{
if (si == NULL) return NULL;
OSAtomicIncrement32Barrier(&si->refcount);
return si;
}
void
si_module_release(si_mod_t *si)
{
int32_t i;
if (si == NULL) return;
i = OSAtomicDecrement32Barrier(&si->refcount);
if (i > 0) return;
pthread_mutex_lock(&module_mutex);
for (i = 0; (i < module_count) && (module_list[i] != si); i++);
if (i >= module_count)
{
pthread_mutex_unlock(&module_mutex);
return;
}
if (module_count == 1)
{
free(module_list);
module_list = NULL;
module_count = 0;
pthread_mutex_unlock(&module_mutex);
return;
}
for (i++; i < module_count; i++) module_list[i - 1] = module_list[i];
module_count--;
module_list = (si_mod_t **)reallocf(module_list, module_count * sizeof(si_mod_t *));
if (module_list == NULL) module_count = 0;
pthread_mutex_unlock(&module_mutex);
if (si->sim_close != NULL) si->sim_close(si);
if (si->bundle != NULL) dlclose(si->bundle);
if (si->name != NULL) free(si->name);
free(si);
}
__private_extern__ const char *
si_module_name(si_mod_t *si)
{
if (si == NULL) return NULL;
return si->name;
}
__private_extern__ int
si_module_vers(si_mod_t *si)
{
if (si == NULL) return 0;
return si->vers;
}
__private_extern__ int
si_item_match(si_item_t *item, int cat, const void *name, uint32_t num, int which)
{
int i;
union
{
char *x;
struct passwd *u;
struct group *g;
struct grouplist_s *l;
struct aliasent *a;
struct hostent *h;
struct netent *n;
struct servent *s;
struct protoent *p;
struct rpcent *r;
struct fstab *f;
struct mac_s *m;
} ent;
if (item == NULL) return 0;
if (which == SEL_ALL) return 1;
if ((which == SEL_NAME) && (name == NULL)) return 0;
ent.x = (char *)((uintptr_t)item + sizeof(si_item_t));
switch (cat)
{
case CATEGORY_USER:
{
if ((which == SEL_NAME) && (string_equal(name, ent.u->pw_name))) return 1;
else if ((which == SEL_NUMBER) && (num == (uint32_t)ent.u->pw_uid)) return 1;
return 0;
}
case CATEGORY_GROUP:
{
if ((which == SEL_NAME) && (string_equal(name, ent.g->gr_name))) return 1;
else if ((which == SEL_NUMBER) && (num == (uint32_t)ent.g->gr_gid)) return 1;
return 0;
}
case CATEGORY_GROUPLIST:
{
if ((which == SEL_NAME) && (string_equal(name, ent.l->gl_user))) return 1;
return 0;
}
case CATEGORY_ALIAS:
{
if ((which == SEL_NAME) && (string_equal(name, ent.a->alias_name))) return 1;
return 0;
}
case CATEGORY_HOST_IPV4:
case CATEGORY_HOST_IPV6:
{
if (ent.h->h_addrtype != num) return 0;
if (which == SEL_NAME)
{
if (string_equal(name, ent.h->h_name)) return 1;
if (ent.h->h_aliases != NULL)
{
for (i = 0; ent.h->h_aliases[i] != NULL; i++)
{
if (string_equal(name, ent.h->h_aliases[i])) return 1;
}
}
}
else if (which == SEL_NUMBER)
{
if (memcmp(name, ent.h->h_addr_list[0], ent.h->h_length) == 0) return 1;
}
return 0;
}
case CATEGORY_NETWORK:
{
if (which == SEL_NAME)
{
if (string_equal(name, ent.n->n_name)) return 1;
if (ent.n->n_aliases != NULL)
{
for (i = 0; ent.n->n_aliases[i] != NULL; i++)
{
if (string_equal(name, ent.n->n_aliases[i])) return 1;
}
}
}
else if (which == SEL_NUMBER)
{
if (num == ent.n->n_net) return 1;
}
return 0;
}
case CATEGORY_SERVICE:
{
if (which == SEL_NAME)
{
if ((num == 1) && (string_not_equal("udp", ent.s->s_proto))) return 0;
if ((num == 2) && (string_not_equal("tcp", ent.s->s_proto))) return 0;
if (string_equal(name, ent.s->s_name)) return 1;
if (ent.s->s_aliases != NULL)
{
for (i = 0; ent.s->s_aliases[i] != NULL; i++)
{
if (string_equal(name, ent.s->s_aliases[i])) return 1;
}
}
}
else if (which == SEL_NUMBER)
{
if ((name != NULL) && (string_not_equal(name, ent.s->s_proto))) return 0;
if (num == ent.s->s_port) return 1;
}
return 0;
}
case CATEGORY_PROTOCOL:
{
if (which == SEL_NAME)
{
if (string_equal(name, ent.p->p_name)) return 1;
if (ent.p->p_aliases != NULL)
{
for (i = 0; ent.p->p_aliases[i] != NULL; i++)
{
if (string_equal(name, ent.p->p_aliases[i])) return 1;
}
}
}
else if (which == SEL_NUMBER)
{
if (num == ent.p->p_proto) return 1;
}
return 0;
}
case CATEGORY_RPC:
{
if (which == SEL_NAME)
{
if (string_equal(name, ent.r->r_name)) return 1;
if (ent.r->r_aliases != NULL)
{
for (i = 0; ent.r->r_aliases[i] != NULL; i++)
{
if (string_equal(name, ent.r->r_aliases[i])) return 1;
}
}
}
else if (which == SEL_NUMBER)
{
if (num == ent.r->r_number) return 1;
}
return 0;
}
case CATEGORY_FS:
{
if ((which == SEL_NAME) && (string_equal(name, ent.f->fs_spec))) return 1;
if ((which == SEL_NUMBER) && (string_equal(name, ent.f->fs_file))) return 1;
return 0;
}
case CATEGORY_MAC:
{
if ((which == SEL_NAME) && (string_equal(name, ent.m->host))) return 1;
if ((which == SEL_NUMBER) && (string_equal(name, ent.m->mac))) return 1;
return 0;
}
default: return 0;
}
return 0;
}
__private_extern__ int
si_item_is_valid(si_item_t *item)
{
si_mod_t *si;
if (item == NULL) return 0;
si = item->src;
if (si == NULL) return 0;
if (si->sim_is_valid == NULL) return 0;
return si->sim_is_valid(si, item);
}
__private_extern__ si_item_t *
si_user_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_user_byname == NULL) return NULL;
return si->sim_user_byname(si, name);
}
__private_extern__ si_item_t *
si_user_byuid(si_mod_t *si, uid_t uid)
{
if (si == NULL) return NULL;
if (si->sim_user_byuid == NULL) return NULL;
return si->sim_user_byuid(si, uid);
}
__private_extern__ si_list_t *
si_user_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_user_all == NULL) return NULL;
return si->sim_user_all(si);
}
__private_extern__ si_item_t *
si_group_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_group_byname == NULL) return NULL;
return si->sim_group_byname(si, name);
}
__private_extern__ si_item_t *
si_group_bygid(si_mod_t *si, gid_t gid)
{
if (si == NULL) return NULL;
if (si->sim_group_bygid == NULL) return NULL;
return si->sim_group_bygid(si, gid);
}
__private_extern__ si_list_t *
si_group_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_group_all == NULL) return NULL;
return si->sim_group_all(si);
}
__private_extern__ si_item_t *
si_grouplist(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_grouplist == NULL) return NULL;
return si->sim_grouplist(si, name);
}
__private_extern__ si_list_t *
si_netgroup_byname(struct si_mod_s *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_netgroup_byname == NULL) return NULL;
return si->sim_netgroup_byname(si, name);
}
__private_extern__ int
si_in_netgroup(struct si_mod_s *si, const char *name, const char *host, const char *user, const char *domain)
{
if (si == NULL) return 0;
if (si->sim_in_netgroup == NULL) return 0;
return si->sim_in_netgroup(si, name, host, user, domain);
}
__private_extern__ si_item_t *
si_alias_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_alias_byname == NULL) return NULL;
return si->sim_alias_byname(si, name);
}
__private_extern__ si_list_t *
si_alias_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_alias_all == NULL) return NULL;
return si->sim_alias_all(si);
}
__private_extern__ si_item_t *
si_host_byname(si_mod_t *si, const char *name, int af, const char *interface, uint32_t *err)
{
if (si == NULL) return NULL;
if (si->sim_host_byname == NULL) return NULL;
return si->sim_host_byname(si, name, af, interface, err);
}
__private_extern__ si_item_t *
si_host_byaddr(si_mod_t *si, const void *addr, int af, const char *interface, uint32_t *err)
{
if (si == NULL) return NULL;
if (si->sim_host_byaddr == NULL) return NULL;
return si->sim_host_byaddr(si, addr, af, interface, err);
}
__private_extern__ si_list_t *
si_host_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_host_all == NULL) return NULL;
return si->sim_host_all(si);
}
__private_extern__ si_item_t *
si_mac_byname(struct si_mod_s *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_mac_byname == NULL) return NULL;
return si->sim_mac_byname(si, name);
}
__private_extern__ si_item_t *
si_mac_bymac(struct si_mod_s *si, const char *mac)
{
if (si == NULL) return NULL;
if (si->sim_mac_bymac == NULL) return NULL;
return si->sim_mac_bymac(si, mac);
}
__private_extern__ si_list_t *
si_mac_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_mac_all == NULL) return NULL;
return si->sim_mac_all(si);
}
__private_extern__ si_item_t *
si_network_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_network_byname == NULL) return NULL;
return si->sim_network_byname(si, name);
}
__private_extern__ si_item_t *
si_network_byaddr(si_mod_t *si, uint32_t addr)
{
if (si == NULL) return NULL;
if (si->sim_network_byaddr == NULL) return NULL;
return si->sim_network_byaddr(si, addr);
}
__private_extern__ si_list_t *
si_network_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_network_all == NULL) return NULL;
return si->sim_network_all(si);
}
__private_extern__ si_item_t *
si_service_byname(si_mod_t *si, const char *name, const char *proto)
{
if (si == NULL) return NULL;
if (si->sim_service_byname == NULL) return NULL;
return si->sim_service_byname(si, name, proto);
}
__private_extern__ si_item_t *
si_service_byport(si_mod_t *si, int port, const char *proto)
{
if (si == NULL) return NULL;
if (si->sim_service_byport == NULL) return NULL;
return si->sim_service_byport(si, port, proto);
}
__private_extern__ si_list_t *
si_service_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_service_all == NULL) return NULL;
return si->sim_service_all(si);
}
__private_extern__ si_item_t *
si_protocol_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_protocol_byname == NULL) return NULL;
return si->sim_protocol_byname(si, name);
}
__private_extern__ si_item_t *
si_protocol_bynumber(si_mod_t *si, uint32_t number)
{
if (si == NULL) return NULL;
if (si->sim_protocol_bynumber == NULL) return NULL;
return si->sim_protocol_bynumber(si, number);
}
__private_extern__ si_list_t *
si_protocol_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_protocol_all == NULL) return NULL;
return si->sim_protocol_all(si);
}
__private_extern__ si_item_t *
si_rpc_byname(si_mod_t *si, const char *name)
{
if (si == NULL) return NULL;
if (si->sim_rpc_byname == NULL) return NULL;
return si->sim_rpc_byname(si, name);
}
__private_extern__ si_item_t *
si_rpc_bynumber(si_mod_t *si, int number)
{
if (si == NULL) return NULL;
if (si->sim_rpc_bynumber == NULL) return NULL;
return si->sim_rpc_bynumber(si, number);
}
__private_extern__ si_list_t *
si_rpc_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_rpc_all == NULL) return NULL;
return si->sim_rpc_all(si);
}
__private_extern__ si_item_t *
si_fs_byspec(si_mod_t *si, const char *spec)
{
if (si == NULL) return NULL;
if (si->sim_fs_byspec == NULL) return NULL;
return si->sim_fs_byspec(si, spec);
}
__private_extern__ si_item_t *
si_fs_byfile(si_mod_t *si, const char *file)
{
if (si == NULL) return NULL;
if (si->sim_fs_byfile == NULL) return NULL;
return si->sim_fs_byfile(si, file);
}
__private_extern__ si_list_t *
si_fs_all(si_mod_t *si)
{
if (si == NULL) return NULL;
if (si->sim_fs_all == NULL) return NULL;
return si->sim_fs_all(si);
}
__private_extern__ si_item_t *
si_item_call(struct si_mod_s *si, int call, const char *str1, const char *str2, const char *str3, uint32_t num1, uint32_t num2, uint32_t *err)
{
if (si == NULL) return NULL;
switch (call)
{
case SI_CALL_USER_BYNAME: return si_user_byname(si, str1);
case SI_CALL_USER_BYUID: return si_user_byuid(si, (uid_t)num1);
case SI_CALL_GROUP_BYNAME: return si_group_byname(si, str1);
case SI_CALL_GROUP_BYGID: return si_group_bygid(si, (gid_t)num1);
case SI_CALL_GROUPLIST: return si_grouplist(si, str1);
case SI_CALL_ALIAS_BYNAME: return si_alias_byname(si, str1);
case SI_CALL_HOST_BYNAME: return si_host_byname(si, str1, num1, str3, err);
case SI_CALL_HOST_BYADDR: return si_host_byaddr(si, (void *)str1, num1, str3, err);
case SI_CALL_NETWORK_BYNAME: return si_network_byname(si, str1);
case SI_CALL_NETWORK_BYADDR: return si_network_byaddr(si, num1);
case SI_CALL_SERVICE_BYNAME: return si_service_byname(si, str1, str2);
case SI_CALL_SERVICE_BYPORT: return si_service_byport(si, num1, str2);
case SI_CALL_PROTOCOL_BYNAME: return si_protocol_byname(si, str1);
case SI_CALL_PROTOCOL_BYNUMBER: return si_protocol_bynumber(si, num1);
case SI_CALL_RPC_BYNAME: return si_network_byname(si, str1);
case SI_CALL_RPC_BYNUMBER: return si_rpc_bynumber(si, num1);
case SI_CALL_FS_BYSPEC: return si_fs_byspec(si, str1);
case SI_CALL_FS_BYFILE: return si_fs_byfile(si, str1);
case SI_CALL_NAMEINFO: return si_nameinfo(si, (const struct sockaddr *)str1, num1, str3, err);
case SI_CALL_IPNODE_BYNAME: return si_ipnode_byname(si, (const char *)str1, num1, num2, str3, err);
case SI_CALL_MAC_BYNAME: return si_mac_byname(si, (const char *)str1);
case SI_CALL_MAC_BYMAC: return si_mac_bymac(si, (const char *)str1);
case SI_CALL_DNS_QUERY:
case SI_CALL_DNS_SEARCH:
{
if (si->sim_item_call == NULL) return NULL;
return si->sim_item_call(si, call, str1, str2, str3, num1, num2, err);
}
default: return NULL;
}
return NULL;
}
__private_extern__ si_list_t *
si_list_call(struct si_mod_s *si, int call, const char *str1, const char *str2, const char *str3, uint32_t num1, uint32_t num2, uint32_t num3, uint32_t num4, uint32_t *err)
{
if (si == NULL) return NULL;
switch (call)
{
case SI_CALL_USER_ALL: return si_user_all(si);
case SI_CALL_GROUP_ALL: return si_group_all(si);
case SI_CALL_ALIAS_ALL: return si_alias_all(si);
case SI_CALL_HOST_ALL: return si_host_all(si);
case SI_CALL_NETWORK_ALL: return si_network_all(si);
case SI_CALL_SERVICE_ALL: return si_service_all(si);
case SI_CALL_PROTOCOL_ALL: return si_protocol_all(si);
case SI_CALL_RPC_ALL: return si_rpc_all(si);
case SI_CALL_FS_ALL: return si_fs_all(si);
case SI_CALL_MAC_ALL: return si_mac_all(si);
case SI_CALL_ADDRINFO: return si_addrinfo(si, str1, str2, num1, num2, num3, num4, str3, err);
default: return NULL;
}
return NULL;
}
static void
si_async_worklist_add_unit(si_async_workunit_t *r)
{
pthread_mutex_lock(&module_mutex);
r->next = si_async_worklist;
si_async_worklist = r;
pthread_mutex_unlock(&module_mutex);
}
static void
si_async_worklist_remove_unit(si_async_workunit_t *r)
{
si_async_workunit_t *x;
pthread_mutex_lock(&module_mutex);
if (si_async_worklist == r)
{
si_async_worklist = r->next;
}
else
{
for (x = si_async_worklist; (x != NULL) && (x->next != r); x = x->next) {;}
if (x != NULL) x->next = r->next;
}
pthread_mutex_unlock(&module_mutex);
}
static si_async_workunit_t*
si_async_worklist_find_unit(mach_port_t p)
{
si_async_workunit_t *r;
pthread_mutex_lock(&module_mutex);
for (r = si_async_worklist; (r != NULL) && (r->port != p); r = r->next) {;}
pthread_mutex_unlock(&module_mutex);
return r;
}
static si_async_workunit_t *
si_async_workunit_create(si_mod_t *si, int call, const char *str1, const char *str2, const char *str3, uint32_t num1, uint32_t num2, uint32_t num3, uint32_t num4, void *callback, void *context)
{
si_async_workunit_t *r;
kern_return_t status;
mach_port_t reply, send;
mach_msg_type_name_t type;
char *s1, *s2, *s3;
s1 = NULL;
s2 = NULL;
s3 = NULL;
if (si_call_str1_is_buffer(call))
{
if (num3 > 0)
{
s1 = calloc(1, num3);
if (s1 == NULL) return NULL;
memcpy(s1, str1, num3);
}
}
else if (str1 != NULL)
{
s1 = strdup(str1);
if (s1 == NULL) return NULL;
}
if (str2 != NULL)
{
s2 = strdup(str2);
if (s2 == NULL)
{
if (s1 != NULL) free(s1);
return NULL;
}
}
if (str3 != NULL)
{
s3 = strdup(str3);
if (s3 == NULL)
{
if (s1 != NULL) free(s1);
if (s2 != NULL) free(s2);
return NULL;
}
}
r = (si_async_workunit_t *)calloc(1, sizeof(si_async_workunit_t));
if (r == NULL)
{
if (s1 != NULL) free(s1);
if (s2 != NULL) free(s2);
if (s3 != NULL) free(s3);
return NULL;
}
reply = MACH_PORT_NULL;
send = MACH_PORT_NULL;
type = 0;
status = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &reply);
if (status == KERN_SUCCESS) status = mach_port_extract_right(mach_task_self(), reply, MACH_MSG_TYPE_MAKE_SEND_ONCE, &send, &type);
if (status != KERN_SUCCESS)
{
if (reply != MACH_PORT_NULL) mach_port_mod_refs(mach_task_self(), reply, MACH_PORT_RIGHT_RECEIVE, -1);
if (s1 != NULL) free(s1);
if (s2 != NULL) free(s2);
if (s3 != NULL) free(s3);
free(r);
return NULL;
}
r->si = si;
r->call = call;
r->str1 = s1;
r->str2 = s2;
r->str3 = s3;
r->num1 = num1;
r->num2 = num2;
r->num3 = num3;
r->num4 = num4;
r->flags = WORKUNIT_CALL_ACTIVE | WORKUNIT_THREAD_ACTIVE;
if (si_call_returns_list(call)) r->flags |= WORKUNIT_RETURNS_LIST;
r->callback = callback;
r->context = context;
r->port = reply;
r->send = send;
si_async_worklist_add_unit(r);
return r;
}
static void
si_async_workunit_release(si_async_workunit_t *r)
{
if (r == NULL) return;
if (r->flags & (WORKUNIT_THREAD_ACTIVE | WORKUNIT_CALL_ACTIVE)) return;
si_async_worklist_remove_unit(r);
if (r->resitem != NULL) si_item_release(r->resitem);
if (r->reslist != NULL) si_list_release(r->reslist);
if (r->str1 != NULL) free(r->str1);
if (r->str2 != NULL) free(r->str2);
if (r->str3 != NULL) free(r->str3);
free(r);
}
static void *
si_async_launchpad(void *x)
{
si_async_workunit_t *r;
kern_return_t status;
mach_msg_empty_send_t msg;
if (x == NULL) pthread_exit(NULL);
r = (si_async_workunit_t *)x;
if (r->flags & WORKUNIT_RETURNS_LIST) r->reslist = si_list_call(r->si, r->call, r->str1, r->str2, r->str3, r->num1, r->num2, r->num3, r->num4, &(r->err));
else r->resitem = si_item_call(r->si, r->call, r->str1, r->str2, r->str3, r->num1, r->num2, &(r->err));
memset(&msg, 0, sizeof(mach_msg_empty_send_t));
msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, MACH_MSGH_BITS_ZERO);
msg.header.msgh_remote_port = r->send;
msg.header.msgh_local_port = MACH_PORT_NULL;
msg.header.msgh_size = sizeof(mach_msg_empty_send_t);
msg.header.msgh_id = r->call;
OSAtomicAnd32Barrier(~WORKUNIT_THREAD_ACTIVE, &r->flags);
si_async_workunit_release(r);
status = mach_msg(&(msg.header), MACH_SEND_MSG, msg.header.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (status != MACH_MSG_SUCCESS)
{
mach_msg_destroy(&(msg.header));
}
pthread_exit(NULL);
return NULL;
}
mach_port_t
si_async_call(struct si_mod_s *si, int call, const char *str1, const char *str2, const char *str3, uint32_t num1, uint32_t num2, uint32_t num3, uint32_t num4, void *callback, void *context)
{
si_async_workunit_t *req;
pthread_attr_t attr;
pthread_t t;
if (si == NULL) return MACH_PORT_NULL;
if (callback == NULL) return MACH_PORT_NULL;
if (si->sim_async_call != NULL)
{
return si->sim_async_call(si, call, str1, str2, str3, num1, num2, num3, num4, callback, context);
}
req = si_async_workunit_create(si, call, str1, str2, str3, num1, num2, num3, num4, callback, context);
if (req == NULL) return MACH_PORT_NULL;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&t, &attr, si_async_launchpad, req);
pthread_attr_destroy(&attr);
return req->port;
}
void
si_async_cancel(mach_port_t p)
{
si_async_workunit_t *r;
r = si_async_worklist_find_unit(p);
if (r == NULL) return;
OSAtomicAnd32Barrier(~WORKUNIT_CALL_ACTIVE, &r->flags);
if (r->callback != NULL)
{
if (r->flags & WORKUNIT_RETURNS_LIST) ((list_async_callback)(r->callback))(NULL, SI_STATUS_CALL_CANCELLED, r->context);
else ((item_async_callback)(r->callback))(NULL, SI_STATUS_CALL_CANCELLED, r->context);
}
si_async_workunit_release(r);
mach_port_mod_refs(mach_task_self(), p, MACH_PORT_RIGHT_RECEIVE, -1);
}
void
si_async_handle_reply(mach_msg_header_t *msg)
{
si_async_workunit_t *r;
mach_port_t reply = msg->msgh_local_port;
r = si_async_worklist_find_unit(reply);
if (r == NULL)
{
#ifdef CALL_TRACE
fprintf(stderr, "** %s can't find worklist item\n", __func__);
#endif
return;
}
if (r->flags & WORKUNIT_THREAD_ACTIVE)
{
#ifdef CALL_TRACE
fprintf(stderr, "** %s workunit thread is still active\n", __func__);
#endif
return;
}
if (r->callback != NULL)
{
if (r->flags & WORKUNIT_RETURNS_LIST) ((list_async_callback)(r->callback))(r->reslist, r->err, r->context);
else ((item_async_callback)(r->callback))(r->resitem, r->err, r->context);
r->reslist = NULL;
r->resitem = NULL;
}
else
{
#ifdef CALL_TRACE
fprintf(stderr, "** %s workunit has no callback\n", __func__);
#endif
}
OSAtomicAnd32Barrier(~WORKUNIT_CALL_ACTIVE, &r->flags);
si_async_workunit_release(r);
mach_port_mod_refs(mach_task_self(), reply, MACH_PORT_RIGHT_RECEIVE, -1);
}
__private_extern__ char *
si_canonical_mac_address(const char *addr)
{
char e[6][3];
char *out;
struct ether_addr *ether;
int i, bit;
if (addr == NULL) return NULL;
pthread_mutex_lock(&module_mutex);
ether = ether_aton(addr);
if (ether == NULL)
{
pthread_mutex_unlock(&module_mutex);
return NULL;
}
for (i = 0, bit = 1; i < 6; i++, bit *= 2)
{
if ((i & bit) && (ether->ether_addr_octet[i] <= 15))
{
sprintf(e[i], "0%x", ether->ether_addr_octet[i]);
}
else
{
sprintf(e[i], "%x", ether->ether_addr_octet[i]);
}
}
pthread_mutex_unlock(&module_mutex);
out = NULL;
asprintf(&out, "%s:%s:%s:%s:%s:%s", e[0], e[1], e[2], e[3], e[4], e[5]);
return out;
}