void EnableNetworkManager()
{
try
{
HandleStatus(RunCmdRedirect(START_NETWORK_MANAGER_COMMAND),ERROR_MSG_ENABLING_NETWORK_MANAGER);
HandleStatus(RunCmdRedirect(DISABLE_FIREWALL),ERROR_DISABLING_FW);
}
catch (CException & error)
{
SLogger::getInstance().Log(error.what());
SLogger::getInstance().Log(__PRETTY_FUNCTION__);
throw;
}
}
/* Handle an event, passing it to widgets until they return a status */
void
GUI:: HandleEvent(const SDL_Event *event)
{
int i;
GUI_status status;
switch (event->type) {
/* SDL_QUIT events quit the GUI */
case SDL_QUIT:
status = GUI_QUIT;
break;
/* Keyboard and mouse events go to widgets */
case SDL_KEYDOWN:
case SDL_KEYUP:
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
/* Go through widgets, topmost first */
status = GUI_PASS;
for (i=numwidgets-1; (i>=0)&&(status==GUI_PASS); --i) {
if ( widgets[i]->Status() == WIDGET_VISIBLE ) {
status = widgets[i]->HandleEvent(event);
}
}
break;
/* Ignore unhandled events */
default:
status = GUI_PASS;
break;
}
HandleStatus(status);
}
bool nifpga::Close(uint32_t attribute) {
bool status = false;
if (sessionOpen) {
if (sessionRunning) status = Abort();
status = HandleStatus(NiFpga_Close(sessionHandle,attribute));
if (status) sessionOpen = false;
}
return status;
}
/**
* Calling System to disabled the Network Manager service in order for the emulation
* to determine IP's subnet masks and more.
*
* If the Manager couldn't be stopped an exception will be throw
* and the emulation will be terminated.
*/
void DisableNetworkManager()
{
try
{
HandleStatus(RunCmdRedirect(STOP_NETWORK_MANAGER_COMMAND,false),ERROR_MSG_DISABLING_NETWORK_MANAGER);
HandleStatus(RunCmdRedirect(STOP_IP_FORWARDING),ERROR_MSG_DISABLING_IP_FORWARDING);
HandleStatus(RunCmdRedirect(STOP_ICMP_RESPONSE),ERROR_MSG_DISABLING_ICMP_RESPONSE);
HandleStatus(RunCmdRedirect(ENABLE_FIREWALL),ERROR_FW);
HandleStatus(RunCmdRedirect(STOP_ALL_INCOMING_PACKETS),ERROR_DISABLING_PACKETS_TRAFFIC);
HandleStatus(RunCmdRedirect(STOP_ALL_OUTGOING_PACKETS),ERROR_DISABLING_PACKETS_TRAFFIC);
}
catch (CException & error)
{
SLogger::getInstance().Log(error.what());
SLogger::getInstance().Log(__PRETTY_FUNCTION__);
throw;
}
}
bool nifpga::GetPeerToPeerFifoEndpoint(uint32_t fifo, uint32_t* endpoint) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_GetPeerToPeerFifoEndpoint(sessionHandle, fifo, endpoint));
return false;
}
bool nifpga::AcquireFifoWriteElementsU64(uint32_t fifo, uint64_t** elements, size_t elementsRequested, uint32_t timeout, size_t* elementsAcquired, size_t* elementsRemaining) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_AcquireFifoWriteElementsU64(sessionHandle, fifo, elements, elementsRequested, timeout, elementsAcquired, elementsRemaining));
return false;
}
bool nifpga::ReadFifoU32(uint32_t fifo, uint32_t* data, size_t numberOfElements, uint32_t timeout, size_t* elementsRemaining) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_ReadFifoU32(sessionHandle, fifo, data, numberOfElements, timeout, elementsRemaining));
return false;
}
bool nifpga::ConfigureFifo(uint32_t fifo, size_t requestedDepth, size_t* actualDepth) {
if (sessionOpen) return HandleStatus(NiFpga_ConfigureFifo2(sessionHandle, fifo, requestedDepth, actualDepth));
return false;
}
bool nifpga::AcknowledgeIrqs(uint32_t irqs) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_AcknowledgeIrqs(sessionHandle, irqs));
return false;
}
bool nifpga::Abort() {
bool status = false;
if (sessionOpen && sessionRunning) status = HandleStatus(NiFpga_Abort(sessionHandle));
if (status) sessionRunning = false;
return status;
}
bool nifpga::Run(uint32_t attribute) {
bool status = false;
if (sessionOpen && !sessionRunning) status = HandleStatus(NiFpga_Run(sessionHandle, attribute));
if (status) sessionRunning = true;
return status;
}
bool nifpga::Open(char* bitfile, char* signature, char* resource, uint32_t attribute) {
bool status = false;
if (driverInitialized && !sessionOpen) status = HandleStatus(NiFpga_Open(bitfile, signature, resource, attribute, &sessionHandle));
if (status) sessionOpen = true;
return status;
}
bool nifpga::Finalize() {
bool status = false;
if (driverInitialized) status = HandleStatus(NiFpga_Finalize());
if (status) driverInitialized = false;
return status;
}
bool nifpga::Initialize() {
bool status = false;
if (!driverInitialized) status = HandleStatus(NiFpga_Initialize());
if (status) driverInitialized = true;
return status;
}
bool nifpga::UnreserveIrqContext(NiFpga_IrqContext context) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_UnreserveIrqContext(sessionHandle, context));
return false;
}
bool nifpga::WaitOnIrqs(NiFpga_IrqContext context, uint32_t irqs, uint32_t timeout, uint32_t* irqsAsserted, NiFpga_Bool* timedOut) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_WaitOnIrqs(sessionHandle, context, irqs, timeout, irqsAsserted, timedOut));
return false;
}
bool nifpga::Reset() {
bool status = false;
if (sessionOpen) status = HandleStatus(NiFpga_Reset(sessionHandle));
return status;
}
bool nifpga::ConfigureFifo(uint32_t fifo, size_t depth) {
if (sessionOpen) return HandleStatus(NiFpga_ConfigureFifo(sessionHandle, fifo, depth));
return false;
}
bool nifpga::Download() {
bool status = false;
if (sessionOpen) status = HandleStatus(NiFpga_Download(sessionHandle));
if (status) sessionRunning = false;
return status;
}
bool nifpga::StopFifo(uint32_t fifo) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_StopFifo(sessionHandle, fifo));
return false;
}
bool nifpga::ReadU32(uint32_t indicator, uint32_t* value) {
if (sessionOpen) return HandleStatus(NiFpga_ReadU32(sessionHandle, indicator, value));
return false;
}
bool nifpga::WriteFifoU64(uint32_t fifo, uint64_t* data, size_t numberOfElements, uint32_t timeout, size_t* emptyElementsRemaining) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_WriteFifoU64(sessionHandle, fifo, data, numberOfElements, timeout, emptyElementsRemaining));
return false;
}
bool nifpga::WriteBool(uint32_t control, NiFpga_Bool value) {
if (sessionOpen) return HandleStatus(NiFpga_WriteBool(sessionHandle, control, value));
return false;
}
bool nifpga::ReleaseFifoElements(uint32_t fifo, size_t elements) {
if (sessionOpen && sessionRunning) return HandleStatus(NiFpga_ReleaseFifoElements(sessionHandle, fifo, elements));
return false;
}
bool nifpga::WriteU64(uint32_t control, uint64_t value) {
if (sessionOpen) return HandleStatus(NiFpga_WriteU64(sessionHandle, control, value));
return false;
}
//---------------------------------------------------------------------------
bool TFileZillaIntf::HandleMessage(WPARAM wParam, LPARAM lParam)
{
bool Result;
unsigned int MessageID = FZ_MSG_ID(wParam);
switch (MessageID)
{
case FZ_MSG_STATUS:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_ffam_statusmessage * Status = (t_ffam_statusmessage *)lParam;
ASSERT(Status->post);
Result = HandleStatus(Status->status, Status->type);
delete Status;
}
break;
case FZ_MSG_ASYNCREQUEST:
if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_OVERWRITE)
{
int RequestResult = 0;
wchar_t FileName1[MAX_PATH];
COverwriteRequestData * Data = (COverwriteRequestData *)lParam;
try
{
ASSERT(Data != NULL);
wcsncpy(FileName1, Data->FileName1, _countof(FileName1));
FileName1[_countof(FileName1) - 1] = L'\0';
TRemoteFileTime RemoteTime;
CopyFileTime(RemoteTime, Data->remotetime);
Result = HandleAsynchRequestOverwrite(
FileName1, _countof(FileName1), Data->FileName2, Data->path1, Data->path2,
Data->size1, Data->size2,
(Data->localtime != NULL) ? Data->localtime->GetTime() : 0,
(Data->localtime != NULL) && ((Data->localtime->GetHour() != 0) || (Data->localtime->GetMinute() != 0)),
RemoteTime,
ToPtr(Data->pTransferFile->nUserData),
Data->localFileHandle,
RequestResult);
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(FILEEXISTS_SKIP, Data);
throw;
}
if (Result)
{
Data->FileName1 = FileName1;
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, Data),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_VERIFYCERT)
{
int RequestResult;
CVerifyCertRequestData * AData = (CVerifyCertRequestData *)lParam;
try
{
ASSERT(AData != NULL);
TFtpsCertificateData Data;
CopyContact(Data.Subject, AData->pCertData->subject);
CopyContact(Data.Issuer, AData->pCertData->issuer);
CopyValidityTime(Data.ValidFrom, AData->pCertData->validFrom);
CopyValidityTime(Data.ValidUntil, AData->pCertData->validUntil);
Data.SubjectAltName = AData->pCertData->subjectAltName;
Data.Hash = AData->pCertData->hash;
Data.Certificate = AData->pCertData->certificate;
Data.CertificateLen = AData->pCertData->certificateLen;
Data.VerificationResult = AData->pCertData->verificationResult;
Data.VerificationDepth = AData->pCertData->verificationDepth;
Result = HandleAsynchRequestVerifyCertificate(Data, RequestResult);
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else if (FZ_MSG_PARAM(wParam) == FZ_ASYNCREQUEST_NEEDPASS)
{
int RequestResult = 0;
CNeedPassRequestData * AData = (CNeedPassRequestData *)lParam;
try
{
TNeedPassRequestData Data;
Data.Password = NULL;
Data.Password = AData->Password.GetBuffer(AData->Password.GetLength());
Result = HandleAsynchRequestNeedPass(Data, RequestResult);
AData->Password.ReleaseBuffer(AData->Password.GetLength());
if (Result && (RequestResult == TFileZillaIntf::REPLY_OK))
{
AData->Password = Data.Password;
free(Data.Password);
Data.Password = NULL;
}
}
catch (...)
{
FFileZillaApi->SetAsyncRequestResult(0, AData);
throw;
}
if (Result)
{
Result = Check(FFileZillaApi->SetAsyncRequestResult(RequestResult, AData),
L"setasyncrequestresult");
}
}
else
{
// FZ_ASYNCREQUEST_GSS_AUTHFAILED
// FZ_ASYNCREQUEST_GSS_NEEDUSER
// FZ_ASYNCREQUEST_GSS_NEEDPASS
ASSERT(FALSE);
Result = false;
}
break;
case FZ_MSG_LISTDATA:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_directory * Directory = (t_directory *)lParam;
CString Path = Directory->path.GetPath();
rde::vector<TListDataEntry> Entries(Directory->num);
for (intptr_t Index = 0; Index < Directory->num; ++Index)
{
t_directory::t_direntry & Source = Directory->direntry[Index];
TListDataEntry & Dest = Entries[Index];
Dest.Name = Source.name;
Dest.Permissions = Source.permissionstr;
Dest.HumanPerm = Source.humanpermstr;
Dest.OwnerGroup = Source.ownergroup;
Dest.Size = Source.size;
Dest.Dir = Source.dir;
Dest.Link = Source.bLink;
CopyFileTime(Dest.Time, Source.date);
Dest.LinkTarget = Source.linkTarget;
}
int Num = Directory->num;
TListDataEntry * pEntries = Num > 0 ? &Entries[0] : NULL;
Result = HandleListData(Path, pEntries, Num);
delete Directory;
}
break;
case FZ_MSG_TRANSFERSTATUS:
{
ASSERT(FZ_MSG_PARAM(wParam) == 0);
t_ffam_transferstatus * Status = reinterpret_cast<t_ffam_transferstatus *>(lParam);
if (Status != NULL)
{
Result = HandleTransferStatus(true, Status->transfersize, Status->bytes,
Status->percent, Status->timeelapsed, Status->timeleft,
Status->transferrate, Status->bFileTransfer != 0);
delete Status;
}
else
{
Result = HandleTransferStatus(false, -1, -1, -1, -1, -1, -1, false);
}
}
break;
case FZ_MSG_REPLY:
Result = HandleReply(FZ_MSG_PARAM(wParam), lParam);
break;
case FZ_MSG_CAPABILITIES:
Result = HandleCapabilities((TFTPServerCapabilities *)lParam);
break;
case FZ_MSG_SOCKETSTATUS:
case FZ_MSG_SECURESERVER:
case FZ_MSG_QUITCOMPLETE:
default:
ASSERT(false);
Result = false;
break;
}
return Result;
}
bool nifpga::ReadArrayU64(uint32_t indicator, uint64_t* values, size_t size) {
if (sessionOpen) return HandleStatus(NiFpga_ReadArrayU64(sessionHandle, indicator, values, size));
return false;
}
/* Run the GUI.
This returns when either a widget requests a quit, the idle
function requests a quit, or the SDL window has been closed.
*/
void
GUI:: Run(GUI_IdleProc idle, int once, int multitaskfriendly)
{
int i;
SDL_Event event;
/* If there's nothing to do, return immediately */
if ( (numwidgets == 0) && (idle == NULL) ) {
return;
}
running = 1;
if ( ! once ) {
display = 1;
}
do {
/* Garbage collection */
for ( i=0; i<numwidgets; ++i ) {
if ( widgets[i]->Status() == WIDGET_DELETED ) {
delete widgets[i];
for ( int j=i+1; j<numwidgets; ++j ) {
widgets[j-1] = widgets[j];
}
--numwidgets;
}
}
/* Display widgets if necessary */
if ( display ) {
Display();
display = 0;
}
///////////////////////////////////////////////////////////////// Polling is time consuming - instead:
if (multitaskfriendly && (idle==NULL))
{
SDL_WaitEvent(&event);
HandleEvent(&event);
}
else
/////////////////////////////////////////////////////////////////
/* Handle events, or run idle functions */
if ( SDL_PollEvent(&event) )
{
/* Handle all pending events */
do {
HandleEvent(&event);
} while ( SDL_PollEvent(&event) );
}
else
{
if ( idle != NULL )
{
HandleStatus(idle());
}
for ( i=numwidgets-1; i>=0; --i ) {
HandleStatus(widgets[i]->Idle());
}
}
SDL_Delay(10);
} while ( running && ! once );
}
bool nifpga::WriteArrayU64(uint32_t control, const uint64_t* values, size_t size) {
if (sessionOpen) return HandleStatus(NiFpga_WriteArrayU64(sessionHandle, control, values, size));
return false;
}
