Annotation of embedaddon/ntp/ntpd/ntpsim.c, revision 1.1
1.1 ! misho 1: /* ntpdsim.c
! 2: *
! 3: * The source code for the ntp discrete event simulator.
! 4: *
! 5: * Written By: Sachin Kamboj
! 6: * University of Delaware
! 7: * Newark, DE 19711
! 8: * Copyright (c) 2006
! 9: * (Some code shamelessly based on the original NTP discrete event simulator)
! 10: */
! 11:
! 12: #ifdef SIM
! 13: #include "ntpd.h"
! 14: #include "ntpsim.h"
! 15: #include "ntp_data_structures.h"
! 16:
! 17:
! 18: /* Global Variable Definitions */
! 19:
! 20: sim_info simulation; /* Simulation Control Variables */
! 21: local_clock_info simclock; /* Local Clock Variables */
! 22: queue *event_queue; /* Event Queue */
! 23: queue *recv_queue; /* Receive Queue */
! 24: static double sys_residual = 0; /* adjustment residue (s) */
! 25:
! 26: void (*event_ptr[]) (Event *) = {
! 27: sim_event_beep, sim_update_clocks, sim_event_timer, sim_event_recv_packet
! 28: }; /* Function pointer to the events */
! 29:
! 30:
! 31: /* Define a function to compare two events to determine which one occurs first
! 32: */
! 33:
! 34: int determine_event_ordering(Event *e1, Event *e2);
! 35:
! 36: int determine_event_ordering(Event *e1, Event *e2)
! 37: {
! 38: return (e1->time - e2->time);
! 39: }
! 40:
! 41: /* Define a function to compare two received packets to determine which one
! 42: * is received first
! 43: */
! 44: int determine_recv_buf_ordering(struct recvbuf *b1, struct recvbuf *b2);
! 45:
! 46: int determine_recv_buf_ordering(struct recvbuf *b1, struct recvbuf *b2)
! 47: {
! 48: double recv_time1, recv_time2;
! 49:
! 50: /* Simply convert the time received to double and subtract */
! 51: LFPTOD(&b1->recv_time, recv_time1);
! 52: LFPTOD(&b2->recv_time, recv_time2);
! 53: return ((int)(recv_time1 - recv_time2));
! 54: }
! 55:
! 56: /* Define a function to create the server associations */
! 57: void create_server_associations()
! 58: {
! 59: int i;
! 60: for (i = 0;i < simulation.num_of_servers;++i) {
! 61: printf("%s\n", stoa(simulation.servers[i].addr));
! 62: if (peer_config(simulation.servers[i].addr,
! 63: ANY_INTERFACE_CHOOSE(simulation.servers[i].addr),
! 64: MODE_CLIENT,
! 65: NTP_VERSION,
! 66: NTP_MINDPOLL,
! 67: NTP_MAXDPOLL,
! 68: 0, /* peerflags */
! 69: 0, /* ttl */
! 70: 0, /* peerkey */
! 71: (u_char *)"*" /* peerkeystr */) == 0) {
! 72: fprintf(stderr, "ERROR!! Could not create association for: %s",
! 73: stoa(simulation.servers[i].addr));
! 74: }
! 75: }
! 76: }
! 77:
! 78:
! 79: /* Main Simulator Code */
! 80:
! 81: int ntpsim(int argc, char *argv[])
! 82: {
! 83: Event *curr_event;
! 84: struct timeval seed;
! 85:
! 86: /* Initialize the local Clock
! 87: */
! 88: simclock.local_time = 0;
! 89: simclock.adj = 0;
! 90: simclock.slew = 0;
! 91:
! 92: /* Initialize the simulation
! 93: */
! 94: simulation.num_of_servers = 0;
! 95: simulation.beep_delay = BEEP_DLY;
! 96: simulation.sim_time = 0;
! 97: simulation.end_time = SIM_TIME;
! 98:
! 99: /*
! 100: * Initialize ntp variables
! 101: */
! 102: initializing = 1;
! 103: init_auth();
! 104: init_util();
! 105: init_restrict();
! 106: init_mon();
! 107: init_timer();
! 108: init_lib();
! 109: init_request();
! 110: init_control();
! 111: init_peer();
! 112: init_proto();
! 113: init_io();
! 114: init_loopfilter();
! 115: mon_start(MON_OFF);
! 116:
! 117: /* Call getconfig to parse the configuration file */
! 118: getconfig(argc, argv);
! 119: initializing = 0;
! 120: loop_config(LOOP_DRIFTCOMP, old_drift / 1e6);
! 121:
! 122: /*
! 123: * Watch out here, we want the real time, not the silly stuff.
! 124: */
! 125: gettimeofday(&seed, NULL);
! 126: ntp_srandom(seed.tv_usec);
! 127:
! 128:
! 129: /* Initialize the event queue */
! 130: event_queue = create_priority_queue((int(*)(void *, void*))
! 131: determine_event_ordering);
! 132:
! 133: /* Initialize the receive queue */
! 134: recv_queue = create_priority_queue((int(*)(void *, void*))
! 135: determine_recv_buf_ordering);
! 136:
! 137: /* Push a beep and a timer on the event queue */
! 138: enqueue(event_queue, event(0, BEEP));
! 139: enqueue(event_queue, event(simulation.sim_time + 1.0, TIMER));
! 140: /*
! 141: * Pop the queue until nothing is left or time is exceeded
! 142: */
! 143: /* maxtime = simulation.sim_time + simulation.end_time;*/
! 144: while (simulation.sim_time <= simulation.end_time &&
! 145: (!empty(event_queue))) {
! 146: curr_event = dequeue(event_queue);
! 147: /* Update all the clocks to the time on the event */
! 148: sim_update_clocks(curr_event);
! 149:
! 150: /* Execute the function associated with the event */
! 151: event_ptr[curr_event->function](curr_event);
! 152: free_node(curr_event);
! 153: }
! 154: return (0);
! 155: }
! 156:
! 157:
! 158:
! 159: /* Define a function to create an return an Event */
! 160:
! 161: Event *event(double t, funcTkn f)
! 162: {
! 163: Event *e;
! 164:
! 165: if ((e = get_node(sizeof(*e))) == NULL)
! 166: abortsim("get_node failed in event");
! 167: e->time = t;
! 168: e->function = f;
! 169: return (e);
! 170: }
! 171:
! 172: /* NTP SIMULATION FUNCTIONS */
! 173:
! 174: /* Define a function for processing a timer interrupt.
! 175: * On every timer interrupt, call the NTP timer to send packets and process
! 176: * the clock and then call the receive function to receive packets.
! 177: */
! 178: void sim_event_timer(Event *e)
! 179: {
! 180: struct recvbuf *rbuf;
! 181:
! 182: /* Call the NTP timer.
! 183: * This will be responsible for actually "sending the packets."
! 184: * Since this is a simulation, the packets sent over the network
! 185: * will be processed by the simulate_server routine below.
! 186: */
! 187: timer();
! 188:
! 189: /* Process received buffers */
! 190: while (!empty(recv_queue)) {
! 191: rbuf = (struct recvbuf *)dequeue(recv_queue);
! 192: (rbuf->receiver)(rbuf);
! 193: free_node(rbuf);
! 194: }
! 195:
! 196: /* Arm the next timer interrupt. */
! 197: enqueue(event_queue,
! 198: event(simulation.sim_time + (1 << EVENT_TIMEOUT), TIMER));
! 199: }
! 200:
! 201:
! 202:
! 203: /* Define a function to simulate a server.
! 204: * This function processes the sent packet according to the server script,
! 205: * creates a reply packet and pushes the reply packet onto the event queue
! 206: */
! 207: int simulate_server(
! 208: sockaddr_u *serv_addr, /* Address of the server */
! 209: struct interface *inter, /* Interface on which the reply should
! 210: be inserted */
! 211: struct pkt *rpkt /* Packet sent to the server that
! 212: needs to be processed. */
! 213: )
! 214: {
! 215: struct pkt xpkt; /* Packet to be transmitted back
! 216: to the client */
! 217: struct recvbuf rbuf; /* Buffer for the received packet */
! 218: Event *e; /* Packet receive event */
! 219: server_info *server; /* Pointer to the server being simulated */
! 220: script_info *curr_script; /* Current script being processed */
! 221: int i;
! 222: double d1, d2, d3; /* Delays while the packet is enroute */
! 223: double t1, t2, t3, t4; /* The four timestamps in the packet */
! 224:
! 225: memset(&xpkt, 0, sizeof(xpkt));
! 226: memset(&rbuf, 0, sizeof(rbuf));
! 227:
! 228: /* Search for the server with the desired address */
! 229: server = NULL;
! 230: for (i = 0; i < simulation.num_of_servers; ++i) {
! 231: fprintf(stderr,"Checking address: %s\n", stoa(simulation.servers[i].addr));
! 232: if (memcmp(simulation.servers[i].addr, serv_addr,
! 233: sizeof(*serv_addr)) == 0) {
! 234: server = &simulation.servers[i];
! 235: break;
! 236: }
! 237: }
! 238:
! 239: fprintf(stderr, "Received packet for: %s\n", stoa(serv_addr));
! 240: if (server == NULL)
! 241: abortsim("Server with specified address not found!!!");
! 242:
! 243: /* Get the current script for the server */
! 244: curr_script = server->curr_script;
! 245:
! 246: /* Create a server reply packet.
! 247: * Masquerade the reply as a stratum-1 server with a GPS clock
! 248: */
! 249: xpkt.li_vn_mode = PKT_LI_VN_MODE(LEAP_NOWARNING, NTP_VERSION,
! 250: MODE_SERVER);
! 251: xpkt.stratum = STRATUM_TO_PKT(((u_char)1));
! 252: memcpy(&xpkt.refid, "GPS", 4);
! 253: xpkt.ppoll = rpkt->ppoll;
! 254: xpkt.precision = rpkt->precision;
! 255: xpkt.rootdelay = 0;
! 256: xpkt.rootdisp = 0;
! 257:
! 258: /* TIMESTAMP CALCULATIONS
! 259: t1 t4
! 260: \ /
! 261: d1 \ / d3
! 262: \ /
! 263: t2 ----------------- t3
! 264: d2
! 265: */
! 266: /* Compute the delays */
! 267: d1 = poisson(curr_script->prop_delay, curr_script->jitter);
! 268: d2 = poisson(curr_script->proc_delay, 0);
! 269: d3 = poisson(curr_script->prop_delay, curr_script->jitter);
! 270:
! 271: /* Note: In the transmitted packet:
! 272: * 1. t1 and t4 are times in the client according to the local clock.
! 273: * 2. t2 and t3 are server times according to the simulated server.
! 274: * Compute t1, t2, t3 and t4
! 275: * Note: This function is called at time t1.
! 276: */
! 277:
! 278: LFPTOD(&rpkt->xmt, t1);
! 279: t2 = server->server_time + d1;
! 280: t3 = server->server_time + d1 + d2;
! 281: t4 = t1 + d1 + d2 + d3;
! 282:
! 283: /* Save the timestamps */
! 284: xpkt.org = rpkt->xmt;
! 285: DTOLFP(t2, &xpkt.rec);
! 286: DTOLFP(t3, &xpkt.xmt);
! 287: xpkt.reftime = xpkt.xmt;
! 288:
! 289:
! 290:
! 291: /* Ok, we are done with the packet. Now initialize the receive buffer for
! 292: * the packet.
! 293: */
! 294: rbuf.receiver = receive; /* Function to call to process the packet */
! 295: rbuf.recv_length = LEN_PKT_NOMAC;
! 296: rbuf.recv_pkt = xpkt;
! 297: rbuf.used = 1;
! 298:
! 299: memcpy(&rbuf.srcadr, serv_addr, sizeof(rbuf.srcadr));
! 300: memcpy(&rbuf.recv_srcadr, serv_addr, sizeof(rbuf.recv_srcadr));
! 301: if ((rbuf.dstadr = malloc(sizeof(*rbuf.dstadr))) == NULL)
! 302: abortsim("malloc failed in simulate_server");
! 303: memcpy(rbuf.dstadr, inter, sizeof(*rbuf.dstadr));
! 304: /* rbuf.link = NULL; */
! 305:
! 306: /* Create a packet event and insert it onto the event_queue at the
! 307: * arrival time (t4) of the packet at the client
! 308: */
! 309: e = event(t4, PACKET);
! 310: e->rcv_buf = rbuf;
! 311: enqueue(event_queue, e);
! 312:
! 313:
! 314: /* Check if the time of the script has expired. If yes, delete the script.
! 315: * If not, re-enqueue the script onto the server script queue
! 316: */
! 317: if (curr_script->duration > simulation.sim_time &&
! 318: !empty(server->script)) {
! 319: printf("Hello\n");
! 320: /*
! 321: * For some reason freeing up the curr_script memory kills the
! 322: * simulation. Further debugging is needed to determine why.
! 323: * free_node(curr_script);
! 324: */
! 325: curr_script = dequeue(server->script);
! 326: }
! 327:
! 328: return (0);
! 329: }
! 330:
! 331:
! 332: /* Define a function to update all the clocks
! 333: * Most of the code is modified from the systime.c file by Prof. Mills
! 334: */
! 335:
! 336: void sim_update_clocks (Event *e)
! 337: {
! 338: double time_gap;
! 339: double adj;
! 340: int i;
! 341:
! 342: /* Compute the time between the last update event and this update */
! 343: time_gap = e->time - simulation.sim_time;
! 344:
! 345: /* Advance the client clock */
! 346: simclock.local_time = e->time + time_gap;
! 347:
! 348: /* Advance the simulation time */
! 349: simulation.sim_time = e->time;
! 350:
! 351: /* Advance the server clocks adjusted for systematic and random frequency
! 352: * errors. The random error is a random walk computed as the
! 353: * integral of samples from a Gaussian distribution.
! 354: */
! 355: for (i = 0;i < simulation.num_of_servers; ++i) {
! 356: simulation.servers[i].curr_script->freq_offset +=
! 357: gauss(0, time_gap * simulation.servers[i].curr_script->wander);
! 358:
! 359: simulation.servers[i].server_time += time_gap *
! 360: (1 + simulation.servers[i].curr_script->freq_offset);
! 361: }
! 362:
! 363:
! 364: /* Perform the adjtime() function. If the adjustment completed
! 365: * in the previous interval, amortize the entire amount; if not,
! 366: * carry the leftover to the next interval.
! 367: */
! 368:
! 369: adj = time_gap * simclock.slew;
! 370: if (adj < fabs(simclock.adj)) {
! 371: if (simclock.adj < 0) {
! 372: simclock.adj += adj;
! 373: simclock.local_time -= adj;
! 374: }
! 375: else {
! 376: simclock.adj -= adj;
! 377: simclock.local_time += adj;
! 378: }
! 379: }
! 380: else {
! 381: simclock.local_time += simclock.adj;
! 382: simclock.adj = 0;
! 383: }
! 384: }
! 385:
! 386:
! 387: /* Define a function that processes a receive packet event.
! 388: * This function simply inserts the packet received onto the receive queue
! 389: */
! 390:
! 391: void sim_event_recv_packet(Event *e)
! 392: {
! 393: struct recvbuf *rbuf;
! 394:
! 395: /* Allocate a receive buffer and copy the packet to it */
! 396: if ((rbuf = get_node(sizeof(*rbuf))) == NULL)
! 397: abortsim("get_node failed in sim_event_recv_packet");
! 398: memcpy(rbuf, &e->rcv_buf, sizeof(*rbuf));
! 399:
! 400: /* Store the local time in the received packet */
! 401: DTOLFP(simclock.local_time, &rbuf->recv_time);
! 402:
! 403: /* Insert the packet received onto the receive queue */
! 404: enqueue(recv_queue, rbuf);
! 405: }
! 406:
! 407:
! 408:
! 409: /* Define a function to output simulation statistics on a beep event
! 410: */
! 411:
! 412: /*** TODO: Need to decide on how to output for multiple servers ***/
! 413: void sim_event_beep(Event *e)
! 414: {
! 415: #if 0
! 416: static int first_time = 1;
! 417: char *dash = "-----------------";
! 418: #endif
! 419:
! 420: fprintf(stderr, "BEEP!!!\n");
! 421: enqueue(event_queue, event(e->time + simulation.beep_delay, BEEP));
! 422: #if 0
! 423: if(simulation.beep_delay > 0) {
! 424: if (first_time) {
! 425: printf("\t%4c T %4c\t%4c T+ERR %3c\t%5cT+ERR+NTP\n",
! 426: ' ', ' ', ' ', ' ',' ');
! 427: printf("\t%s\t%s\t%s\n", dash, dash, dash);
! 428: first_time = 0;
! 429:
! 430: printf("\t%16.6f\t%16.6f\t%16.6f\n",
! 431: n->time, n->clk_time, n->ntp_time);
! 432: return;
! 433: }
! 434: printf("\t%16.6f\t%16.6f\t%16.6f\n",
! 435: simclock.local_time,
! 436: n->time, n->clk_time, n->ntp_time);
! 437: #endif
! 438:
! 439: }
! 440:
! 441:
! 442: /* Define a function to abort the simulation on an error and spit out an
! 443: * error message
! 444: */
! 445:
! 446: void abortsim(char *errmsg)
! 447: {
! 448: perror(errmsg);
! 449: exit(1);
! 450: }
! 451:
! 452:
! 453:
! 454: /* CODE ORIGINALLY IN libntp/systime.c
! 455: * -----------------------------------
! 456: * This code was a part of the original NTP simulator and originally
! 457: * had its home in the libntp/systime.c file.
! 458: *
! 459: * It has been shamelessly moved to here and has been modified for the
! 460: * purposes of the current simulator.
! 461: */
! 462:
! 463:
! 464: /*
! 465: * get_systime - return the system time in NTP timestamp format
! 466: */
! 467: void
! 468: get_systime(
! 469: l_fp *now /* current system time in l_fp */ )
! 470: {
! 471: /*
! 472: * To fool the code that determines the local clock precision,
! 473: * we advance the clock a minimum of 200 nanoseconds on every
! 474: * clock read. This is appropriate for a typical modern machine
! 475: * with nanosecond clocks. Note we make no attempt here to
! 476: * simulate reading error, since the error is so small. This may
! 477: * change when the need comes to implement picosecond clocks.
! 478: */
! 479: if (simclock.local_time == simclock.last_read_time)
! 480: simclock.local_time += 200e-9;
! 481:
! 482: simclock.last_read_time = simclock.local_time;
! 483: DTOLFP(simclock.local_time, now);
! 484: /* OLD Code
! 485: if (ntp_node.ntp_time == ntp_node.last_time)
! 486: ntp_node.ntp_time += 200e-9;
! 487: ntp_node.last_time = ntp_node.ntp_time;
! 488: DTOLFP(ntp_node.ntp_time, now);
! 489: */
! 490: }
! 491:
! 492:
! 493: /*
! 494: * adj_systime - advance or retard the system clock exactly like the
! 495: * real thng.
! 496: */
! 497: int /* always succeeds */
! 498: adj_systime(
! 499: double now /* time adjustment (s) */
! 500: )
! 501: {
! 502: struct timeval adjtv; /* new adjustment */
! 503: double dtemp;
! 504: long ticks;
! 505: int isneg = 0;
! 506:
! 507: /*
! 508: * Most Unix adjtime() implementations adjust the system clock
! 509: * in microsecond quanta, but some adjust in 10-ms quanta. We
! 510: * carefully round the adjustment to the nearest quantum, then
! 511: * adjust in quanta and keep the residue for later.
! 512: */
! 513: dtemp = now + sys_residual;
! 514: if (dtemp < 0) {
! 515: isneg = 1;
! 516: dtemp = -dtemp;
! 517: }
! 518: adjtv.tv_sec = (long)dtemp;
! 519: dtemp -= adjtv.tv_sec;
! 520: ticks = (long)(dtemp / sys_tick + .5);
! 521: adjtv.tv_usec = (long)(ticks * sys_tick * 1e6);
! 522: dtemp -= adjtv.tv_usec / 1e6;
! 523: sys_residual = dtemp;
! 524:
! 525: /*
! 526: * Convert to signed seconds and microseconds for the Unix
! 527: * adjtime() system call. Note we purposely lose the adjtime()
! 528: * leftover.
! 529: */
! 530: if (isneg) {
! 531: adjtv.tv_sec = -adjtv.tv_sec;
! 532: adjtv.tv_usec = -adjtv.tv_usec;
! 533: sys_residual = -sys_residual;
! 534: }
! 535: simclock.adj = now;
! 536: /* ntp_node.adj = now; */
! 537: return (1);
! 538: }
! 539:
! 540:
! 541: /*
! 542: * step_systime - step the system clock. We are religious here.
! 543: */
! 544: int /* always succeeds */
! 545: step_systime(
! 546: double now /* step adjustment (s) */
! 547: )
! 548: {
! 549: #ifdef DEBUG
! 550: if (debug)
! 551: printf("step_systime: time %.6f adj %.6f\n",
! 552: simclock.local_time, now);
! 553: #endif
! 554: simclock.local_time += now;
! 555: return (1);
! 556: }
! 557:
! 558: /*
! 559: * gauss() - returns samples from a gaussion distribution
! 560: */
! 561: double /* Gaussian sample */
! 562: gauss(
! 563: double m, /* sample mean */
! 564: double s /* sample standard deviation (sigma) */
! 565: )
! 566: {
! 567: double q1, q2;
! 568:
! 569: /*
! 570: * Roll a sample from a Gaussian distribution with mean m and
! 571: * standard deviation s. For m = 0, s = 1, mean(y) = 0,
! 572: * std(y) = 1.
! 573: */
! 574: if (s == 0)
! 575: return (m);
! 576: while ((q1 = drand48()) == 0);
! 577: q2 = drand48();
! 578: return (m + s * sqrt(-2. * log(q1)) * cos(2. * PI * q2));
! 579: }
! 580:
! 581:
! 582: /*
! 583: * poisson() - returns samples from a network delay distribution
! 584: */
! 585: double /* delay sample (s) */
! 586: poisson(
! 587: double m, /* fixed propagation delay (s) */
! 588: double s /* exponential parameter (mu) */
! 589: )
! 590: {
! 591: double q1;
! 592:
! 593: /*
! 594: * Roll a sample from a composite distribution with propagation
! 595: * delay m and exponential distribution time with parameter s.
! 596: * For m = 0, s = 1, mean(y) = std(y) = 1.
! 597: */
! 598: if (s == 0)
! 599: return (m);
! 600: while ((q1 = drand48()) == 0);
! 601: return (m - s * log(q1 * s));
! 602: }
! 603:
! 604: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntpsim.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd