void safemode::add_rules( std::vector<rules_class> &rules_in )
{
//if a specific monster is being added, all the rules need to be checked now
//may have some performance issues since exclusion needs to check all monsters also
for( auto &rule : rules_in ) {
if( !rule.whitelist ) {
//Check include patterns against all monster mtypes
for( const auto &mtype : MonsterGenerator::generator().get_all_mtypes() ) {
set_rule( rule, mtype.nname(), RULE_BLACKLISTED );
}
} else {
//exclude monsters from the existing mapping
for( auto iter = safemode_rules.begin(); iter != safemode_rules.end(); ++iter ) {
set_rule( rule, iter->first, RULE_WHITELISTED );
}
}
}
}
u_int64_t* get_hourly_packets(char *path,capture_time *time_cap)
{
int i,tot_pkt=0;
display_rule dr1;
u_int64_t *cap_size=(u_int64_t*)calloc(24,sizeof(u_int64_t));
set_rule(&dr1,-1);
time_cap->month=2;
time_cap->day=26;
time_cap->start_hr=0;
time_cap->start_min=0;
time_cap->end_hr=23;
time_cap->end_min=59;
comp_flow_list* flow_list=get_flow_packets(&dr1,path,time_cap);
while(flow_list)
{
flow_rec_nos *frec=flow_list->frec;
while(frec)
{
//use frec->fr to get flow_rec structure
hs_pkt_hdr *hs_hdr=frec->pkt_list;
while(hs_hdr)
{
//use hs_hdr to get packet details
update_packet_count(hs_hdr->pkf,cap_size);
hs_hdr=hs_hdr->next;
//break;
}
frec=frec->next;
}
flow_list=flow_list->down;
}
printf("\n");
for(i=0;i<24;i++)
printf("Hour %d == %llu Bytes\n",i,cap_size[i]);
return cap_size;
}
static int processCFI(const u8 *start,
const u8 *end,
unsigned long targetLoc,
signed ptrType,
struct unwind_state *state)
{
union {
const u8 *p8;
const u16 *p16;
const u32 *p32;
} ptr;
int result = 1;
if (start != state->cieStart) {
state->loc = state->org;
result = processCFI(state->cieStart, state->cieEnd, 0, ptrType, state);
if (targetLoc == 0 && state->label == NULL)
return result;
}
for (ptr.p8 = start; result && ptr.p8 < end; ) {
switch(*ptr.p8 >> 6) {
uleb128_t value;
case 0:
switch(*ptr.p8++) {
case DW_CFA_nop:
break;
case DW_CFA_set_loc:
if ((state->loc = read_pointer(&ptr.p8, end,
ptrType)) == 0)
result = 0;
break;
case DW_CFA_advance_loc1:
result = ptr.p8 < end && advance_loc(*ptr.p8++, state);
break;
case DW_CFA_advance_loc2:
result = ptr.p8 <= end + 2
&& advance_loc(*ptr.p16++, state);
break;
case DW_CFA_advance_loc4:
result = ptr.p8 <= end + 4
&& advance_loc(*ptr.p32++, state);
break;
case DW_CFA_offset_extended:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Memory,
get_uleb128(&ptr.p8, end), state);
break;
case DW_CFA_val_offset:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Value,
get_uleb128(&ptr.p8, end), state);
break;
case DW_CFA_offset_extended_sf:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Memory,
get_sleb128(&ptr.p8, end), state);
break;
case DW_CFA_val_offset_sf:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Value,
get_sleb128(&ptr.p8, end), state);
break;
case DW_CFA_restore_extended:
case DW_CFA_undefined:
case DW_CFA_same_value:
set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0, state);
break;
case DW_CFA_register:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Register,
get_uleb128(&ptr.p8, end), state);
break;
case DW_CFA_remember_state:
if (ptr.p8 == state->label) {
state->label = NULL;
return 1;
}
if (state->stackDepth >= MAX_STACK_DEPTH)
return 0;
state->stack[state->stackDepth++] = ptr.p8;
break;
case DW_CFA_restore_state:
if (state->stackDepth) {
const uleb128_t loc = state->loc;
const u8 *label = state->label;
state->label = state->stack[state->stackDepth - 1];
memcpy(&state->cfa, &badCFA, sizeof(state->cfa));
memset(state->regs, 0, sizeof(state->regs));
state->stackDepth = 0;
result = processCFI(start, end, 0, ptrType, state);
state->loc = loc;
state->label = label;
} else
return 0;
break;
case DW_CFA_def_cfa:
state->cfa.reg = get_uleb128(&ptr.p8, end);
/*nobreak*/
case DW_CFA_def_cfa_offset:
state->cfa.offs = get_uleb128(&ptr.p8, end);
break;
case DW_CFA_def_cfa_sf:
state->cfa.reg = get_uleb128(&ptr.p8, end);
/*nobreak*/
case DW_CFA_def_cfa_offset_sf:
state->cfa.offs = get_sleb128(&ptr.p8, end)
* state->dataAlign;
break;
case DW_CFA_def_cfa_register:
state->cfa.reg = get_uleb128(&ptr.p8, end);
break;
/*todo case DW_CFA_def_cfa_expression: */
/*todo case DW_CFA_expression: */
/*todo case DW_CFA_val_expression: */
case DW_CFA_GNU_args_size:
get_uleb128(&ptr.p8, end);
break;
case DW_CFA_GNU_negative_offset_extended:
value = get_uleb128(&ptr.p8, end);
set_rule(value, Memory, (uleb128_t)0 -
get_uleb128(&ptr.p8, end), state);
break;
case DW_CFA_GNU_window_save:
default:
result = 0;
break;
}
break;
case 1:
result = advance_loc(*ptr.p8++ & 0x3f, state);
break;
case 2:
value = *ptr.p8++ & 0x3f;
set_rule(value, Memory, get_uleb128(&ptr.p8, end),
state);
break;
case 3:
set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
break;
}
if (ptr.p8 > end)
result = 0;
if (result && targetLoc != 0 && targetLoc < state->loc)
return 1;
}
return result
&& ptr.p8 == end
&& (targetLoc == 0
|| (/*todo While in theory this should apply, gcc in practice omits
everything past the function prolog, and hence the location
never reaches the end of the function.
targetLoc < state->loc &&*/ state->label == NULL));
}
void MultiGridRefiner::
select_copy_elements(std::vector<Vertex*>& vVrts, int iFirst, int copyRange)
{
if(copyRange == -1)
copyRange = get_copy_range();
vector<Edge*> vEdges;// vector used for temporary results
vector<Face*> vFaces;// vector used for temporary results
// regard the multi-grid as a grid
Grid& grid =*static_cast<Grid*>(m_pMG);
MultiGrid& mg = *m_pMG;
// we'll collect unselected edges, faces and volumes that are in
// a neighbourhood to the selection
if(copyRange > 0){
// we have to make sure that we'll only collect copy-elements in
// the correct neighbourhood.
// After we processed all elements between iFirst and iEnd, the
// first neighbourhood is done. We may then set iFirst to iEnd and
// iEnd to vVrts.size(), to process the next neighbourhood.
size_t iEnd = vVrts.size();
// iterate for each neighbourhood
for(int iNbr = 0; iNbr < copyRange; ++iNbr)
{
// iterate over candidates
for(size_t i = iFirst; i != iEnd; ++i){
Vertex* vrt = vVrts[i];
// check all associated elements.
// If we can find an unselected, it is a copy-element.
// we then have to add all its associated unselected vertices
// to vVrts.
// check edges
{
Grid::AssociatedEdgeIterator iterEnd = grid.associated_edges_end(vrt);
for(Grid::AssociatedEdgeIterator iter = grid.associated_edges_begin(vrt);
iter != iterEnd; ++iter)
{
Edge* e = *iter;
if(!m_selMarks.is_selected(e) && (!mg.has_children(e))){
// we found a copy-element
mark_for_refinement(e);
set_rule(e, RM_COPY);
// schedule associated unselected vertices for further checks
for(size_t j = 0; j < 2; ++j){
if(!m_selMarks.is_selected(e->vertex(j))){
mark_for_refinement(e->vertex(j));
vVrts.push_back(e->vertex(j));
set_rule(e->vertex(j), RM_COPY);
}
}
}
}
}
// check faces
{
Grid::AssociatedFaceIterator iterEnd = grid.associated_faces_end(vrt);
for(Grid::AssociatedFaceIterator iter = grid.associated_faces_begin(vrt);
iter != iterEnd; ++iter)
{
Face* f = *iter;
if(!m_selMarks.is_selected(f) && (!mg.has_children(f))){
// we found a copy-element
mark_for_refinement(f);
set_rule(f, RM_COPY);
// schedule associated unselected vertices for further checks
for(size_t j = 0; j < f->num_vertices(); ++j){
if(!m_selMarks.is_selected(f->vertex(j))){
mark_for_refinement(f->vertex(j));
vVrts.push_back(f->vertex(j));
set_rule(f->vertex(j), RM_COPY);
}
}
// mark associated unselected edges as copy-edge
CollectEdges(vEdges, grid, f);
for(size_t j = 0; j < vEdges.size(); ++j){
Edge* e = vEdges[j];
if(!m_selMarks.is_selected(e) && (!mg.has_children(e))){
mark_for_refinement(e);
set_rule(e, RM_COPY);
}
}
}
}
}
// check volumes
{
Grid::AssociatedVolumeIterator iterEnd = grid.associated_volumes_end(vrt);
for(Grid::AssociatedVolumeIterator iter = grid.associated_volumes_begin(vrt);
iter != iterEnd; ++iter)
{
Volume* v = *iter;
if(!m_selMarks.is_selected(v) && (!mg.has_children(v))){
// we found a copy-element
mark_for_refinement(v);
set_rule(v, RM_COPY);
// schedule associated unselected vertices for further checks
for(size_t j = 0; j < v->num_vertices(); ++j){
if(!m_selMarks.is_selected(v->vertex(j))){
mark_for_refinement(v->vertex(j));
vVrts.push_back(v->vertex(j));
set_rule(v->vertex(j), RM_COPY);
}
}
// mark associated unselected edges as copy-edge
CollectEdges(vEdges, grid, v);
for(size_t j = 0; j < vEdges.size(); ++j){
Edge* e = vEdges[j];
if(!m_selMarks.is_selected(e) && (!mg.has_children(e))){
mark_for_refinement(e);
set_rule(e, RM_COPY);
}
}
// mark associated unselected faces as copy-edge
CollectFaces(vFaces, grid, v);
for(size_t j = 0; j < vFaces.size(); ++j){
Face* f = vFaces[j];
if(!m_selMarks.is_selected(f) && (!mg.has_children(f))){
mark_for_refinement(f);
set_rule(f, RM_COPY);
}
}
}
}
}
}
// the neighbourhood is done. check the next neighbourhood.
iFirst = iEnd;
iEnd = vVrts.size();
}
}
}
void MultiGridRefiner::
select_closure(std::vector<Vertex*>& vVrts)
{
vector<Edge*> vEdges;// vector used for temporary results
vector<Face*> vFaces;// vector used for temporary results
vector<Volume*> vVolumes;// vector used for temporary results
// regard the multi-grid as a grid
Grid& grid =*static_cast<Grid*>(m_pMG);
MultiGrid& mg = *m_pMG;
// collect associated faces of refine-edges that will be used for the closure.
// associated volumes will be collected implicitly later on from refine-faces.
if(mg.num<Face>() > 0)
{
// store end-iterator so that newly marked edges won't be considered.
for(EdgeIterator iter = m_selMarks.begin<Edge>();
iter != m_selMarks.end<Edge>(); ++iter)
{
// as soon as we encounter an edge that is scheduled for COPY, we're done in here
if(get_rule(*iter) == RM_COPY)
break;
CollectFaces(vFaces, grid, *iter);
for(size_t i = 0; i < vFaces.size(); ++i){
Face* f = vFaces[i];
if(!m_selMarks.is_selected(f) && (!mg.has_children(f)))
{
mark_for_refinement(f);
// we now have to check all associated edges.
// unselected ones will be added as copy-elements
size_t numRegular = 0;
CollectEdges(vEdges, grid, f);
for(size_t j = 0; j < vEdges.size(); ++j){
Edge* e = vEdges[j];
if(m_selMarks.is_selected(e)){
if(get_rule(e) == RM_REFINE)
++numRegular;
}
else{
if(!mg.has_children(e)){
set_rule(e, RM_COPY);
mark_for_refinement(e);
}
}
}
// set rule
// if all associated edges are refined regular,
// we'll refine the face regular, too.
if(numRegular == vEdges.size())
set_rule(f, RM_REFINE);
else
set_rule(f, RM_IRREGULAR);
// finally we have to make sure that all vertices are selected.
for(size_t j = 0; j < f->num_vertices(); ++j)
{
if(!m_selMarks.is_selected(f->vertex(j))){
if(get_copy_range() > 0)
vVrts.push_back(f->vertex(j));
mark_for_refinement(f->vertex(j));
set_rule(f->vertex(j), RM_COPY);
}
}
}
}
}
}
// collect associated volumes of refine-faces that will be used for the closure.
// we don't have to check associated volumes of refine-edges, since
// those are associated volumes of refine-faces, too.
if(mg.num<Volume>() > 0)
{
// store end-iterator so that newly marked faces won't be considered.
for(FaceIterator iter = m_selMarks.begin<Face>();
iter != m_selMarks.end<Face>(); ++iter)
{
// as soon as we encounter a face that is scheduled for COPY, we're done in here
if(get_rule(*iter) == RM_COPY)
break;
CollectVolumes(vVolumes, grid, *iter);
for(size_t i = 0; i < vVolumes.size(); ++i){
Volume* v = vVolumes[i];
if(!m_selMarks.is_selected(v) && (!mg.has_children(v)))
{
mark_for_refinement(v);
// we now have to check all associated faces.
// unselected ones will be added as copy-elements.
size_t numRegular = 0;
CollectFaces(vFaces, grid, v);
for(size_t j = 0; j < vFaces.size(); ++j){
Face* f = vFaces[j];
if(m_selMarks.is_selected(f)){
if(get_rule(f) == RM_REFINE)
++numRegular;
}
else{
if(!mg.has_children(f)){
set_rule(f, RM_COPY);
mark_for_refinement(f);
}
}
}
// set rule
// if all faces are refined regular, we'll refine the volume regular, too.
if(numRegular == vFaces.size())
set_rule(v, RM_REFINE);
else
set_rule(v, RM_IRREGULAR);
// we now have to check all associated edges.
// unselected ones will be added as copy-elements.
CollectEdges(vEdges, grid, v);
for(size_t j = 0; j < vEdges.size(); ++j){
Edge* e = vEdges[j];
if(!m_selMarks.is_selected(e)
&& (!mg.has_children(e)))
{
if(!mg.has_children(e)){
set_rule(e, RM_COPY);
mark_for_refinement(e);
}
}
}
// finally we have to make sure that all vertices are selected.
for(size_t j = 0; j < v->num_vertices(); ++j)
{
if(!m_selMarks.is_selected(v->vertex(j))){
if(get_copy_range() > 0)
vVrts.push_back(v->vertex(j));
mark_for_refinement(v->vertex(j));
set_rule(v->vertex(j), RM_COPY);
}
}
}
}
}
}
}
void MultiGridRefiner::
adjust_initial_selection()
{
vector<Edge*> vEdges;// vector used for temporary results
vector<Face*> vFaces;// vector used for temporary results
// regard the multi-grid as a grid
Grid& grid =*static_cast<Grid*>(m_pMG);
MultiGrid& mg = *m_pMG;
////////////////////////////////
// initial selection
// select elements that are associated with volumes
// make sure to deselect all elements that must not be refined.
for(VolumeIterator iter = m_selMarks.begin<Volume>();
iter != m_selMarks.end<Volume>();)
{
Volume* v = *iter;
++iter;//iterator is incremented since it would be invalidated during deselect.
if(mg.has_children(v))
{
// the element has already been refined.
// don't refine it again.
m_selMarks.deselect(v);
}
else if(get_status(v) == SM_COPY){
// copy elements must not be refined in the current version
LOG(" WARNING: copy-elements must not be refined in the current version!\n");
m_selMarks.deselect(v);
}
else if(get_status(v) == SM_IRREGULAR){
// irregular elements must not be refined in the current version
LOG(" WARNING: irregular-elements must not be refined in the current version!\n");
m_selMarks.deselect(v);
}
else{
// mark it for regular refinement
set_rule(v, RM_REFINE);
// collect associated faces
CollectFaces(vFaces, grid, v);
for(uint i = 0; i < vFaces.size(); ++i)
if(!mg.has_children(vFaces[i]))
mark_for_refinement(vFaces[i]);
}
}
// select elements that are associated with faces
for(FaceIterator iter = m_selMarks.begin<Face>();
iter != m_selMarks.end<Face>();)
{
Face* f = *iter;
++iter; //iterator is incremented since it would be invalidated during deselect.
if(mg.has_children(f))
{
// the element has already been refined.
// don't refine it again.
m_selMarks.deselect(f);
}
else if(get_status(f) == SM_COPY){
// copy elements must not be refined in the current version
LOG(" WARNING: copy-elements must not be refined in the current version!\n");
m_selMarks.deselect(f);
}
else if(get_status(f) == SM_IRREGULAR){
// irregular elements must not be refined in the current version
LOG(" WARNING: irregular-elements must not be refined in the current version!\n");
m_selMarks.deselect(f);
}
else{
// mark it for regular refinement
set_rule(f, RM_REFINE);
// collect associated edges
CollectEdges(vEdges, grid, f);
for(uint i = 0; i < vEdges.size(); ++i)
if(!mg.has_children(vEdges[i]))
mark_for_refinement(vEdges[i]);
}
}
// select elements that are associated with edges
for(EdgeIterator iter = m_selMarks.begin<Edge>();
iter != m_selMarks.end<Edge>();)
{
Edge* e = *iter;
++iter; //iterator is incremented since it would be invalidated during deselect.
if(mg.has_children(e)){
// the element has already been refined.
// don't refine it again.
m_selMarks.deselect(e);
}
else if(get_status(e) == SM_COPY){
// copy elements must not be refined in the current version
LOG(" WARNING: copy-elements must not be refined in the current version!\n");
m_selMarks.deselect(e);
}
else if(get_status(e) == SM_IRREGULAR){
// irregular elements must not be refined in the current version
LOG(" WARNING: irregular-elements must not be refined in the current version!\n");
m_selMarks.deselect(e);
}
else{
// mark it for regular refinement
set_rule(e, RM_REFINE);
// select associated vertices
for(uint i = 0; i < e->num_vertices(); ++i)
mark_for_refinement(e->vertex(i));
}
}
// set rule for all marked vertices
for(VertexIterator iter = m_selMarks.begin<Vertex>();
iter != m_selMarks.end<Vertex>(); ++iter)
{
set_rule(*iter, RM_COPY);
}
}
