int
extract_nat_lcaf_data(uint8_t *offset, uint16_t *ms_udp_port,
uint16_t *etr_udp_port, lisp_addr_t *global_etr_rloc,
lisp_addr_t *ms_rloc, lisp_addr_t *private_etr_rloc,
rtr_locators_list_t **rtr_list, uint32_t *length)
{
lcaf_hdr_t *pkt_lcaf;
lispd_pkt_nat_lcaf_t *pkt_nat_lcaf;
rtr_locators_list_t *rtr_locator_list = NULL;
rtr_locator_t *rtr_locator;
lisp_addr_t rtr_address = {.afi=LM_AFI_NO_ADDR};
uint8_t *ptr = offset;
uint32_t lcaf_length;
uint32_t cumulative_add_length;
pkt_lcaf = (lcaf_hdr_t *)ptr;
if (pkt_lcaf->type != LCAF_NATT){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Packet doesn't have NAT LCAF address");
return (BAD);
}
lcaf_length = ntohs(pkt_lcaf->len);
ptr = CO(ptr,sizeof(lcaf_hdr_t));
pkt_nat_lcaf = (lispd_pkt_nat_lcaf_t *)ptr;
*ms_udp_port = ntohs(pkt_nat_lcaf->ms_udp_port);
*etr_udp_port = ntohs(pkt_nat_lcaf->etr_udp_port);
cumulative_add_length = FIELD_PORT_LEN * 2; /* 2 UDP ports */
ptr = CO(ptr,sizeof(lispd_pkt_nat_lcaf_t));
/* Extract the Global ETR RLOC */
if ((extract_lisp_address(ptr, global_etr_rloc)) != GOOD){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Couldn't process Global ETR RLOC");
return (BAD);
}
cumulative_add_length += get_addr_len(global_etr_rloc->afi) + FIELD_AFI_LEN;
ptr = CO(ptr, get_addr_len(global_etr_rloc->afi) + FIELD_AFI_LEN);
/* Extract the MS RLOC */
if ((extract_lisp_address(ptr, ms_rloc)) != GOOD){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Couldn't process MS RLOC");
return (BAD);
}
cumulative_add_length += get_addr_len(ms_rloc->afi) + FIELD_AFI_LEN;
ptr = CO(ptr, get_addr_len(ms_rloc->afi) + FIELD_AFI_LEN);
/* Extract the Private ETR RLOC */
if (extract_lisp_address(ptr, private_etr_rloc) != GOOD){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Couldn't process private ETR RLOC");
return (BAD);
}
cumulative_add_length += get_addr_len(private_etr_rloc->afi) + FIELD_AFI_LEN;
ptr = CO(ptr, get_addr_len(private_etr_rloc->afi) + FIELD_AFI_LEN);
/* Extract the list of RTR RLOCs */
while (cumulative_add_length < lcaf_length) {
if ((extract_lisp_address(ptr, &rtr_address))!= GOOD){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Coudln't process rtr address");
return (BAD);
}
rtr_locator = rtr_locator_new (rtr_address);
if (rtr_locator == NULL){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Error malloc lispd_rtr_locator");
return (BAD);
}
if ((rtr_list_add(&rtr_locator_list,rtr_locator))!=GOOD){
LMLOG(LDBG_2, "extract_nat_lcaf_data: Error adding rtr_locator");
return (BAD);
}
// Return the first element of the list
if (*rtr_list == NULL){
*rtr_list = rtr_locator_list;
}
LMLOG(LDBG_3, "Added RTR with RLOC %s to the list of RTRs",
get_char_from_lisp_addr_t(rtr_locator->address));
cumulative_add_length += get_addr_len(rtr_locator->address.afi) + FIELD_AFI_LEN;
ptr = CO(ptr, get_addr_len(rtr_locator->address.afi) + FIELD_AFI_LEN);
}
*length = sizeof(lcaf_hdr_t) + lcaf_length;
return (GOOD);
}
/* BPLUS delete key functions */
int delete_key(ENTRY *pe, IX_DESC *pix)
{
ENTRY e;
RECPOS ads;
int h, leveli, levelf;
if (!find_exact(pe, pix))
{
return (IX_NOTEXISTED);
}
h = 1;
if ((ads = pe->idxptr) != NULLREC)
{
leveli = pci->level;
do
{
retrieve_block(++(pci->level), ads);
CO(pci->level) = -1;
}
while ((ads = block_ptr->p0) != NULLREC);
CO(pci->level) = 0;
copy_entry(&e, ENT_ADR(block_ptr, CO(pci->level)));
levelf = pci->level;
pci->level = leveli;
replace_entry(&e);
pci->level = levelf;
/*update_root(&pci->root);*/
}
while ( h )
{
retrieve_block(pci->level, CB(pci->level));
del_block(block_ptr, CO(pci->level));
update_block();
if ( (pci->level == 0) && (block_ptr->bend == 0))
/* tree was reduced in height */
{
if (pci->root.p0 != NULLREC)
{
retrieve_block(++pci->level, pci->root.p0);
memcpy(&(pci->root), block_ptr, sizeof(BLOCK));
(pci->dx.nl)--;
write_free(block_ptr->brec, block_ptr);
BUFDIRTY(cache_ptr) = 0;
BUFHANDLE(cache_ptr) = 0;
update_root(&pci->root);
}
break;
}
h = (block_ptr->bend < comb_size) && (pci->level > 0);
if ( h )
{
h = combineblk(CB(pci->level), block_ptr->bend);
}
}
/*return flush_index(pix);*/
if(root_dirty == 1)
{
flush_index(pix);
root_dirty = 0;
}
return(IX_OK);
}
void CSharpFlatCodeGen::writeData()
{
/* If there are any transtion functions then output the array. If there
* are none, don't bother emitting an empty array that won't be used. */
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActArrItem), A() );
ACTIONS_ARRAY();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyConditions() ) {
OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
COND_KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpan), CSP() );
COND_KEY_SPANS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCond), C() );
CONDS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondIndexOffset), CO() );
COND_INDEX_OFFSET();
CLOSE_ARRAY() <<
"\n";
}
OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSpan), SP() );
KEY_SPANS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxFlatIndexOffset), IO() );
FLAT_INDEX_OFFSET();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
INDICIES();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS();
CLOSE_ARRAY() <<
"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TA() );
TRANS_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofTrans() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
EOF_TRANS();
CLOSE_ARRAY() <<
"\n";
}
STATE_IDS();
}
int main(int argc, char** argv)
{
try {
if(argc != 2){
/* Print usage and exit. */
std::cout << "\nusage: " << argv[0] << " ModelConf.conf\n" << std::endl;
return EXIT_SUCCESS;
}
/* Define the model configuration file. */
/* Here it is passed as the first argument to the executable. */
/* The model configuration file provides the default values of */
/* the mandatory model parameters. */
std::string ModelConf = argv[1];
/* Define a map for the parameters to be varied. */
std::map<std::string, double> DPars;
/* Create objects of the classes ModelFactory and ThObsFactory */
ModelFactory ModelF;
ThObsFactory ThObsF;
/* register user-defined model named ModelName defined in class ModelClass using the following syntax: */
/* ModelF.addModelToFactory(ModelName, boost::factory<ModelClass*>() ) */
/* register user-defined ThObservable named ThObsName defined in class ThObsClass using the following syntax: */
/* ThObsF.addObsToFactory(ThObsName, boost::factory<ThObsClass*>() )*/
/* Create an object of the class ComputeObservables. */
ComputeObservables CO(ModelF, ThObsF, ModelConf);
/* Add the observables to be returned. */
CO.AddObservable("Mw");
CO.AddObservable("GammaZ");
CO.AddObservable("AFBbottom");
/* Remove a previously added observable if necessary. */
//CO.RemoveObservable("AFBbottom");
/* Set the flags for the model being used, if necessary. */
/* The flags have to correspond to the model specified in the model config file. */
std::map<std::string, std::string> DFlags;
// DFlags["FLAG"] = "TRUE";
CO.setFlags(DFlags);
/* Get the map of observables if necessary. */
std::map<std::string, double> DObs = CO.getObservables();
for (int i = 0; i < 2; i++) {
/* Vary the parameters that need to be varied in the analysis. */
DPars["Mz"] = 91.1875 + 0.0001 * i;
DPars["AlsMz"] = 0.1184 + 0.000001 * i;
/* Get the map of observables with the parameter values defined above. */
DObs = CO.compute(DPars);
std::cout << "\nParameters[" << i + 1 << "]:"<< std::endl;
for (std::map<std::string, double>::iterator it = DPars.begin(); it != DPars.end(); it++) {
std::cout << it->first << " = " << it->second << std::endl;
}
std::cout << "\nObservables[" << i + 1 << "]:" << std::endl;
for (std::map<std::string, double>::iterator it = DObs.begin(); it != DObs.end(); it++) {
std::cout << it->first << " = " << it->second << std::endl;
}
}
return EXIT_SUCCESS;
} catch (const std::runtime_error& e) {
std::cerr << e.what() << std::endl;
return EXIT_FAILURE;
}
}
void TextWindow::ScreenChangeViewProjection(int link, uint32_t v) {
std::string edit_value =
ssprintf("%.3f, %.3f, %.3f", CO(SS.GW.projRight));
SS.TW.edit.meaning = Edit::VIEW_PROJ_RIGHT;
SS.TW.ShowEditControl(10, edit_value);
}
void CSharpFFlatCodeGen::writeData()
{
if ( redFsm->anyConditions() ) {
OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
COND_KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpan), CSP() );
COND_KEY_SPANS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCond), C() );
CONDS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondIndexOffset), CO() );
COND_INDEX_OFFSET();
CLOSE_ARRAY() <<
"\n";
}
OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSpan), SP() );
KEY_SPANS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxFlatIndexOffset), IO() );
FLAT_INDEX_OFFSET();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
INDICIES();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS();
CLOSE_ARRAY() <<
"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
TRANS_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofTrans() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
EOF_TRANS();
CLOSE_ARRAY() <<
"\n";
}
STATE_IDS();
}
void OCamlFFlatCodeGen::writeData()
{
if ( redFsm->anyConditions() ) {
OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
COND_KEYS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpan), CSP() );
COND_KEY_SPANS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCond), C() );
CONDS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondIndexOffset), CO() );
COND_INDEX_OFFSET();
CLOSE_ARRAY() <<
L"\n";
}
OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
KEYS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSpan), SP() );
KEY_SPANS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxFlatIndexOffset), IO() );
FLAT_INDEX_OFFSET();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
INDICIES();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS();
CLOSE_ARRAY() <<
L"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
TRANS_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyEofTrans() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
EOF_TRANS();
CLOSE_ARRAY() <<
L"\n";
}
STATE_IDS();
out << L"type " << TYPE_STATE() << L" = { mutable keys : int; mutable trans : int; }"
<< TOP_SEP();
out << L"exception Goto_match" << TOP_SEP();
out << L"exception Goto_again" << TOP_SEP();
out << L"exception Goto_eof_trans" << TOP_SEP();
}
void StepFileWriter::ExportSurface(SSurface *ss, SBezierList *sbl) {
int i, j, srfid = id;
// First, we create the untrimmed surface. We always specify a rational
// B-spline surface (in fact, just a Bezier surface).
fprintf(f, "#%d=(\n", srfid);
fprintf(f, "BOUNDED_SURFACE()\n");
fprintf(f, "B_SPLINE_SURFACE(%d,%d,(", ss->degm, ss->degn);
for(i = 0; i <= ss->degm; i++) {
fprintf(f, "(");
for(j = 0; j <= ss->degn; j++) {
fprintf(f, "#%d", srfid + 1 + j + i*(ss->degn + 1));
if(j != ss->degn) fprintf(f, ",");
}
fprintf(f, ")");
if(i != ss->degm) fprintf(f, ",");
}
fprintf(f, "),.UNSPECIFIED.,.F.,.F.,.F.)\n");
fprintf(f, "B_SPLINE_SURFACE_WITH_KNOTS((%d,%d),(%d,%d),",
(ss->degm + 1), (ss->degm + 1),
(ss->degn + 1), (ss->degn + 1));
fprintf(f, "(0.000,1.000),(0.000,1.000),.UNSPECIFIED.)\n");
fprintf(f, "GEOMETRIC_REPRESENTATION_ITEM()\n");
fprintf(f, "RATIONAL_B_SPLINE_SURFACE((");
for(i = 0; i <= ss->degm; i++) {
fprintf(f, "(");
for(j = 0; j <= ss->degn; j++) {
fprintf(f, "%.10f", ss->weight[i][j]);
if(j != ss->degn) fprintf(f, ",");
}
fprintf(f, ")");
if(i != ss->degm) fprintf(f, ",");
}
fprintf(f, "))\n");
fprintf(f, "REPRESENTATION_ITEM('')\n");
fprintf(f, "SURFACE()\n");
fprintf(f, ");\n");
// The control points for the untrimmed surface.
for(i = 0; i <= ss->degm; i++) {
for(j = 0; j <= ss->degn; j++) {
fprintf(f, "#%d=CARTESIAN_POINT('',(%.10f,%.10f,%.10f));\n",
srfid + 1 + j + i*(ss->degn + 1),
CO(ss->ctrl[i][j]));
}
}
fprintf(f, "\n");
id = srfid + 1 + (ss->degm + 1)*(ss->degn + 1);
// Now we do the trim curves. We must group each outer loop separately
// along with its inner faces, so do that now.
SBezierLoopSetSet sblss;
ZERO(&sblss);
SPolygon spxyz;
ZERO(&spxyz);
bool allClosed;
SEdge notClosedAt;
// We specify a surface, so it doesn't check for coplanarity; and we
// don't want it to give us any open contours. The polygon and chord
// tolerance are required, because they are used to calculate the
// contour directions and determine inner vs. outer contours.
sblss.FindOuterFacesFrom(sbl, &spxyz, ss,
SS.ChordTolMm() / SS.exportScale,
&allClosed, ¬ClosedAt,
NULL, NULL,
NULL);
// So in our list of SBezierLoopSet, each set contains at least one loop
// (the outer boundary), plus any inner loops associated with that outer
// loop.
SBezierLoopSet *sbls;
for(sbls = sblss.l.First(); sbls; sbls = sblss.l.NextAfter(sbls)) {
SBezierLoop *loop = sbls->l.First();
List<int> listOfLoops;
ZERO(&listOfLoops);
// Create the face outer boundary from the outer loop.
int fob = ExportCurveLoop(loop, false);
listOfLoops.Add(&fob);
// And create the face inner boundaries from any inner loops that
// lie within this contour.
loop = sbls->l.NextAfter(loop);
for(; loop; loop = sbls->l.NextAfter(loop)) {
int fib = ExportCurveLoop(loop, true);
listOfLoops.Add(&fib);
}
// And now create the face that corresponds to this outer loop
// and all of its holes.
int advFaceId = id;
fprintf(f, "#%d=ADVANCED_FACE('',(", advFaceId);
int *fb;
for(fb = listOfLoops.First(); fb; fb = listOfLoops.NextAfter(fb)) {
fprintf(f, "#%d", *fb);
if(listOfLoops.NextAfter(fb) != NULL) fprintf(f, ",");
}
fprintf(f, "),#%d,.T.);\n", srfid);
fprintf(f, "\n");
advancedFaces.Add(&advFaceId);
id++;
listOfLoops.Clear();
}
sblss.Clear();
spxyz.Clear();
}
int process_map_request_msg(
uint8_t *packet,
lisp_addr_t *local_rloc,
uint16_t dst_port) {
lispd_mapping_elt *source_mapping = NULL;
lispd_map_cache_entry *map_cache_entry = NULL;
lisp_addr_t itr_rloc[32];
lisp_addr_t *remote_rloc = NULL;
int itr_rloc_count = 0;
int itr_rloc_afi = 0;
uint8_t *cur_ptr = NULL;
int len = 0;
lispd_pkt_map_request_t *msg = NULL;
lisp_addr_t aux_eid_prefix;
int aux_eid_prefix_length = 0;
int aux_iid = -1;
int i = 0;
/* If the packet is an Encapsulated Map Request, verify checksum and remove the inner IP header */
if (((lisp_encap_control_hdr_t *) packet)->type == LISP_ENCAP_CONTROL_TYPE) {
if ((err = process_encapsulated_map_request_headers(packet,&len,&dst_port)) != GOOD){
return (BAD);
}
msg = (lispd_pkt_map_request_t *) CO(packet, len);
} else if (((lispd_pkt_map_request_t *) packet)->type == LISP_MAP_REQUEST) {
msg = (lispd_pkt_map_request_t *) packet;
} else
return(BAD); //we should never reach this return()
/*
* Source EID is optional in general, but required for SMRs
*/
/* Auxiliar lispd_mapping_elt created to be filled with pkt_process_eid_afi */
source_mapping = new_local_mapping(aux_eid_prefix,aux_eid_prefix_length,aux_iid);
if (source_mapping == NULL){
return (BAD);
}
cur_ptr = (uint8_t *)&(msg->source_eid_afi);
if (pkt_process_eid_afi(&cur_ptr, source_mapping) != GOOD){
free_mapping_elt(source_mapping, FALSE);
return (BAD);
}
/* If packet is a Solicit Map Request, process it */
if (source_mapping->eid_prefix.afi != 0 && msg->solicit_map_request) {
/*
* Lookup the map cache entry that match with the source EID prefix of the message
*/
map_cache_entry = lookup_map_cache(source_mapping->eid_prefix);
if (map_cache_entry == NULL){
free_mapping_elt(source_mapping, FALSE);
return (BAD);
}
/*
* Check IID of the received Solicit Map Request match the IID of the map cache
*/
if (map_cache_entry->mapping->iid != source_mapping->iid){
lispd_log_msg(LISP_LOG_DEBUG_2,"process_map_request_msg: The IID of the received Solicit Map Request doesn't match the IID of "
"the entry in the map cache");
free_mapping_elt(source_mapping, FALSE);
return (BAD);
}
/* Free source_mapping once we have a valid map cache entry */
free_mapping_elt(source_mapping, FALSE);
/*
* Only accept a solicit map request for an EID prefix ->If node which generates the message
* has more than one locator, it probably will generate a solicit map request for each one.
* Only the first one is considered.
* If map_cache_entry->nonces is different of null, we have already received a solicit map request
*/
if (map_cache_entry->nonces == NULL){
solicit_map_request_reply(NULL,(void *)map_cache_entry);
}
/* Return here only if RLOC probe bit is not set */
if (!msg->rloc_probe){
return(GOOD);
}
}
/* Get the array of ITR-RLOCs */
itr_rloc_count = msg->additional_itr_rloc_count + 1;
for (i = 0; i < itr_rloc_count; i++) {
itr_rloc_afi = lisp2inetafi(ntohs(*(uint16_t *)cur_ptr));
cur_ptr = CO(cur_ptr, sizeof(uint16_t));
memcpy(&(itr_rloc[i].address), cur_ptr, get_addr_len(itr_rloc_afi));
itr_rloc[i].afi = itr_rloc_afi;
cur_ptr = CO(cur_ptr, get_addr_len(itr_rloc_afi));
// Select the first accessible rloc from the ITR-RLOC list
if (remote_rloc == NULL){
if (local_rloc != NULL && itr_rloc[i].afi == local_rloc->afi){
remote_rloc = &itr_rloc[i];
}
}
}
if (remote_rloc == NULL){
lispd_log_msg(LISP_LOG_DEBUG_1,"process_map_request_msg: Couldn't generate map replay - "
"No supported afi in the list of ITR-RLOCS");
return (BAD);
}
/* Process record and send Map Reply for each one */
for (i = 0; i < msg->record_count; i++) {
process_map_request_record(&cur_ptr, local_rloc, remote_rloc, dst_port, msg->rloc_probe, msg->nonce);
}
return(GOOD);
}
void TextWindow::ScreenChangeLightDirection(int link, uint32_t v) {
SS.TW.ShowEditControl(8, ssprintf("%.2f, %.2f, %.2f", CO(SS.lightDir[v])));
SS.TW.edit.meaning = Edit::LIGHT_DIRECTION;
SS.TW.edit.i = v;
}
double hepfit_call(double *theta, int nDims, double *phi, int nDerived, int index){
std::string selected_pars[nDims] = {"mtop","AlsMz"};
std::string selected_obsvs[nDerived] = {"Mw"};
std::string ModelName = "StandardModel";
/* Create an object of the class InputParameters. */
InputParameters IP;
/* Read a map for the mandatory model parameters. (Default values in InputParameters.h) */
std::map<std::string, double> DPars_IN = IP.getInputParameters(ModelName);
/* Create objects of the classes ModelFactory and ThObsFactory */
ModelFactory ModelF;
ThObsFactory ThObsF;
/* Create an object of the class ComputeObservables. */
ComputeObservables CO(ModelF, ThObsF, ModelName, DPars_IN);
/* Add the observables to be returned. */
CO.AddObservable( selected_obsvs[0] );
/* Set the flags for the model being used, if necessary. */
// std::map<std::string, std::string> DFlags;
// DFlags["epsilon2SM"] = "TRUE";
// CO.setFlags(DFlags);
/* Get the map of observables */
std::map<std::string, double> DObs = CO.getObservables();
/* Define a map for the parameters to be varied. */
std::map<std::string, double> DPars;
/* Vary the parameters that need to be varied in the analysis. */
// to be obtained from sampler: PolyChord or MultiNest
for(int i = 0; i < nDims; i++){
DPars[ selected_pars[i] ] = theta[i];
std::cout << "DPars[ "<< selected_pars[i] << " ] = " << DPars[ selected_pars[i] ];
}
/* Get the map of observables with the parameter values defined above. */
DObs = CO.compute(DPars);
for (int i = 0; i < nDerived; i++){
phi[i] = DObs[ selected_obsvs[i] ];
std::cout << "DObs[ "<< selected_obsvs[i] << " ] = " << DObs[ selected_obsvs[i] ] << std::endl;
}
//@@@@ HEPfit should have option for return log-likelihood ??
// compute and retrun log likelihood
// Observable: Mw = 80.3613 +- 0.03, say
double Mw = 80.3613;
double Mw_err = 0.03;
double MwPredicted = phi[0];
double chi = (MwPredicted - Mw) / ( sqrt(2.) * Mw_err );
std::cout << "log-likelihood = " << - chi * chi - log( Mw_err * sqrt(2.0 * M_PI) );
return - chi * chi - log( Mw_err * sqrt(2.0 * M_PI) );
}
#define __CONSOLE_APP__
#include "eC.h"
APP_INTRO(0)
{
printLn(CO(String), "C: Hello, eC!", null);
}
APP_OUTRO
/*
* This function modifies kernel's list of ip rules
*/
inline int modify_rule (
int afi,
int if_index, // interface index
int command, // add or del the rule?
uint8_t table, // rule for which routing table?
uint32_t priority, // rule priority
uint8_t type, // type of route
lisp_addr_t *src_addr, // src addr to match
int src_plen, // src addr prefix length
lisp_addr_t *dst_addr, // dst addr to match
int dst_plen, // dst addr prefix length
int flags) // flags, if any
{
struct nlmsghdr *nlh = NULL;
struct rtmsg *rtm = NULL;
struct rtattr *rta = NULL;
char buf[4096];
int rta_len = 0;
int addr_size = 0;
int sockfd = 0;
int result = BAD;
sockfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (sockfd < 0) {
lispd_log_msg(LISP_LOG_CRIT, "Failed to connect to netlink socket for creating route");
exit_cleanup();
}
if (afi == AF_INET){
addr_size = sizeof(struct in_addr);
}
else{
addr_size = sizeof(struct in6_addr);
}
/*
* Build the command
*/
memset(buf, 0, sizeof(buf));
nlh = (struct nlmsghdr *)buf;
//rtm = (struct rtmsg *)(CO(buf,sizeof(struct nlmsghdr)));
rtm = NLMSG_DATA(nlh);
rta_len = sizeof(struct rtmsg);
rta = (struct rtattr *)(CO(rtm, sizeof(struct rtmsg)));
/*
* Add src address for the route
*/
if (src_addr != NULL){
rta->rta_type = RTA_SRC;
rta->rta_len = sizeof(struct rtattr) + addr_size;
memcpy(((char *)rta) + sizeof(struct rtattr), &src_addr->address, addr_size);
rta_len += rta->rta_len;
}
/*
* Add the destination
*/
if (dst_addr != NULL){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_DST;
rta->rta_len = sizeof(struct rtattr) + addr_size;
memcpy(((char *)rta) + sizeof(struct rtattr), &dst_addr->address, addr_size);
rta_len += rta->rta_len;
}
/*
* Add priority
*/
if (priority != 0){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_PRIORITY;
rta->rta_len = sizeof(struct rtattr) + sizeof(uint32_t);
memcpy(((char *)rta) + sizeof(struct rtattr), &priority, sizeof(uint32_t));
rta_len += rta->rta_len;
}
/*
* Select interface
*/
if (if_index != 0){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_IIF;
rta->rta_len = sizeof(struct rtattr) + sizeof(int);
memcpy(((char *)rta) + sizeof(struct rtattr), &if_index, sizeof(int));
rta_len += rta->rta_len;
}
/*
* Fill up the netlink message flags and attributes
*/
nlh->nlmsg_len = NLMSG_LENGTH(rta_len);
nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
if (command == RTM_NEWRULE) {
nlh->nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
nlh->nlmsg_type = RTM_NEWRULE;
}else{
nlh->nlmsg_type = RTM_DELRULE;
}
rtm->rtm_family = afi;
rtm->rtm_dst_len = dst_plen;
rtm->rtm_src_len = src_plen;
if (table == 0){
rtm->rtm_table = RT_TABLE_MAIN;
}else{
rtm->rtm_table = table;
}
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
rtm->rtm_type = type;
rtm->rtm_flags = flags;
/*
* Send the netlink message to kernel
*/
result = send(sockfd, buf, NLMSG_LENGTH(rta_len), 0);
if (result < 0) {
lispd_log_msg(LISP_LOG_CRIT, "mod_route: send netlink command failed %s", strerror(errno));
close(sockfd);
exit_cleanup();
}
close(sockfd);
return(GOOD);
}
inline int modify_route(
int command, /* add or del */
int afi,
uint32_t ifindex,
lisp_addr_t *dest,
lisp_addr_t *src,
lisp_addr_t *gw,
uint32_t prefix_len,
uint32_t metric,
uint32_t table)
{
struct nlmsghdr *nlh = NULL;
struct rtmsg *rtm = NULL;
struct rtattr *rta = NULL;
char sndbuf[4096];
int rta_len = 0;
int retval = 0;
int sockfd = 0;
int addr_size = 0;
if (afi == AF_INET){
addr_size = sizeof(struct in_addr);
}
else{
addr_size = sizeof(struct in6_addr);
}
sockfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (sockfd < 0) {
lispd_log_msg(LISP_LOG_CRIT, "modify_route: Failed to connect to netlink socket");
exit_cleanup();
}
/*
* Build the command
*/
memset(sndbuf, 0, 4096);
nlh = (struct nlmsghdr *)sndbuf;
rtm = (struct rtmsg *)(CO(sndbuf,sizeof(struct nlmsghdr)));
rta_len = sizeof(struct rtmsg);
rta = (struct rtattr *)(CO(rtm, sizeof(struct rtmsg)));
/*
* Add the destination
*/
if (dest != NULL){
rta->rta_type = RTA_DST;
rta->rta_len = sizeof(struct rtattr) + addr_size;
memcpy(((char *)rta) + sizeof(struct rtattr), &dest->address, addr_size);
rta_len += rta->rta_len;
}
/*
* Add src address for the route
*/
if (src != NULL){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_PREFSRC;
rta->rta_len = sizeof(struct rtattr) + addr_size;
memcpy(((char *)rta) + sizeof(struct rtattr), &src->address, addr_size);
rta_len += rta->rta_len;
}
/*
* Add the outgoing interface
*/
if (ifindex>0)
{
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_OIF;
rta->rta_len = sizeof(struct rtattr) + sizeof(uint32_t); // if_index
memcpy(((char *)rta) + sizeof(struct rtattr), &ifindex, sizeof(uint32_t));
rta_len += rta->rta_len;
}
/*
* Add the gateway
*/
if (gw != NULL){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
rta->rta_type = RTA_GATEWAY;
rta->rta_len = sizeof(struct rtattr) + addr_size;
memcpy(((char *)rta) + sizeof(struct rtattr), &gw->address, addr_size);
rta_len += rta->rta_len;
}
/* Add the route metric */
if (metric > 0){
if (rta_len > sizeof(struct rtmsg)){
rta = (struct rtattr *)(CO(rta, rta->rta_len));
}
//rta->rta_type = RTA_METRICS;
rta->rta_type = RTA_PRIORITY; /* This is the actual atr type to set the metric... */
rta->rta_len = sizeof(struct rtattr) + sizeof(uint32_t);
memcpy(((char *)rta) + sizeof(struct rtattr), &metric, sizeof(uint32_t));
rta_len += rta->rta_len;
}
nlh->nlmsg_len = NLMSG_LENGTH(rta_len);
if ( command == RTM_NEWROUTE){
nlh->nlmsg_flags = NLM_F_REQUEST | (NLM_F_CREATE | NLM_F_REPLACE);
nlh->nlmsg_type = RTM_NEWROUTE;
}else{
nlh->nlmsg_flags = NLM_F_REQUEST;
nlh->nlmsg_type = RTM_DELROUTE;
}
rtm->rtm_family = afi;
if (table == 0){
rtm->rtm_table = RT_TABLE_MAIN;
}else{
rtm->rtm_table = table;
}
rtm->rtm_protocol = RTPROT_STATIC;
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
rtm->rtm_type = RTN_UNICAST;
rtm->rtm_src_len = 0;
rtm->rtm_tos = 0;
rtm->rtm_dst_len = prefix_len;
retval = send(sockfd, sndbuf, NLMSG_LENGTH(rta_len), 0);
if (retval < 0) {
lispd_log_msg(LISP_LOG_CRIT, "modify_route: send netlink command failed %s", strerror(errno));
close(sockfd);
exit_cleanup();
}
close(sockfd);
return(GOOD);
}
void clsIGInterface::NtfyData(const BYTE* pData, UINT nSize)
{
_chk_debug(+1,">clsIGInterface::NtfyData (%d bytes)",nSize);
#if GPFPROTECT
clsGPFProtection GPF(GPFPROTFLAG_TRACE|GPFPROTFLAG_MSGBOX);
if (GPF.Error())
{
exit(255);
}
#endif
for (int n = 0; n < nSize; ++n)
{
// _chk_utildebug("%d: %d %d",_MessageStack.entries(),n,pData[n]);
if (pData[n] == 0x31)
{
// a new message starts
_MessageStack.push(new clsMessageBuffer);
continue;
}
if (!_MessageStack.isEmpty())
{
clsMessageBuffer* pCurrentMessage = _MessageStack.top();
if (pData[n] == 0x32)
{
// message finished
clsIGMessage Msg(pCurrentMessage->pData(),pCurrentMessage->nDataSize());
if (Msg.bChecksumOk())
{
_chk_debug(0,"received message %s",(LPCTSTR)Msg.AsString());
++_nPacketsReceived;
switch (Msg.nCmd())
{
case clsIGMessage::IGCMD_DEVICELIST:
if ((Msg.nFrom() == IGID_DATALOGGER || Msg.nFrom() == IGID_INTERFACECARD) &&
Msg.nTo() == IGID_BROADCAST)
{
_DeviceListManager.OnDeviceList(Msg);
break;
}
// fallthrough
default:
{
clsCritObj CO(_CritQueryList);
if (_QueryList.contains(Msg))
{
_chk_utildebug("(is in query list)");
_QueryList[Msg]->Append(Msg);
}
else
{
_chk_utildebug("(is unassigned message)");
_UnassignedMessages.Append(Msg);
}
}
break;
}
}
else
{
_chk_debug(0,"received message %s with BAD CHECKSUM",(LPCTSTR)Msg.AsString());
++_nPacketsReceivedWithBadChecksum;
printf("WRN: received a message with BAD CHECKSUM\n");
}
delete _MessageStack.pop();
}
else
{
pCurrentMessage->Append(pData[n]);
}
}
else
{
_chk_debug(0,"orphan byte %02x received",pData[n]);
}
}
_chk_debug(-1,"<clsIGInterface::NtfyData");
}
uint8_t *build_map_request_pkt(
lispd_mapping_elt *requested_mapping,
lisp_addr_t *src_eid,
uint8_t encap,
uint8_t probe,
uint8_t solicit_map_request,/* boolean really */
uint8_t smr_invoked,
int *len, /* return length here */
uint64_t *nonce) /* return nonce here */
{
uint8_t *packet = NULL;
uint8_t *mr_packet = NULL;
lispd_pkt_map_request_t *mrp = NULL;
lispd_pkt_mapping_record_t *rec = NULL;
lispd_pkt_map_request_itr_rloc_t *itr_rloc = NULL;
lispd_pkt_map_request_eid_prefix_record_t *request_eid_record = NULL;
uint8_t *cur_ptr = NULL;
int map_request_msg_len = 0;
int ctr = 0;
int cpy_len = 0;
int locators_ctr = 0;
lispd_mapping_elt *src_mapping = NULL;
lispd_locators_list *locators_list[2] = {NULL,NULL};
lispd_locator_elt *locator = NULL;
lisp_addr_t *ih_src_ip = NULL;
/*
* Lookup the local EID prefix from where we generate the message.
* src_eid is null for RLOC probing and refreshing map_cache -> Source-EID AFI = 0
*/
if (src_eid != NULL){
src_mapping = lookup_eid_in_db(*src_eid);
if (!src_mapping){
lispd_log_msg(LISP_LOG_DEBUG_2,"build_map_request_pkt: Source EID address not found in local data base - %s -",
get_char_from_lisp_addr_t(*src_eid));
return (NULL);
}
}
/* Calculate the packet size and reserve memory */
map_request_msg_len = get_map_request_length(requested_mapping,src_mapping);
*len = map_request_msg_len;
if ((packet = malloc(map_request_msg_len)) == NULL){
lispd_log_msg(LISP_LOG_WARNING,"build_map_request_pkt: Unable to allocate memory for Map Request (packet_len): %s", strerror(errno));
return (NULL);
}
memset(packet, 0, map_request_msg_len);
cur_ptr = packet;
mrp = (lispd_pkt_map_request_t *)cur_ptr;
mrp->type = LISP_MAP_REQUEST;
mrp->authoritative = 0;
if (src_eid != NULL)
mrp->map_data_present = 1;
else
mrp->map_data_present = 0;
if (probe)
mrp->rloc_probe = 1;
else
mrp->rloc_probe = 0;
if (solicit_map_request)
mrp->solicit_map_request = 1;
else
mrp->solicit_map_request = 0;
if (smr_invoked)
mrp->smr_invoked = 1;
else
mrp->smr_invoked = 0;
mrp->additional_itr_rloc_count = 0; /* To be filled later */
mrp->record_count = 1; /* XXX: assume 1 record */
mrp->nonce = build_nonce((unsigned int) time(NULL));
*nonce = mrp->nonce;
if (src_eid != NULL){
cur_ptr = pkt_fill_eid(&(mrp->source_eid_afi),src_mapping);
/* Add itr-rlocs */
locators_list[0] = src_mapping->head_v4_locators_list;
locators_list[1] = src_mapping->head_v6_locators_list;
for (ctr=0 ; ctr < 2 ; ctr++){
while (locators_list[ctr]){
locator = locators_list[ctr]->locator;
if (*(locator->state)==DOWN){
locators_list[ctr] = locators_list[ctr]->next;
continue;
}
/* Remove ITR locators behind NAT: No control message (4342) can be received in these interfaces */
if (((lcl_locator_extended_info *)locator->extended_info)->rtr_locators_list != NULL){
locators_list[ctr] = locators_list[ctr]->next;
continue;
}
itr_rloc = (lispd_pkt_map_request_itr_rloc_t *)cur_ptr;
itr_rloc->afi = htons(get_lisp_afi(locator->locator_addr->afi,NULL));
/* Add rloc address */
cur_ptr = CO(itr_rloc,sizeof(lispd_pkt_map_request_itr_rloc_t));
cpy_len = copy_addr((void *) cur_ptr ,locator->locator_addr, 0);
cur_ptr = CO(cur_ptr, cpy_len);
locators_ctr ++;
locators_list[ctr] = locators_list[ctr]->next;
}
}
}else {
// XXX If no source EID is used, then we only use one ITR-RLOC for IPv4 and one for IPv6-> Default control RLOC
mrp->source_eid_afi = 0;
cur_ptr = CO(mrp, sizeof(lispd_pkt_map_request_t));
if (default_ctrl_iface_v4 != NULL){
itr_rloc = (lispd_pkt_map_request_itr_rloc_t *)cur_ptr;
itr_rloc->afi = htons((uint16_t)LISP_AFI_IP);
cur_ptr = CO(itr_rloc,sizeof(lispd_pkt_map_request_itr_rloc_t));
cpy_len = copy_addr((void *) cur_ptr ,default_ctrl_iface_v4->ipv4_address, 0);
cur_ptr = CO(cur_ptr, cpy_len);
locators_ctr ++;
}
if (default_ctrl_iface_v6 != NULL){
itr_rloc = (lispd_pkt_map_request_itr_rloc_t *)cur_ptr;
itr_rloc->afi = htons(get_lisp_afi(AF_INET6,NULL));
cur_ptr = CO(itr_rloc,sizeof(lispd_pkt_map_request_itr_rloc_t));
cpy_len = copy_addr((void *) cur_ptr ,default_ctrl_iface_v6->ipv6_address, 0);
cur_ptr = CO(cur_ptr, cpy_len);
locators_ctr ++;
}
}
mrp->additional_itr_rloc_count = locators_ctr - 1; /* IRC = 0 --> 1 ITR-RLOC */
if (locators_ctr == 0){
lispd_log_msg(LISP_LOG_DEBUG_2,"build_map_request_pkt: No ITR RLOCs.");
free(packet);
return (NULL);
}
/* Requested EID record */
request_eid_record = (lispd_pkt_map_request_eid_prefix_record_t *)cur_ptr;
request_eid_record->eid_prefix_length = requested_mapping->eid_prefix_length;
cur_ptr = pkt_fill_eid(&(request_eid_record->eid_prefix_afi),requested_mapping);
if (mrp->map_data_present == 1){
/* Map-Reply Record */
rec = (lispd_pkt_mapping_record_t *)cur_ptr;
if ((pkt_fill_mapping_record(rec, src_mapping, NULL))== NULL) {
lispd_log_msg(LISP_LOG_DEBUG_2,"build_map_request_pkt: Couldn't buil map reply record for map request. "
"Map Request will not be send");
free(packet);
return(NULL);
}
}
/* Add Encapsulated (Inner) control header*/
if (encap){
/*
* If no source EID is included (Source-EID-AFI = 0), The default RLOC address is used for
* the source address in the inner IP header
*/
if (src_eid != NULL){
ih_src_ip = &(src_mapping->eid_prefix);;
}else{
if (requested_mapping->eid_prefix.afi == AF_INET){
ih_src_ip = get_main_eid (AF_INET);
}else{
ih_src_ip = get_main_eid (AF_INET6);
}
}
mr_packet = packet;
packet = build_control_encap_pkt(mr_packet, map_request_msg_len, ih_src_ip, &(requested_mapping->eid_prefix), LISP_CONTROL_PORT, LISP_CONTROL_PORT, len);
if (packet == NULL){
lispd_log_msg(LISP_LOG_DEBUG_1,"build_map_request_pkt: Couldn't encapsulate the map request");
free (mr_packet);
return (NULL);
}
}
return (packet);
}
uint8_t *
build_ip_udp_pcket(uint8_t *orig_pkt, int orig_pkt_len,lisp_addr_t *addr_from,
lisp_addr_t *addr_dest, int port_from,int port_dest, int *encap_pkt_len)
{
uint8_t *encap_pkt;
void *iph_ptr;
struct udphdr *udph_ptr;
int ip_hdr_len;
int udp_hdr_len;
int udp_hdr_and_payload_len;
uint16_t udpsum;
if (lisp_addr_ip_afi(addr_from) != lisp_addr_ip_afi(addr_dest)) {
OOR_LOG(LDBG_2,
"add_ip_udp_header: Different AFI addresses %d (%s) and %d (%s)",
lisp_addr_ip_afi(addr_from), lisp_addr_to_char(addr_from),
lisp_addr_ip_afi(addr_dest), lisp_addr_to_char(addr_dest));
return (NULL);
}
if ((lisp_addr_ip_afi(addr_from) != AF_INET)
&& (lisp_addr_ip_afi(addr_from) != AF_INET6)) {
OOR_LOG(LDBG_2, "add_ip_udp_header: Unknown AFI %d",
lisp_addr_ip_afi(addr_from));
return (NULL);
}
/* Headers lengths */
ip_hdr_len = ip_sock_afi_to_hdr_len(lisp_addr_ip_afi(addr_from));
udp_hdr_len = sizeof(struct udphdr);
udp_hdr_and_payload_len = udp_hdr_len + orig_pkt_len;
/* Assign memory for the original packet plus the new headers */
*encap_pkt_len = ip_hdr_len + udp_hdr_len + orig_pkt_len;
if ((encap_pkt = (uint8_t *) malloc(*encap_pkt_len)) == NULL) {
OOR_LOG(LDBG_2,
"add_ip_udp_header: Couldn't allocate memory for the packet to be generated %s",
strerror(errno));
return (NULL);
}
/* Make sure it's clean */
memset(encap_pkt, 0, *encap_pkt_len);
/* IP header */
iph_ptr = encap_pkt;
if ((udph_ptr = build_ip_header(iph_ptr, addr_from, addr_dest,
udp_hdr_and_payload_len)) == NULL) {
OOR_LOG(LDBG_2,
"add_ip_udp_header: Couldn't build the inner ip header");
free(encap_pkt);
return (NULL);
}
/* UDP header */
#ifdef BSD
udph_ptr->uh_sport = htons(port_from);
udph_ptr->uh_dport = htons(port_dest);
udph_ptr->uh_ulen = htons(udp_payload_len);
udph_ptr->uh_sum = 0;
#else
udph_ptr->source = htons(port_from);
udph_ptr->dest = htons(port_dest);
udph_ptr->len = htons(udp_hdr_and_payload_len);
udph_ptr->check = 0;
#endif
/* Copy original packet after the headers */
memcpy(CO(udph_ptr, udp_hdr_len), orig_pkt, orig_pkt_len);
/*
* Now compute the headers checksums
*/
if ((udpsum = udp_checksum(udph_ptr, udp_hdr_and_payload_len, iph_ptr,
lisp_addr_ip_afi(addr_from))) == -1) {
free(encap_pkt);
return (NULL);
}
udpsum(udph_ptr) = udpsum;
return (encap_pkt);
}
int get_all_ifaces_name_list(
char ***ifaces,
int *count)
{
struct nlmsghdr *nlh = NULL;
struct nlmsghdr *rcvhdr = NULL;
struct ifinfomsg *ifm = NULL;
struct ifinfomsg *if_msg = NULL;
char sndbuf[4096];
char rcvbuf[4096];
int ifa_len = 0;
int retval = 0;
char name[IF_NAMESIZE];
int readlen = 0;
*ifaces = calloc(100,sizeof(char *));
/*
* Build the command
*/
memset(sndbuf, 0, 4096);
nlh = (struct nlmsghdr *)sndbuf;
ifm = (struct ifinfomsg *)(CO(sndbuf,sizeof(struct nlmsghdr)));
ifa_len = sizeof(struct ifinfomsg);
nlh->nlmsg_len = NLMSG_LENGTH(ifa_len);
nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
nlh->nlmsg_type = RTM_GETLINK;
ifm->ifi_family = AF_PACKET;
retval = send(netlink_fd, sndbuf, NLMSG_LENGTH(ifa_len), 0);
if (retval < 0) {
lispd_log_msg(LISP_LOG_CRIT, "request_route_table: send netlink command failed 0x%s", strerror(errno));
return(BAD);
}
/*
* Receive the responses from the kernel
*/
while ((readlen = recv(netlink_fd,rcvbuf,4096,MSG_DONTWAIT)) > 0){
rcvhdr = (struct nlmsghdr *)rcvbuf;
/*
* Walk through everything it sent us
*/
for (; NLMSG_OK(rcvhdr, (unsigned int)readlen); rcvhdr = NLMSG_NEXT(rcvhdr, readlen)) {
if (rcvhdr->nlmsg_type == RTM_NEWLINK) {
if_msg = (struct ifinfomsg *)NLMSG_DATA(rcvhdr);
if (if_indextoname(if_msg->ifi_index, name) != NULL){
(*ifaces)[*count] = strdup(name);
(*count)++;
}
}
}
}
return (GOOD);
}
void FTabCodeGen::writeData()
{
if ( redFsm->anyConditions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondOffset), CO() );
COND_OFFSETS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondLen), CL() );
COND_LENS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
COND_KEYS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpaceId), C() );
COND_SPACES();
CLOSE_ARRAY() <<
L"\n";
}
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxKeyOffset), KO() );
KEY_OFFSETS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
KEYS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSingleLen), SL() );
SINGLE_LENS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxRangeLen), RL() );
RANGE_LENS();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset), IO() );
INDEX_OFFSETS();
CLOSE_ARRAY() <<
L"\n";
if ( useIndicies ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
INDICIES();
CLOSE_ARRAY() <<
L"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS_WI();
CLOSE_ARRAY() <<
L"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
TRANS_ACTIONS_WI();
CLOSE_ARRAY() <<
L"\n";
}
}
else {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS();
CLOSE_ARRAY() <<
L"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
TRANS_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
}
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyEofTrans() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
EOF_TRANS();
CLOSE_ARRAY() <<
L"\n";
}
STATE_IDS();
}
void TextWindow::DescribeSelection(void) {
Entity *e;
Vector p;
int i;
Printf(false, "");
if(gs.n == 1 && (gs.points == 1 || gs.entities == 1)) {
e = SK.GetEntity(gs.points == 1 ? gs.point[0] : gs.entity[0]);
#define COSTR(p) \
SS.MmToString((p).x), SS.MmToString((p).y), SS.MmToString((p).z)
#define PT_AS_STR "(%Fi%s%E, %Fi%s%E, %Fi%s%E)"
#define PT_AS_NUM "(%Fi%3%E, %Fi%3%E, %Fi%3%E)"
switch(e->type) {
case Entity::POINT_IN_3D:
case Entity::POINT_IN_2D:
case Entity::POINT_N_TRANS:
case Entity::POINT_N_ROT_TRANS:
case Entity::POINT_N_COPY:
case Entity::POINT_N_ROT_AA:
p = e->PointGetNum();
Printf(false, "%FtPOINT%E at " PT_AS_STR, COSTR(p));
break;
case Entity::NORMAL_IN_3D:
case Entity::NORMAL_IN_2D:
case Entity::NORMAL_N_COPY:
case Entity::NORMAL_N_ROT:
case Entity::NORMAL_N_ROT_AA: {
Quaternion q = e->NormalGetNum();
p = q.RotationN();
Printf(false, "%FtNORMAL / COORDINATE SYSTEM%E");
Printf(true, " basis n = " PT_AS_NUM, CO(p));
p = q.RotationU();
Printf(false, " u = " PT_AS_NUM, CO(p));
p = q.RotationV();
Printf(false, " v = " PT_AS_NUM, CO(p));
break;
}
case Entity::WORKPLANE: {
p = SK.GetEntity(e->point[0])->PointGetNum();
Printf(false, "%FtWORKPLANE%E");
Printf(true, " origin = " PT_AS_STR, COSTR(p));
Quaternion q = e->Normal()->NormalGetNum();
p = q.RotationN();
Printf(true, " normal = " PT_AS_NUM, CO(p));
break;
}
case Entity::LINE_SEGMENT: {
Vector p0 = SK.GetEntity(e->point[0])->PointGetNum();
p = p0;
Printf(false, "%FtLINE SEGMENT%E");
Printf(true, " thru " PT_AS_STR, COSTR(p));
Vector p1 = SK.GetEntity(e->point[1])->PointGetNum();
p = p1;
Printf(false, " " PT_AS_STR, COSTR(p));
Printf(true, " len = %Fi%s%E",
SS.MmToString((p1.Minus(p0).Magnitude())));
break;
}
case Entity::CUBIC_PERIODIC:
case Entity::CUBIC:
int pts;
if(e->type == Entity::CUBIC_PERIODIC) {
Printf(false, "%FtPERIODIC C2 CUBIC SPLINE%E");
pts = (3 + e->extraPoints);
} else if(e->extraPoints > 0) {
Printf(false, "%FtINTERPOLATING C2 CUBIC SPLINE%E");
pts = (4 + e->extraPoints);
} else {
Printf(false, "%FtCUBIC BEZIER CURVE%E");
pts = 4;
}
for(i = 0; i < pts; i++) {
p = SK.GetEntity(e->point[i])->PointGetNum();
Printf((i==0), " p%d = " PT_AS_STR, i, COSTR(p));
}
break;
case Entity::ARC_OF_CIRCLE: {
Printf(false, "%FtARC OF A CIRCLE%E");
p = SK.GetEntity(e->point[0])->PointGetNum();
Printf(true, " center = " PT_AS_STR, COSTR(p));
p = SK.GetEntity(e->point[1])->PointGetNum();
Printf(true, " endpoints = " PT_AS_STR, COSTR(p));
p = SK.GetEntity(e->point[2])->PointGetNum();
Printf(false, " " PT_AS_STR, COSTR(p));
double r = e->CircleGetRadiusNum();
Printf(true, " diameter = %Fi%s", SS.MmToString(r*2));
Printf(false, " radius = %Fi%s", SS.MmToString(r));
double thetas, thetaf, dtheta;
e->ArcGetAngles(&thetas, &thetaf, &dtheta);
Printf(false, " arc len = %Fi%s", SS.MmToString(dtheta*r));
break;
}
case Entity::CIRCLE: {
Printf(false, "%FtCIRCLE%E");
p = SK.GetEntity(e->point[0])->PointGetNum();
Printf(true, " center = " PT_AS_STR, COSTR(p));
double r = e->CircleGetRadiusNum();
Printf(true, " diameter = %Fi%s", SS.MmToString(r*2));
Printf(false, " radius = %Fi%s", SS.MmToString(r));
break;
}
case Entity::FACE_NORMAL_PT:
case Entity::FACE_XPROD:
case Entity::FACE_N_ROT_TRANS:
case Entity::FACE_N_ROT_AA:
case Entity::FACE_N_TRANS:
Printf(false, "%FtPLANE FACE%E");
p = e->FaceGetNormalNum();
Printf(true, " normal = " PT_AS_NUM, CO(p));
p = e->FaceGetPointNum();
Printf(false, " thru = " PT_AS_STR, COSTR(p));
break;
case Entity::TTF_TEXT: {
Printf(false, "%FtTRUETYPE FONT TEXT%E");
Printf(true, " font = '%Fi%s%E'", e->font.str);
if(e->h.isFromRequest()) {
Printf(false, " text = '%Fi%s%E' %Fl%Ll%f%D[change]%E",
e->str.str, &ScreenEditTtfText, e->h.request());
Printf(true, " select new font");
SS.fonts.LoadAll();
int i;
for(i = 0; i < SS.fonts.l.n; i++) {
TtfFont *tf = &(SS.fonts.l.elem[i]);
if(strcmp(e->font.str, tf->FontFileBaseName())==0) {
Printf(false, "%Bp %s",
(i & 1) ? 'd' : 'a',
tf->name.str);
} else {
Printf(false, "%Bp %f%D%Fl%Ll%s%E%Bp",
(i & 1) ? 'd' : 'a',
&ScreenSetTtfFont, i,
tf->name.str,
(i & 1) ? 'd' : 'a');
}
}
} else {
Printf(false, " text = '%Fi%s%E'", e->str.str);
}
break;
}
default:
Printf(true, "%Ft?? ENTITY%E");
break;
}
Group *g = SK.GetGroup(e->group);
Printf(false, "");
Printf(false, "%FtIN GROUP%E %s", g->DescriptionString());
if(e->workplane.v == Entity::FREE_IN_3D.v) {
Printf(false, "%FtNOT LOCKED IN WORKPLANE%E");
} else {
Entity *w = SK.GetEntity(e->workplane);
Printf(false, "%FtIN WORKPLANE%E %s", w->DescriptionString());
}
if(e->style.v) {
Style *s = Style::Get(e->style);
Printf(false, "%FtIN STYLE%E %s", s->DescriptionString());
} else {
Printf(false, "%FtIN STYLE%E none");
}
if(e->construction) {
Printf(false, "%FtCONSTRUCTION");
}
} else if(gs.n == 2 && gs.points == 2) {
Printf(false, "%FtTWO POINTS");
Vector p0 = SK.GetEntity(gs.point[0])->PointGetNum();
Printf(true, " at " PT_AS_STR, COSTR(p0));
Vector p1 = SK.GetEntity(gs.point[1])->PointGetNum();
Printf(false, " " PT_AS_STR, COSTR(p1));
double d = (p1.Minus(p0)).Magnitude();
Printf(true, " d = %Fi%s", SS.MmToString(d));
} else if(gs.n == 2 && gs.faces == 1 && gs.points == 1) {
Printf(false, "%FtA POINT AND A PLANE FACE");
Vector pt = SK.GetEntity(gs.point[0])->PointGetNum();
Printf(true, " point = " PT_AS_STR, COSTR(pt));
Vector n = SK.GetEntity(gs.face[0])->FaceGetNormalNum();
Printf(true, " plane normal = " PT_AS_NUM, CO(n));
Vector pl = SK.GetEntity(gs.face[0])->FaceGetPointNum();
Printf(false, " plane thru = " PT_AS_STR, COSTR(pl));
double dd = n.Dot(pl) - n.Dot(pt);
Printf(true, " distance = %Fi%s", SS.MmToString(dd));
} else if(gs.n == 3 && gs.points == 2 && gs.vectors == 1) {
Printf(false, "%FtTWO POINTS AND A VECTOR");
Vector p0 = SK.GetEntity(gs.point[0])->PointGetNum();
Printf(true, " pointA = " PT_AS_STR, COSTR(p0));
Vector p1 = SK.GetEntity(gs.point[1])->PointGetNum();
Printf(false, " pointB = " PT_AS_STR, COSTR(p1));
Vector v = SK.GetEntity(gs.vector[0])->VectorGetNum();
v = v.WithMagnitude(1);
Printf(true, " vector = " PT_AS_NUM, CO(v));
double d = (p1.Minus(p0)).Dot(v);
Printf(true, " proj_d = %Fi%s", SS.MmToString(d));
} else if(gs.n == 2 && gs.lineSegments == 1 && gs.points == 1) {
Entity *ln = SK.GetEntity(gs.entity[0]);
Vector lp0 = SK.GetEntity(ln->point[0])->PointGetNum(),
lp1 = SK.GetEntity(ln->point[1])->PointGetNum();
Printf(false, "%FtLINE SEGMENT AND POINT%E");
Printf(true, " ln thru " PT_AS_STR, COSTR(lp0));
Printf(false, " " PT_AS_STR, COSTR(lp1));
Vector pp = SK.GetEntity(gs.point[0])->PointGetNum();
Printf(true, " point " PT_AS_STR, COSTR(pp));
Printf(true, " pt-ln distance = %Fi%s%E",
SS.MmToString(pp.DistanceToLine(lp0, lp1.Minus(lp0))));
} else if(gs.n == 2 && gs.vectors == 2) {
Printf(false, "%FtTWO VECTORS");
Vector v0 = SK.GetEntity(gs.entity[0])->VectorGetNum(),
v1 = SK.GetEntity(gs.entity[1])->VectorGetNum();
v0 = v0.WithMagnitude(1);
v1 = v1.WithMagnitude(1);
Printf(true, " vectorA = " PT_AS_NUM, CO(v0));
Printf(false, " vectorB = " PT_AS_NUM, CO(v1));
double theta = acos(v0.Dot(v1));
Printf(true, " angle = %Fi%2%E degrees", theta*180/PI);
while(theta < PI/2) theta += PI;
while(theta > PI/2) theta -= PI;
Printf(false, " or angle = %Fi%2%E (mod 180)", theta*180/PI);
} else if(gs.n == 2 && gs.faces == 2) {
Printf(false, "%FtTWO PLANE FACES");
Vector n0 = SK.GetEntity(gs.face[0])->FaceGetNormalNum();
Printf(true, " planeA normal = " PT_AS_NUM, CO(n0));
Vector p0 = SK.GetEntity(gs.face[0])->FaceGetPointNum();
Printf(false, " planeA thru = " PT_AS_STR, COSTR(p0));
Vector n1 = SK.GetEntity(gs.face[1])->FaceGetNormalNum();
Printf(true, " planeB normal = " PT_AS_NUM, CO(n1));
Vector p1 = SK.GetEntity(gs.face[1])->FaceGetPointNum();
Printf(false, " planeB thru = " PT_AS_STR, COSTR(p1));
double theta = acos(n0.Dot(n1));
Printf(true, " angle = %Fi%2%E degrees", theta*180/PI);
while(theta < PI/2) theta += PI;
while(theta > PI/2) theta -= PI;
Printf(false, " or angle = %Fi%2%E (mod 180)", theta*180/PI);
if(fabs(theta) < 0.01) {
double d = (p1.Minus(p0)).Dot(n0);
Printf(true, " distance = %Fi%s", SS.MmToString(d));
}
} else if(gs.n == 0 && gs.stylables > 0) {
Printf(false, "%FtSELECTED:%E comment text");
} else if(gs.n == 0 && gs.constraints == 1) {
Printf(false, "%FtSELECTED:%E %s",
SK.GetConstraint(gs.constraint[0])->DescriptionString());
} else {
int n = SS.GW.selection.n;
Printf(false, "%FtSELECTED:%E %d item%s", n, n == 1 ? "" : "s");
}
if(shown.screen == SCREEN_STYLE_INFO &&
shown.style.v >= Style::FIRST_CUSTOM && gs.stylables > 0)
{
// If we are showing a screen for a particular style, then offer the
// option to assign our selected entities to that style.
Style *s = Style::Get(shown.style);
Printf(true, "%Fl%D%f%Ll(assign to style %s)%E",
shown.style.v,
&ScreenAssignSelectionToStyle,
s->DescriptionString());
}
// If any of the selected entities have an assigned style, then offer
// the option to remove that style.
bool styleAssigned = false;
for(i = 0; i < gs.entities; i++) {
Entity *e = SK.GetEntity(gs.entity[i]);
if(e->style.v != 0) {
styleAssigned = true;
}
}
for(i = 0; i < gs.constraints; i++) {
Constraint *c = SK.GetConstraint(gs.constraint[i]);
if(c->type == Constraint::COMMENT && c->disp.style.v != 0) {
styleAssigned = true;
}
}
if(styleAssigned) {
Printf(true, "%Fl%D%f%Ll(remove assigned style)%E",
0,
&ScreenAssignSelectionToStyle);
}
Printf(true, "%Fl%f%Ll(unselect all)%E", &TextWindow::ScreenUnselectAll);
}
void Tier3StorageMain(Tier3StorageRef me){
do
{
if(me->doQuitGracefully)
{
OCObjectLock((OCObjectRef)me->newPLChunks);
if(OCListGetCount(me->newPLChunks) == 0 &&
OCListGetCount(me->toWritePLChunks) == 0)
{
OCObjectUnlock((OCObjectRef)me->newPLChunks);
break;
}
OCObjectUnlock((OCObjectRef)me->newPLChunks);
}
OCObjectLock((OCObjectRef)me->newPLChunks);
if(OCListGetCount(me->newPLChunks) == 0)
{
OCObjectUnlock((OCObjectRef)me->newPLChunks);
OCThreadSleep(me->thread, 1);
continue;
}
OCListRef _tmp = me->newPLChunks;
me->newPLChunks = me->toWritePLChunks;
me->toWritePLChunks = _tmp;
OCObjectUnlock((OCObjectRef)me->newPLChunks);
// do the writing here
// NOTE usually we would use a lock file here,
// however: we are the only process _writing_ to any file -
// the worker tool should only read or delete a file,
// since we can write to a deleted file (posix) we are fine
// in the case of concurrent access to the same file the worker
// may fail on this one, which is ok for us
ALPayloadChunkRef plc = NULL;
OCAutoreleasePoolCreate();
OCSerializerRef s = (OCSerializerRef)OCAutorelease(OCSerializerCreate());
while( (plc=(ALPayloadChunkRef)OCListFifoPop(me->toWritePLChunks)) != NULL)
{
OCAutorelease(plc);
OCByte* key;
size_t keyLength;
ALPayloadChunkGetKey(plc, &key, &keyLength);
OCByte* keyHexBytes = OCAllocate(ocDefaultAllocator, 2*keyLength+1);
if(keyHexBytes == NULL)
continue;
bzero(keyHexBytes, 2*keyLength+1);
OCBytes2Hex(keyHexBytes, key, keyLength);
OCStringRef keyStr = (OCStringRef)OC((char*)keyHexBytes);
if(keyStr == NULL)
{
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
OCStringRef pathStr = (OCStringRef)OCAutorelease(OCStringCreateAppended(me->path, keyStr));
if(pathStr == NULL)
{
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
ALPayloadChunkSerialize(plc, s);
FILE* fp = fopen(CO(pathStr), "a");
if(fp == NULL)
{
OCLog("Storage: Could not open file at %s", CO(pathStr));
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
OCSerializerWriteToStream(s, fp);
fclose(fp);
OCDeallocate(ocDefaultAllocator, keyHexBytes);
OCSerializerReset(s);
}
OCRelease(&me->toWritePLChunks);
OCAutoreleasePoolDestroy();
me->toWritePLChunks = OCListCreate();
}
while(1);
}
int process_map_notify(uint8_t *packet)
{
lispd_pkt_map_notify_t *mn;
lispd_pkt_mapping_record_t *record;
lispd_pkt_mapping_record_locator_t *locator;
lispd_pkt_lcaf_iid_t *lcaf_iid;
int eid_afi;
int loc_afi;
int record_count;
int locator_count;
int i,j;
uint8_t auth_data[LISP_SHA1_AUTH_DATA_LEN];
int map_notify_length;
int partial_map_notify_length1;
int partial_map_notify_length2;
uint32_t md_len;
mn = (lispd_pkt_map_notify_t *)packet;
record_count = mn->record_count;
map_notify_length = sizeof(lispd_pkt_map_notify_t);
record = (lispd_pkt_mapping_record_t *)CO(mn, sizeof(lispd_pkt_map_notify_t));
for (i=0; i < record_count; i++)
{
partial_map_notify_length1 = sizeof(lispd_pkt_mapping_record_t);
eid_afi = lisp2inetafi(ntohs(record->eid_prefix_afi));
/* XXX: If we have LCAF, just assume it's Instance ID, jump over
* and get the EID
* TODO: Proper LCAF handling on receipt
*/
if (eid_afi < 0) {
partial_map_notify_length1 += sizeof(lispd_pkt_lcaf_t);
lcaf_iid = (lispd_pkt_lcaf_iid_t *)
CO(record, partial_map_notify_length1);
eid_afi = lisp2inetafi(ntohs(lcaf_iid->afi));
partial_map_notify_length1 += sizeof(lispd_pkt_lcaf_iid_t);
}
switch (eid_afi) {
case AF_INET:
partial_map_notify_length1 += sizeof(struct in_addr);
break;
case AF_INET6:
partial_map_notify_length1 += sizeof(struct in6_addr);
break;
default:
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_notify: Unknown AFI (%d) - EID", record->eid_prefix_afi);
return(ERR_AFI);
}
locator_count = record->locator_count;
locator = (lispd_pkt_mapping_record_locator_t *)CO(record, partial_map_notify_length1);
for ( j=0 ; j<locator_count ; j++)
{
partial_map_notify_length2 = sizeof(lispd_pkt_mapping_record_locator_t);
loc_afi = lisp2inetafi(ntohs(locator->locator_afi));
switch (loc_afi) {
case AF_INET:
partial_map_notify_length2 = partial_map_notify_length2 + sizeof(struct in_addr);
break;
case AF_INET6:
partial_map_notify_length2 = partial_map_notify_length2 + sizeof(struct in6_addr);
break;
default:
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_notify: Unknown AFI (%d) - Locator", htons(locator->locator_afi));
return(ERR_AFI);
}
locator = (lispd_pkt_mapping_record_locator_t *)CO(locator, partial_map_notify_length2);
partial_map_notify_length1 = partial_map_notify_length1 + partial_map_notify_length2;
}
map_notify_length = map_notify_length + partial_map_notify_length1;
record = (lispd_pkt_mapping_record_t *)locator;
}
for (i=0 ; i < LISP_SHA1_AUTH_DATA_LEN; i++)
{
auth_data[i] = mn->auth_data[i];
mn->auth_data[i] = 0;
}
if (!HMAC((const EVP_MD *) EVP_sha1(),
(const void *) map_servers->key,
strlen(map_servers->key),
(uchar *) mn,
map_notify_length,
(uchar *) mn->auth_data,
&md_len)) {
lispd_log_msg(LISP_LOG_DEBUG_2, "HMAC failed for Map-Notify");
return(BAD);
}
if ((strncmp((char *)mn->auth_data, (char *)auth_data, (size_t)LISP_SHA1_AUTH_DATA_LEN)) == 0)
lispd_log_msg(LISP_LOG_DEBUG_1, "Map-Notify message confirms correct registration");
else
lispd_log_msg(LISP_LOG_DEBUG_1, "Map-Notify message is invalid");
return(GOOD);
}
void CSharpTabCodeGen::writeData()
{
/* If there are any transtion functions then output the array. If there
* are none, don't bother emitting an empty array that won't be used. */
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActArrItem), A() );
ACTIONS_ARRAY();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyConditions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondOffset), CO() );
COND_OFFSETS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondLen), CL() );
COND_LENS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
COND_KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpaceId), C() );
COND_SPACES();
CLOSE_ARRAY() <<
"\n";
}
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxKeyOffset), KO() );
KEY_OFFSETS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
KEYS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSingleLen), SL() );
SINGLE_LENS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxRangeLen), RL() );
RANGE_LENS();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset), IO() );
INDEX_OFFSETS();
CLOSE_ARRAY() <<
"\n";
if ( useIndicies ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
INDICIES();
CLOSE_ARRAY() <<
"\n";
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS_WI();
CLOSE_ARRAY() <<
"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TA() );
TRANS_ACTIONS_WI();
CLOSE_ARRAY() <<
"\n";
}
}
else {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
TRANS_TARGS();
CLOSE_ARRAY() <<
"\n";
if ( redFsm->anyActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TA() );
TRANS_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
}
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofTrans() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
EOF_TRANS();
CLOSE_ARRAY() <<
"\n";
}
STATE_IDS();
}
void process_input_packet(int fd,
int afi,
int tun_receive_fd)
{
uint8_t *packet = NULL;
int length = 0;
uint8_t ttl = 0;
uint8_t tos = 0;
struct lisphdr *lisp_hdr = NULL;
struct iphdr *iph = NULL;
struct ip6_hdr *ip6h = NULL;
struct udphdr *udph = NULL;
if ((packet = (uint8_t *) malloc(MAX_IP_PACKET))==NULL){
lispd_log_msg(LISP_LOG_ERR,"process_input_packet: Couldn't allocate space for packet: %s", strerror(errno));
return;
}
memset(packet,0,MAX_IP_PACKET);
if (get_data_packet (fd,
afi,
packet,
&length,
&ttl,
&tos) == BAD){
lispd_log_msg(LISP_LOG_DEBUG_2,"process_input_packet: get_data_packet error: %s", strerror(errno));
free(packet);
return;
}
if(afi == AF_INET){
/* With input RAW UDP sockets in IPv4, we get the whole external IPv4 packet */
udph = (struct udphdr *) CO(packet,sizeof(struct iphdr));
}else{
/* With input RAW UDP sockets in IPv6, we get the whole external UDP packet */
udph = (struct udphdr *) packet;
}
/* With input RAW UDP sockets, we receive all UDP packets, we only want lisp data ones */
if(ntohs(udph->dest) != LISP_DATA_PORT){
free(packet);
//lispd_log_msg(LISP_LOG_DEBUG_3,"INPUT (No LISP data): UDP dest: %d ",ntohs(udph->dest));
return;
}
lisp_hdr = (struct lisphdr *) CO(udph,sizeof(struct udphdr));
length = length - sizeof(struct udphdr) - sizeof(struct lisphdr);
iph = (struct iphdr *) CO(lisp_hdr,sizeof(struct lisphdr));
lispd_log_msg(LISP_LOG_DEBUG_3,"INPUT (4341): Inner src: %s | Inner dst: %s ",
get_char_from_lisp_addr_t(extract_src_addr_from_packet((char *)iph)),
get_char_from_lisp_addr_t(extract_dst_addr_from_packet((char *)iph)));
if (iph->version == 4) {
if(ttl!=0){ /*XXX It seems that there is a bug in uClibc that causes ttl=0 in OpenWRT. This is a quick workaround */
iph->ttl = ttl;
}
iph->tos = tos;
/* We need to recompute the checksum since we have changed the TTL and TOS header fields */
iph->check = 0; /* New checksum must be computed with the checksum header field with 0s */
iph->check = ip_checksum((uint16_t*) iph, sizeof(struct iphdr));
}else{
ip6h = ( struct ip6_hdr *) iph;
if(ttl!=0){ /*XXX It seems that there is a bug in uClibc that causes ttl=0 in OpenWRT. This is a quick workaround */
ip6h->ip6_hops = ttl; /* ttl = Hops limit in IPv6 */
}
IPV6_SET_TC(ip6h,tos); /* tos = Traffic class field in IPv6 */
}
if ((write(tun_receive_fd, iph, length)) < 0){
lispd_log_msg(LISP_LOG_DEBUG_2,"lisp_input: write error: %s\n ", strerror(errno));
}
free(packet);
}
//RT New edit renderDetailWhenSaving
void TextWindow::ShowConfiguration(void) {
int i;
Printf(true, "%Ft user color (r, g, b)");
for(i = 0; i < SS.MODEL_COLORS; i++) {
Printf(false, "%Bp #%d: %Bz %Bp (%@, %@, %@) %f%D%Ll%Fl[change]%E",
(i & 1) ? 'd' : 'a',
i, &SS.modelColor[i],
(i & 1) ? 'd' : 'a',
SS.modelColor[i].redF(),
SS.modelColor[i].greenF(),
SS.modelColor[i].blueF(),
&ScreenChangeColor, i);
}
Printf(false, "");
Printf(false, "%Ft light direction intensity");
for(i = 0; i < 2; i++) {
Printf(false, "%Bp #%d (%2,%2,%2)%Fl%D%f%Ll[c]%E "
"%2 %Fl%D%f%Ll[c]%E",
(i & 1) ? 'd' : 'a', i,
CO(SS.lightDir[i]), i, &ScreenChangeLightDirection,
SS.lightIntensity[i], i, &ScreenChangeLightIntensity);
}
Printf(false, "");
Printf(false, "%Ft chord tolerance (in screen pixels)%E");
Printf(false, "%Ba %@ %Fl%Ll%f%D[change]%E; now %d triangles",
SS.chordTol,
&ScreenChangeChordTolerance, 0,
SK.GetGroup(SS.GW.activeGroup)->displayMesh.l.n);
Printf(false, "%Ft max piecewise linear segments%E");
Printf(false, "%Ba %d %Fl%Ll%f[change]%E",
SS.maxSegments,
&ScreenChangeMaxSegments);
Printf(false, "");
Printf(false, "%Ft perspective factor (0 for parallel)%E");
Printf(false, "%Ba %# %Fl%Ll%f%D[change]%E",
SS.cameraTangent*1000,
&ScreenChangeCameraTangent, 0);
Printf(false, "%Ft snap grid spacing%E");
Printf(false, "%Ba %s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.gridSpacing),
&ScreenChangeGridSpacing, 0);
Printf(false, "%Ft digits after decimal point to show%E");
Printf(false, "%Ba %d %Fl%Ll%f%D[change]%E (e.g. '%s')",
SS.UnitDigitsAfterDecimal(),
&ScreenChangeDigitsAfterDecimal, 0,
SS.MmToString(SS.StringToMm("1.23456789")));
Printf(false, "");
Printf(false, "%Ft export scale factor (1:1=mm, 1:25.4=inch)");
Printf(false, "%Ba 1:%# %Fl%Ll%f%D[change]%E",
(double)SS.exportScale,
&ScreenChangeExportScale, 0);
Printf(false, "%Ft cutter radius offset (0=no offset) ");
Printf(false, "%Ba %s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportOffset),
&ScreenChangeExportOffset, 0);
Printf(false, "");
Printf(false, " %Fd%f%Ll%c export shaded 2d triangles%E",
&ScreenChangeShadedTriangles,
SS.exportShadedTriangles ? CHECK_TRUE : CHECK_FALSE);
if(fabs(SS.exportOffset) > LENGTH_EPS) {
Printf(false, " %Fd%c curves as piecewise linear%E "
"(since cutter radius is not zero)", CHECK_TRUE);
} else {
Printf(false, " %Fd%f%Ll%c export curves as piecewise linear%E",
&ScreenChangePwlCurves,
SS.exportPwlCurves ? CHECK_TRUE : CHECK_FALSE);
}
Printf(false, " %Fd%f%Ll%c fix white exported lines%E",
&ScreenChangeFixExportColors,
SS.fixExportColors ? CHECK_TRUE : CHECK_FALSE);
Printf(false, "");
Printf(false, "%Ft export canvas size: "
"%f%Fd%Lf%c fixed%E "
"%f%Fd%Lt%c auto%E",
&ScreenChangeCanvasSizeAuto,
!SS.exportCanvasSizeAuto ? RADIO_TRUE : RADIO_FALSE,
&ScreenChangeCanvasSizeAuto,
SS.exportCanvasSizeAuto ? RADIO_TRUE : RADIO_FALSE);
if(SS.exportCanvasSizeAuto) {
Printf(false, "%Ft (by margins around exported geometry)");
Printf(false, "%Ba%Ft left: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportMargin.left), &ScreenChangeCanvasSize, 0);
Printf(false, "%Bd%Ft right: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportMargin.right), &ScreenChangeCanvasSize, 1);
Printf(false, "%Ba%Ft bottom: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportMargin.bottom), &ScreenChangeCanvasSize, 2);
Printf(false, "%Bd%Ft top: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportMargin.top), &ScreenChangeCanvasSize, 3);
} else {
Printf(false, "%Ft (by absolute dimensions and offsets)");
Printf(false, "%Ba%Ft width: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportCanvas.width), &ScreenChangeCanvasSize, 10);
Printf(false, "%Bd%Ft height: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportCanvas.height), &ScreenChangeCanvasSize, 11);
Printf(false, "%Ba%Ft offset x: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportCanvas.dx), &ScreenChangeCanvasSize, 12);
Printf(false, "%Bd%Ft offset y: %Fd%s %Fl%Ll%f%D[change]%E",
SS.MmToString(SS.exportCanvas.dy), &ScreenChangeCanvasSize, 13);
}
Printf(false, "");
Printf(false, "%Ft exported g code parameters");
Printf(false, "%Ba%Ft depth: %Fd%s %Fl%Ld%f[change]%E",
SS.MmToString(SS.gCode.depth), &ScreenChangeGCodeParameter);
Printf(false, "%Bd%Ft passes: %Fd%d %Fl%Ls%f[change]%E",
SS.gCode.passes, &ScreenChangeGCodeParameter);
Printf(false, "%Ba%Ft feed: %Fd%s %Fl%LF%f[change]%E",
SS.MmToString(SS.gCode.feed), &ScreenChangeGCodeParameter);
Printf(false, "%Bd%Ft plunge fd: %Fd%s %Fl%LP%f[change]%E",
SS.MmToString(SS.gCode.plungeFeed), &ScreenChangeGCodeParameter);
Printf(false, "");
Printf(false, " %Fd%f%Ll%c draw triangle back faces in red%E",
&ScreenChangeBackFaces,
SS.drawBackFaces ? CHECK_TRUE : CHECK_FALSE);
Printf(false, " %Fd%f%Ll%c check sketch for closed contour%E",
&ScreenChangeCheckClosedContour,
SS.checkClosedContour ? CHECK_TRUE : CHECK_FALSE);
Printf(false, "");
Printf(false, " %Ftgl vendor %E%s", glGetString(GL_VENDOR));
Printf(false, " %Ft renderer %E%s", glGetString(GL_RENDERER));
Printf(false, " %Ft version %E%s", glGetString(GL_VERSION));
}
int process_info_reply_msg(
uint8_t *packet,
lisp_addr_t local_rloc)
{
uint8_t *ptr = packet;
uint8_t lisp_type = 0;
uint8_t reply = 0;
uint64_t nonce = 0;
uint16_t key_id = 0;
uint16_t auth_data_len = 0;
uint8_t *auth_data_pos = NULL;
uint32_t ttl = 0;
uint8_t eid_mask_len = 0;
lisp_addr_t eid_prefix = {.afi=AF_UNSPEC};
uint16_t ms_udp_port = 0;
uint16_t etr_udp_port = 0;
uint32_t info_reply_hdr_len = 0;
uint32_t lcaf_addr_len = 0;
uint32_t pckt_len = 0;
uint16_t *lcaf_afi = NULL;
lisp_addr_t global_etr_rloc = {.afi=AF_UNSPEC};
lisp_addr_t ms_rloc = {.afi=AF_UNSPEC};
lisp_addr_t private_etr_rloc = {.afi=AF_UNSPEC};
lispd_rtr_locators_list *rtr_locators_list = NULL;
lispd_mapping_elt *mapping = NULL;
lispd_locator_elt *locator = NULL;
lcl_locator_extended_info *lcl_locator_ext_inf = NULL;
char rtrs_list_str[2000];
int rtrs_list_str_size = 0;
lispd_rtr_locators_list *aux_rtr_locators_list = NULL;
uint8_t is_behind_nat = FALSE;
/*
* Get source port and address.
*/
err = extract_info_nat_header(ptr,
&lisp_type,
&reply,
&nonce,
&key_id,
&auth_data_len,
&auth_data_pos,
&ttl,
&eid_mask_len,
&eid_prefix,
&info_reply_hdr_len);
if (err != GOOD){
lispd_log_msg(LISP_LOG_DEBUG_1,"process_info_reply_msg: Couldn't process Info Reply message");
return (BAD);
}
ptr = CO(ptr,info_reply_hdr_len);
lcaf_afi = (uint16_t *)ptr;
if ( ntohs(*lcaf_afi) != LISP_AFI_LCAF){
lispd_log_msg(LISP_LOG_DEBUG_1,"process_info_reply_msg: Malformed packet");
return (BAD);
}
ptr = CO(ptr,FIELD_AFI_LEN);
/* Extract Info-Reply body fields */
err = extract_nat_lcaf_data(ptr,
&ms_udp_port,
&etr_udp_port,
&global_etr_rloc,
&ms_rloc,
&private_etr_rloc,
&rtr_locators_list,
&lcaf_addr_len);
if (err == BAD) {
lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Error extracting packet data");
return (BAD);
}
/* Leave only RTR with same afi as the local rloc where we received the message */
remove_rtr_locators_with_afi_different_to(&rtr_locators_list, local_rloc.afi);
lcaf_addr_len = lcaf_addr_len + FIELD_AFI_LEN;
/* Print the extracted information of the message */
if (is_loggable(LISP_LOG_DEBUG_2)){
aux_rtr_locators_list = rtr_locators_list;
rtrs_list_str[0] = '\0';
while (aux_rtr_locators_list != NULL){
sprintf(rtrs_list_str + rtrs_list_str_size, " %s ", get_char_from_lisp_addr_t(aux_rtr_locators_list->locator->address));
rtrs_list_str_size = rtrs_list_str_size + strlen(rtrs_list_str);
aux_rtr_locators_list = aux_rtr_locators_list->next;
}
lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply message data->"
"Nonce: %s , KeyID: %hu ,TTL: %u , EID-prefix: %s/%hhu , "
"MS UDP Port Number: %hu , ETR UDP Port Number: %hu , Global ETR RLOC Address: %s , "
"MS RLOC Address: %s , Private ETR RLOC Address: %s, RTR RLOC Compatible list: %s",
get_char_from_nonce(nonce), key_id, ttl, get_char_from_lisp_addr_t(eid_prefix),eid_mask_len,
ms_udp_port, etr_udp_port, get_char_from_lisp_addr_t(global_etr_rloc),
get_char_from_lisp_addr_t(ms_rloc),get_char_from_lisp_addr_t(private_etr_rloc),rtrs_list_str);
}
/* Checking the nonce */
if (check_nonce(nat_ir_nonce,nonce) == GOOD ){
lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Correct nonce field checking ");
free(nat_ir_nonce);
nat_ir_nonce = NULL;
}else{
lispd_log_msg(LISP_LOG_DEBUG_1, "Info-Reply: Error checking nonce field. No Info Request generated with nonce: %s",
get_char_from_nonce (nonce));
return (BAD);
}
/* Check authentication data */
pckt_len = info_reply_hdr_len + lcaf_addr_len;
if(BAD == check_auth_field(key_id, map_servers->key, (void *) packet, pckt_len, auth_data_pos)){
lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Error checking auth data field");
return(BAD);
}else{
lispd_log_msg(LISP_LOG_DEBUG_2, "Info-Reply: Correct auth data field checking");
}
// TODO Select the best RTR from the list retrieved from the Info-Reply
/* Check if behind NAT */
switch (compare_lisp_addr_t(&global_etr_rloc, &local_rloc)) {
case 0:
is_behind_nat = FALSE;
lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: MN is not behind NAT");
break;
case 1:
case 2:
is_behind_nat = TRUE;
lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: MN is behind NAT");
break;
case -1:
is_behind_nat = UNKNOWN;
lispd_log_msg(LISP_LOG_DEBUG_2, "NAT Traversal: Unknown state");
break;
}
if (is_behind_nat == TRUE){
if (rtr_locators_list == NULL){
lispd_log_msg(LISP_LOG_WARNING, "process_info_reply_msg: The interface with IP address %s is behind NAT"
" but there is no RTR compatible with local AFI", get_char_from_lisp_addr_t(local_rloc));
}
mapping = lookup_eid_exact_in_db(eid_prefix, eid_mask_len);
if (mapping == NULL){
lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Info Reply is not for any local EID");
return (BAD);
}
locator = get_locator_from_mapping(mapping,local_rloc);
if (locator == NULL){
lispd_log_msg(LISP_LOG_DEBUG_2, "process_info_reply_msg: Info Reply received in the wrong locator");
return (BAD);
}
lcl_locator_ext_inf = (lcl_locator_extended_info *)locator->extended_info;
if (lcl_locator_ext_inf->rtr_locators_list != NULL){
free_rtr_list(lcl_locator_ext_inf->rtr_locators_list);
}
lcl_locator_ext_inf->rtr_locators_list = rtr_locators_list;
if (nat_status == NO_NAT || nat_status == PARTIAL_NAT){
nat_status = PARTIAL_NAT;
}else{
nat_status = FULL_NAT;
}
}else{
if (nat_status == FULL_NAT || nat_status == PARTIAL_NAT){
nat_status = PARTIAL_NAT;
}else{
nat_status = NO_NAT;
}
}
/* If we are behind NAT, the program timer to send Info Request after TTL minutes */
if (is_behind_nat == TRUE){
if (info_reply_ttl_timer == NULL) {
info_reply_ttl_timer = create_timer(INFO_REPLY_TTL_TIMER);
}
start_timer(info_reply_ttl_timer, ttl*60, info_request, (void *)mapping);
lispd_log_msg(LISP_LOG_DEBUG_1, "Reprogrammed info request in %d minutes",ttl);
}else{
stop_timer(info_reply_ttl_timer);
info_reply_ttl_timer = NULL;
}
/* Once we know the NAT state we send a Map-Register */
map_register(NULL,NULL);
return (GOOD);
}
int combineblk(RECPOS ads, int size)
{
ENTRY e;
RECPOS address;
int esize, off, ret, saveoff, ibuff;
ret = 0;
saveoff = CO(--(pci->level));
retrieve_block(pci->level, CB(pci->level));
if ((off = next_entry( saveoff )) < block_ptr->bend)
/* combine with page on right */
{
if ((ENT_SIZE(ENT_ADR(block_ptr, off)) + size) < (uint32_t)split_size)
{
copy_entry(&e, ENT_ADR(block_ptr, off));
address = ENT_ADR(block_ptr, CO(pci->level))->idxptr;
retrieve_block(++pci->level, address);
ibuff = cache_ptr;
spare_block = block_ptr;
retrieve_block(pci->level, ads);
esize = ENT_SIZE(&e);
if(((block_ptr->bend + spare_block->bend + esize) >= split_size)&& (spare_block->bend <= block_ptr->bend + esize))
{
return ret;
}
e.idxptr = spare_block->p0;
ins_block(block_ptr, &e, block_ptr->bend);
update_block();
if ((block_ptr->bend + spare_block->bend) < split_size)
/* combine the blocks */
{
memcpy(ENT_ADR(block_ptr, block_ptr->bend),ENT_ADR(spare_block, 0),spare_block->bend);
block_ptr->bend += spare_block->bend;
write_free(spare_block->brec, spare_block);
BUFDIRTY(ibuff) = 0;
BUFHANDLE(ibuff) = 0;
--pci->level;
ret = 1;
}
else
/* move an entry up to replace the one moved */
{
copy_entry(&e, ENT_ADR(spare_block, 0));
esize = ENT_SIZE(&e);
movedown(spare_block, 0, esize);
spare_block->bend -= esize;
spare_block->p0 = e.idxptr;
BUFDIRTY(ibuff) = 1;
--(pci->level);
replace_entry(&e);
}
}
}
else
/* move from page on left */
{
if ( (ENT_SIZE(ENT_ADR(block_ptr, CO(pci->level))) + size) < (uint32_t)split_size)
{
copy_entry(&e, ENT_ADR(block_ptr, saveoff));
off = prev_entry(saveoff);
if (CO(pci->level) == -1)
address = block_ptr->p0;
else
address = ENT_ADR(block_ptr, CO(pci->level))->idxptr;
retrieve_block(++pci->level, address);
off = last_entry();
ibuff = cache_ptr;
spare_block = block_ptr;
retrieve_block(pci->level, ads);
esize = ENT_SIZE(&e);
if(((block_ptr->bend + spare_block->bend + esize) >= split_size)&& (spare_block->bend <= block_ptr->bend + esize))
{
return ret;
}
BUFDIRTY(ibuff) = 1;
CO(pci->level) = 0;
e.idxptr = block_ptr->p0;
ins_block(block_ptr, &e, 0);
if ((block_ptr->bend + spare_block->bend) < split_size)
/* combine the blocks */
{
memcpy(ENT_ADR(spare_block, spare_block->bend),ENT_ADR(block_ptr, 0),block_ptr->bend);
spare_block->bend += block_ptr->bend;
write_free(block_ptr->brec, block_ptr);
BUFDIRTY(cache_ptr) = 0;
BUFHANDLE(cache_ptr) = 0;
CO(--(pci->level)) = saveoff;
ret = 1;
}
else
/* move an entry up to replace the one moved */
{
block_ptr->p0 = ENT_ADR(spare_block,off)->idxptr;
copy_entry(&e, ENT_ADR(spare_block, off));
spare_block->bend = off;
update_block();
CO(--(pci->level)) = saveoff;
replace_entry(&e);
}
}
}
root_dirty = 1;
return ret;
}
bool SolveSpace::SaveToFile(char *filename) {
// Make sure all the entities are regenerated up to date, since they
// will be exported.
SS.GenerateAll(0, INT_MAX);
fh = fopen(filename, "wb");
if(!fh) {
Error("Couldn't write to file '%s'", filename);
return false;
}
fprintf(fh, "%s\n\n\n", VERSION_STRING);
int i, j;
for(i = 0; i < SK.group.n; i++) {
sv.g = SK.group.elem[i];
SaveUsingTable('g');
fprintf(fh, "AddGroup\n\n");
}
for(i = 0; i < SK.param.n; i++) {
sv.p = SK.param.elem[i];
SaveUsingTable('p');
fprintf(fh, "AddParam\n\n");
}
for(i = 0; i < SK.request.n; i++) {
sv.r = SK.request.elem[i];
SaveUsingTable('r');
fprintf(fh, "AddRequest\n\n");
}
for(i = 0; i < SK.entity.n; i++) {
(SK.entity.elem[i]).CalculateNumerical(true);
sv.e = SK.entity.elem[i];
SaveUsingTable('e');
fprintf(fh, "AddEntity\n\n");
}
for(i = 0; i < SK.constraint.n; i++) {
sv.c = SK.constraint.elem[i];
SaveUsingTable('c');
fprintf(fh, "AddConstraint\n\n");
}
for(i = 0; i < SK.style.n; i++) {
sv.s = SK.style.elem[i];
if(sv.s.h.v >= Style::FIRST_CUSTOM) {
SaveUsingTable('s');
fprintf(fh, "AddStyle\n\n");
}
}
// A group will have either a mesh or a shell, but not both; but the code
// to print either of those just does nothing if the mesh/shell is empty.
SMesh *m = &(SK.group.elem[SK.group.n-1].runningMesh);
for(i = 0; i < m->l.n; i++) {
STriangle *tr = &(m->l.elem[i]);
fprintf(fh, "Triangle %08x %08x "
"%.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f\n",
tr->meta.face, tr->meta.color.ToPackedInt(),
CO(tr->a), CO(tr->b), CO(tr->c));
}
SShell *s = &(SK.group.elem[SK.group.n-1].runningShell);
SSurface *srf;
for(srf = s->surface.First(); srf; srf = s->surface.NextAfter(srf)) {
fprintf(fh, "Surface %08x %08x %08x %d %d\n",
srf->h.v, srf->color.ToPackedInt(), srf->face, srf->degm, srf->degn);
for(i = 0; i <= srf->degm; i++) {
for(j = 0; j <= srf->degn; j++) {
fprintf(fh, "SCtrl %d %d %.20f %.20f %.20f Weight %20.20f\n",
i, j, CO(srf->ctrl[i][j]), srf->weight[i][j]);
}
}
STrimBy *stb;
for(stb = srf->trim.First(); stb; stb = srf->trim.NextAfter(stb)) {
fprintf(fh, "TrimBy %08x %d %.20f %.20f %.20f %.20f %.20f %.20f\n",
stb->curve.v, stb->backwards ? 1 : 0,
CO(stb->start), CO(stb->finish));
}
fprintf(fh, "AddSurface\n");
}
SCurve *sc;
for(sc = s->curve.First(); sc; sc = s->curve.NextAfter(sc)) {
fprintf(fh, "Curve %08x %d %d %08x %08x\n",
sc->h.v,
sc->isExact ? 1 : 0, sc->exact.deg,
sc->surfA.v, sc->surfB.v);
if(sc->isExact) {
for(i = 0; i <= sc->exact.deg; i++) {
fprintf(fh, "CCtrl %d %.20f %.20f %.20f Weight %.20f\n",
i, CO(sc->exact.ctrl[i]), sc->exact.weight[i]);
}
}
SCurvePt *scpt;
for(scpt = sc->pts.First(); scpt; scpt = sc->pts.NextAfter(scpt)) {
fprintf(fh, "CurvePt %d %.20f %.20f %.20f\n",
scpt->vertex ? 1 : 0, CO(scpt->p));
}
fprintf(fh, "AddCurve\n");
}
fclose(fh);
return true;
}
int main(int argc, char** argv)
{
try {
/* Define the name of the model to be used. */
std::string ModelName = "NPEpsilons";
/* Create an object of the class InputParameters. */
InputParameters IP;
/* Read a map for the mandatory model parameters. (Default values in InputParameters.h) */
std::map<std::string, double> DPars_IN = IP.getInputParameters(ModelName);
/* Change the default values of the mandatory model parameters if necessary. */
/* This can also be done with DPars after creating an object of ComputeObservables. */
DPars_IN["mcharm"] = 1.3;
DPars_IN["mub"] = 4.2;
/* Create objects of the classes ModelFactory and ThObsFactory */
ModelFactory ModelF;
ThObsFactory ThObsF;
/* Create an object of the class ComputeObservables. */
ComputeObservables CO(ModelF, ThObsF, ModelName, DPars_IN);
/* Add the observables to be returned. */
CO.AddObservable("Mw");
CO.AddObservable("GammaZ");
CO.AddObservable("AFBbottom");
/* Remove a previously added observables if necessary. */
//CO.RemoveObservable("AFBbottom");
/* Set the flags for the model being used, if necessary. */
std::map<std::string, std::string> DFlags;
DFlags["epsilon2SM"] = "TRUE";
DFlags["epsilonbSM"] = "TRUE";
CO.setFlags(DFlags);
/* Get the map of observables if necessary. */
std::map<std::string, double> DObs = CO.getObservables();
/* Define a map for the parameters to be varied. */
std::map<std::string, double> DPars;
for (int i = 0; i < 2; i++) {
/* Vary the parameters that need to be varied in the analysis. */
DPars["epsilon_1"] = 0. + i * 0.01;
DPars["epsilon_3"] = 0. + i * 0.01;
/* Get the map of observables with the parameter values defined above. */
DObs = CO.compute(DPars);
std::cout << "\nParameters[" << i + 1 << "]:"<< std::endl;
for (std::map<std::string, double>::iterator it = DPars.begin(); it != DPars.end(); it++) {
std::cout << it->first << " = " << it->second << std::endl;
}
std::cout << "\nObservables[" << i + 1 << "]:" << std::endl;
for (std::map<std::string, double>::iterator it = DObs.begin(); it != DObs.end(); it++) {
std::cout << it->first << " = " << it->second << std::endl;
}
}
return EXIT_SUCCESS;
} catch (const std::runtime_error& e) {
std::cerr << e.what() << std::endl;
return EXIT_FAILURE;
}
}
int process_encapsulated_map_request_headers(
uint8_t *packet,
int *len,
uint16_t *dst_port){
struct ip *iph = NULL;
struct ip6_hdr *ip6h = NULL;
struct udphdr *udph = NULL;
int ip_header_len = 0;
int encap_afi = 0;
uint16_t udpsum = 0;
uint16_t ipsum = 0;
int udp_len = 0;
/*
* Read IP header.source_mapping
*/
iph = (struct ip *) CO(packet, sizeof(lisp_encap_control_hdr_t));
switch (iph->ip_v) {
case IPVERSION:
ip_header_len = sizeof(struct ip);
udph = (struct udphdr *) CO(iph, ip_header_len);
encap_afi = AF_INET;
break;
case IP6VERSION:
ip6h = (struct ip6_hdr *) CO(packet, sizeof(lisp_encap_control_hdr_t));
ip_header_len = sizeof(struct ip6_hdr);
udph = (struct udphdr *) CO(ip6h, ip_header_len);
encap_afi = AF_INET6;
break;
default:
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_request_msg: couldn't read incoming Encapsulated Map-Request: IP header corrupted.");
return(BAD);
}
/* This should overwrite the external port (dst_port in map-reply = inner src_port in encap map-request) */
*dst_port = ntohs(udph->source);
#ifdef BSD
udp_len = ntohs(udph->uh_ulen);
// sport = ntohs(udph->uh_sport);
#else
udp_len = ntohs(udph->len);
// sport = ntohs(udph->source);
#endif
/*
* Verify the checksums.
*/
if (iph->ip_v == IPVERSION) {
ipsum = ip_checksum((uint16_t *)iph, ip_header_len);
if (ipsum != 0) {
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_request_msg: Map-Request: IP checksum failed.");
}
/* We accept checksum 0 in the inner header*/
if (udph->check != 0){
if ((udpsum = udp_checksum(udph, udp_len, iph, encap_afi)) == -1) {
return(BAD);
}
if (udpsum != 0) {
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_request_msg: Map-Request: UDP checksum failed.");
return(BAD);
}
}
}
//Pranathi: Added this
if (iph->ip_v == IP6VERSION) {
/* We accept checksum 0 in the inner header*/
if (udph->check != 0){
if ((udpsum = udp_checksum(udph, udp_len, iph, encap_afi)) == -1) {
return(BAD);
}
if (udpsum != 0) {
lispd_log_msg(LISP_LOG_DEBUG_2, "process_map_request_msg: Map-Request:v6 UDP checksum failed.");
return(BAD);
}
}
}
*len = sizeof(lisp_encap_control_hdr_t)+ip_header_len + sizeof(struct udphdr);
return (GOOD);
}