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; }