static int
ipf_modload(void)
{
char *defpass, *c, *str;
int i, j, error;
RWLOCK_INIT(&ipf_global, "ipf filter load/unload mutex");
RWLOCK_INIT(&ipf_mutex, "ipf filter rwlock");
RWLOCK_INIT(&ipf_frcache, "ipf cache rwlock");
error = ipfattach();
if (error) {
RW_DESTROY(&ipf_global);
RW_DESTROY(&ipf_mutex);
RW_DESTROY(&ipf_frcache);
return error;
}
for (i = 0; i < IPL_LOGSIZE; i++)
ipf_devs[i] = NULL;
for (i = 0; (str = ipf_devfiles[i]); i++) {
c = NULL;
for(j = strlen(str); j > 0; j--)
if (str[j] == '/') {
c = str + j + 1;
break;
}
if (!c)
c = str;
ipf_devs[i] = make_dev(&ipl_cdevsw, i, 0, 0, 0600, c);
}
error = ipf_pfil_hook();
if (error != 0)
return error;
ipf_event_reg();
if (FR_ISPASS(fr_pass))
defpass = "******";
else if (FR_ISBLOCK(fr_pass))
defpass = "******";
else
defpass = "******";
printf("%s initialized. Default = %s all, Logging = %s%s\n",
ipfilter_version, defpass,
#ifdef IPFILTER_LOG
"enabled",
#else
"disabled",
#endif
#ifdef IPFILTER_COMPILED
" (COMPILED)"
#else
""
#endif
);
return 0;
}
/* ------------------------------------------------------------------------ */
int ipfsync_init()
{
RWLOCK_INIT(&ipf_syncstate, "add things to state sync table");
RWLOCK_INIT(&ipf_syncnat, "add things to nat sync table");
MUTEX_INIT(&ipf_syncadd, "add things to sync table");
MUTEX_INIT(&ipsl_mutex, "add things to sync table");
# if SOLARIS && defined(_KERNEL)
cv_init(&ipslwait, "ipsl condvar", CV_DRIVER, NULL);
# endif
bzero((char *)syncnattab, sizeof(syncnattab));
bzero((char *)syncstatetab, sizeof(syncstatetab));
return 0;
}
int _init()
{
int status;
/*
* Initialize mutex's
*/
RWLOCK_INIT(&ipf_global, "ipf filter load/unload mutex");
RWLOCK_INIT(&ipf_mutex, "ipf filter rwlock");
status = mod_install(&modlink1);
if (status != 0) {
RW_DESTROY(&ipf_mutex);
RW_DESTROY(&ipf_global);
}
return status;
}
int
ipsc_init(void)
{
RWLOCK_INIT(&ipsc_rwlock, "ip scan rwlock");
ipsc_inited = 1;
return 0;
}
bool Trace::ConnectToFileAndStart(char *filename, unsigned int trace_index, int register_size, int register_count, bool is_big_endian) {
trace_index_ = trace_index;
is_big_endian_ = is_big_endian;
register_size_ = register_size;
register_count_ = register_count;
RWLOCK_INIT(db_lock_);
MUTEX_INIT(backing_mutex_);
registers_.resize(register_count_);
#ifdef _WIN32
fd_ = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
#else
fd_ = open(filename, O_RDONLY);
if (fd_ == -1) {
printf("ERROR: file open failed\n");
return false;
}
#endif
if (!remap_backing(sizeof(struct change))) {
printf("ERROR: remap backing failed\n");
return false;
}
THREAD_CREATE(thread, thread_entry, this);
return true;
}
/* Essentially sets up mutexes to protect global data/devices */
void LockSetup(void)
{
/* global mutex attribute */
_MUTEX_ATTR_INIT(Mutex.mattr);
#ifdef __UCLIBC__
#if ((__UCLIBC_MAJOR__ << 16)+(__UCLIBC_MINOR__ << 8)+(__UCLIBC_SUBLEVEL__) < 0x00091D)
/* If uClibc < 0.9.29, then re-initialize internal pthread-structs
* pthread and mutexes doesn't work after daemon() is called and
* the main-process is gone.
*
* This workaround will probably be fixed in uClibc-0.9.28
* Other uClibc developers have noticed similar problems which are
* trigged when pthread functions are used in shared libraries. */
__pthread_initial_thread_bos = NULL;
__pthread_initialize();
_MUTEX_ATTR_SET(Mutex.mattr, PTHREAD_MUTEX_ADAPTIVE_NP);
#else /* UCLIBC_VERSION */
_MUTEX_ATTR_SET(Mutex.mattr, PTHREAD_MUTEX_DEFAULT);
#endif /* UCLIBC_VERSION */
_MUTEX_INIT(Mutex.uclibc_mutex);
#else /* __UCLIBC__ */
_MUTEX_ATTR_SET(Mutex.mattr, PTHREAD_MUTEX_DEFAULT);
#endif /* __UCLIBC__ */
_MUTEX_INIT(Mutex.stat_mutex);
_MUTEX_INIT(Mutex.controlflags_mutex);
_MUTEX_INIT(Mutex.fstat_mutex);
_MUTEX_INIT(Mutex.dir_mutex);
_MUTEX_INIT(Mutex.typedir_mutex);
_MUTEX_INIT(Mutex.externaldir_mutex);
_MUTEX_INIT(Mutex.namefind_mutex);
_MUTEX_INIT(Mutex.aliasfind_mutex);
_MUTEX_INIT(Mutex.externalcount_mutex);
_MUTEX_INIT(Mutex.timegm_mutex);
_MUTEX_INIT(Mutex.detail_mutex);
RWLOCK_INIT(Mutex.lib);
RWLOCK_INIT(Mutex.cache);
RWLOCK_INIT(Mutex.persistent_cache);
RWLOCK_INIT(Inbound_Control.lock);
RWLOCK_INIT(Inbound_Control.monitor_lock);
#if OW_USB
_MUTEX_INIT(Mutex.libusb_mutex);
#endif /* OW_USB */
}
LKV *lkv_init(char *file)
{
LKV *lkv = NULL;
char path[1024];
struct stat st = {0};
off_t size = 0;
int i = 0;
if(file && (lkv = (LKV *)calloc(1, sizeof(LKV))))
{
#ifdef __LKV_USE_IDX__
if((lkv->fd = open(file, O_CREAT|O_RDWR, 0644)) > 0)
{
size = lkv->msize = (off_t)sizeof(LVVSTATE) + (off_t)sizeof(LVVKV) * (off_t)LVV_NODES_MAX;
lkv->state = (LVVSTATE*)mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, lkv->fd, 0);
lkv->map = (LVVKV *)((char *)lkv->state + sizeof(LVVSTATE));
fstat(lkv->fd, &st);
lkv->size = st.st_size;
if(st.st_size < sizeof(LVVSTATE))
{
i = ftruncate(lkv->fd, sizeof(LVVSTATE));
memset(lkv->state, 0, sizeof(LVVSTATE));
lkv->size = sizeof(LVVSTATE);
for(i = 0; i < LVV_SLOT_MAX; i++)
{
lkv->state->slots[i].nodeid = -1;
}
}
lkv->roots = lkv->state->roots;
lkv->slots = lkv->state->slots;
//fprintf(stdout, "size:%lld/%d\n", lkv->size, sizeof(LVVSTATE));
}
else
{
fprintf(stderr, "open %s failed, %s\n", file, strerror(errno));
}
#endif
sprintf(path, "%s.v", file);
if((lkv->vfd = open(path, O_CREAT|O_RDWR, 0644)) > 0)
{
size = lkv->vmsize = (off_t)sizeof(LVVV) * (off_t)LVV_NODES_MAX;
lkv->vmap = (LVVV *)mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, lkv->vfd, 0);
fstat(lkv->vfd, &st);
lkv->vsize = st.st_size;
}
else
{
fprintf(stderr, "open %s failed, %s\n", file, strerror(errno));
}
RWLOCK_INIT(lkv->rwlock);
}
return lkv;
}
/* ------------------------------------------------------------------------ */
int ip_lookup_init()
{
if (ip_pool_init() == -1)
return -1;
RWLOCK_INIT(&ip_poolrw, "ip pool rwlock");
ip_lookup_inited = 1;
return 0;
}
DMAP *dmap_init(char *file)
{
DMAP *dmap = NULL;
char path[1024];
struct stat st = {0};
off_t size = 0;
int i = 0;
if(file && (dmap = (DMAP *)calloc(1, sizeof(DMAP))))
{
if((dmap->fd = open(file, O_CREAT|O_RDWR, 0644)) > 0)
{
size = dmap->msize = (off_t)sizeof(DMMSTATE) + (off_t)sizeof(DMMKV) * (off_t)DMM_NODES_MAX;
dmap->state = (DMMSTATE*)mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, dmap->fd, 0);
dmap->map = (DMMKV *)((char *)dmap->state + sizeof(DMMSTATE));
fstat(dmap->fd, &st);
dmap->size = st.st_size;
if(st.st_size < sizeof(DMMSTATE))
{
i = ftruncate(dmap->fd, sizeof(DMMSTATE));
memset(dmap->state, 0, sizeof(DMMSTATE));
dmap->size = sizeof(DMMSTATE);
for(i = 0; i < DMM_SLOT_MAX; i++)
{
dmap->state->slots[i].nodeid = -1;
}
}
dmap->roots = dmap->state->roots;
dmap->slots = dmap->state->slots;
//fprintf(stdout, "size:%lld/%d\n", dmap->size, sizeof(DMMSTATE));
}
else
{
fprintf(stderr, "open %s failed, %s\n", file, strerror(errno));
}
sprintf(path, "%s.v", file);
if((dmap->vfd = open(path, O_CREAT|O_RDWR, 0644)) > 0)
{
size = dmap->vmsize = (off_t)sizeof(DMMV) * (off_t)DMM_NODES_MAX;
dmap->vmap = (DMMV *)mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, dmap->vfd, 0);
fstat(dmap->vfd, &st);
dmap->vsize = st.st_size;
//fprintf(stdout, "vsize:%lld\n", dmap->vsize);
}
else
{
fprintf(stderr, "open %s failed, %s\n", file, strerror(errno));
}
RWLOCK_INIT(dmap->rwlock);
}
return dmap;
}
static int _init(T *thiz)
{
RWLOCK_INIT(&thiz->lock);
ADD_METHOD(init);
ADD_METHOD(destroy);
ADD_METHOD(parse);
ADD_METHOD(mkeyflt);
ADD_METHOD(mvalflt);
ADD_METHOD(fkeyflt);
ADD_METHOD(fvalflt);
return 0;
}
static int
monitor_pthread_create (p_lock_t *plock)
{
int status;
p_lock_t lock = calloc (1, sizeof (*lock));
if (lock == NULL)
return ENOMEM;
status = RWLOCK_INIT (&(lock->mutex), NULL);
if (status != 0)
{
free (lock);
return status;
}
*plock = lock;
return 0;
}
EXPORT int
OSPX_error_register(uint8_t *m, const char *desc, OSPX_ansi_error efunc)
{
static int slinitializied = 0;
OSPX_em_t *ectx;
if (!slinitializied) {
memset(&ospx_ectx, 0, sizeof(ospx_ectx));
if ((errno = RWLOCK_INIT(&ospx_ectx)))
return -1;
slinitializied = 1;
}
ectx = (OSPX_em_t *)calloc(1, sizeof(OSPX_em_t) + (desc ? (strlen(desc) + 1) : 0));
if (!ectx) {
errno = ENOMEM;
return -1;
}
ectx->desc = (char *)(ectx + 1);
ectx->m = *m;
ectx->efunc = efunc;
if (desc)
strcpy(ectx->desc, desc);
RWLOCK_WRITER_ACQUIRE(&ospx_ectx);
if (!OSPX_m_isfree(ectx->m))
OSPX_m_new(ectx->m);
if (!ospx_ectx.em)
ospx_ectx.em = ectx;
else {
ectx->next = ospx_ectx.em;
ospx_ectx.em = ectx;
}
*m = ectx->m;
OSPX_m_used(ectx->m);
RWLOCK_RELEASE(&ospx_ectx);
return 0;
}
static int _init(T *thiz)
{
RWLOCK_INIT(LOCK);
thiz->hdr = PCALLOC(SUPER->mpool, sizeof(hdr_block_t));
#if 1
thiz->hdr->fend_off = BTR_HEADER_BLK_SIZE;
#else
thiz->hdr->fend_off = BTR_HEADER_BLK_SIZE;
thiz->hdr->version = DB_FILE_VERSION;
thiz->hdr->blktype = BTR_HEADER_BLK;
strncpy(thiz->hdr->magic, DB_MAGIC_NUM, sizeof(thiz->hdr->magic));
#endif
thiz->rfd = -1;
thiz->wfd = -1;
ADD_METHOD(destroy);
ADD_METHOD(store);
ADD_METHOD(restore);
ADD_METHOD(merge_start);
ADD_METHOD(merge);
ADD_METHOD(merge_flush);
ADD_METHOD(merge_hdr);
ADD_METHOD(merge_fin);
ADD_METHOD(find);
ADD_METHOD(exist);
ADD_METHOD(find_in_index);
ADD_METHOD(range_cmp);
ADD_METHOD(krange_cmp);
ADD_METHOD(pkrange_cmp);
ADD_METHOD(split);
ADD_METHOD(shrink);
ADD_METHOD(invalid);
ADD_METHOD(get_iter);
return 0;
}
int get_mac_addr(char* mac)
{
int status;
char filename[128];
char filebuf[128];
RWLOCK_INIT(&mac_lock);
RWLOCK_WLOCK(&mac_lock);
memset(filebuf, 0, 128);
printk("%s : enter\n", __func__);
// 1. if "mac.bin" exist ?
make_filename(filename, sizeof(filename), "mac.bin");
status = mac_read_file(filebuf, filename);
if(status < 0) {
//printk("Not find file: %s!\n", filename);
}
else {
printk("Find file: %s \n", filename);
memcpy(&(registry.general.macAddress), filebuf, 6);
goto _exit;
}
#if 0
// 2. if mib file mac available ?
if(macaddr_valid(mac, 6)) {
printk("Find mac in mib file or EEPROM\n");
memcpy(filebuf, mac, 6);
goto _exit;
}
#endif
#ifdef WINNER_SN2MAC
// 2. if mac.sn exist ?
make_filename(filename, sizeof(filename), "mac.sn");
status = mac_read_file(filebuf, filename);
if(status < 0) {
if(sn_to_mac(filebuf)==TRUE)
{
printk("sn_to_mac : %02X:%02X:%02X:%02X:%02X:%02X\n", filebuf[0], filebuf[1], filebuf[2], filebuf[3], filebuf[4], filebuf[5]);
mac_write_file(filebuf, 6, filename);
goto _exit;
}
}
else {
printk("Find file %s\n", filename);
goto _exit;
}
#endif
// 3. if mac.random exist ?
make_filename(filename, sizeof(filename), "mac.random");
status = mac_read_file(filebuf, filename);
if(status < 0) {
//printk("Not find file: %s!\n", filename);
}
else {
printk("Find file %s\n", filename);
goto _exit;
}
// 4. mac.random not exist, generate it
printk("No mac , generate random one!\n");
WiFiEngine_RandomMAC(0, filebuf, 6);
memcpy(filebuf, MAC_PREFIX, strlen(MAC_PREFIX));
//mac_write_file(filebuf, 6, filename);
_exit:
RWLOCK_WUNLOCK(&mac_lock);
memcpy(mac, filebuf, 6);
printk("mac = %02X:%02X:%02X:%02X:%02X:%02X\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
return 0;
}
