/*************************************************************************
*
* Verify that a packet is legal
*
*************************************************************************/
int verify_packet( struct session *ses, struct pppoe_packet *p){
struct session * hu_val;
/* This code here should do all of the error checking and
validation on the incoming packet */
/* If we receive any error tags, abort */
#define CHECK_TAG(name, val) \
if((NULL==p->tags[name])== val){ \
poe_error(ses,"Tag error: " #name ); \
return -1; \
}
/* If packet is not directed to our MAC address, forget it */
if (ses->state == PADS_CODE) {
if (memcmp(p->addr.sll_addr, ses->remote.sll_addr, ETH_ALEN)) {
poe_info(ses,"ETH_DEST mismatch: %E %E \n",p->addr.sll_addr, ses->remote.sll_addr);
return -1;
}
}
CHECK_TAG(TAG_SRV_ERR,0);
CHECK_TAG(TAG_SYS_ERR,0);
CHECK_TAG(TAG_GEN_ERR,0);
/* A HOST_UNIQ must be present */
CHECK_TAG(TAG_HOST_UNIQ,1);
hu_val = *TAG_DATA(struct session* ,p->tags[TAG_HOST_UNIQ]);
if( hu_val != ses ){
poe_info(ses,"HOST_UNIQ mismatch: %08x %i\n",(int)hu_val,getpid());
return -1;
}
if(ses->filt->htag &&
!verify_tag(ses,p,TAG_HOST_UNIQ,ses->filt->htag->tag_data,(int)ntohs(ses->filt->htag->tag_len))) {
poe_info(ses,"HOST_UNIQ failure");
return -1;
}
if(ses->filt->ntag && ses->state == PADO_CODE &&
!verify_tag(ses,p,TAG_AC_NAME,ses->filt->ntag->tag_data,(int)ntohs(ses->filt->ntag->tag_len))){
poe_info(ses,"AC_NAME failure");
return -1;
}
if(ses->filt->stag &&
!verify_tag(ses,p,TAG_SRV_NAME,ses->filt->stag->tag_data,(int)ntohs(ses->filt->stag->tag_len))){
poe_info(ses,"SRV_NAME failure");
return -1;
}
return 0;
}
/*************************************************************************
*
* Verify that a packet is legal
*
*************************************************************************/
int verify_packet( struct session *ses, struct pppoe_packet *p){
struct session * hu_val;
/* This code here should do all of the error checking and
validation on the incoming packet */
/* If we receive any error tags, abort */
#define CHECK_TAG(name, val) \
if((NULL==p->tags[name])== val){ \
char format[sizeof("Tag error: ") + sizeof (#name) + \
sizeof("- %.65535s")]; \
sprintf(format, "Tag error: %s - %%.%ds", #name,\
p->tags[name]->tag_len);\
poe_error(ses,format,p->tags[name]->tag_data);\
return -1; \
}
/* This causes an unaligned access here */
CHECK_TAG(TAG_SRV_ERR,0);
CHECK_TAG(TAG_SYS_ERR,0);
CHECK_TAG(TAG_GEN_ERR,0);
/* A HOST_UNIQ must be present */
CHECK_TAG(TAG_HOST_UNIQ,1);
hu_val = *TAG_DATA(struct session* ,p->tags[TAG_HOST_UNIQ]);
if( hu_val != ses ){
poe_info(ses,"HOST_UNIQ mismatch: %08x %i\n",(int)hu_val,getpid());
return -1;
}
if(ses->filt->htag &&
!verify_tag(ses,p,TAG_HOST_UNIQ,ses->filt->htag->tag_data,(int)ntohs(ses->filt->htag->tag_len))) {
poe_info(ses, "HOST_NAME failure");
return -1;
}
if(ses->filt->ntag &&
!verify_tag(ses,p,TAG_AC_NAME,ses->filt->ntag->tag_data,(int)ntohs(ses->filt->ntag->tag_len))){
poe_info(ses,"AC_NAME failure");
return -1;
}
if(ses->filt->stag &&
!verify_tag(ses,p,TAG_SRV_NAME,ses->filt->stag->tag_data,(int)ntohs(ses->filt->stag->tag_len))){
poe_info(ses,"SRV_NAME failure");
return -1;
}
return 1;
}
/*************************************************************************
*
* Verify that a packet is legal
*
*************************************************************************/
int verify_packet( struct session *ses, struct pppoe_packet *p){
struct session * hu_val;
/* This code here should do all of the error checking and
validation on the incoming packet */
/* If we receive any error tags, abort */
#define CHECK_TAG(name, val) \
if((NULL==p->tags[name])== val){ \
poe_error(ses,"Tag error: " #name ); \
return -1; \
}
CHECK_TAG(TAG_SRV_ERR,0);
CHECK_TAG(TAG_SYS_ERR,0);
CHECK_TAG(TAG_GEN_ERR,0);
/* A HOST_UNIQ must be present */
CHECK_TAG(TAG_HOST_UNIQ,1);
hu_val = *TAG_DATA(struct session* ,p->tags[TAG_HOST_UNIQ]);
if( hu_val != ses ){
poe_info(ses,"HOST_UNIQ mismatch: %08x %i\n",(int)hu_val,getpid());
return -1;
}
if(ses->filt->htag &&
!verify_tag(ses,p,TAG_HOST_UNIQ,ses->filt->htag->tag_data,(int)ntohs(ses->filt->htag->tag_len)))
return -1;
else
poe_info(ses,"HOST_UNIQ successful match\n");
if(ses->filt->ntag &&
!verify_tag(ses,p,TAG_AC_NAME,ses->filt->ntag->tag_data,(int)ntohs(ses->filt->ntag->tag_len))){
poe_info(ses,"AC_NAME failure");
return -1;
}
if(ses->filt->stag &&
!verify_tag(ses,p,TAG_SRV_NAME,ses->filt->stag->tag_data,(int)ntohs(ses->filt->stag->tag_len))){
poe_info(ses,"SRV_NAME failure");
return -1;
}
}
bool read_multiboot_tags(uintptr_t descriptor, multiboot* mb) {
auto info = Multiboot::Information(descriptor);
for(const auto& tag : info) {
#define EXTRACT_TAG(field, class) \
auto field = tag.cast<Multiboot::Tag##class>(); \
if (field) { mb->field = field; continue; }
EXTRACT_TAG(mmap, Mmap);
EXTRACT_TAG(shdr, ElfSections);
EXTRACT_TAG(acpi_old, OldAcpi);
EXTRACT_TAG(acpi_new, NewAcpi);
EXTRACT_TAG(cmd_line, CommandLine);
auto biggest_tag = sizeof(tag_names) / sizeof(tag_names[0]);
if (tag.type > biggest_tag) {
klog("Ignorning an unknown multiboot tag of type ", tag.type, "\n");
} else {
klog("Ignorning a multiboot tag of type ", tag_names[tag.type], "\n");
}
}
#define CHECK_TAG(field, class) \
if (mb->field == nullptr) { \
klog("Missing multiboot tag of type ", tag_names[Multiboot::Tag##class::Id], "\n"); \
return false; \
}
CHECK_TAG(mmap, Mmap);
CHECK_TAG(shdr, ElfSections);
CHECK_TAG(cmd_line, CommandLine);
// special case - we only need one of these
if(mb->acpi_old == nullptr && mb->acpi_new == nullptr) {
klog("Missing multiboot tag of type ",
tag_names[Multiboot::TagOldAcpi::Id], " or ",
tag_names[Multiboot::TagNewAcpi::Id], "\n");
return false;
}
return true;
}
int
eqv(Value *v1, Value *v2)
{
switch (v1->tag) {
/*
case any:
return 1;
break;
*/
case nil:
CHECK_TAG(v2, nil);
return 1;
break;
case cons:
CHECK_TAG(v2, cons);
return (eqv(VCAR(v1), VCAR(v2)) &&
eqv(VCDR(v1), VCDR(v2)));
break;
case string:
CHECK_TAG(v2, string);
return (VSLENGTH(v1) == VSLENGTH(v2) &&
0 == bcmp(VSDATA(v1), VSDATA(v2), VSLENGTH(v1)));
break;
case symbol:
CHECK_TAG(v2, symbol);
return (VSLENGTH(v1) == VSLENGTH(v2) &&
0 == bcmp(VSDATA(v1), VSDATA(v2), VSLENGTH(v1)));
break;
case integer:
CHECK_TAG(v2, integer);
return (VINTEGER(v1) == VINTEGER(v2));
break;
case var:
if (VVTAG(v1) != any)
CHECK_TAG(v2, VVTAG(v1));
return 1;
break;
default:
/* ??? error */
break;
}
}
int
destructure(Value *pattern, Value *match)
{
switch (VTAG(pattern)) {
case any:
return 1;
break;
case nil:
CHECK_TAG(match, nil);
return 1;
break;
case cons:
CHECK_TAG(match, cons);
return (destructure(VCAR(pattern), VCAR(match)) &&
destructure(VCDR(pattern), VCDR(match)));
break;
case string:
CHECK_TAG(match, string);
return (VSLENGTH(pattern) == VSLENGTH(match) &&
0 == bcmp(VSDATA(pattern), VSDATA(match), VSLENGTH(pattern)));
break;
case symbol:
CHECK_TAG(match, symbol);
return (VSLENGTH(pattern) == VSLENGTH(match) &&
0 == bcmp(VSDATA(pattern), VSDATA(match), VSLENGTH(pattern)));
break;
case integer:
CHECK_TAG(match, integer);
return (VINTEGER(pattern) == VINTEGER(match));
break;
case var:
if (VVTAG(pattern) != any)
CHECK_TAG(match, VVTAG(pattern));
if (VVDATA(pattern) != NULL)
*VVDATA(pattern) = (void *) match;
return 1;
break;
default:
/* ??? error */
break;
}
}
void ParseSAPFile(const Locus::MountedFilePath& mountedFilePath, std::vector<std::unique_ptr<Locus::Mesh>>& meshes)
{
Locus::XMLTag rootTag;
Locus::ParseXMLFile(mountedFilePath, rootTag);
#define CHECK_TAG(tag) if (tag == nullptr) throw std::runtime_error("Failed to find SAP XML tag")
#define CHECK_TAG_NAME(tagName, expectedName) if (tagName != expectedName) std::runtime_error(std::string("Unexpected tag found in SAP file: ") + tagName)
Locus::FVector3 positionFromFile;
Locus::Mesh::face_t faceFromFile;
Locus::TextureCoordinate textureCoordFromFile;
for (Locus::XMLTag& modelTag : rootTag.subTags)
{
CHECK_TAG_NAME(modelTag.name, XML_Model);
std::unique_ptr<Locus::Mesh> mesh = std::make_unique<Locus::Mesh>();
Locus::XMLTag* positionsTag = modelTag.FindSubTag(XML_Positions, 0);
CHECK_TAG(positionsTag);
for (Locus::XMLTag& singlePositionTag : positionsTag->subTags)
{
CHECK_TAG_NAME(singlePositionTag.name, XML_Position);
//read X
Locus::XMLTag* coordTag = singlePositionTag.FindSubTag(XML_X, 0);
CHECK_TAG(coordTag);
positionFromFile.x = std::stof(coordTag->value);
//read Y
coordTag = singlePositionTag.FindSubTag(XML_Y, 0);
CHECK_TAG(coordTag);
positionFromFile.y = std::stof(coordTag->value);
//read Z
coordTag = singlePositionTag.FindSubTag(XML_Z, 0);
CHECK_TAG(coordTag);
positionFromFile.z = std::stof(coordTag->value);
mesh->AddPosition(positionFromFile);
}
Locus::XMLTag* textureCoordsTag = modelTag.FindSubTag(XML_TextureCoordinates, 0);
CHECK_TAG(textureCoordsTag);
for (Locus::XMLTag& singleTextureCoordTag : textureCoordsTag->subTags)
{
CHECK_TAG_NAME(singleTextureCoordTag.name, XML_TextureCoordinate);
//read tx
Locus::XMLTag* coordTag = singleTextureCoordTag.FindSubTag(XML_TX, 0);
CHECK_TAG(coordTag);
textureCoordFromFile.x = std::stof(coordTag->value);
//read tY
coordTag = singleTextureCoordTag.FindSubTag(XML_TY, 0);
CHECK_TAG(coordTag);
textureCoordFromFile.y = std::stof(coordTag->value);
mesh->AddTextureCoordinate(textureCoordFromFile);
}
Locus::XMLTag* facesTag = modelTag.FindSubTag(XML_Faces, 0);
CHECK_TAG(facesTag);
for (Locus::XMLTag& singleFaceTag : facesTag->subTags)
{
CHECK_TAG_NAME(singleFaceTag.name, XML_Face);
faceFromFile.clear();
for (Locus::XMLTag& vertexTag : singleFaceTag.subTags)
{
CHECK_TAG_NAME(vertexTag.name, XML_Vertex);
Locus::XMLTag* positionIndexTag = vertexTag.FindSubTag(XML_PositionIndex, 0);
CHECK_TAG(positionIndexTag);
std::size_t positionIndex = static_cast<std::size_t>(std::stoul(positionIndexTag->value));
Locus::XMLTag* textureCoordIndexTag = vertexTag.FindSubTag(XML_TextureCoordinateIndex, 0);
CHECK_TAG(textureCoordIndexTag);
std::size_t textureCoordIndex = static_cast<std::size_t>(std::stoul(textureCoordIndexTag->value));
faceFromFile.push_back( Locus::MeshVertexIndexer(positionIndex, textureCoordIndex, 0, 0) );
}
mesh->AddFace(faceFromFile);
}
mesh->ComputeCentroid();
mesh->ToModel();
mesh->centroid = Locus::Vec3D::ZeroVector();
mesh->Triangulate();
mesh->UpdateEdgeAdjacency();
mesh->AssignNormals();
meshes.push_back( std::move(mesh) );
}
#undef CHECK_TAG
#undef CHECK_TAG_NAME
}
