void MainClientWindow::on_button_send_clicked()
{
IRCData::MessageData *message = new IRCData::MessageData();
message->channelName = GetCurrentChannel()->GetChannelData()->name;
message->content = ui->lineEdit_message->text();
message->username = user->username;
ui->lineEdit_message->setText("");
connection->SendMessage(message);
}
CFrameCursorPos CFrameEditorModel::GetCurrentPos() const {
return {GetCurrentFrame(), GetCurrentChannel()};
}
int _tmain(int argc, _TCHAR* argv[])
{
SetConsoleTitle(_T("WlanHelper for Npcap ") _T(WINPCAP_VER_STRING) _T(" (http://npcap.org)"));
vector<tstring> strArgs;
for (int i = 0; i < argc; i++)
{
strArgs.push_back(argv[i]);
}
if (argc == 1)
{
_tprintf(STR_COMMAND_USAGE);
return -1;
}
else if (argc == 2)
{
if (strArgs[1] ==_T("-h") || strArgs[1] == _T("--help"))
{
_tprintf(STR_COMMAND_USAGE);
return -1;
}
else if (strArgs[1] == _T("-i"))
{
_tprintf(_T("WlanHelper [Interactive Mode]:\n****************************************************\n"));
return MainInteractive();
}
else
{
_tprintf(STR_INVALID_PARAMETER);
return -1;
}
}
else if (argc == 3)
{
if (strArgs[2] == _T("mode"))
{
tstring strMode;
if (GetCurrentOperationMode(getGuidFromAdapterName_Wrapper(strArgs[1]), strMode))
{
_tprintf(_T("%s\n"), strMode.c_str());
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modes"))
{
tstring strModes;
if (GetOperationModeCapability(getGuidFromAdapterName_Wrapper(strArgs[1]), strModes))
{
_tprintf(_T("%s\n"), strModes.c_str());
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modes-monitor"))
{
tstring strModes;
if (IsMonitorModeSupported(getGuidFromAdapterName_Wrapper(strArgs[1])))
{
_tprintf(_T("%d\n"), TRUE);
return 0;
}
else
{
_tprintf(_T("%d\n"), FALSE);
return 0;
}
}
else if (strArgs[2] == _T("channel"))
{
ULONG ulChannel;
if (GetCurrentChannel(getGuidFromAdapterName_Wrapper(strArgs[1]), ulChannel))
{
_tprintf(_T("%u\n"), ulChannel);
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("freq"))
{
ULONG ulFrequency;
if (GetCurrentFrequency(getGuidFromAdapterName_Wrapper(strArgs[1]), ulFrequency))
{
_tprintf(_T("%u\n"), ulFrequency);
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modus"))
{
vector<tstring> nstrPhyTypes;
if (GetSupportedPhyTypes(getGuidFromAdapterName_Wrapper(strArgs[1]), nstrPhyTypes))
{
_tprintf(_T("%s\n"), printArray(nstrPhyTypes).c_str());
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modus2"))
{
vector<tstring> nstrPhyList;
if (GetDesiredPhyList(getGuidFromAdapterName_Wrapper(strArgs[1]), nstrPhyList))
{
_tprintf(_T("%s\n"), printArray(nstrPhyList).c_str());
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modu"))
{
tstring ulPhyID;
if (GetCurrentPhyID(getGuidFromAdapterName_Wrapper(strArgs[1]), ulPhyID))
{
_tprintf(_T("%s\n"), ulPhyID.c_str());
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else
{
_tprintf(STR_INVALID_PARAMETER);
return -1;
}
}
else if (argc == 4)
{
if (strArgs[2] == _T("mode"))
{
if (SetWlanOperationMode(getGuidFromAdapterName_Wrapper(strArgs[1]), strArgs[3]))
{
_tprintf(_T("Success\n"));
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("channel"))
{
int ulChannel = _ttoi(strArgs[3].c_str());
if (SetCurrentChannel(getGuidFromAdapterName_Wrapper(strArgs[1]), ulChannel))
{
_tprintf(_T("Success\n"));
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("freq"))
{
int ulFrequency = _ttoi(strArgs[3].c_str());
if (SetCurrentFrequency(getGuidFromAdapterName_Wrapper(strArgs[1]), ulFrequency))
{
_tprintf(_T("Success\n"));
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else if (strArgs[2] == _T("modu"))
{
if (SetCurrentPhyID(getGuidFromAdapterName_Wrapper(strArgs[1]), strArgs[3]))
{
_tprintf(_T("Success\n"));
return 0;
}
else
{
_tprintf(_T("Failure\n"));
return -1;
}
}
else
{
_tprintf(STR_INVALID_PARAMETER);
return -1;
}
}
else
{
_tprintf(_T("Error: too many parameters.\n"));
return -1;
}
return 0;
}
//main function, here main PCIE thread runs
int main(int argc, char** argv)
{
int DragonDevHandle; //handle for opening PCIE device file
dragon_buffer buf;
size_t buf_count = DRAGON_BUFFER_COUNT;
unsigned char* user_bufs[DRAGON_BUFFER_COUNT];
unsigned long dtStart, dtEnd;
unsigned int i, j, k, m, n;
uint8_t *tmp_buf;
int switcherState = -1;
unsigned long FrameCounter=0; //count input frames; when it reaches FrameCount - new output data is ready
bool Output_ChannelReadSelector=false; //used to switch output buffers (double-buffering)
OUTPUT_BUFFER_TYPE *Output[2]; //double output buffers
OUTPUT_BUFFER_TYPE *Output_Write; //pointers to part of output buffer to be filled in PCIE thread
//start TCPIP server thread
pthread_t SocketThreadHandle;
pthread_create(&SocketThreadHandle, NULL, SocketThread, NULL);
//allocate memory for output buffers, assign pointers to parts of double-buffers
Output[0] = (OUTPUT_BUFFER_TYPE*)malloc(OUTPUT_BUFFER_SIZE_BYTES);
Output[1] = (OUTPUT_BUFFER_TYPE*)malloc(OUTPUT_BUFFER_SIZE_BYTES);
memset(Output[0], 0, OUTPUT_BUFFER_SIZE_BYTES);
memset(Output[1], 0, OUTPUT_BUFFER_SIZE_BYTES);
Output_Read=Output[Output_ChannelReadSelector];
Output_Write=Output[!Output_ChannelReadSelector];
signal(SIGINT, ExitHandler);
//open PCIE device
DragonDevHandle = open(DRAGON_DEV_FILENAME, O_RDWR);
if(DragonDevHandle<0)
{
puts("Failed to open PCIE device!\n");
return -1;
}
ioctl(DragonDevHandle, DRAGON_SET_ACTIVITY, 0);
uint32_t dID=0;
ioctl(DragonDevHandle, DRAGON_GET_ID, &dID);
printf("Dragon ID: %u\n", dID);
dragon_params p;
ioctl(DragonDevHandle, DRAGON_QUERY_PARAMS, &p);
p.adc_type=0; // 0 for 8-bit, 1 for 12-bit
p.board_type=0; // 0 for red KNJN, 1 for new green
p.channel=ActiveChannel;
p.channel_auto=0;
p.frames_per_buffer=(DRAGON_MAX_DATA_IN_BUFFER/FrameLength);
p.frame_length=FrameLength;
p.half_shift=0;
p.switch_period=FrameCount;
p.sync_offset=0;
p.sync_width=127;
p.dac_data=PcieDacData;
ioctl(DragonDevHandle, DRAGON_SET_PARAMS, &p);
printf("frames per buffer: %d\n", p.frames_per_buffer);
if (!ioctl(DragonDevHandle, DRAGON_REQUEST_BUFFERS, &buf_count) )
{
printf("buf_count = %ld\n", buf_count);
}
else
{
printf("DRAGON_REQUEST_BUFFERS error\n");
return -1;
}
ioctl(DragonDevHandle, DRAGON_SET_ACTIVITY, 1);
for (i = 0; i < buf_count; ++i)
{
buf.idx = i;
if (ioctl(DragonDevHandle, DRAGON_QUERY_BUFFER, &buf) )
{
printf("DRAGON_QUERY_BUFFER %d error\n", i);
return -1;
}
user_bufs[i] = (unsigned char*)mmap(NULL, buf.len,
PROT_READ | PROT_WRITE,
MAP_SHARED, DragonDevHandle,
buf.offset);
if (!user_bufs[i])
{
printf("mmap buffer %d error\n", i);
return -1;
}
if (ioctl(DragonDevHandle, DRAGON_QBUF, &buf) )
{
printf("DRAGON_QBUF error\n");
return -1;
}
}
fd_set fds;
FD_ZERO(&fds);
FD_SET(DragonDevHandle, &fds);
dtStart = GetTickCount();
int count = 0;
for (;!ExitFlag;)
{
select(DragonDevHandle + 1, &fds, NULL, NULL, NULL);
//Dequeue buffer
if (ioctl(DragonDevHandle, DRAGON_DQBUF, &buf) )
{
printf("DRAGON_DQBUF error\n");
continue;
}
tmp_buf=user_bufs[buf.idx];
if (switcherState == -1)
{
switcherState = GetSwitcherState(buf, user_bufs);
}
int switcherStateCurrent = GetSwitcherState(buf, user_bufs);
if (switcherState != switcherStateCurrent)
{
std::unique_lock<std::mutex> lock(gWaitMutex);
printf("Polarization collected frame count = %ld\n", FrameCounter);
CollectedFramesCount = FrameCounter;
FrameCounter=0;
switcherState = switcherStateCurrent;
Output_ChannelReadSelector=!Output_ChannelReadSelector;
Output_Read=Output[Output_ChannelReadSelector];
Output_Write=Output[!Output_ChannelReadSelector];
LastOutputDataChannel = GetCurrentChannel(buf, user_bufs);
NewDataReady=true; // indicate TCPIP thread that new data is ready
//clear write-buffer
memset(Output_Write, 0, OUTPUT_BUFFER_SIZE_BYTES);
if ( FrameLength != FrameLengthToSet ||
FrameCount != FrameCountToSet ||
PcieDacData != PcieDacDataToSet ||
ActiveChannel != ActiveChannelToSet
)
{
FrameLength = FrameLengthToSet;
FrameCount = FrameCountToSet;
PcieDacData = PcieDacDataToSet;
ActiveChannel = ActiveChannelToSet;
ioctl(DragonDevHandle, DRAGON_SET_ACTIVITY, 0);
p.frames_per_buffer=(DRAGON_MAX_DATA_IN_BUFFER/FrameLength);
p.frame_length=FrameLength;
p.switch_period=FrameCount;
p.dac_data=PcieDacData;
p.channel=ActiveChannel;
printf("Active Channel: %d\n", ActiveChannel);
ioctl(DragonDevHandle, DRAGON_SET_PARAMS, &p);
ioctl(DragonDevHandle, DRAGON_SET_ACTIVITY, 1);
}
gWaitCondition.notify_one();
}
for(i=0; i<p.frames_per_buffer; i++)
{
m=0;
for(j=0; j<p.frame_length/DRAGON_DATA_PER_PACKET; j++)
{
n=i*(p.frame_length*DRAGON_PACKET_SIZE_BYTES/DRAGON_DATA_PER_PACKET)+j*DRAGON_PACKET_SIZE_BYTES+4;
if(p.adc_type==0) //8-bit
for(k=4; k<DRAGON_PACKET_SIZE_BYTES-4; k++)
Output_Write[m++] += tmp_buf[n++];
else if(p.adc_type==1) //12-bit
{
for(k=4; k<DRAGON_PACKET_SIZE_BYTES-4; k+=8)
{
// aa-ab-bb-cc-cd-dd-ee-e_
Output_Write[m++] += (tmp_buf[n]<<4)|(tmp_buf[n+1]>>4);
Output_Write[m++] += ((15&tmp_buf[n+1])<<8)|tmp_buf[n+2];
Output_Write[m++] += (tmp_buf[n+3]<<4)|(tmp_buf[n+4]>>4);
Output_Write[m++] += ((15&tmp_buf[n+4])<<8)|(tmp_buf[n+5]);
Output_Write[m++] += (tmp_buf[n+6]<<4)|(tmp_buf[n+7]>>4);
n+=8;
}
}
}
}
FrameCounter+=p.frames_per_buffer;
//Queue buffer
if (ioctl(DragonDevHandle, DRAGON_QBUF, &buf) )
{
printf("DRAGON_QBUF error\n");
return -1;
}
++count;
if (count % LOOPS_COUNT == 0)
{
dtEnd = GetTickCount();
double FPS = 1000*LOOPS_COUNT / (double)(dtEnd - dtStart);
count = 0;
dtStart = dtEnd;
printf("FPS = %lf\n", FPS);
}
}
close(DragonDevHandle);
printf("Dragon closed\n");
return 0;
}
