int dmap_range(DMAP *dmap, double from, double to, u32_t *list)
{
int i = 0, ii = 0, k = 0, kk = 0, j = 0, x = 0, z = 0, ret = 0, n = 0;
DMMKV *kvs = NULL;
if(dmap && dmap->state)
{
if(from == to) return dmap_in(dmap, from, list);
RWLOCK_RDLOCK(dmap->rwlock);
k = dmap_find_slot(dmap, from);
kk = dmap_find_slot2(dmap, to);
i = dmap_find_kv(dmap, k, from);
if(i == -1)
{
RWLOCK_UNLOCK(dmap->rwlock);
return ret;
}
ii = dmap_find_kv2(dmap, kk, to);
if(k == kk)
{
ret = ii + 1 - i;
if(list)
{
kvs = dmap->map + dmap->slots[k].nodeid;
for(x = i; x <= ii; x++) list[z++] = kvs[x].val;
}
}
else
{
n = dmap->slots[k].count;
ret = n - i;
if(list)
{
kvs = dmap->map + dmap->slots[k].nodeid;
for(x = i; x < n; x++) list[z++] = kvs[x].val;
}
for(j = k+1; j < kk; j++)
{
ret += dmap->slots[j].count;
if(list)
{
kvs = dmap->map + dmap->slots[j].nodeid;
for(x = 0; x < dmap->slots[j].count; x++) list[z++] = kvs[x].val;
}
}
ret += ii + 1;
if(list)
{
kvs = dmap->map + dmap->slots[kk].nodeid;
for(x = 0; x <= ii; x++) list[z++] = kvs[x].val;
}
}
RWLOCK_UNLOCK(dmap->rwlock);
}
return ret;
}
int imap_in(IMAP *imap, int32_t key, u32_t *list)
{
int i = 0, k = 0, z = 0, ret = 0, n = 0;
IMMKV *kvs = NULL;
if(imap && imap->state && (n = imap->state->count) > 0)
{
RWLOCK_RDLOCK(imap->rwlock);
k = imap_find_slot(imap, key);
i = imap_find_kv(imap, k, key);
fprintf(stdout,"\t\timap_in_%d(key:%d count:%d min:%d max:%d)\n",k,key,imap->slots[k].count,imap->slots[k].min,imap->slots[k].max);
if(k > 0)
{
fprintf(stdout,"\t\timap_slot_left_%d(key:%d count:%d min:%d max:%d)\n",k-1,key,imap->slots[k-1].count,imap->slots[k-1].min,imap->slots[k-1].max);
}
if(k < (imap->state->count-1))
{
fprintf(stdout,"\t\timap_slot_right_%d(key:%d count:%d min:%d max:%d)\n",k+1,key,imap->slots[k+1].count,imap->slots[k+1].min,imap->slots[k+1].max);
}
if(i == -1)
{
RWLOCK_UNLOCK(imap->rwlock);
return ret;
}
do
{
kvs = imap->map + imap->slots[k].nodeid;
if(key == kvs[i].key && i < imap->slots[k].count)
{
if(key == imap->slots[k].max)
{
ret += imap->slots[k].count - i;
if(list)
{
while(i < imap->slots[k].count) list[z++] = kvs[i++].val;
}
}
else
{
while(i < imap->slots[k].count && key == kvs[i].key)
{
if(list)list[z++] = kvs[i].val;
++ret;
++i;
}
}
}
i = 0;
}while(++k < n && imap->slots[k].min == key);
RWLOCK_UNLOCK(imap->rwlock);
}
return ret;
}
int lkv_rangefrom(LKV *lkv, int64_t key, u32_t *list) /* key = from */
{
int i = 0, k = 0, x = 0, z = 0, ret = 0, n = 0;
LVVKV *kvs = NULL;
if(lkv && lkv->state)
{
RWLOCK_RDLOCK(lkv->rwlock);
if((k = lkv_find_slot(lkv, key)) >= 0 && (i = lkv_find_kv(lkv, k, key)) >= 0)
{
//fprintf(stdout, "k:%d i:%d\n", k, i);
kvs = lkv->map + lkv->slots[k].nodeid;
n = lkv->slots[k].count;
if(list)
{
for(x = i; x < n; x++) list[z++] = kvs[x].val;
}
ret = n - i;
for(i = k + 1; i < lkv->state->count; i++)
{
ret += lkv->slots[i].count;
if(list)
{
kvs = lkv->map + lkv->slots[i].nodeid;
n = lkv->slots[i].count;
for(x = 0; x < n; x++) list[z++] = kvs[x].val;
}
}
}
RWLOCK_UNLOCK(lkv->rwlock);
}
//fprintf(stdout, "%s::%d k:%d ret:%d/%d\n", __FILE__, __LINE__, k, ret, z);
return ret;
}
int dmap_set(DMAP *dmap, u32_t no, double key)
{
int ret = -1;
if(dmap)
{
RWLOCK_WRLOCK(dmap->rwlock);
dmap_vset(dmap, no, key);
if(dmap->vmap[no].off < 0)
{
dmap_insert(dmap, no, key);
}
else
{
if(key != dmap->vmap[no].val)
{
dmap_remove(dmap, no);
dmap_insert(dmap, no, key);
}
}
ret = 0;
dmap->vmap[no].val = key;
RWLOCK_UNLOCK(dmap->rwlock);
}
return ret;
}
int lkv_set(LKV *lkv, u32_t no, int64_t key)
{
int ret = -1;
if(lkv)
{
RWLOCK_WRLOCK(lkv->rwlock);
lkv_vset(lkv, no, key);
#ifdef __LKV_USE_IDX__
if(lkv->vmap[no].off < 0)
{
lkv_insert(lkv, no, key);
}
else
{
if(key != lkv->vmap[no].val)
{
lkv_remove(lkv, no);
lkv_insert(lkv, no, key);
}
}
#endif
lkv->vmap[no].val = key;
ret = 0;
RWLOCK_UNLOCK(lkv->rwlock);
}
return ret;
}
int dmap_rangefrom(DMAP *dmap, double key, u32_t *list) /* key = from */
{
int i = 0, k = 0, x = 0, z = 0, ret = 0, n = 0;
DMMKV *kvs = NULL;
if(dmap && dmap->state)
{
RWLOCK_RDLOCK(dmap->rwlock);
if((k = dmap_find_slot(dmap, key)) >= 0 && (i = dmap_find_kv(dmap, k, key)) >= 0)
{
kvs = dmap->map + dmap->slots[k].nodeid;
n = dmap->slots[k].count;
if(list)
{
for(x = i; x < n; x++) list[z++] = kvs[x].val;
}
ret = n - i;
for(i = k + 1; i < dmap->state->count; i++)
{
ret += dmap->slots[i].count;
if(list)
{
kvs = dmap->map + dmap->slots[i].nodeid;
n = dmap->slots[i].count;
for(x = 0; x < n; x++) list[z++] = kvs[x].val;
}
}
}
RWLOCK_UNLOCK(dmap->rwlock);
}
//fprintf(stdout, "%s::%d k:%d ret:%d/%d\n", __FILE__, __LINE__, k, ret, z);
return ret;
}
int imap_set(IMAP *imap, u32_t no, int32_t key)
{
int ret = -1;
if(imap)
{
RWLOCK_WRLOCK(imap->rwlock);
imap_vset(imap, no, key);
if(imap->vmap[no].off < 0)
{
imap_insert(imap, no, key);
}
else
{
if(key != imap->vmap[no].val)
{
imap_remove(imap, no);
imap_insert(imap, no, key);
}
}
ret = 0;
imap->vmap[no].val = key;
RWLOCK_UNLOCK(imap->rwlock);
}
return ret;
}
int dmap_in(DMAP *dmap, double key, u32_t *list)
{
int i = 0, k = 0, z = 0, ret = 0, n = 0;
DMMKV *kvs = NULL;
if(dmap && dmap->state && (n = dmap->state->count) > 0)
{
RWLOCK_RDLOCK(dmap->rwlock);
k = dmap_find_slot(dmap, key);
i = dmap_find_kv(dmap, k, key);
if(i == -1)
{
RWLOCK_UNLOCK(dmap->rwlock);
return ret;
}
do
{
kvs = dmap->map + dmap->slots[k].nodeid;
if(i >= 0 && key == kvs[i].key && i < dmap->slots[k].count)
{
if(key == dmap->slots[k].max)
{
ret += dmap->slots[k].count - i;
if(list)
{
while(i < dmap->slots[k].count) list[z++] = kvs[i++].val;
}
}
else
{
while(i < dmap->slots[k].count && key == kvs[i].key)
{
if(list)list[z++] = kvs[i].val;
++ret;
++i;
}
}
}
i = 0;
}while(++k < n && dmap->slots[k].min == key);
RWLOCK_UNLOCK(dmap->rwlock);
}
return ret;
}
int lkv_range(LKV *lkv, int64_t from, int64_t to, u32_t *list)
{
int i = 0, ii = 0, k = 0, kk = 0, j = 0, x = 0, z = 0, ret = 0, n = 0;
LVVKV *kvs = NULL;
if(lkv && lkv->state)
{
if(from == to) return lkv_in(lkv, from, list);
RWLOCK_RDLOCK(lkv->rwlock);
k = lkv_find_slot(lkv, from);
kk = lkv_find_slot2(lkv, to);
i = lkv_find_kv(lkv, k, from);
ii = lkv_find_kv2(lkv, kk, to);
if(k == -1 || kk == -1 || i == -1 || ii == -1) goto end;
if(k == kk)
{
ret = ii + 1 - i;
if(list)
{
kvs = lkv->map + lkv->slots[k].nodeid;
for(x = i; x <= ii; x++) list[z++] = kvs[x].val;
}
}
else
{
n = lkv->slots[k].count;
ret = n - i;
if(list)
{
kvs = lkv->map + lkv->slots[k].nodeid;
for(x = i; x < n; x++) list[z++] = kvs[x].val;
}
for(j = k+1; j < kk; j++)
{
ret += lkv->slots[j].count;
if(list)
{
kvs = lkv->map + lkv->slots[j].nodeid;
for(x = 0; x < lkv->slots[j].count; x++) list[z++] = kvs[x].val;
}
}
ret += ii + 1;
if(list)
{
kvs = lkv->map + lkv->slots[kk].nodeid;
for(x = 0; x <= ii; x++) list[z++] = kvs[x].val;
}
}
end:
RWLOCK_UNLOCK(lkv->rwlock);
}
return ret;
}
int lkv_get(LKV *lkv, u32_t no, u32_t *val)
{
int ret = -1, n = 0;
if(lkv)
{
RWLOCK_RDLOCK(lkv->rwlock);
if((n = (lkv->vsize/sizeof(LVVV))) > 0 && no < n)
{
if(val) *val = lkv->vmap[no].val;
ret = 0;
}
RWLOCK_UNLOCK(lkv->rwlock);
}
return ret;
}
int dmap_get(DMAP *dmap, u32_t no, u32_t *val)
{
int ret = -1, n = 0;
if(dmap)
{
RWLOCK_RDLOCK(dmap->rwlock);
if((n = (dmap->vsize/sizeof(DMMV))) > 0 && no < n)
{
if(val) *val = dmap->vmap[no].val;
ret = 0;
}
RWLOCK_UNLOCK(dmap->rwlock);
}
return ret;
}
int imap_del(IMAP *imap, u32_t no)
{
int ret = -1, n = 0;
if(imap)
{
RWLOCK_WRLOCK(imap->rwlock);
if((n = (imap->vsize/sizeof(IMMV))) > 0 && no < n)
{
imap_remove(imap, no);
imap->vmap[no].off = -1;
ret = 0;
}
RWLOCK_UNLOCK(imap->rwlock);
}
return ret;
}
int dmap_del(DMAP *dmap, u32_t no)
{
int ret = -1, n = 0;
if(dmap)
{
RWLOCK_WRLOCK(dmap->rwlock);
if((n = (dmap->vsize/sizeof(DMMV))) > 0 && no < n)
{
dmap_remove(dmap, no);
dmap->vmap[no].off = -1;
ret = 0;
}
RWLOCK_UNLOCK(dmap->rwlock);
}
return ret;
}
int lkv_del(LKV *lkv, u32_t no)
{
int ret = -1, n = 0;
if(lkv)
{
RWLOCK_WRLOCK(lkv->rwlock);
if((n = (lkv->vsize/sizeof(LVVV))) > 0 && no < n)
{
lkv_remove(lkv, no);
lkv->vmap[no].off = -1;
ret = 0;
}
RWLOCK_UNLOCK(lkv->rwlock);
}
return ret;
}
int lkv_in(LKV *lkv, int64_t key, u32_t *list)
{
int i = 0, k = 0, z = 0, ret = 0, n = 0;
LVVKV *kvs = NULL;
if(lkv && lkv->state && (n = lkv->state->count) > 0)
{
RWLOCK_RDLOCK(lkv->rwlock);
k = lkv_find_slot(lkv, key);
i = lkv_find_kv(lkv, k, key);
do
{
kvs = lkv->map + lkv->slots[k].nodeid;
if(i >= 0 && key == kvs[i].key && i < lkv->slots[k].count)
{
if(key == lkv->slots[k].max)
{
ret += lkv->slots[k].count - i;
if(list)
{
while(i < lkv->slots[k].count) list[z++] = kvs[i++].val;
}
}
else
{
while(i < lkv->slots[k].count && key == kvs[i].key)
{
if(list)list[z++] = kvs[i].val;
++ret;
++i;
}
}
}
i=0;
}while(++k < n && lkv->slots[k].min == key);
RWLOCK_UNLOCK(lkv->rwlock);
}
return ret;
}
int dmap_rangeto(DMAP *dmap, double key, u32_t *list) /* key = to */
{
int i = 0, k = 0, x = 0, j = 0, z = 0, ret = 0, n = 0;
DMMKV *kvs = NULL;
if(dmap && dmap->state && (n = (dmap->state->count)) > 0)
{
RWLOCK_RDLOCK(dmap->rwlock);
if((k = dmap_find_slot2(dmap, key)) >= 0 && k < n)
{
i = dmap_find_kv2(dmap, k, key);
for(j = 0; j < k; j++)
{
ret += dmap->slots[j].count;
if(list)
{
kvs = dmap->map + dmap->slots[j].nodeid;
for(x = 0; x < dmap->slots[j].count; x++)
{
list[z++] = kvs[x].val;
}
}
}
ret += i + 1;
if(list)
{
kvs = dmap->map + dmap->slots[k].nodeid;
for(x = 0; x <= i; x++)
{
list[z++] = kvs[x].val;
}
}
}
RWLOCK_UNLOCK(dmap->rwlock);
}
//fprintf(stdout, "%s::%d k:%d ret:%d/%d\n", __FILE__, __LINE__, k, ret, z);
return ret;
}
int lkv_rangeto(LKV *lkv, int64_t key, u32_t *list) /* key = to */
{
int i = 0, k = 0, x = 0, j = 0, z = 0, ret = 0, n = 0;
LVVKV *kvs = NULL;
if(lkv && lkv->state && (n = (lkv->state->count)) > 0)
{
RWLOCK_RDLOCK(lkv->rwlock);
if((k = lkv_find_slot2(lkv, key)) >= 0 && k < n
&& (i = lkv_find_kv2(lkv, k, key)) >= 0)
{
for(j = 0; j < k; j++)
{
ret += lkv->slots[j].count;
if(list)
{
kvs = lkv->map + lkv->slots[j].nodeid;
for(x = 0; x < lkv->slots[j].count; x++)
{
list[z++] = kvs[x].val;
}
}
}
ret += i + 1;
if(list)
{
kvs = lkv->map + lkv->slots[k].nodeid;
for(x = 0; x <= i; x++)
{
list[z++] = kvs[x].val;
}
}
}
RWLOCK_UNLOCK(lkv->rwlock);
}
//fprintf(stdout, "%s::%d k:%d ret:%d/%d\n", __FILE__, __LINE__, k, ret, z);
return ret;
}
static int
monitor_pthread_unlock (p_lock_t lock)
{
return RWLOCK_UNLOCK (&(lock->mutex));
}
int imap_range(IMAP *imap, int32_t from, int32_t to, u32_t *list)
{
int i = 0, ii = 0, k = 0, kk = 0, j = 0, x = 0, z = 0, ret = 0, n = 0;
IMMKV *kvs = NULL;
if(imap && imap->state)
{
if(from == to) return imap_in(imap, from, list);
RWLOCK_RDLOCK(imap->rwlock);
k = imap_find_slot(imap, from);
fprintf(stdout,"\t\timap_range_%d(from:%d count:%d min:%d max:%d)\n",k,from,imap->slots[k].count,imap->slots[k].min,imap->slots[k].max);
if(k > 0)
{
fprintf(stdout,"\t\timap_slot_left_%d(from:%d count:%d min:%d max:%d)\n",k-1,from,imap->slots[k-1].count,imap->slots[k-1].min,imap->slots[k-1].max);
}
if(k < (imap->state->count-1))
{
fprintf(stdout,"\t\timap_slot_right_%d(from:%d count:%d min:%d max:%d)\n",k+1,from,imap->slots[k+1].count,imap->slots[k+1].min,imap->slots[k+1].max);
}
fprintf(stdout,"--------------------------\n");
kk = imap_find_slot2(imap, to);
fprintf(stdout,"\t\timap_range_%d(to:%d count:%d min:%d max:%d)\n",kk,to,imap->slots[kk].count,imap->slots[kk].min,imap->slots[kk].max);
if(kk > 0)
{
fprintf(stdout,"\t\timap_slot_left_%d(to:%d count:%d min:%d max:%d)\n",kk-1,to,imap->slots[kk-1].count,imap->slots[kk-1].min,imap->slots[kk-1].max);
}
if(kk < (imap->state->count-1))
{
fprintf(stdout,"\t\timap_slot_right_%d(to:%d count:%d min:%d max:%d)\n",kk+1,to,imap->slots[kk+1].count,imap->slots[kk+1].min,imap->slots[kk+1].max);
}
fprintf(stdout,"--------------------------\n");
kvs = imap->map + imap->slots[k].nodeid;
i = imap_find_kv(imap, k, from);
if(i == -1)
{
RWLOCK_UNLOCK(imap->rwlock);
return ret;
}
fprintf(stdout,"\t\timap_kv_%d(from:%d key:%d)\n",i,from,kvs[i].key);
if(i > 0)
{
fprintf(stdout,"\t\timap_kv_left_%d(from:%d key:%d)\n",i-1,from,kvs[i-1].key);
fprintf(stdout,"\t\timap_kv_right_%d(from:%d key:%d)\n",i+1,from,kvs[i+1].key);
}
fprintf(stdout,"--------------------------\n");
ii = imap_find_kv2(imap, kk, to);
if(ii == -1)
{
RWLOCK_UNLOCK(imap->rwlock);
return ret;
}
kvs = imap->map + imap->slots[kk].nodeid;
fprintf(stdout,"\t\timap_kv2_%d(to:%d key:%d)\n",ii,to,kvs[ii].key);
if(ii > 0)
{
fprintf(stdout,"\t\timap_kv2_left_%d(to:%d key:%d)\n",ii-1,to,kvs[ii-1].key);
fprintf(stdout,"\t\timap_kv2_right_%d(to:%d key:%d)\n",ii+1,to,kvs[ii+1].key);
}
fprintf(stdout,"--------------------------\n");
fprintf(stdout,"\t\timap_range(from:%d to:%d slot:%d/%d kv:%d/%d)\n",from,to,k,kk,i,ii);
fprintf(stdout,"--------------------------\n");
if(k == kk)
{
ret = ii + 1 - i;
if(list)
{
kvs = imap->map + imap->slots[k].nodeid;
for(x = i; x <= ii; x++) list[z++] = kvs[x].val;
}
}
else
{
n = imap->slots[k].count;
ret = n - i;
fprintf(stdout,"\t\timap_range(k:%d n:%d i:%d ret:%d)\n",k,n,i,ret);
if(list)
{
kvs = imap->map + imap->slots[k].nodeid;
for(x = i; x < n; x++) list[z++] = kvs[x].val;
}
fprintf(stdout,"\t\timap_range(kk:%d k:%d ret:%d)\n",kk,k+1,ret);
for(j = k+1; j < kk; j++)
{
ret += imap->slots[j].count;
fprintf(stdout,"\t\timap_range(j:%d n:%d ret:%d)\n",j,imap->slots[j].count,ret);
if(list)
{
kvs = imap->map + imap->slots[j].nodeid;
for(x = 0; x < imap->slots[j].count; x++) list[z++] = kvs[x].val;
}
}
ret += ii;
fprintf(stdout,"\t\timap_range(ii:%d ret:%d)\n",ii,ret);
if(list)
{
kvs = imap->map + imap->slots[kk].nodeid;
for(x = 0; x < ii; x++) list[z++] = kvs[x].val;
}
}
RWLOCK_UNLOCK(imap->rwlock);
}
return ret;
}
static int
WebServletRun(struct http_servlet *servlet,
struct http_request *req, struct http_response *resp)
{
FILE *f;
const char *path;
const char *query;
int priv = 0;
if (Enabled(&gWeb.options, WEB_AUTH)) {
const char *username;
const char *password;
ConsoleUser u;
struct console_user iu;
/* Get username and password */
if ((username = http_request_get_username(req)) == NULL)
username = "";
if ((password = http_request_get_password(req)) == NULL)
password = "";
strlcpy(iu.username, username, sizeof(iu.username));
RWLOCK_RDLOCK(gUsersLock);
u = ghash_get(gUsers, &iu);
RWLOCK_UNLOCK(gUsersLock);
if ((u == NULL) || strcmp(u->password, password)) {
http_response_send_basic_auth(resp, "Access Restricted");
return (1);
}
priv = u->priv;
}
if (!(f = http_response_get_output(resp, 1))) {
return 0;
}
if (!(path = http_request_get_path(req)))
return 0;
if (!(query = http_request_get_query_string(req)))
return 0;
if (!strcmp(path,"/mpd.css")) {
http_response_set_header(resp, 0, "Content-Type", "text/css");
WebShowCSS(f);
} else if (!strcmp(path,"/bincmd")) {
http_response_set_header(resp, 0, "Content-Type", "text/plain");
http_response_set_header(resp, 1, "Pragma", "no-cache");
http_response_set_header(resp, 1, "Cache-Control", "no-cache, must-revalidate");
pthread_cleanup_push(WebServletRunCleanup, NULL);
GIANT_MUTEX_LOCK();
WebRunBinCmd(f, query, priv);
GIANT_MUTEX_UNLOCK();
pthread_cleanup_pop(0);
} else if (!strcmp(path,"/") || !strcmp(path,"/cmd")) {
http_response_set_header(resp, 0, "Content-Type", "text/html");
http_response_set_header(resp, 1, "Pragma", "no-cache");
http_response_set_header(resp, 1, "Cache-Control", "no-cache, must-revalidate");
pthread_cleanup_push(WebServletRunCleanup, NULL);
GIANT_MUTEX_LOCK();
fprintf(f, "<!DOCTYPE HTML "
"PUBLIC \"-//W3C//DTD HTML 4.01//EN\" "
"\"http://www.w3.org/TR/html4/strict.dtd\">\n");
fprintf(f, "<HTML>\n");
fprintf(f, "<HEAD><TITLE>Multi-link PPP Daemon for FreeBSD (mpd)</TITLE>\n");
fprintf(f, "<LINK rel='stylesheet' href='/mpd.css' type='text/css'>\n");
fprintf(f, "</HEAD>\n<BODY>\n");
fprintf(f, "<H1>Multi-link PPP Daemon for FreeBSD</H1>\n");
if (!strcmp(path,"/"))
WebShowSummary(f, priv);
else if (!strcmp(path,"/cmd"))
WebRunCmd(f, query, priv);
GIANT_MUTEX_UNLOCK();
pthread_cleanup_pop(0);
fprintf(f, "</BODY>\n</HTML>\n");
} else {
http_response_send_error(resp, 404, NULL);
}
return 1;
}
