static int push_state(struct stack* stack,struct rtf_state* state)
{
int toplevel;
size_t defelements;
stack->elements++;
if( compare_state(state,&base_state)) {
state->default_elements++;
return 0;/* this is default state, don't push it, we'll know when we pop it that it was the default one,
we store in the state how many default elements we have on the stack */
}
if(stack->stack_cnt >= stack->stack_size) {
/* grow stack */
struct rtf_state *states;
stack->stack_size += 128;
states = cli_realloc2(stack->states, stack->stack_size*sizeof(*stack->states));
if(!states)
return CL_EMEM;
stack->states = states;
}
stack->states[stack->stack_cnt++] = *state;
toplevel = state->encounteredTopLevel;
defelements = state->default_elements;
*state = base_state;
state->encounteredTopLevel = toplevel;
state->default_elements = defelements;
return 0;
}
// Set stencil state, plus read it back and check that it's correct.
// Note: we only test with one reference value and one mask value
// even though EXT and GL2 support separate front/back refs/masks
bool
Stencil2Test::set_stencil_state(int method,
GLenum frontStencilFail,
GLenum backStencilFail,
GLenum frontZFail,
GLenum backZFail,
GLenum frontZPass,
GLenum backZPass,
GLenum frontFunc,
GLenum backFunc,
GLint frontRef,
GLint backRef,
GLuint frontMask,
GLuint backMask,
GLuint frontWriteMask,
GLuint backWriteMask)
{
GLint get_frontStencilFail;
GLint get_backStencilFail;
GLint get_frontZFail;
GLint get_backZFail;
GLint get_frontZPass;
GLint get_backZPass;
GLint get_frontFunc;
GLint get_backFunc;
GLint get_frontRef;
GLint get_backRef;
GLint get_frontMask;
GLint get_backMask;
GLint get_frontWriteMask;
GLint get_backWriteMask;
GLint twoEnabled;
switch (method) {
case ATI:
assert(frontRef == backRef);
assert(frontMask == backMask);
assert(frontWriteMask == backWriteMask);
// set state
glStencilOpSeparateATI_func(GL_FRONT,
frontStencilFail,
frontZFail,
frontZPass);
glStencilOpSeparateATI_func(GL_BACK,
backStencilFail,
backZFail,
backZPass);
glStencilFuncSeparateATI_func(frontFunc, backFunc, frontRef, frontMask);
glStencilMask(frontWriteMask);
// get state
glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
glGetIntegerv(GL_STENCIL_BACK_FUNC_ATI, &get_backFunc);
glGetIntegerv(GL_STENCIL_BACK_FAIL_ATI, &get_backStencilFail);
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI, &get_backZFail);
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI, &get_backZPass);
get_backRef = get_frontRef;
get_backMask = get_frontMask;
get_backWriteMask = get_frontWriteMask;
twoEnabled = GL_TRUE;
break;
case EXT:
// set state
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glActiveStencilFaceEXT_func(GL_FRONT);
glStencilOp(frontStencilFail, frontZFail, frontZPass);
glStencilFunc(frontFunc, frontRef, frontMask);
glStencilMask(frontWriteMask);
glActiveStencilFaceEXT_func(GL_BACK);
glStencilOp(backStencilFail, backZFail, backZPass);
glStencilFunc(backFunc, backRef, backMask);
glStencilMask(backWriteMask);
// get state
glActiveStencilFaceEXT_func(GL_FRONT);
glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
glActiveStencilFaceEXT_func(GL_BACK);
glGetIntegerv(GL_STENCIL_FAIL, &get_backStencilFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_backZFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_backZPass);
glGetIntegerv(GL_STENCIL_FUNC, &get_backFunc);
glGetIntegerv(GL_STENCIL_REF, &get_backRef);
glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_backMask);
glGetIntegerv(GL_STENCIL_WRITEMASK, &get_backWriteMask);
glGetIntegerv(GL_STENCIL_TEST_TWO_SIDE_EXT, &twoEnabled);
break;
case GL2:
// set state
glStencilOpSeparate_func(GL_FRONT,
frontStencilFail,
frontZFail,
frontZPass);
glStencilOpSeparate_func(GL_BACK,
backStencilFail,
backZFail,
backZPass);
glStencilFuncSeparate_func(GL_FRONT, frontFunc, frontRef, frontMask);
glStencilFuncSeparate_func(GL_BACK, backFunc, backRef, backMask);
glStencilMaskSeparate_func(GL_FRONT, frontWriteMask);
glStencilMaskSeparate_func(GL_BACK, backWriteMask);
// get state
glGetIntegerv(GL_STENCIL_FAIL, &get_frontStencilFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &get_frontZFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &get_frontZPass);
glGetIntegerv(GL_STENCIL_FUNC, &get_frontFunc);
glGetIntegerv(GL_STENCIL_REF, &get_frontRef);
glGetIntegerv(GL_STENCIL_VALUE_MASK, &get_frontMask);
glGetIntegerv(GL_STENCIL_WRITEMASK, &get_frontWriteMask);
glGetIntegerv(GL_STENCIL_BACK_FUNC, &get_backFunc);
glGetIntegerv(GL_STENCIL_BACK_FAIL, &get_backStencilFail);
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &get_backZFail);
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &get_backZPass);
glGetIntegerv(GL_STENCIL_BACK_REF, &get_backRef);
glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &get_backMask);
glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &get_backWriteMask);
twoEnabled = GL_TRUE;
break;
default:
assert(0);
}
// mask off bits we don't care about
get_frontMask &= stencilMax;
frontMask &= stencilMax;
get_backMask &= stencilMax;
backMask &= stencilMax;
get_frontWriteMask &= stencilMax;
frontWriteMask &= stencilMax;
get_backWriteMask &= stencilMax;
backWriteMask &= stencilMax;
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
env->log << "FAIL:\n";
env->log << "\tGL error " << err << " detected.\n";
return false;
}
// see if state-get matches state-set
if (!compare_state(method, get_frontStencilFail, frontStencilFail,
"front stencil fail"))
return false;
if (!compare_state(method, get_backStencilFail, backStencilFail,
"back stencil fail"))
return false;
if (!compare_state(method, get_frontZFail, frontZFail,
"front Z fail"))
return false;
if (!compare_state(method, get_backZFail, backZFail,
"back Z fail"))
return false;
if (!compare_state(method, get_frontZPass, frontZPass,
"front Z pass"))
return false;
if (!compare_state(method, get_backZPass, backZPass,
"back Z pass"))
return false;
if (!compare_state(method, get_frontFunc, frontFunc,
"front stencil func"))
return false;
if (!compare_state(method, get_backFunc, backFunc,
"back stencil func"))
return false;
if (!compare_state(method, get_frontRef, frontRef,
"front stencil ref"))
return false;
if (!compare_state(method, get_backRef, backRef,
"back stencil ref"))
return false;
if (!compare_state(method, get_frontMask, frontMask,
"front stencil mask"))
return false;
if (!compare_state(method, get_backMask, backMask,
"back stencil mask"))
return false;
if (!compare_state(method, get_frontWriteMask, frontWriteMask,
"front stencil writemask"))
return false;
if (!compare_state(method, get_backWriteMask, backWriteMask,
"back stencil writemask"))
return false;
if (!compare_state(method, twoEnabled, GL_TRUE, "two-side enable"))
return false;
return true;
}
int
zebra_evaluate_rnh_table (vrf_id_t vrfid, int family)
{
struct route_table *ptable;
struct route_table *ntable;
struct route_node *prn;
struct route_node *nrn;
struct rnh *rnh;
struct zserv *client;
struct listnode *node;
struct rib *rib;
ntable = lookup_rnh_table(vrfid, family);
if (!ntable)
{
zlog_debug("evaluate_rnh_table: rnh table not found\n");
return -1;
}
ptable = zebra_vrf_table(family2afi(family), SAFI_UNICAST, vrfid);
if (!ptable)
{
zlog_debug("evaluate_rnh_table: prefix table not found\n");
return -1;
}
for (nrn = route_top (ntable); nrn; nrn = route_next (nrn))
{
if (!nrn->info)
continue;
rnh = nrn->info;
prn = route_node_match(ptable, &nrn->p);
if (!prn)
rib = NULL;
else
{
RNODE_FOREACH_RIB(prn, rib)
{
if (CHECK_FLAG (rib->status, RIB_ENTRY_REMOVED))
continue;
if (! CHECK_FLAG (rib->status, RIB_ENTRY_SELECTED_FIB))
continue;
if (CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED))
{
if (rib->type == ZEBRA_ROUTE_CONNECT)
break;
if (rib->type == ZEBRA_ROUTE_NHRP)
{
struct nexthop *nexthop;
for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
if (nexthop->type == NEXTHOP_TYPE_IFINDEX ||
nexthop->type == NEXTHOP_TYPE_IFNAME)
break;
if (nexthop)
break;
}
}
else
break;
}
}
if (compare_state(rib, rnh->state))
{
if (IS_ZEBRA_DEBUG_NHT)
{
char bufn[INET6_ADDRSTRLEN];
char bufp[INET6_ADDRSTRLEN];
prefix2str(&nrn->p, bufn, INET6_ADDRSTRLEN);
if (prn)
prefix2str(&prn->p, bufp, INET6_ADDRSTRLEN);
else
strcpy(bufp, "null");
zlog_debug("rnh %s resolved through route %s - sending "
"nexthop %s event to clients", bufn, bufp,
rib ? "reachable" : "unreachable");
}
copy_state(rnh, rib);
for (ALL_LIST_ELEMENTS_RO(rnh->client_list, node, client))
send_client(rnh, client, vrfid);
}
}
return 1;
}
