计算机网络自顶向下：距离向量算法实验

前言

关于这个实验的文档可以从下面这个博主的链接中拿到
博客链接：计算机网络自顶向下：距离向量算法
我本身也是参考了他的部分思路以及其实验文档而做出来的

实验思路

其主要核心就是距离向量算法的步骤，哈工大计算机网络公开中对于距离向量算法讲的挺好的，当然，其本质就是动态规划，这个就相当于当前节点的邻居节点到终点的最短距离已知一样，这样就只要求出当前节点到邻居节点的代价与这个最短距离之和最小即可，由于这样不停递推，且每次只要当前节点距离向量表中当前节点到其他节点的距离发生了改变，就会向其邻居发送数据包来交换距离，并且确定最短路径，于是能够得到其各个节点的最短路径。

实验代码

node.c

#include <stdio.h>

extern struct rtpkt {
    int sourceid;       /* id of sending router sending this pkt */
    int destid;         /* id of router to which pkt being sent
                           (must be an immediate neighbor) */
    int mincost[4];    /* min cost to node 0 ... 3 */
};

extern int TRACE;
extern int YES;
extern int NO;

struct distance_table
{
    int costs[4][4];
} dt0;


/* students to write the following two routines, and maybe some others */

void rtinit0()
{
    int _max = 999;
    //memset(dt0.costs, _max, sizeof(dt0.costs));
    //memset(packet.mincost, _max, sizeof(packet.mincost));
    for (int i = 0; i < 4; i++) {

        for (int j = 0; j < 4; j++) {
            if (i == j) {
                dt0.costs[i][j] = 0;
            }
            else {
                dt0.costs[i][j] = 999;
            }
        }
    }
    struct rtpkt packet[4];
    for (int i = 0; i < 4; i++) {
        packet[i].mincost[0] = dt0.costs[0][0] = 0;
        packet[i].mincost[1] = dt0.costs[0][1] = 1;
        packet[i].mincost[2] = dt0.costs[0][2] = 3;
        packet[i].mincost[3] = dt0.costs[0][3] = 7;

        packet[i].sourceid = 0;
    }
    int count = 0;
    for (int i = 0; i < 4; i++) {
        if (i != 0) {
            packet[count++].destid = i;
            if (dt0.costs[0][i] != 999)tolayer2(packet[count-1]);
        }
    }
}

int isRight(int a[4], int b[4]) {
    for (int i = 0; i < 4; i++) {
        if (a[i] != b[i])return 1;
    }
    return 0;
}
void rtupdate0(rcvdpkt)
struct rtpkt* rcvdpkt;
{

    int src_id = rcvdpkt->sourceid;
    //将信息加入到表中
    for (int i = 0; i < 4; i++) {
        dt0.costs[src_id][i] = rcvdpkt->mincost[i];
        dt0.costs[i][src_id] = rcvdpkt->mincost[i];
    }
    int connect[4];
    for (int i = 0; i < 4; i++) {
        connect[i] = dt0.costs[0][i];
    }
    //求其最短距离
    for (int i = 0; i < 4; i++) {
        if (i != 0) {
            int min_num = 999;
            for (int j = 0; j < 4; j++) {
                if (j != 0) {
                    min_num = min(min_num, dt0.costs[0][j] + dt0.costs[j][i]);
                }
            }
            dt0.costs[0][i] = min_num;
            dt0.costs[i][0] = min_num;
        }
    }
    //新加的
    if (isRight(connect, dt0.costs[0])) {
        struct rtpkt packet[4];
        for (int i = 0; i < 4; i++) {
            packet[i].mincost[0] = dt0.costs[0][0];
            packet[i].mincost[1] = dt0.costs[0][1];
            packet[i].mincost[2] = dt0.costs[0][2];
            packet[i].mincost[3] = dt0.costs[0][3];

            packet[i].sourceid = 0;
        }
        int count = 0;
        for (int i = 0; i < 4; i++) {
            if (i != 0) {
                packet[count++].destid = i;
                if (dt0.costs[0][i] != 999)tolayer2(packet[count - 1]);
            }
        }
    }
    //end

}


printdt0(dtptr)
struct distance_table* dtptr;
{
    printf("                via     \n");
    printf("   D0 |    1     2    3 \n");
    printf("  ----|-----------------\n");
    printf("     1|  %3d   %3d   %3d\n", dtptr->costs[1][1],
        dtptr->costs[1][2], dtptr->costs[1][3]);
    printf("dest 2|  %3d   %3d   %3d\n", dtptr->costs[2][1],
        dtptr->costs[2][2], dtptr->costs[2][3]);
    printf("     3|  %3d   %3d   %3d\n", dtptr->costs[3][1],
        dtptr->costs[3][2], dtptr->costs[3][3]);
}

linkhandler0(linkid, newcost)
int linkid, newcost;
/* called when cost from 0 to linkid changes from current value to newcost*/
/* You can leave this routine empty if you're an undergrad. If you want */
/* to use this routine, you'll need to change the value of the LINKCHANGE */
/* constant definition in prog3.c from 0 to 1 */
{
    
}

node1.c

#include <stdio.h>

int min(int x, int y) { return x < y ? x : y; };
extern struct rtpkt
{
    int sourceid;       /* id of sending router sending this pkt */
    int destid;         /* id of router to which pkt being sent
                           (must be an immediate neighbor) */
    int mincost[4];    /* min cost to node 0 ... 3 */
};

extern int TRACE;
extern int YES;
extern int NO;

int connectcosts1[4] = { 1,  0,  1, 999 };

struct distance_table
{
    int costs[4][4];
}dt1;

/* students to write the following two routines, and maybe some others */

rtinit1()
{
    //int _max = 999;
    //memset(dt1.costs, _max, sizeof(dt1.costs));
    struct rtpkt packet[4];
    //memset(packet.mincost, _max, sizeof(packet.mincost));
    for (int i = 0; i < 4; i++) {
        
        for (int j = 0; j < 4; j++) {
            if (i == j) {
                dt1.costs[i][j] = 0;
            }
            else {
                dt1.costs[i][j] = 999;
            }
        }
    }
    for (int i = 0; i < 4; i++) {
        packet[i].mincost[0] = dt1.costs[1][0] = 1;
        packet[i].mincost[1] = dt1.costs[1][1] = 0;
        packet[i].mincost[2] = dt1.costs[1][2] = 1;
        packet[i].mincost[3] = dt1.costs[1][3] = 999;

        packet[i].sourceid = 1;
    }
    int count = 0;
    for (int i = 0; i < 4; i++) {
        if (i != 1) {
            packet[count++].destid = i;
            if (dt1.costs[1][i] != 999)tolayer2(packet[count-1]);
        }
    }

}

rtupdate1(rcvdpkt)
struct rtpkt* rcvdpkt;
{
    int src_id = rcvdpkt->sourceid;
    //将信息加入到表中
    for (int i = 0; i < 4; i++) {
        dt1.costs[src_id][i] = rcvdpkt->mincost[i];
        dt1.costs[i][src_id] = rcvdpkt->mincost[i];
    }
    //候补
   /* for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d      ", dt1.costs[i][j]);
        }
        printf("\n");
    }*/
    //printf("\r\r");
    //start
    int connect[4];
    for (int i = 0; i < 4; i++) {
        connect[i] = dt1.costs[1][i];
    }
    //end
    for (int i = 0; i < 4; i++) {
        if (i != 1) {
            int _min1 = 999;
            for (int j = 0; j < 4; j++) {
                if (j != 1) {
                    _min1 = min(_min1, dt1.costs[1][j] + dt1.costs[j][i]);
                }
            }
            dt1.costs[1][i] = _min1;
            dt1.costs[i][1] = _min1;
        }
    }
    //start
    if (isRight(connect, dt1.costs[1])) {
        struct rtpkt packet[4];
        for (int i = 0; i < 4; i++) {
            packet[i].mincost[0] = dt1.costs[1][0];
            packet[i].mincost[1] = dt1.costs[1][1];
            packet[i].mincost[2] = dt1.costs[1][2];
            packet[i].mincost[3] = dt1.costs[1][3];

            packet[i].sourceid = 1;
        }
        int count = 0;
        for (int i = 0; i < 4; i++) {
            if (i != 1) {
                packet[count++].destid = i;
                if (dt1.costs[1][i] != 999)tolayer2(packet[count - 1]);
            }
        }
    }
    //end
}

printdt1(dtptr)
struct distance_table* dtptr;
{
    printf("                via     \n");
    printf("   D0 |    0     2    3 \n");
    printf("  ----|-----------------\n");
    printf("     0|  %3d   %3d   %3d\n", dtptr->costs[0][0],
        dtptr->costs[0][2], dtptr->costs[0][3]);
    printf("dest 2|  %3d   %3d   %3d\n", dtptr->costs[2][0],
        dtptr->costs[2][2], dtptr->costs[2][3]);
    printf("     3|  %3d   %3d   %3d\n", dtptr->costs[3][0],
        dtptr->costs[3][2], dtptr->costs[3][3]);
}

linkhandler1(linkid, newcost)
int linkid, newcost;
/* called when cost from 1 to linkid changes from current value to newcost*/
/* You can leave this routine empty if you're an undergrad. If you want */
/* to use this routine, you'll need to change the value of the LINKCHANGE */
/* constant definition in prog3.c from 0 to 1 */
{

}

node2.c

#include <stdio.h>

extern struct rtpkt
{
    int sourceid;       /* id of sending router sending this pkt */
    int destid;         /* id of router to which pkt being sent
                         (must be an immediate neighbor) */
    int mincost[4];    /* min cost to node 0 ... 3 */
};

extern int TRACE;
extern int YES;
extern int NO;

struct distance_table
{
    int costs[4][4];
} dt2;

/* students to write the following two routines, and maybe some others */

void rtinit2()
{
    int _max = 999;
    //memset(dt2.costs, _max, sizeof(dt2.costs));
    struct rtpkt packet[4];
    //memset(packet.mincost, _max, sizeof(packet.mincost));

    for (int i = 0; i < 4; i++) {

        for (int j = 0; j < 4; j++) {
            if (i == j) {
                dt2.costs[i][j] = 0;
            }
            else {
                dt2.costs[i][j] = 999;
            }
        }
    }
    for (int i = 0; i < 4; i++) {
        packet[i].mincost[0] = dt2.costs[2][0] = 3;
        packet[i].mincost[1] = dt2.costs[2][1] = 1;
        packet[i].mincost[2] = dt2.costs[2][2] = 0;
        packet[i].mincost[3] = dt2.costs[2][3] = 2;


        packet[i].sourceid = 2;
    }
    int count = 0;
    for (int i = 0; i < 4; i++) {
        if (i != 2) {
            packet[count++].destid = i;
            if (dt2.costs[2][i] != 999)tolayer2(packet[count-1]);
        }
    }
}

void rtupdate2(rcvdpkt)
struct rtpkt* rcvdpkt;

{
    int src_id = rcvdpkt->sourceid;
    //将信息加入到表中
    for (int i = 0; i < 4; i++) {
        dt2.costs[src_id][i] = rcvdpkt->mincost[i];
        dt2.costs[i][src_id] = rcvdpkt->mincost[i];
    }
    //候补
    /*for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d      ", dt2.costs[i][j]);
        }
        printf("\n");
    }
    printf("\r\r");*/
    int connect[4];
    for (int i = 0; i < 4; i++) {
        connect[i] = dt2.costs[2][i];
    }
    for (int i = 0; i < 4; i++) {
        if (i != 2) {
            int _min1 = 999;
            for (int j = 0; j < 4; j++) {
                if (j != 2) {
                    _min1 = min(_min1, dt2.costs[2][j] + dt2.costs[j][i]);
                }
            }
            dt2.costs[2][i] = _min1;
            dt2.costs[i][2] = _min1;
        }
    }
    //start
    if (isRight(connect, dt2.costs[2])) {
        struct rtpkt packet[4];
        for (int i = 0; i < 4; i++) {
            packet[i].mincost[0] = dt2.costs[2][0];
            packet[i].mincost[1] = dt2.costs[2][1];
            packet[i].mincost[2] = dt2.costs[2][2];
            packet[i].mincost[3] = dt2.costs[2][3];

            packet[i].sourceid = 2;
        }
        int count = 0;
        for (int i = 0; i < 4; i++) {
            if (i != 2) {
                packet[count++].destid = i;
                if (dt2.costs[2][i] != 999)tolayer2(packet[count - 1]);
            }
        }
    }
    //end
}

printdt2(dtptr)
struct distance_table* dtptr;

{
    printf("                via     \n");
    printf("   D2 |    0     1    3 \n");
    printf("  ----|-----------------\n");
    printf("     0|  %3d   %3d   %3d\n", dtptr->costs[0][0],
        dtptr->costs[0][1], dtptr->costs[0][3]);
    printf("dest 1|  %3d   %3d   %3d\n", dtptr->costs[1][0],
        dtptr->costs[1][1], dtptr->costs[1][3]);
    printf("     3|  %3d   %3d   %3d\n", dtptr->costs[3][0],
        dtptr->costs[3][1], dtptr->costs[3][3]);
}

node3.c

#include <stdio.h>

extern struct rtpkt
{
    int sourceid;       /* id of sending router sending this pkt */
    int destid;         /* id of router to which pkt being sent
                         (must be an immediate neighbor) */
    int mincost[4];    /* min cost to node 0 ... 3 */
};

extern int TRACE;
extern int YES;
extern int NO;

struct distance_table
{
    int costs[4][4];
} dt3;

/* students to write the following two routines, and maybe some others */

void rtinit3()
{
    int _max = 999;
    //memset(dt3.costs, _max, sizeof(dt3.costs));
    struct rtpkt packet[4];
    //memset(packet.mincost, _max, sizeof(packet.mincost));
    for (int i = 0; i < 4; i++) {

        for (int j = 0; j < 4; j++) {
            if (i == j) {
                dt3.costs[i][j] = 0;
            }
            else {
                dt3.costs[i][j] = 999;
            }
        }
    }
    for (int i = 0; i < 4; i++) {
        packet[i].mincost[0] = dt3.costs[3][0] = 7;
        packet[i].mincost[1] = dt3.costs[3][1] = 999;
        packet[i].mincost[2] = dt3.costs[3][2] = 2;
        packet[i].mincost[3] = dt3.costs[3][3] = 0;

        packet[i].sourceid = 3;
    }
    int count = 0;
    for (int i = 0; i < 4; i++) {
        if (i != 3) {
            packet[count++].destid = i;
            if (dt3.costs[3][i] != 999)tolayer2(packet[count-1]);
        }
    }
    //dt3.costs[3][3] = 2;
}

void rtupdate3(rcvdpkt)
struct rtpkt* rcvdpkt;

{
    int src_id = rcvdpkt->sourceid;
    //将信息加入到表中
    for (int i = 0; i < 4; i++) {
        dt3.costs[src_id][i] = rcvdpkt->mincost[i];
        dt3.costs[i][src_id] = rcvdpkt->mincost[i];
    }
    //候补
    /*for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d      ", dt3.costs[i][j]);
        }
        printf("\n");
    }*/
   // printf("\r\r");

    int connect[4];
    for (int i = 0; i < 4; i++) {
        connect[i] = dt3.costs[3][i];
    }
    for (int i = 0; i < 4; i++) {
        if (i != 3) {
            int _min1 = 999;
            for (int j = 0; j < 4; j++) {
                if (j != 3) {
                    _min1 = min(_min1, dt3.costs[3][j] + dt3.costs[j][i]);
                }
            }
            dt3.costs[3][i] = _min1;
            dt3.costs[i][3] = _min1;
        }
    }

    //start
    if (isRight(connect, dt3.costs[3])) {
        struct rtpkt packet[4];
        for (int i = 0; i < 4; i++) {
            packet[i].mincost[0] = dt3.costs[3][0];
            packet[i].mincost[1] = dt3.costs[3][1];
            packet[i].mincost[2] = dt3.costs[3][2];
            packet[i].mincost[3] = dt3.costs[3][3];

            packet[i].sourceid = 3;
        }
        int count = 0;
        for (int i = 0; i < 4; i++) {
            if (i != 3) {
                packet[count++].destid = i;
                if (dt3.costs[3][i] != 999)tolayer2(packet[count - 1]);
            }
        }
    }
    //end
}

printdt3(dtptr)
struct distance_table* dtptr;

{
    printf("                via     \n");
    printf("   D2 |    0     1    2 \n");
    printf("  ----|-----------------\n");
    printf("     0|  %3d   %3d   %3d\n", dtptr->costs[0][0],
        dtptr->costs[0][1], dtptr->costs[0][2]);
    printf("dest 1|  %3d   %3d   %3d\n", dtptr->costs[1][0],
        dtptr->costs[1][1], dtptr->costs[1][2]);
    printf("     2|  %3d   %3d   %3d\n", dtptr->costs[2][0],
        dtptr->costs[2][1], dtptr->costs[2][3]);
}

prog.c

#include <stdio.h>

#define LINKCHANGES 1
/* ******************************************************************
Programming assignment 3: implementing distributed, asynchronous,
                          distance vector routing.

THIS IS THE MAIN ROUTINE.  IT SHOULD NOT BE TOUCHED AT ALL BY STUDENTS!

**********************************************************************/


/* a rtpkt is the packet sent from one routing update process to
   another via the call tolayer3() */
struct rtpkt
{
    int sourceid;       /* id of sending router sending this pkt */
    int destid;         /* id of router to which pkt being sent
                         (must be an immediate neighbor) */
    int mincost[4];    /* min cost to node 0 ... 3 */
};

int TRACE = 1;             /* for my debugging */
int YES = 1;
int NO = 0;

creatertpkt(initrtpkt, srcid, destid, mincosts)
struct rtpkt* initrtpkt;
int srcid;
int destid;
int mincosts[];
{
    int i;
    initrtpkt->sourceid = srcid;
    initrtpkt->destid = destid;
    for (i = 0; i < 4; i++)
        initrtpkt->mincost[i] = mincosts[i];
}
extern printdt0(dtptr);
extern printdt1(dtptr);
extern printdt2(dtptr);
extern printdt3(dtptr);
extern struct distance_table dt0;
extern struct distance_table dt1;
extern struct distance_table dt2;
extern struct distance_table dt3;

/*****************************************************************
***************** NETWORK EMULATION CODE STARTS BELOW ***********
The code below emulates the layer 2 and below network environment:
  - emulates the tranmission and delivery (with no loss and no
    corruption) between two physically connected nodes
  - calls the initializations routines rtinit0, etc., once before
    beginning emulation

THERE IS NOT REASON THAT ANY STUDENT SHOULD HAVE TO READ OR UNDERSTAND
THE CODE BELOW.  YOU SHOLD NOT TOUCH, OR REFERENCE (in your code) ANY
OF THE DATA STRUCTURES BELOW.  If you're interested in how I designed
the emulator, you're welcome to look at the code - but again, you should have
to, and you defeinitely should not have to modify
******************************************************************/

struct event
{
    float evtime;           /* event time */
    int evtype;             /* event type code */
    int eventity;           /* entity where event occurs */
    struct rtpkt* rtpktptr; /* ptr to packet (if any) assoc w/ this event */
    struct event* prev;
    struct event* next;
};
struct event* evlist = NULL;   /* the event list */

/* possible events: */
#define  FROM_LAYER2     2
#define  LINK_CHANGE     10

float clocktime = 0.000;


main()
{
    struct event* eventptr;
    init();

    while (1)
    {
        eventptr = evlist;            /* get next event to simulate */
        if (eventptr == NULL)
            goto terminate;
        evlist = evlist->next;        /* remove this event from event list */
        if (evlist != NULL)
            evlist->prev = NULL;
        if (TRACE > 1)
        {
            printf("MAIN: rcv event, t=%.3f, at %d", eventptr->evtime, eventptr->eventity);
            if (eventptr->evtype == FROM_LAYER2)
            {
                printf(" src:%2d,", eventptr->rtpktptr->sourceid);
                printf(" dest:%2d,", eventptr->rtpktptr->destid);
                printf(" contents: %3d %3d %3d %3d\n",
                    eventptr->rtpktptr->mincost[0], eventptr->rtpktptr->mincost[1],
                    eventptr->rtpktptr->mincost[2], eventptr->rtpktptr->mincost[3]);
            }
        }
        clocktime = eventptr->evtime;    /* update time to next event time */
        if (eventptr->evtype == FROM_LAYER2)
        {
            if (eventptr->eventity == 0)
                rtupdate0(eventptr->rtpktptr);
            else if (eventptr->eventity == 1)
                rtupdate1(eventptr->rtpktptr);
            else if (eventptr->eventity == 2)
                rtupdate2(eventptr->rtpktptr);
            else if (eventptr->eventity == 3)
                rtupdate3(eventptr->rtpktptr);
            else
            {
                printf("Panic: unknown event entity\n");
                exit(0);
            }
        }
        else if (eventptr->evtype == LINK_CHANGE)
        {
            if (clocktime < 10001.0)
            {
                linkhandler0(1, 20);
                linkhandler1(0, 20);
            }
            else
            {
                linkhandler0(1, 1);
                linkhandler1(0, 1);
            }
        }
        else
        {
            printf("Panic: unknown event type\n");
            exit(0);
        }
        if (eventptr->evtype == FROM_LAYER2)
            free(eventptr->rtpktptr);        /* free memory for packet, if any */
        free(eventptr);                    /* free memory for event struct   */
    }


terminate:
    printdt0(&dt0);
    printf("\n");
    printdt1(&dt1);
    printf("\n");
    printdt2(&dt2);
    printf("\n");
    printdt3(&dt3);
    printf("\n");
    printf("\nSimulator terminated at t=%f, no packets in medium\n", clocktime);
}



init()                         /* initialize the simulator */
{
    int i;
    float sum, avg;
    float jimsrand();
    struct event* evptr;

    printf("Enter TRACE:");
    scanf_s("%d", &TRACE);

    srand(9999);              /* init random number generator */
    sum = 0.0;                /* test random number generator for students */
    for (i = 0; i < 1000; i++)
        sum = sum + jimsrand();    /* jimsrand() should be uniform in [0,1] */
    avg = sum / 1000.0;
    if (avg < 0.25 || avg > 0.75)
    {
        printf("It is likely that random number generation on your machine\n");
        printf("is different from what this emulator expects.  Please take\n");
        printf("a look at the routine jimsrand() in the emulator code. Sorry. \n");
        exit(0);
    }

    clocktime = 0.0;                /* initialize time to 0.0 */
    rtinit0();
    rtinit1();
    rtinit2();
    rtinit3();

    /* initialize future link changes */
    if (LINKCHANGES == 1)
    {
        evptr = (struct event*)malloc(sizeof(struct event));
        evptr->evtime = 10000.0;
        evptr->evtype = LINK_CHANGE;
        evptr->eventity = -1;
        evptr->rtpktptr = NULL;
        insertevent(evptr);
        evptr = (struct event*)malloc(sizeof(struct event));
        evptr->evtype = LINK_CHANGE;
        evptr->evtime = 20000.0;
        evptr->rtpktptr = NULL;
        insertevent(evptr);
    }
}

/****************************************************************************/
/* jimsrand(): return a float in range [0,1].  The routine below is used to */
/* isolate all random number generation in one location.  We assume that the*/
/* system-supplied rand() function return an int in therange [0,mmm]        */
/****************************************************************************/

float jimsrand()
{
    double mmm = 0x7fff;   /* largest int  - MACHINE DEPENDENT!!!!!!!!   */
    float x;                   /* individual students may need to change mmm */
    x = rand() / mmm;            /* x should be uniform in [0,1] */
    return(x);
}

/********************* EVENT HANDLINE ROUTINES *******/
/*  The next set of routines handle the event list   */
/*****************************************************/


insertevent(p)
struct event* p;
{
    struct event* q, * qold;
    if (TRACE > 3)
    {
        printf("            INSERTEVENT: time is %lf\n", clocktime);
        printf("            INSERTEVENT: future time will be %lf\n", p->evtime);
    }
    q = evlist;     /* q points to header of list in which p struct inserted */
    if (q == NULL)
    {   /* list is empty */
        evlist = p;
        p->next = NULL;
        p->prev = NULL;
    }
    else
    {
        for (qold = q; q != NULL && p->evtime > q->evtime; q = q->next)
            qold = q;
        if (q == NULL)    /* end of list */
        {
            qold->next = p;
            p->prev = qold;
            p->next = NULL;
        }
        else if (q == evlist) /* front of list */
        {
            p->next = evlist;
            p->prev = NULL;
            p->next->prev = p;
            evlist = p;
        }
        else    /* middle of list */
        {
            p->next = q;
            p->prev = q->prev;
            q->prev->next = p;
            q->prev = p;
        }
    }
}

printevlist()
{
    struct event* q;
    printf("--------------\nEvent List Follows:\n");
    for (q = evlist; q != NULL; q = q->next)
        printf("Event time: %f, type: %d entity: %d\n", q->evtime, q->evtype, q->eventity);
    printf("--------------\n");
}


/************************** TOLAYER2 ***************/
tolayer2(packet)
struct rtpkt packet;
{
    struct rtpkt* mypktptr;
    struct event* evptr, * q;
    float jimsrand(), lastime;
    int i;

    int connectcosts[4][4];

    /* initialize by hand since not all compilers allow array initilization */
    connectcosts[0][0] = 0;  connectcosts[0][1] = 1;  connectcosts[0][2] = 3;
    connectcosts[0][3] = 7;
    connectcosts[1][0] = 1;  connectcosts[1][1] = 0;  connectcosts[1][2] = 1;
    connectcosts[1][3] = 999;
    connectcosts[2][0] = 3;  connectcosts[2][1] = 1;  connectcosts[2][2] = 0;
    connectcosts[2][3] = 2;
    connectcosts[3][0] = 7;  connectcosts[3][1] = 999;  connectcosts[3][2] = 2;
    connectcosts[3][3] = 0;

    /* be nice: check if source and destination id's are reasonable */
    if (packet.sourceid < 0 || packet.sourceid >3)
    {
        printf("WARNING: illegal source id in your packet, ignoring packet!\n");
        return;
    }
    if (packet.destid < 0 || packet.destid >3)
    {
        printf("WARNING: illegal dest id in your packet, ignoring packet!\n");
        return;
    }
    if (packet.sourceid == packet.destid)
    {
        printf("WARNING: source and destination id's the same, ignoring packet!\n");
        return;
    }
    if (connectcosts[packet.sourceid][packet.destid] == 999)
    {
        printf("WARNING: source and destination not connected, ignoring packet!\n");
        return;
    }
    /* make a copy of the packet student just gave me since he/she may decide */
    /* to do something with the packet after we return back to him/her */
    mypktptr = (struct rtpkt*)malloc(sizeof(struct rtpkt));
    mypktptr->sourceid = packet.sourceid;
    mypktptr->destid = packet.destid;

    for (i = 0; i < 4; i++)
        mypktptr->mincost[i] = packet.mincost[i];
    if (TRACE > 2)
    {
        printf("    TOLAYER2: source: %d, dest: %d\n              costs:",
            mypktptr->sourceid, mypktptr->destid);
        for (i = 0; i < 4; i++)
            printf("%d  ", mypktptr->mincost[i]);
        printf("\n");
    }

    /* create future event for arrival of packet at the other side */
    evptr = (struct event*)malloc(sizeof(struct event));
    evptr->evtype = FROM_LAYER2;   /* packet will pop out from layer3 */
    evptr->eventity = packet.destid; /* event occurs at other entity */
    evptr->rtpktptr = mypktptr;       /* save ptr to my copy of packet */

    /* finally, compute the arrival time of packet at the other end.
    medium can not reorder, so make sure packet arrives between 1 and 10
    time units after the latest arrival time of packets
    currently in the medium on their way to the destination */
    lastime = clocktime;
    for (q = evlist; q != NULL; q = q->next)
    {
        if ((q->evtype == FROM_LAYER2 && q->eventity == evptr->eventity))
            lastime = q->evtime;
    }
    evptr->evtime = lastime + 2. * jimsrand();
    if (TRACE > 2)
        printf("    TOLAYER2: scheduling arrival on other side\n");
    insertevent(evptr);
}

实验结果

可以自己验算一下对不对