{

LARGE_INTEGER count, freq;

QueryPerformanceCounter(&count);

QueryPerformanceFrequency(&freq);

return (double)count.QuadPart / (double)freq.QuadPart;

{

struct timeval tv;

gettimeofday(&tv,NULL);

return tv_to_double(&tv);

: FXMainWindow(app, "PlayCap", NULL/*icon*/, NULL/*icon*/, DECOR_CLOSE|DECOR_MINIMIZE|DECOR_MAXIMIZE|DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, 200,200,250,0 )

{

/* Initialize class members */

next_packet_data = NULL;

next_packet_header = (struct pcap_pkthdr*) calloc(1,sizeof(struct pcap_pkthdr));

pcap_file = NULL;

live_capture = NULL;

this->filename = filename;

state = STOPPED;

loop_playback = false;

send_handle = -1;

pcap_if = "";

total_packets = 0;

packets_processed = 0;

initialized = false;

#ifdef WIN32

timeBeginPeriod(1);

#endif

/* Window Icons, large and small */

mainWindowIcon = new FXICOIcon(getApp(), Signal11, FXRGB(192,192,192),0,16,16);

setIcon(mainWindowIcon);

mainWindowMiniIcon = new FXICOIcon(getApp(), Signal11small, FXRGB(192,192,192),0,16,16);

setMiniIcon(mainWindowMiniIcon);

/* Create Icons */

startIcon = new FXPNGIcon(getApp(), mediaplaybackstart);

startIcon->blend(getBackColor());

stopIcon = new FXPNGIcon(getApp(), mediaplaybackstop);

stopIcon->blend(getBackColor());

pauseIcon= new FXPNGIcon(getApp(), mediaplaybackpause);

pauseIcon->blend(getBackColor());

rewindIcon= new FXPNGIcon(getApp(), mediaskipbackward);

rewindIcon->blend(getBackColor());

loopIcon = new FXPNGIcon(getApp(), viewrefresh);

loopIcon->blend(getBackColor());

/* Create Controls */

FXVerticalFrame *topVF = new FXVerticalFrame(this, LAYOUT_FILL_X, 0,0,0,0, 0,0,0,0, 0,0);

/* Create Menu */

menubar = new FXMenuBar(topVF, LAYOUT_SIDE_TOP|LAYOUT_FILL_X);

filemenu = new FXMenuPane(this);

new FXMenuTitle(menubar, "&File", NULL, filemenu);

new FXMenuCommand(filemenu, "&Open...\tCtrl-O\tOpen Existing File", NULL, this, ID_OPEN);

new FXMenuSeparator(filemenu);

new FXMenuCommand(filemenu, "E&xit\tCtrl-X", NULL, getApp(), FXApp::ID_QUIT);

FXMenuPane *helpmenu = new FXMenuPane(this);

new FXMenuTitle(menubar, "&Help", NULL, helpmenu);

new FXMenuCommand(helpmenu, "&About...", NULL, this, ID_ABOUT);

new FXSeparator(topVF);

FXVerticalFrame *vf = new FXVerticalFrame(topVF, LAYOUT_FILL_X);

/* Buttons */

FXHorizontalFrame *hf = new FXHorizontalFrame(vf, 0x0, 0,0,0,0, 0,0,0,0);

startButton = new FXButton(hf, "\tPlay", startIcon, this, ID_START_BUTTON);

stopButton = new FXButton(hf, "\tStop", stopIcon, this, ID_STOP_BUTTON);

pauseButton = new FXButton(hf, "\tPause", pauseIcon, this, ID_PAUSE_BUTTON);

//rewindButton= new FXButton(hf, "\tRewind", rewindIcon, this, ID_PAUSE_BUTTON);

loopButton = new FXToggleButton(hf, "\tLoop", "\tLoop", loopIcon, loopIcon, this, ID_LOOP_BUTTON, TOGGLEBUTTON_NORMAL|TOGGLEBUTTON_KEEPSTATE);

startButton->disable();

stopButton->disable();

pauseButton->disable();

/* Progress Bar */

progress = new FXProgressBar(new FXHorizontalFrame(vf, LAYOUT_FILL_X|FRAME_SUNKEN,0,0,0,0,0,0,0,0), this, ID_START_BUTTON, LAYOUT_FILL_X);

progress->setProgress(0);

/* Packets processed Label */

processedLabel = new FXLabel(vf, "");

/* Elapsed Time */

hf = new FXHorizontalFrame(vf, 0x0, 0,0,0,0, 0,0,0,0);

elapsedTimeLabel = new FXLabel(hf,secToString(0.0));

slashLabel = new FXLabel(hf, "/");

totalTimeLabel = new FXLabel(hf, secToString(0.0));

/* Close button with icon */

if (!PlaybackWindow::closeIcon) {

PlaybackWindow::closeIcon = new FXPNGIcon(getApp(), crossorig);

PlaybackWindow::closeIcon->blend(getBackColor());

}

new FXButton(vf, "Close", closeIcon, this, ID_CLOSE, BUTTON_NORMAL|LAYOUT_RIGHT);

// Set the packets processed readout.

setPlaybackPacketsProcessed(0);

pcap_file = NULL;

{

char time_string[64];

int minutes = sec / 60;

double seconds = fmod(sec,60);

sprintf(time_string, "%d:%06.3f", minutes, seconds);

return time_string;

{

FXString s;

s.format("Processed %u of %u", packets_processed, total_packets);

processedLabel->setText(s);

{

int ret;

ret = pcap_sendpacket(live_capture, data, hdr.caplen);

if (ret < 0) {

FXMessageBox::information( this, MBOX_OK, "Network Error", "Unable to send data on the network.\n");

onStop(NULL,0,NULL);

return false;

}

return true;

{

/* Return immediately if we're paused (or stopped, but that

shouldn't happen as this function isn't called from STOP). */

if (state != PLAYING)

return true;

bool ready_to_send = false;

do {

ready_to_send = false;

// See if it's ready to send

if (!next_packet_data) {

// Get the next packet

next_packet_data = (const char*)

pcap_next(pcap_file, next_packet_header);

// next_packet_data now contains the next packet to

// send, or it's NULL, meaning end of capture.

}

if (next_packet_data) {

// See if it's time to send this packet.

double pkt_time =

tv_to_double(&next_packet_header->ts)

- capture_start_time;

double playback_time =

get_time() - playback_start_time;

if (playback_time > pkt_time)

ready_to_send = true;

// Update the time readout

elapsed_time = playback_time;

}

else {

// next_packet_data was NULL, so We're done,

// don't get called again.

return false;

}

if (ready_to_send) {

// Update the progress status.

packets_processed++;

// Send the packet.

sendPacket((const u_char*)next_packet_data, *next_packet_header);

// Set the next packet to NULL, so that a new one

// will be grabbed from the file on the next iteration.

next_packet_data = NULL;

}

} while (ready_to_send);

/* Call this function again */

return true;

{

bool keep_going = true;

while (run_thread && keep_going) {

keep_going = pollASyncPlayback();

// Sleep for 1 millisecond.

#define SLEEP_MILLIS 1

#ifdef WIN32

Sleep(SLEEP_MILLIS);

#else

usleep(SLEEP_MILLIS*1000);

#endif

}

printf("Exiting playback thread.\n");

run_thread = false;

{

/* Update the progress indicator */

progress->setProgress(packets_processed);

/* Update the playback time indicator */

setPlaybackElapsedTime(elapsed_time);

/* Update the packets processed label */

setPlaybackPacketsProcessed(packets_processed);

/* Call us again if we're still running, otherwise

* get into the STOP state. */

if (run_thread) {

// FOX 1.7 changes the timeouts to all be nanoseconds.

// Fox 1.6 had all timeouts as milliseconds.

int timeout_scalar = 1;

#if (FOX_MINOR >= 7)

timeout_scalar = 1000*1000;

#endif

getApp()->addTimeout(this, ID_CAPTURE_TIMEOUT,

5 * timeout_scalar /*5ms*/);

}

else {

if (loop_playback) {

onStop(NULL,0,NULL);

onStart(NULL, sel, NULL);

}

else {

/* Thread is not running because the playback has finised.

onStop() will reset the player. */

onStop(NULL,0,NULL);

}

}

return 1;

{

// If we're PAUSED, then just set the state back to playing.

// There's no need to re-open the socket or anything.

if (state == PAUSED) {

state = PLAYING;

startButton->disable();

stopButton->enable();

pauseButton->enable();

//rewindButton->disable();

// Fake the playback_start_time, so that the time-based

// asynchronous playback will pick up where it left off.

playback_start_time += get_time() - pause_time;

return 1;

}

/* Starting the capture from the beginning. */

progress->setProgress(0);

pcap_if_t *devs = NULL;

char errbuf[PCAP_ERRBUF_SIZE];

// Open the capture file.

pcap_file = pcap_open_offline(filename.text(), errbuf);

if (!pcap_file) {

FXMessageBox::information( this, MBOX_OK, "File Open Error", "Can't open original file %s for reading.\n", filename.text() );

// Set the GUI and app state to

// the STOPPED state.

state = STOPPED;

progress->setProgress(0);

startButton->enable();

stopButton->disable();

pauseButton->disable();

return 1;

}

// Prompt for the interface if one isn't set, or if called from the Play button click.

if (FXSELID(sel) == ID_START_BUTTON || pcap_if.length() == 0) {

// Popup window with list of interfaces in it.

pcap_findalldevs(&devs, errbuf);

if (devs) {

// Show the interface Window.

FXDialogBox *dlg = new FXDialogBox(this, "Select a device", DECOR_CLOSE|DECOR_TITLE|DECOR_BORDER);

InterfaceWindow *ifwin = new InterfaceWindow(dlg, devs, "Select Playback Device", "Playback");

FXuint res = dlg->execute();

if (res) {

// User selected an interface. Start capturing.

pcap_if = ifwin->getSelectedInterface()->name;

cout << "User selected " << pcap_if << endl;

}

else {

// User pushed cancel from the interface window.

pcap_if = "";

}

delete dlg;

}

else {

// report error.

cout << "Error finding devices " << errbuf << endl;

#ifdef WIN32

const char *privs = "Administrator";

#else

const char *privs = "root user";

#endif

FXString s;

s.format("There was an error trying to open the network device.\nThis most likely means that you do not have permission to open raw sockets.\nEnsure that you have %s privileges and try again.\n\nError: %s", privs, errbuf);

FXMessageBox::error(this, MBOX_OK, "Capture Error", "%s", s.text());

}

pcap_freealldevs(devs);

}

// Begin playback if an interface was selected.

if (pcap_if.length() > 0) {

live_capture = pcap_open_live(pcap_if.c_str(), 9999, 1/*promisc*/, 5/*read_timeout*/, errbuf);

if (live_capture) {

int res = pcap_setnonblock(live_capture, 1, errbuf);

if (res >= 0) {

}

else

cout << "Error setting nonblock: " << errbuf << endl;

#ifndef WIN32

send_handle = pcap_get_selectable_fd(live_capture);

#else

send_handle = 0;

#endif

if (send_handle >= 0) {

// Set the GUI and app state to

// the PLAYING state.

state = PLAYING;

startButton->disable();

stopButton->enable();

pauseButton->enable();

//rewindButton->disable();

playback_start_time = get_time();

// Start the playback thread.

run_thread = true;

packets_processed = 0;

elapsed_time = 0.0;

pthread_create(&thread, NULL, &thread_function, this);

// Start the periodic update timer.

// FOX 1.7 changes the timeouts to all be nanoseconds.

// Fox 1.6 had all timeouts as milliseconds.

int timeout_scalar = 1;

#if (FOX_MINOR >= 7)

timeout_scalar = 1000*1000;

#endif

getApp()->addTimeout(this, ID_CAPTURE_TIMEOUT, 1 * timeout_scalar /*1ms*/);

}

else {

FXMessageBox::information(this, MBOX_OK, "Networking Error", "Unable to get a write handle for the playback.");

}

}

}

return 1;

{

// Reset the state of the GUI

state = STOPPED;

progress->setProgress(0);

startButton->enable();

stopButton->disable();

pauseButton->disable();

//rewindButton->disable();

next_packet_data = NULL;

getApp()->removeTimeout(this, ID_CAPTURE_TIMEOUT);

// Stop the playback thread and wait for it to exit.

run_thread = false;

pthread_join(thread, NULL);

elapsed_time = 0.0;

packets_processed = 0;

setPlaybackPacketsProcessed(0);

setPlaybackElapsedTime(0.0);

// Clean up the libpcap objects.

pcap_close(live_capture);

pcap_close(pcap_file);

send_handle = -1;

cout << "Stopped" << endl;

return 1;

{

state = PAUSED;

startButton->enable();

stopButton->enable();

pauseButton->disable();

//rewindButton->enable();

pause_time = get_time();

return 1;

{

/* What to do here ?? */

return 1;

{

loop_playback = !loop_playback;

return 1;

{

char filename[512];

char file_title[512];

int res;

filename[0] = '\0';

file_title[0] = '\0';

#ifdef WIN32

OPENFILENAME ofn;

memset(&ofn, 0, sizeof(ofn));

ofn.lStructSize = sizeof(OPENFILENAME);

ofn.hwndOwner = (HWND) this->id();

ofn.hInstance = NULL;//GetModuleHandle(NULL);

ofn.lpstrFilter = "All Files\0*.*\0\0";

ofn.lpstrCustomFilter = NULL;

ofn.nMaxCustFilter = 0;

ofn.nFilterIndex = 0;

ofn.lpstrFile = filename;

ofn.nMaxFile = sizeof(filename);

ofn.lpstrFileTitle = file_title;

ofn.nMaxFileTitle = sizeof(file_title);

ofn.lpstrInitialDir = NULL;

ofn.lpstrTitle = NULL;

ofn.Flags = /*OFN_DONTADDTORECENT |*/ OFN_ENABLESIZING | OFN_EXPLORER | OFN_FILEMUSTEXIST;

ofn.nFileOffset = 0;

ofn.nFileExtension = 0;

ofn.lpstrDefExt = 0;

ofn.lCustData = 0;

ofn.lpfnHook = 0;

ofn.lpTemplateName = 0;

//ofn.pvReserved = 0;

//ofn.dwReserved = 0;

//ofn.FlagsEx = 0;

res = GetOpenFileName( &ofn );

unsigned int err = CommDlgExtendedError();

#else

// Use the Fox File open dialog.

FXFileDialog *dlg = new FXFileDialog(this, "Open PCAP File");

dlg->setPatternList("TCPDump Files (*.dump,*.tcpdump,*.pcap,*.pcapng)\nAll Files (*)");

res = dlg->execute();

strncpy(filename, dlg->getFilename().text(), sizeof(filename));

filename[sizeof(filename)-1] = '\0';

#endif

if( res ) {

/* Open the file */

FXApp::instance()->beginWaitCursor();

this->filename = filename;

openFile();

FXApp::instance()->endWaitCursor();

}

return 1;

{

AboutWindow box(this);

box.execute(PLACEMENT_OWNER);

return 1;

{

FXMainWindow::create();

/* Show the window */

show();

/* Open the file, if one was provided */

if (filename != "")

openFile();

{

// If we are playing, stop.

if (state == PLAYING || state == PAUSED)

onStop(NULL,0,NULL);

// Count the total number of packets in the file and find out

// what the total elapsed time of the capture is. The only way to do

// this with libpcap is to call pcap_next() until you get to the

// end.

const u_char *data;

struct pcap_pkthdr header;

char errbuf[PCAP_ERRBUF_SIZE];

// Open the file.

pcap_file = pcap_open_offline(filename.text(), errbuf);

if (!pcap_file) {

FXMessageBox::information( getApp(), MBOX_OK, "File Open Error", "Can't open original file %s for reading.\n", filename.text() );

initialized = false;

return false;

}

else {

total_packets = 0;

memset(&header,0,sizeof(header));

// Look at the first packet and get the start time;

capture_start_time = 0;

if (pcap_next(pcap_file, &header)) {

capture_start_time = tv_to_double(&header.ts);

total_packets++;

}

// Count the packets in the file.

while ((data = pcap_next(pcap_file, &header))) {

total_packets++;

}

// Get the total time based on the _last_

// packet header in the file.

total_time = tv_to_double(&header.ts) - capture_start_time;

setPlaybackTotalTime(total_time);

// Set the total number of packets in the progress bar.

progress->setTotal(total_packets);

// Close the open file.

pcap_close(pcap_file);

pcap_file = NULL;

// Set the state of the buttons.

startButton->enable();

stopButton->disable();

pauseButton->disable();

// Reset the counters.

elapsed_time = 0.0;

packets_processed = 0;

setPlaybackPacketsProcessed(0);

setPlaybackElapsedTime(0.0);

initialized = true;

}

return true;