int processVLANPacket(const void * data, int size, int length, PEtherHeader ether) {
PSoderoPeriodResult result = getPeriodResult();
const PVLANPacket packet = (PVLANPacket) data;
void * payload_data = VLAN_OVERLOAD_DATA(data);
int payload_size = VLAN_OVERLOAD_SIZE(size);
processA(&gVLAN, length);
processA(&result->protocol.l2.vlan.total, size);
long id = VLAN_ID(packet->vlan.value);
PSoderoSingleDatum datum = (PSoderoSingleDatum) sodero_map_ensure(getPeriodResult()->items.vlan, &id);
processSD(datum, size);
switch(packet->vlan.type) {
case ETHER_TYPE_IPv4:
processA(&result->protocol.l2.ether.ipv4, payload_size);
payload_size = processIPv4Packet(payload_data, payload_size, length, ether, id);
return payload_size;
case ETHER_TYPE_MPLS:
processA(&result->protocol.l2.ether.mpls, size);
payload_size = processMPLSPacket(payload_data, payload_size, length, ether, id);
return payload_size;
}
return 0;
}
int processEtherSTP(PEtherPacket packet, int length, void * data, int size) {
do {
if (isSTPMAC(&packet->head.dest)) {
if (isLinkSTP((PLinkRSTPHeader) packet)) {
PSoderoPeriodResult result = getPeriodResult();
processA(&result->protocol.l2.ether.rstp, length);
PNodeValue node = takeMACNode(&packet->head.sour);
processA(&node->l2.rstp.outgoing, length);
processRSTPPacket (data, size, length, &packet->head);
return true;
}
}
if (isSTPMAC(&packet->head.sour)) {
if (isLinkSTP((PLinkRSTPHeader) packet)) {
PSoderoPeriodResult result = getPeriodResult();
processA(&result->protocol.l2.ether.rstp, length);
PNodeValue node = takeMACNode(&packet->head.dest);
processA(&node->l2.rstp.incoming, length);
processRSTPPacket (data, size, length, &packet->head);
return true;
}
}
} while (false);
return false;
}
int processLACPPacket(const void * data, int size, int length, PEtherHeader ether) {
PSoderoPeriodResult result = getPeriodResult();
// const PLACPPacket packet = (PLACPPacket) data;
// void * payload_data = VLAN_OVERLOAD_DATA(data);
// int payload_size = VLAN_OVERLOAD_SIZE(size);
processA(&gLACP, length);
processA(&result->protocol.l2.lacp.total, size);
return 0;
}
static inline
int processOtherPacket(const void * data, int size, int length, PEtherHeader ether) {
processA(&gOtherEther, length);
return 0;
}
int processEtherUCAST(PEtherPacket packet, int length, void * data, int size) {
if (isSMAC(&packet->head.sour)) {
// PSoderoPeriodResult result = getPeriodResult();
// processA(&result->protocol.l2.ether.ucast, length);
PNodeValue node = takeMACNode(&packet->head.sour);
processA(&node->l2.ucast.outgoing, length);
// processMCASTPacket (data, size, length, &packet->head);
}
if (isSMAC(&packet->head.dest)) {
// PSoderoPeriodResult result = getPeriodResult();
// processA(&result->protocol.l2.ether.ucast, length);
PNodeValue node = takeMACNode(&packet->head.dest);
processA(&node->l2.ucast.incoming, length);
// processMCASTPacket (data, size, length, &packet->head);
}
return true;
}
int processMPLSPacket(const void * data, int size, int length, PEtherHeader ether, unsigned short vlan) {
PSoderoPeriodResult result = getPeriodResult();
const PMPLSPacket packet = (PMPLSPacket) data;
void * payload_data = VLAN_OVERLOAD_DATA(data);
int payload_size = VLAN_OVERLOAD_SIZE(size);
processA(&gMPLS, length);
processA(&result->protocol.l2.mpls.total, size);
long id = MPLS_ID(packet->mlps.value);
PSoderoSingleDatum datum = (PSoderoSingleDatum) sodero_map_ensure(getPeriodResult()->items.mpls, &id);
processSD(datum, size);
processA(&result->protocol.l2.ether.ipv4, payload_size);
payload_size = processIPv4Packet(payload_data, payload_size, length, ether, vlan);
return payload_size;
}
int processARPPacket(const void * data, int size, int length, PEtherHeader ether) {
PSoderoPeriodResult result = getPeriodResult();
const PARPPacket packet = (PARPPacket) data;
// void * payload_data = VLAN_OVERLOAD_DATA(data);
// int payload_size = VLAN_OVERLOAD_SIZE(size);
processA(&gARP, length);
if (isIPv4ARP(&packet->head)) {
PSoderoEvent event = takeEvent(sizeof(TSoderoEvent));
event->time = gTime;
event->type = SODERO_EVENT_REPORT;
event->report.kind = SODERO_REPORT_ARP;
event->report.arp.opcode = packet->head.opcode;
event->report.arp.senderMAC = packet->senderMAC;
event->report.arp.senderIP = packet->senderIP;
event->report.arp.targetMAC = packet->targetMAC;
event->report.arp.targetIP = packet->targetIP;
sodero_pointer_add(getEvents(), event);
}
processA(&result->protocol.l2.arp.total, size);
return 0;
}
/*inicializar el pcb*/
void initPCB(...)
{
//Inicializa el primer nodo del PCB
pcb[0].offset = FP_OFF(processA);
pcb[0].quantum = quantum;
pcb[0].id = 'A';
pcb[0].status = 1;
pcb[0].stcPtr = 0;
//Inicializa el segundo nodo del PCB
pcb[1].offset = FP_OFF(processB);
pcb[1].quantum = quantum;
pcb[1].id = 'B';
pcb[1].status = 2;
//Guarda el SP de nuestro programa
asm mov stackPointer,sp
stackPointerAux = stackPointer;
//Realiza un corrimiento en la pila para el primer proceso
stackPointerAux = stackPointerAux - 512;
indexOffset = pcb[1].offset; //Direccion del proceso i
//Guarda todo el contexto del proceso 1
asm {
mov SP, stackPointerAux
pushf
push cs
push indexOffset
push ax
push bx
push cx
push dx
push es
push ds
push si
push di
push bp
mov stackPointerAux, SP
mov SP, stackPointer
};
//Guarda en el PCB el SP donde se encuentran el contexto del proceso
pcb[1].stcPtr = stackPointerAux;
indexProcess = 0;
quantumProcess =pcb[indexProcess].quantum;
}
/*Procemiento que reemplaza la interrupcion del timer con nuestro
codigo fuente.*/
void main()
{
clrscr();
initPCB();
prev=getvect(8); //Guarda la interrupci¢n antigua del timer
setvect(8,myTimer); //Inserta con nuestro c¢digo la interrupcion del time
actualProcess = 1;
processA();
clrscr();
while(1)
{}
}
int processEtherPacket(const void * data, int size, int length) {
const PEtherPacket packet = (PEtherPacket) data;
void * payload_data = ETHER_OVERLOAD_DATA(data);
int payload_size = ETHER_OVERLOAD_SIZE(size);
processA(&gTotal, length);
processA(&gCurrent, length);
PSoderoPeriodResult result = getPeriodResult();
processA(&result->protocol.l2.ether.total, size);
processEtherCast(packet, size, payload_data, payload_size);
PNodeValue sour = takeMACNode(&packet->head.sour);
PNodeValue dest = takeMACNode(&packet->head.dest);
if (sour)
processP(&sour->l2.total.outgoing, size);
if (dest)
processP(&dest->l2.total.incoming, size);
switch (packet->head.type) {
case ETHER_TYPE_IPv4:
processA(&result->protocol.l2.ether.ipv4, size);
if (sour)
processA(&sour->l2.ipv4.outgoing, size);
if (dest)
processA(&dest->l2.ipv4.incoming, size);
payload_size = processIPv4Packet (payload_data, payload_size, size, &packet->head, 0);
break;
case ETHER_TYPE_ARP :
processA(&result->protocol.l2.ether.arp, size);
if (sour)
processA(&sour->l2.arp.outgoing, size);
if (dest)
processA(&dest->l2.arp.incoming, size);
payload_size = processARPPacket (payload_data, payload_size, size, &packet->head);
break;
case ETHER_TYPE_VLAN:
processA(&result->protocol.l2.ether.vlan, size);
if (sour)
processA(&sour->l2.vlan.outgoing, size);
if (dest)
processA(&dest->l2.vlan.incoming, size);
payload_size = processVLANPacket (payload_data, payload_size, size, &packet->head);
break;
case ETHER_TYPE_MPLS:
processA(&result->protocol.l2.ether.mpls, size);
if (sour)
processA(&sour->l2.mpls.outgoing, size);
if (dest)
processA(&dest->l2.mpls.incoming, size);
payload_size = processMPLSPacket (payload_data, payload_size, size, &packet->head, 0);
break;
case ETHER_TYPE_LACP:
processA(&result->protocol.l2.ether.lacp, size);
if (sour)
processA(&sour->l2.lacp.outgoing, size);
if (dest)
processA(&dest->l2.lacp.incoming, size);
payload_size = processLACPPacket (payload_data, payload_size, size, &packet->head);
break;
case ETHER_TYPE_IPv6:
processA(&result->protocol.l2.ether.ipv6, size);
if (sour)
processA(&sour->l2.ipv6.outgoing, size);
if (dest)
processA(&dest->l2.ipv6.incoming, size);
payload_size = processIPv6Packet (payload_data, payload_size, size, &packet->head, 0);
break;
default:
processA(&result->protocol.l2.ether.other, size);
if (sour)
processA(&sour->l2.other.outgoing, size);
if (dest)
processA(&dest->l2.other.incoming, size);
payload_size = processOtherPacket(payload_data, payload_size, size, &packet->head);
break;
}
// PSoderoFlowDatum datum = (PSoderoFlowDatum) sodero_map_ensure(gPeriodResult->items.ether, packet->head.type);
// processA(datum, size);
return payload_size;
}
int processIPv6Packet(const void * data, int size, int length, PEtherHeader ether, unsigned short vlan) {
processA(&gIPv6, length);
return 0;
}
