DjVuDebug&
DjVuDebug::lock(int lvl, int noindent)
{
int threads_num=1;
debug_lock.lock();
// Get per-thread debug object
long threadid = (long) GThread::current();
DjVuDebug &dbg = debug_map()[threadid];
threads_num=debug_map().size();
// Check level
dbg.block = (lvl > debug_level);
// Output thread id and indentation
if (! noindent)
{
if (threads_num>1)
dbg.format("[T%d] ", dbg.id);
int ind = dbg.indent;
char buffer[257];
memset(buffer,' ', sizeof(buffer)-1);
buffer[sizeof(buffer)-1] = 0;
while (ind > (int)sizeof(buffer)-1)
{
dbg.format("%s", buffer);
ind -= sizeof(buffer)-1;
}
if (ind > 0)
{
buffer[ind] = 0;
dbg.format("%s", buffer);
}
}
// Return
return dbg;
}
void map_draw(map* p_map, SDL_Renderer* renderer){
int x_from = -(p_map->o_camera.x);
int x_to = (p_map->width * p_map->tile_width) + x_from;
int y_from = -(p_map->o_camera.y);
int y_to = (p_map->height * p_map->tile_height) + y_from;
int tile_y_index = 0;
for (int y=y_from;y<y_to;y+=p_map->tile_height/2){
int tile_x_index = 0;
for (int x=x_from;x<x_to;x+=p_map->tile_width/2){
//get the tile in the map tiles
tile* p_tile = map_get_tile(p_map,
tile_x_index,
tile_y_index);
//draw the tile
map_draw_tile(p_map, p_tile, x, y, renderer);
//increment the tile index and check if it's in the map size rang
if(++tile_x_index >= p_map->width)break;
}
//increment the tile index and check if it's in the map size rang
if(++tile_y_index >= p_map->height)break;
}
#ifdef DEBUG
debug_map(p_map, renderer,
x_from, x_to,
y_from, y_to,
p_map->o_camera.x / p_map->tile_width*8,
p_map->o_camera.y / p_map->tile_height*8);
#endif
}
/** Convert value_pair_map_t to VALUE_PAIR(s) and add them to a REQUEST.
*
* Takes a single value_pair_map_t, resolves request and list identifiers
* to pointers in the current request, then attempts to retrieve module
* specific value(s) using callback, and adds the resulting values to the
* correct request/list.
*
* @param request The current request.
* @param map specifying destination attribute and location and src identifier.
* @param func to retrieve module specific values and convert them to
* VALUE_PAIRS.
* @param ctx to be passed to func.
* @param src name to be used in debugging if different from map value.
* @return -1 if the operation failed, -2 in the source attribute wasn't valid, 0 on success.
*/
int radius_map2request(REQUEST *request, value_pair_map_t const *map,
UNUSED char const *src, radius_tmpl_getvalue_t func, void *ctx)
{
int rcode, num;
VALUE_PAIR **list, *vp, *head = NULL;
REQUEST *context;
TALLOC_CTX *parent;
vp_cursor_t cursor;
/*
* Sanity check inputs. We can have a list or attribute
* as a destination.
*/
if ((map->dst->type != VPT_TYPE_LIST) &&
(map->dst->type != VPT_TYPE_ATTR)) {
REDEBUG("Invalid mapping destination");
return -2;
}
context = request;
if (radius_request(&context, map->dst->request) < 0) {
REDEBUG("Mapping \"%s\" -> \"%s\" invalid in this context", map->src->name, map->dst->name);
return -2;
}
/*
* If there's no CoA packet and we're updating it,
* auto-allocate it.
*/
if (((map->dst->list == PAIR_LIST_COA) ||
(map->dst->list == PAIR_LIST_DM)) &&
!request->coa) {
request_alloc_coa(context);
if (map->dst->list == PAIR_LIST_COA) {
context->coa->proxy->code = PW_CODE_COA_REQUEST;
} else {
context->coa->proxy->code = PW_CODE_DISCONNECT_REQUEST;
}
}
list = radius_list(context, map->dst->list);
if (!list) {
REDEBUG("Mapping \"%s\" -> \"%s\" invalid in this context", map->src->name, map->dst->name);
return -2;
}
parent = radius_list_ctx(context, map->dst->list);
/*
* The callback should either return -1 to signify operations error, -2 when it can't find the
* attribute or list being referenced, or 0 to signify success.
* It may return "sucess", but still have no VPs to work with.
*/
rcode = func(&head, request, map, ctx);
if (rcode < 0) {
rad_assert(!head);
return rcode;
}
if (!head) return 0;
/*
* Reparent the VP
*/
for (vp = fr_cursor_init(&cursor, &head); vp; vp = fr_cursor_next(&cursor)) {
VERIFY_VP(vp);
if (debug_flag) debug_map(request, map, vp);
(void) talloc_steal(parent, vp);
}
/*
* List to list copies.
*/
if (map->dst->type == VPT_TYPE_LIST) {
switch (map->op) {
case T_OP_CMP_FALSE:
rad_assert(head == NULL);
pairfree(list);
if (map->dst->list == PAIR_LIST_REQUEST) {
context->username = NULL;
context->password = NULL;
}
break;
case T_OP_SET:
if (map->src->type == VPT_TYPE_LIST) {
pairfree(list);
*list = head;
} else {
case T_OP_EQ:
rad_assert(map->src->type == VPT_TYPE_EXEC);
pairmove(parent, list, &head);
pairfree(&head);
}
if (map->dst->list == PAIR_LIST_REQUEST) {
context->username = pairfind(head, PW_USER_NAME, 0, TAG_ANY);
context->password = pairfind(head, PW_USER_PASSWORD, 0, TAG_ANY);
}
break;
case T_OP_ADD:
pairadd(list, head);
break;
default:
pairfree(&head);
return -1;
}
return 0;
}
/*
* We now should have only one destination attribute, and
* only one source attribute.
*/
rad_assert(head->next == NULL);
/*
* Find the destination attribute. We leave with either
* the cursor and vp pointing to the attribute, or vp is
* NULL.
*/
num = map->dst->num;
for (vp = fr_cursor_init(&cursor, list);
vp != NULL;
vp = fr_cursor_next(&cursor)) {
VERIFY_VP(vp);
if ((vp->da == map->dst->da) && (!vp->da->flags.has_tag || (map->dst->tag == TAG_ANY) || (vp->tag == map->dst->tag))) {
if (num == 0) break;
num--;
}
}
/*
* Figure out what to do with the source attribute.
*/
switch (map->op) {
case T_OP_CMP_FALSE: /* remove matching attributes */
pairfree(&head);
if (!vp) return 0;
/*
* Wildcard: delete all of the matching ones,
* based on tag.
*/
if (!map->dst->num) {
pairdelete(list, map->dst->da->attr, map->dst->da->vendor,
map->dst->tag);
vp = NULL;
} else {
/*
* We've found the Nth one. Delete it, and only
* it.
*/
vp = fr_cursor_remove(&cursor);
}
/*
* Check that the User-Name and User-Password
* caches point to the correct attribute.
*/
fixup:
if (map->dst->list == PAIR_LIST_REQUEST) {
context->username = pairfind(*list, PW_USER_NAME, 0, TAG_ANY);
context->password = pairfind(*list, PW_USER_PASSWORD, 0, TAG_ANY);
}
pairfree(&vp);
return 0;
case T_OP_EQ: /* set only if not already set */
if (vp) {
pairfree(&head);
return 0;
}
fr_cursor_insert(&cursor, head);
goto fixup;
case T_OP_SET: /* over-write if existing, or else add */
if (vp) vp = fr_cursor_remove(&cursor);
fr_cursor_insert(&cursor, head);
goto fixup;
case T_OP_ADD: /* append no matter what */
vp = NULL;
pairadd(list, head);
goto fixup;
case T_OP_SUB: /* delete if it matches */
head->op = T_OP_CMP_EQ;
rcode = radius_compare_vps(NULL, head, vp);
pairfree(&head);
if (rcode == 0) {
vp = fr_cursor_remove(&cursor);
goto fixup;
}
return 0;
default: /* filtering operators */
/*
* If the VP doesn't exist, the filters will add
* it with the given value.
*/
if (!vp) {
fr_cursor_insert(&cursor, head);
goto fixup;
}
break;
}
/*
* The LHS exists. We need to limit it's value based on
* the operator, and the value of the RHS.
*/
head->op = map->op;
rcode = radius_compare_vps(NULL, head, vp);
head->op = T_OP_SET;
switch (map->op) {
case T_OP_CMP_EQ:
if (rcode == 0) {
leave:
pairfree(&head);
break;
}
replace:
vp = fr_cursor_remove(&cursor);
fr_cursor_insert(&cursor, head);
goto fixup;
case T_OP_LE:
if (rcode <= 0) goto leave;
goto replace;
case T_OP_GE:
if (rcode >= 0) goto leave;
goto replace;
default:
pairfree(&head);
return -1;
}
return 0;
}
void map_draw(map* p_map, SDL_Renderer* renderer){
//offset the map drawing to the left in order to display the chipset
const int x_offset = p_map->x_offset;
const int x_from = -(p_map->o_camera.x % p_map->tile_width) + x_offset;
const int x_to = x_from + SCREEN_WIDTH + (x_from == 0 ? 0 : p_map->tile_width) + x_offset;
const int y_from = -(p_map->o_camera.y % p_map->tile_height);
const int y_to = y_from + SCREEN_HEIGHT + (y_from == 0 ? 0 : p_map->tile_height);
int tile_y_index = p_map->o_camera.y / p_map->tile_height;
for (int y=y_from;y<y_to;y+=p_map->tile_height){
int tile_x_index = p_map->o_camera.x / p_map->tile_width;
for (int x=x_from;x<x_to;x+=p_map->tile_width){
//get the tile in the map tiles
tile* p_tile = map_get_tile(p_map,
tile_x_index,
tile_y_index);
//draw the tile
map_draw_tile(p_map, p_tile, x, y, renderer);
//draw a horizontal grid line
SDL_RenderDrawLine(renderer,
0,
y,
SCREEN_WIDTH,
y);
//draw a vertical grid line
SDL_RenderDrawLine(renderer,
x,
0,
x,
SCREEN_HEIGHT);
//increment the tile index and check if it's in the map size rang
if(++tile_x_index >= p_map->width)break;
}
//increment the tile index and check if it's in the map size rang
if(++tile_y_index >= p_map->height)break;
}
//draw a rectangle on the selected map tile
SDL_Rect rect = {.x= p_map->map_tile_x_index * p_map->tile_width,
.y= p_map->map_tile_y_index * p_map->tile_height + y_from,
.w= p_map->tile_width,
.h= p_map->tile_height};
SDL_SetRenderDrawColor(renderer, 0xFF, 0x0, 0x0, 0xFF);
SDL_RenderDrawRect(renderer, &rect);
#ifdef DEBUG
//Draw the debug menu
debug_map(p_map, renderer,
x_from, x_to,
y_from, y_to,
p_map->o_camera.x / p_map->tile_width,
p_map->o_camera.y / p_map->tile_height);
#endif
}
void map_mouse_move(map* p_map, SDL_Renderer* renderer, int x, int y){
const int x_from = p_map->o_camera.x % p_map->tile_width;
const int y_from = p_map->o_camera.y % p_map->tile_height;
int map_tile_x_index = (x + x_from) / p_map->tile_width;
int map_tile_y_index = (y + y_from) / p_map->tile_height;
p_map->map_tile_x_index = map_tile_x_index;
p_map->map_tile_y_index = map_tile_y_index;
}
void map_tile_click(map* p_map,
int x,
int y,
Uint8 button){
int x_offset = p_map->x_offset;
if(x < x_offset){
//the click was on the chipset part
//set the selected tile in the chipset
p_map->chipset_tile_x_index = x / p_map->tile_width;
p_map->chipset_tile_y_index = y / p_map->tile_height;
}
else{
//the clic was on the map part
//change the clicked tile with the selected tile
int clicked_tile_x_index = (x + p_map->o_camera.x - x_offset) / p_map->tile_width;
int clicked_tile_y_index = (y + p_map->o_camera.y) / p_map->tile_height;
#ifdef DEBUG
printf("click at index %d %d\n",
clicked_tile_x_index,
clicked_tile_y_index);
#endif
//check if the index is in the map boundaries
if(clicked_tile_x_index >= 0 && clicked_tile_x_index < p_map->width &&
clicked_tile_y_index >= 0 && clicked_tile_y_index < p_map->height){
tile* p_tile = map_get_tile(p_map,
clicked_tile_x_index,
clicked_tile_y_index);
p_tile->x = p_map->chipset_tile_x_index;
p_tile->y = p_map->chipset_tile_y_index;
}
}
}
