//print welcome message
void Print_Welcome()
{
PrintLine();
strcpy(printTxt, "***********"); PrintLn(printTxt);
strcpy(printTxt, "Welcome "); PrintLn(printTxt);
strcpy(printTxt, version ); PrintLn(printTxt);
strcpy(printTxt, "***********"); PrintLn(printTxt);
}
//print welcome message
void Print_Welcome()
{
PrintLine();
strcpy(printTxt, "************************"); PrintLn(printTxt);
strcpy(printTxt, "* AVR IO CONTROL *"); PrintLn(printTxt);
strcpy(printTxt, "* (C) 2007, OLIMEX Ltd *"); PrintLn(printTxt);
strcpy(printTxt, "************************"); PrintLn(printTxt);
}
int VM::InitArgs(size_t argCount, const wchar_t *args[])
{
// Convert command-line arguments to String*s.
Box<Value*[]> argValues(new(std::nothrow) Value*[argCount]);
if (!argValues)
return OVUM_ERROR_NO_MEMORY;
for (size_t i = 0; i < argCount; i++)
{
String *argString = String_FromWString(mainThread.get(), args[i]);
if (!argString)
return OVUM_ERROR_NO_MEMORY;
Value argValue;
argValue.type = types.String;
argValue.v.string = argString;
StaticRef *ref = gc->AddStaticReference(nullptr, &argValue);
if (!ref)
return OVUM_ERROR_NO_MEMORY;
argValues[i] = ref->GetValuePointer();
if (this->verbose)
{
wprintf(L"Argument %d: ", i);
PrintLn(argValue.v.string);
}
}
this->argValues = std::move(argValues);
RETURN_SUCCESS;
}
//print error message
void PrintError()
{
PrintLine();
strcpy(Txt, "ERROR!");
PrintLn(Txt);
PrintLine();
}
// Called by LogonUI to give you a callback. Providers often use the callback if they
// some event would cause them to need to change the set of tiles that they enumerated.
HRESULT MultiotpProvider::Advise(
_In_ ICredentialProviderEvents * /*pcpe*/,
_In_ UINT_PTR /*upAdviseContext*/)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Advise");
return E_NOTIMPL;
}
//print error message
void Print_Error()
{
unsigned char T1 = 0;
PrintLine();
strcpy(printTxt, "ERROR!");
PrintLn(printTxt);
PrintLine();
}
REGISTER()
{
GuiApplication::class_registration(_class);
register_cycle(_class, [](GuiApplication & app, bool idle)
{
PrintLn(class_String, " Cycling!", null);
return true;
});
}
MultiotpProvider::MultiotpProvider():
_cRef(1),
// _pCredential(nullptr),
// _pkiulSetSerialization(NULL), // Experimental
// _dwCredUIFlags(0), // Experimental
_pCredProviderUserArray(nullptr)
{
DllAddRef();
if (DEVELOP_MODE) PrintLn("========== MultiotpProvider created ==========");
}
void MultiotpProvider::_CreateEnumeratedCredentials()
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::_CreateEnumeratedCredentials: %d", _cpus);
switch (_cpus)
{
case CPUS_LOGON:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::_CreateEnumeratedCredentials CPUS_LOGON");
_EnumerateCredentials();
break;
case CPUS_UNLOCK_WORKSTATION:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::_CreateEnumeratedCredentials CPUS_UNLOCK_WORKSTATION");
_EnumerateCredentials();
break;
default:
break;
}
}
void TestReadStatus()
{
uchar b;
char szBuf[17];
b = ReadStatus();
snprintf(szBuf, sizeof(szBuf), "cur: %x", b);
PrintLn(szBuf);
Sleep(true);
b = ReadStatus();
snprintf(szBuf, sizeof(szBuf), "sleep: %x", b);
PrintLn(szBuf);
Sleep(false);
b = ReadStatus();
snprintf(szBuf, sizeof(szBuf), "wake: %x", b);
PrintLn(szBuf);
}
// This function will be called by LogonUI after SetUsageScenario succeeds.
// Sets the User Array with the list of users to be enumerated on the logon screen.
HRESULT MultiotpProvider::SetUserArray(_In_ ICredentialProviderUserArray *users)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUserArray");
// if (_pCredProviderUserArray)
if (_pCredProviderUserArray != nullptr)
{
_pCredProviderUserArray->Release();
}
_pCredProviderUserArray = users;
_pCredProviderUserArray->AddRef();
return S_OK;
}
//print welcome message
void PrintWelcome()
{
PrintLine();
strcpy(Txt, "*************************"); PrintLn(Txt);
strcpy(Txt, "* Pi4J GPIO Extension *"); PrintLn(Txt);
strcpy(Txt, "* -OLIMEX AVR IO M16- *"); PrintLn(Txt);
strcpy(Txt, "* VERSION 1.0.0 *"); PrintLn(Txt);
strcpy(Txt, "*************************"); PrintLn(Txt);
strcpy(Txt, "* (C) 2012, Pi4J.COM *"); PrintLn(Txt);
strcpy(Txt, "*************************"); PrintLn(Txt);
}
/*****************************************************
**
** MultiLineStaticText --- OnSize
**
******************************************************/
void MultiLineStaticText::OnSize( wxSizeEvent &event )
{
printf( "ON size %d\n", event.GetSize().x );
wxString s = text->GetLabel();
s.Replace( wxT( "\n" ), wxEmptyString );
text->SetLabel( s );
PrintLn( text->GetLabel());
text->SetSize( event.GetSize());
text->Wrap( event.GetSize().x - 12 );
text->Layout();
text->Refresh();
//event.Skip();
}
int main()
{
InitTimer();
InitComm();
PrintLn("hello, world!");
InitOLED();
TestOLED();
return 0;
}
// Returns the credential at the index specified by dwIndex. This function is called by logonUI to enumerate
// the tiles.
HRESULT MultiotpProvider::GetCredentialAt(
DWORD dwIndex,
_Outptr_result_nullonfailure_ ICredentialProviderCredential **ppcpc)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::GetCredentialAt: %d", (int)dwIndex);
HRESULT hr = E_INVALIDARG;
*ppcpc = nullptr;
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Credential.size(%d)", (int)_pCredential.size());
/*
if ((dwIndex == 0) && ppcpc)
{
hr = _pCredential->QueryInterface(IID_PPV_ARGS(ppcpc));
}
*/
if ((dwIndex < _pCredential.size()) && ppcpc)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::QueryInterface");
hr = _pCredential[dwIndex]->QueryInterface(IID_PPV_ARGS(ppcpc));
}
return hr;
}
// Boilerplate code to create our provider.
HRESULT Multiotp_CreateInstance(_In_ REFIID riid, _Outptr_ void **ppv)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Provider_CreateInstance");
HRESULT hr;
MultiotpProvider *pProvider = new(std::nothrow) MultiotpProvider();
if (pProvider)
{
hr = pProvider->QueryInterface(riid, ppv);
pProvider->Release();
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
void TestReadPixel()
{
int i;
CLR clr;
char szBuf[17];
SetPixelBox(6, 6, 9, 9, false);
for (i = 0; i < 16; ++i)
{
clr = ReadPixel();
snprintf(szBuf, sizeof(szBuf), "(%02x, %02x, %02x)",
RFromClr(clr), GFromClr(clr), BFromClr(clr));
Print(szBuf);
if (i % 4 == 3)
PrintLn(0);
}
}
MultiotpProvider::~MultiotpProvider()
{
/*
if (_pCredential != nullptr)
{
_pCredential->Release();
_pCredential = nullptr;
}
*/
_ReleaseEnumeratedCredentials();
if (_pCredProviderUserArray != nullptr)
{
_pCredProviderUserArray->Release();
_pCredProviderUserArray = nullptr;
}
if (DEVELOP_MODE) PrintLn("========== MultiotpProvider destroyed ==========");
DllRelease();
}
void MultiotpProvider::_ReleaseEnumeratedCredentials()
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::_ReleaseEnumeratedCredentials");
/*
if (_pCredential != nullptr)
{
_pCredential->Release();
_pCredential = nullptr;
}
*/
for (DWORD i = 0; i < _pCredential.size(); i++) {
if (_pCredential[i] != nullptr)
{
_pCredential[i]->Release();
_pCredential[i] = nullptr;
}
}
_pCredential.clear();
}
// Boilerplate code to create our provider. ADDED BY TBW FOR FILTER
HRESULT CLMSFilter_CreateInstance(__in REFIID riid, __deref_out void** ppv)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Filter_CreateInstance");
HRESULT hr;
CLMSFilter* pProvider = new CLMSFilter();
//MultiotpProvider* pProvider = new MultiotpProvider();
if (pProvider)
{
hr = pProvider->QueryInterface(riid, ppv);
pProvider->Release();
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
// SetUsageScenario is the provider's cue that it's going to be asked for tiles
// in a subsequent call.
HRESULT MultiotpProvider::SetUsageScenario(
CREDENTIAL_PROVIDER_USAGE_SCENARIO cpus,
DWORD /*dwFlags*/)
{
HRESULT hr;
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Provider Scenario: %d", cpus);
// Decide which scenarios to support here. Returning E_NOTIMPL simply tells the caller
// that we're not designed for that scenario.
switch (cpus)
{
case CPUS_LOGON:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUsageScenario CPUS_LOGON");
// The reason why we need _fRecreateEnumeratedCredentials is because ICredentialProviderSetUserArray::SetUserArray() is called after ICredentialProvider::SetUsageScenario(),
// while we need the ICredentialProviderUserArray during enumeration in ICredentialProvider::GetCredentialCount()
_cpus = cpus;
_fRecreateEnumeratedCredentials = true;
hr = S_OK;
break;
case CPUS_UNLOCK_WORKSTATION:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUsageScenario CPUS_UNLOCK_WORKSTATION");
// The reason why we need _fRecreateEnumeratedCredentials is because ICredentialProviderSetUserArray::SetUserArray() is called after ICredentialProvider::SetUsageScenario(),
// while we need the ICredentialProviderUserArray during enumeration in ICredentialProvider::GetCredentialCount()
_cpus = cpus;
_fRecreateEnumeratedCredentials = true;
hr = S_OK;
break;
case CPUS_CHANGE_PASSWORD:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUsageScenario CPUS_CHANGE_PASSWORD");
hr = E_NOTIMPL;
break;
case CPUS_CREDUI:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUsageScenario CPUS_CREDUI");
hr = E_NOTIMPL;
break;
default:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::SetUsageScenario CPUS_xxx default");
hr = E_INVALIDARG;
break;
}
return hr;
}
HRESULT CLMSFilter::UpdateRemoteCredential(const CREDENTIAL_PROVIDER_CREDENTIAL_SERIALIZATION *pcpcsIn, CREDENTIAL_PROVIDER_CREDENTIAL_SERIALIZATION *pcpcsOut)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::UpdateRemoteCredential");
// Based on https://social.msdn.microsoft.com/Forums/en-US/6e1ac74e-a2d0-427a-88d7-65935b08484e/getting-nla-credentials-in-a-credential-provider?forum=visualstudiogeneral
if (!pcpcsIn) // no point continuing has there are no credentials
return E_NOTIMPL;
pcpcsOut->ulAuthenticationPackage = pcpcsIn->ulAuthenticationPackage;
pcpcsOut->cbSerialization = pcpcsIn->cbSerialization;
pcpcsOut->rgbSerialization = pcpcsIn->rgbSerialization;
pcpcsOut->clsidCredentialProvider = CLSID_Multiotp;
if (pcpcsOut->cbSerialization > 0 && (pcpcsOut->rgbSerialization = (BYTE*)CoTaskMemAlloc(pcpcsIn->cbSerialization)) != NULL) {
CopyMemory(pcpcsOut->rgbSerialization, pcpcsIn->rgbSerialization, pcpcsIn-> cbSerialization);
return S_OK;
} else {
return E_NOTIMPL;
}
}
char * fe_fgets_stdin_fe(char *pr,char *s, int size)
{
if(!fe_is_initialized)
fe_init();
if (fe_stdin_is_tty)
{
int h=fe_hist_pos;
int change=0;
char c;
int i=0;
if (fe_is_raw_tty==0)
{
fe_temp_set();
}
fputs(pr,fe_echo); fflush(fe_echo);
fe_cursor_pos=strlen(pr); /* prompt */
memset(s,0,size);
loop
{
c=fe_getchar();
switch(c)
{
case feCTRL('M'):
case feCTRL('J'):
{
fd_set fdset;
struct timeval tv;
int sel;
fe_add_hist(s);
i=strlen(s);
if (i<size-1) s[i]='\n';
fputc('\n',fe_echo);
fflush(fe_echo);
FD_ZERO (&fdset);
FD_SET(STDIN_FILENO, &fdset);
tv.tv_sec = 0;
tv.tv_usec = 0;
#ifdef hpux
sel = select (STDIN_FILENO+1, (int *)fdset.fds_bits, NULL, NULL, &tv);
#else
sel = select (STDIN_FILENO+1, &fdset, NULL, NULL, &tv);
#endif
if (sel==0)
fe_temp_reset();
return s;
}
case feCTRL('H'):
case 127: /*delete the character left of the cursor*/
{
if (i==0) break;
i--;
fe_cursor_pos--;
if(fe_cursor_pos<0)
{
fe_cursor_line--;
fe_cursor_pos=colmax-1;
fe_set_cursor(s,i);
}
else
{
fputc('\b',fe_echo);
}
/* NO BREAK : next: feCTRL('D') */
}
case feCTRL('D'): /*delete the character under the cursor or eof*/
{
int j;
if ((i==0) &&(s[0]=='\0')) return NULL; /*eof*/
if (s[i]!='\0')
{
j=i;
while(s[j]!='\0')
{
s[j]=s[j+1];
fputc(s[j],fe_echo);
j++;
}
fputc(' ',fe_echo);
if (fe_cursor_pos+(j-i)>=colmax)
{
fe_set_cursor(s,i);
}
else
{
while(j>i)
{
fputc('\b',fe_echo);
j--;
}
}
}
change=1;
fflush(fe_echo);
break;
}
case feCTRL('A'): /* move the cursor to the beginning of the line */
{
if (i>=colmax-strlen(pr))
{
while (i>=colmax-strlen(pr))
{
i-=colmax;
fe_cursor_line--;
}
i=0;
fe_cursor_pos=strlen(pr);
fe_set_cursor(s,i);
}
else
{
while(i>0)
{
i--;
fputc('\b',fe_echo);
}
fe_cursor_pos=strlen(pr);
}
break;
}
case feCTRL('E'): /* move the cursor to the end of the line */
{
while(s[i]!='\0')
{
fputc(s[i],fe_echo);
i++;
fe_cursor_pos++;
if(fe_cursor_pos>=colmax)
{
fe_cursor_pos=0;
if(fe_cursor_line!=(pagelength-1))
fe_cursor_line++;
}
}
break;
}
case feCTRL('B'): /* move the cursor backward one character */
{
if (i>0)
{
i--;
fputc('\b',fe_echo);
fe_cursor_pos--;
if(fe_cursor_pos<0)
{
fe_cursor_pos=colmax-1;
fe_cursor_line--;
}
}
break;
}
case feCTRL('F'): /* move the cursor forward one character */
{
if(s[i]!='\0')
{
fputc(s[i],fe_echo);
i++;
fe_cursor_pos++;
if(fe_cursor_pos>=colmax)
{
fe_cursor_pos=0;
if(fe_cursor_line!=(pagelength-1))
fe_cursor_line++;
}
}
break;
}
case feCTRL('U'): /* delete entire input line */
{
fe_ctrl_u(s,&i);
fe_cursor_pos=strlen(pr);
memset(s,0,size);
change=1;
break;
}
#if 0
case feCTRL('W'): /* test hist. */
{
int i;
PrintS("\nstart hist\n");
for(i=0;i<fe_hist_max;i++)
{
if(fe_hist[i]!=NULL)
{
Print("%2d ",i);
if(i==fe_hist_pos) PrintS("-"); else PrintS(" ");
if(i==h) PrintS(">"); else PrintS(" ");
PrintS(fe_hist[i]);
PrintLn();
}
}
Print("end hist, next_pos=%d\n",fe_hist_pos);
break;
}
#endif
case feCTRL('K'): /* delete up to the end of the line */
{
fe_ctrl_k(s,i);
memset(&(s[i]),'\0',size-i);
/* s[i]='\0';*/
change=1;
break;
}
case feCTRL('L'): /* redraw screen */
{
char t_buf[40];
char *t=t_buf;
fe_cursor_line=i/colmax;
/*fputs(tgetstr("cl",&t),fe_echo);*/
tputs(tgetstr("cl",&t),pagelength,fe_out_char);
fflush(fe_echo);
fputs(pr,fe_echo);
fputs(s,fe_echo);
fe_set_cursor(s,i);
break;
}
case feCTRL('P'): /* previous line */
{
fe_ctrl_u(s,&i);
fe_get_hist(s,size,&h,change,-1);
while(s[i]!='\0')
{
fputc(s[i],fe_echo);
i++;
}
fe_cursor_pos=strlen(pr)+i/*strlen(s)*/;
change=0;
break;
}
case feCTRL('N'): /* next line */
{
fe_ctrl_u(s,&i);
fe_get_hist(s,size,&h,change,1);
while(s[i]!='\0')
{
fputc(s[i],fe_echo);
i++;
}
fe_cursor_pos=strlen(pr)+i/*strlen(s)*/;
change=0;
break;
}
default:
{
if ((c>=' ')&&(c<=126))
{
fputc (c,fe_echo);
fe_cursor_pos++;
if(fe_cursor_pos>=colmax)
{
fe_cursor_pos=0;
if(fe_cursor_line!=(pagelength-1))
fe_cursor_line++;
}
if (s[i]!='\0')
{
/* shift by 1 to the right */
int j=i;
int l;
while ((s[j]!='\0')&&(j<size-2)) j++;
l=j-i;
while (j>i) { s[j]=s[j-1]; j--; }
/* display */
fwrite(s+i+1,l,1,fe_echo);
fflush(fe_echo);
/* set cursor */
if(fe_cursor_pos+l>=colmax)
{
while(fe_cursor_pos+l>=colmax)
{
fe_cursor_line--;
l-=colmax;
}
fe_set_cursor(s,i);
}
else
{
while(l>0)
{
l--;
fputc('\b',fe_echo);
}
}
fflush(fe_echo);
}
if (i<size-1) s[i]=c;
i++;
change=1;
}
}
} /* switch */
fflush(fe_echo);
} /* loop */
}
/*else*/
return fgets(s,size,stdin);
}
HRESULT CLMSFilter::Filter(CREDENTIAL_PROVIDER_USAGE_SCENARIO cpus, DWORD dwFlags, GUID* rgclsidProviders, BOOL* rgbAllow, DWORD cProviders)
{
LPOLESTR clsid;//PWSTR
int isRDP;
int onlyRDP = 0;//Local and RDP
if (DEVELOP_MODE) PrintLn("========== MultiotpProvider::Applying CLMSFilter::Filter ==========");
isRDP = IsRemoteSession();
if (!isRDP) {
if (readRegistryValueInteger(CONF_RDP_ONLY, onlyRDP)) {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter: Only RDP is OTP protected!!!");
//isRDP = FALSE;
return S_OK;
}
else {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter: RDP and Local OTP protection");
isRDP = TRUE;
}
} else if (DEVELOP_MODE) {
PrintLn("MultiotpProvider::CLMSFilter::Filter: RDP connection");
}
switch (cpus)
{
case CPUS_LOGON:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter CPUS_LOGON");
case CPUS_UNLOCK_WORKSTATION:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter CPUS_UNLOCK_WORKSTATION");
for (DWORD i = 0; i < cProviders; i++)
{
if (i < dwFlags) {}
if (IsEqualGUID(rgclsidProviders[i], CLSID_Multiotp)) {
rgbAllow[i] = isRDP;// TRUE;
}
else {
rgbAllow[i] = !isRDP;// FALSE;
}
if (DEVELOP_MODE) {
StringFromCLSID(rgclsidProviders[i], &clsid);
if (rgbAllow[i] == FALSE) {
PrintLn(L"\t-", clsid);
}
else {
PrintLn(L"\t+", clsid);
}
CoTaskMemFree(clsid);
}
}
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter End of CPUS_UNLOCK_WORKSTATION");
return S_OK;
case CPUS_CREDUI: //issue #1
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter CPUS_CREDUI");
case CPUS_CHANGE_PASSWORD:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter CPUS_CHANGE_PASSWORD");
return E_NOTIMPL;
default:
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter::Filter default");
return E_INVALIDARG;
}
}
HRESULT MultiotpProvider::_EnumerateCredentials()
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::_EnumerateCredential");
HRESULT hr = E_UNEXPECTED;
/*
if (_pCredProviderUserArray != nullptr)
{
DWORD dwUserCount;
_pCredProviderUserArray->GetCount(&dwUserCount);
if (dwUserCount > 0)
{
ICredentialProviderUser *pCredUser;
hr = _pCredProviderUserArray->GetAt(0, &pCredUser);
if (SUCCEEDED(hr))
{
_pCredential = new(std::nothrow) MultiotpCredential();
if (_pCredential != nullptr)
{
hr = _pCredential->Initialize(_cpus, s_rgCredProvFieldDescriptors, s_rgFieldStatePairs, pCredUser);
if (FAILED(hr))
{
_pCredential->Release();
_pCredential = nullptr;
}
}
else
{
hr = E_OUTOFMEMORY;
}
pCredUser->Release();
}
}
}
*/
DWORD dwUserCount = 0;
if (_pCredProviderUserArray != nullptr)
{
_pCredProviderUserArray->GetCount(&dwUserCount);
if (dwUserCount > 0)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::ProviderUserArrayGetCount: %d", dwUserCount);
//_pCredential = new MultiotpCredential*[dwUserCount];
for (DWORD i = 0; i < dwUserCount; i++) {
ICredentialProviderUser *pCredUser;
hr = _pCredProviderUserArray->GetAt(i, &pCredUser);
if (SUCCEEDED(hr))
{
//_pCredential[i] = new(std::nothrow) MultiotpCredential();
_pCredential.push_back(new(std::nothrow) MultiotpCredential());
if (_pCredential[i] != nullptr)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::new Credential()");
hr = _pCredential[i]->Initialize(_cpus, s_rgCredProvFieldDescriptors, s_rgFieldStatePairs, pCredUser);
if (FAILED(hr))
{
_pCredential[i]->Release();
_pCredential[i] = nullptr;
if (DEVELOP_MODE) PrintLn("MultiotpProvider::User tile initialization failed");
}
else {
// if (DEVELOP_MODE) PrintLn("MultiotpProvider::UserSID: %s", _pCredential[i]->_pszUserSid);
}
}
else
{
hr = E_OUTOFMEMORY;
}
pCredUser->Release();
}
}
}
else {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Empty User List");
//create empty user tile later
/*
_pCredential.push_back(new(std::nothrow) CSampleCredential());
if (_pCredential[_pCredential.size()-1] != nullptr) {
hr = _pCredential[_pCredential.size()-1]->Initialize(_cpus, s_rgCredProvFieldDescriptors, s_rgFieldStatePairs, nullptr);
}
*/
}
}
else {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Unassigned User List");
//it is probably Credential Provider V1 System...
//create empty user tile later
/*
_pCredential.push_back(new(std::nothrow) CSampleCredential());
if (_pCredential[_pCredential.size() - 1] != nullptr) {
hr = _pCredential[_pCredential.size() - 1]->Initialize(_cpus, s_rgCredProvFieldDescriptors, s_rgFieldStatePairs, nullptr);
}
*/
}
// if you are in a domain or have no users on the list you have to show "Other user tile"
if (DEVELOP_MODE) PrintLn("MultiotpProvider::IsOS(OS_DOMAINMEMBER): %d", IsOS(OS_DOMAINMEMBER));
if ((dwUserCount == 0) || (IsOS(OS_DOMAINMEMBER) == 1)) {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Adding empty user tile");
_pCredential.push_back(new(std::nothrow) MultiotpCredential());
if (_pCredential[_pCredential.size() - 1] != nullptr) {
hr = _pCredential[_pCredential.size() - 1]->Initialize(_cpus, s_rgCredProvFieldDescriptors, s_rgFieldStatePairs, nullptr);
}
else {
if (DEVELOP_MODE) PrintLn("MultiotpProvider::Error adding user: %d", (int)_pCredential.size());
}
}
return hr;
}
int start(void) {
int i;
bool bPonderTime;
UcciCommStruct UcciComm;
char szLibEvalFile[1024];
const char *szEngineName;
PositionStruct posProbe;
#ifdef _WIN32
HMODULE hModule;
#else
void *hModule;
#endif
if (BootLine() != UCCI_COMM_UCCI) {
return 0;
}
LocatePath(Search.szBookFile, "BOOK.DAT");
LocatePath(szLibEvalFile, cszLibEvalFile);
hModule = LoadEvalApi(szLibEvalFile);
bPonderTime = false;
PreGenInit();
NewHash(24); // 24=16MB, 25=32MB, 26=64MB, ...
Search.pos.FromFen("rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR b - - 0 1");
Search.pos.nDistance = 0;
Search.PreEvaluate(&Search.pos, &PreEval);
Search.nBanMoves = 0;
Search.bQuit = Search.bBatch = Search.bDebug = Search.bAlwaysCheck = false;
Search.bUseHash = Search.bUseBook = Search.bNullMove = Search.bKnowledge = true;
Search.bIdle = false;
Search.nCountMask = INTERRUPT_COUNT - 1;
Search.nRandomMask = 0;
Search.rc4Random.InitRand();
szEngineName = Search.GetEngineName();
if (szEngineName == NULL) {
PrintLn("#id name ElephantEye");
} else {
//printf("id name %s / ElephantEye\n", szEngineName);
//fflush(stdout);
pipeOutputWrite("id name %s / ElephantEye\n", szEngineName);
}
PrintLn("#id version 3.15");
PrintLn("#id copyright 2004-2008 www.elephantbase.net");
PrintLn("#id author Morning Yellow");
PrintLn("#id user ElephantEye Test Team");
PrintLn("#option usemillisec type check default true");
PrintLn("#option promotion type check default false");
PrintLn("#option batch type check default false");
PrintLn("#option debug type check default false");
PrintLn("#option ponder type check default false");
PrintLn("#option alwayscheck type check default false");
PrintLn("#option usehash type check default true");
PrintLn("#option usebook type check default true");
//printf("option bookfiles type string default %s\n", Search.szBookFile);
//fflush(stdout);
pipeOutputWrite("#option bookfiles type string default %s\n", Search.szBookFile);
//printf("option evalapi type string default %s\n", szLibEvalFile);
//fflush(stdout);
pipeOutputWrite("#option evalapi type string default %s\n", szLibEvalFile);
PrintLn("#option hashsize type spin min 16 max 1024 default 16");
PrintLn("#option idle type combo var none var small var medium var large default none");
PrintLn("#option pruning type combo var none var small var medium var large default large");
PrintLn("#option knowledge type combo var none var small var medium var large default large");
PrintLn("#option randomness type combo var none var small var medium var large default none");
PrintLn("#option newgame type button");
PrintLn("#ucciok");
// 以下是接收指令和提供对策的循环体
while (!Search.bQuit) {
switch (IdleLine(UcciComm, Search.bDebug)) {
case UCCI_COMM_ISREADY:
PrintLn("#readyok");
break;
case UCCI_COMM_STOP:
PrintLn("#nobestmove");
break;
case UCCI_COMM_POSITION:
BuildPos(Search.pos, UcciComm);
Search.pos.nDistance = 0;
Search.PreEvaluate(&Search.pos, &PreEval);
Search.nBanMoves = 0;
break;
case UCCI_COMM_BANMOVES:
Search.nBanMoves = UcciComm.nBanMoveNum;
for (i = 0; i < UcciComm.nBanMoveNum; i ++) {
Search.wmvBanList[i] = COORD_MOVE(UcciComm.lpdwBanMovesCoord[i]);
}
break;
case UCCI_COMM_SETOPTION:
switch (UcciComm.Option) {
case UCCI_OPTION_PROMOTION:
PreEval.bPromotion = UcciComm.bCheck;
break;
case UCCI_OPTION_BATCH:
Search.bBatch = UcciComm.bCheck;
break;
case UCCI_OPTION_DEBUG:
Search.bDebug = UcciComm.bCheck;
break;
case UCCI_OPTION_PONDER:
bPonderTime = UcciComm.bCheck;
break;
case UCCI_OPTION_ALWAYSCHECK:
Search.bAlwaysCheck = UcciComm.bCheck;
break;
case UCCI_OPTION_USEHASH:
Search.bUseHash = UcciComm.bCheck;
break;
case UCCI_OPTION_USEBOOK:
Search.bUseBook = UcciComm.bCheck;
break;
case UCCI_OPTION_BOOKFILES:
if (AbsolutePath(UcciComm.szOption)) {
strcpy(Search.szBookFile, UcciComm.szOption);
} else {
LocatePath(Search.szBookFile, UcciComm.szOption);
}
break;
case UCCI_OPTION_EVALAPI:
if (AbsolutePath(UcciComm.szOption)) {
strcpy(szLibEvalFile, UcciComm.szOption);
} else {
LocatePath(szLibEvalFile, UcciComm.szOption);
}
FreeEvalApi(hModule);
hModule = LoadEvalApi(szLibEvalFile);
break;
case UCCI_OPTION_HASHSIZE:
DelHash();
i = 19; // 小于1，分配0.5M置换表
while (UcciComm.nSpin > 0) {
UcciComm.nSpin /= 2;
i ++;
}
NewHash(MAX(i, 24)); // 最小的置换表设为16M
break;
case UCCI_OPTION_IDLE:
switch (UcciComm.Grade) {
case UCCI_GRADE_NONE:
Search.bIdle = false;
Search.nCountMask = INTERRUPT_COUNT - 1;
break;
case UCCI_GRADE_SMALL:
Search.bIdle = true;
Search.nCountMask = INTERRUPT_COUNT / 4 - 1;
break;
case UCCI_GRADE_MEDIUM:
Search.bIdle = true;
Search.nCountMask = INTERRUPT_COUNT / 16 - 1;
break;
case UCCI_GRADE_LARGE:
Search.bIdle = true;
Search.nCountMask = INTERRUPT_COUNT / 64 - 1;
break;
default:
break;
}
break;
case UCCI_OPTION_PRUNING:
Search.bNullMove = (UcciComm.Grade != UCCI_GRADE_NONE);
break;
case UCCI_OPTION_KNOWLEDGE:
Search.bKnowledge = (UcciComm.Grade != UCCI_GRADE_NONE);
break;
case UCCI_OPTION_RANDOMNESS:
switch (UcciComm.Grade) {
case UCCI_GRADE_NONE:
Search.nRandomMask = 0;
break;
case UCCI_GRADE_SMALL:
Search.nRandomMask = 1;
break;
case UCCI_GRADE_MEDIUM:
Search.nRandomMask = 3;
break;
case UCCI_GRADE_LARGE:
Search.nRandomMask = 7;
break;
default:
break;
}
break;
default:
break;
}
break;
case UCCI_COMM_GO:
Search.bPonder = UcciComm.bPonder;
Search.bDraw = UcciComm.bDraw;
switch (UcciComm.Go) {
case UCCI_GO_DEPTH:
Search.nGoMode = GO_MODE_INFINITY;
Search.nNodes = 0;
SearchMain(UcciComm.nDepth);
break;
case UCCI_GO_NODES:
Search.nGoMode = GO_MODE_NODES;
Search.nNodes = UcciComm.nNodes;
SearchMain(UCCI_MAX_DEPTH);
break;
case UCCI_GO_TIME_MOVESTOGO:
case UCCI_GO_TIME_INCREMENT:
Search.nGoMode = GO_MODE_TIMER;
if (UcciComm.Go == UCCI_GO_TIME_MOVESTOGO) {
// 对于时段制，把剩余时间平均分配到每一步，作为适当时限。
// 剩余步数从1到5，最大时限依次是剩余时间的100%、90%、80%、70%和60%，5以上都是50%
Search.nProperTimer = UcciComm.nTime / UcciComm.nMovesToGo;
Search.nMaxTimer = UcciComm.nTime * MAX(5, 11 - UcciComm.nMovesToGo) / 10;
} else {
// 对于加时制，假设棋局会在20回合内结束，算出平均每一步的适当时限，最大时限是剩余时间的一半
Search.nProperTimer = UcciComm.nTime / 20 + UcciComm.nIncrement;
Search.nMaxTimer = UcciComm.nTime / 2;
}
// 如果是后台思考的时间分配策略，那么适当时限设为原来的1.25倍
Search.nProperTimer += (bPonderTime ? Search.nProperTimer / 4 : 0);
Search.nMaxTimer = MIN(Search.nMaxTimer, Search.nProperTimer * 10);
SearchMain(UCCI_MAX_DEPTH);
break;
default:
break;
}
break;
case UCCI_COMM_PROBE:
BuildPos(posProbe, UcciComm);
if (!PopHash(posProbe)) {
PopLeaf(posProbe);
}
break;
case UCCI_COMM_QUIT:
Search.bQuit = true;
break;
default:
break;
}
}
DelHash();
FreeEvalApi(hModule);
PrintLn("#bye");
return 0;
}
HRESULT GetRDPClientAddress(_In_ int RDPPort, _Outptr_result_nullonfailure_ PWSTR *IPaddress)
{
//PrintLn("GetRDPClientAddress");
HRESULT hr = E_NOTIMPL;
*IPaddress = nullptr;
PMIB_TCPTABLE2 pTcpTable;
ULONG ulSize = 0;
DWORD dwRetVal = 0;
char szLocalAddr[128];
char szRemoteAddr[128];
PWSTR ptAddr;
struct in_addr IpAddr;
int i;
pTcpTable = (MIB_TCPTABLE2 *)MALLOC(sizeof(MIB_TCPTABLE2));
if (pTcpTable == NULL) {
PrintLn("GetRDPClientAddress: Error allocating memory\n");
return 1;
}
ulSize = sizeof(MIB_TCPTABLE);
// Make an initial call to GetTcpTable2 to
// get the necessary size into the ulSize variable
if ((dwRetVal = GetTcpTable2(pTcpTable, &ulSize, TRUE)) ==
ERROR_INSUFFICIENT_BUFFER) {
FREE(pTcpTable);
pTcpTable = (MIB_TCPTABLE2 *)MALLOC(ulSize);
if (pTcpTable == NULL) {
PrintLn("GetRDPClientAddress: Error allocating memory\n");
return 1;
}
}
// Make a second call to GetTcpTable2 to get
// the actual data we require
if ((dwRetVal = GetTcpTable2(pTcpTable, &ulSize, TRUE)) == NO_ERROR) {
for (i = 0; i < (int)pTcpTable->dwNumEntries; i++) {
if ((ntohs((u_short)pTcpTable->table[i].dwLocalPort) == RDPPort) &&
(pTcpTable->table[i].dwState == MIB_TCP_STATE_ESTAB)) {
/*
PrintLn("\n\tTCP[%d] State: %ld - ", i,
pTcpTable->table[i].dwState);
switch (pTcpTable->table[i].dwState) {
case MIB_TCP_STATE_CLOSED:
PrintLn("CLOSED\n");
break;
case MIB_TCP_STATE_LISTEN:
PrintLn("LISTEN\n");
break;
case MIB_TCP_STATE_SYN_SENT:
PrintLn("SYN-SENT\n");
break;
case MIB_TCP_STATE_SYN_RCVD:
PrintLn("SYN-RECEIVED\n");
break;
case MIB_TCP_STATE_ESTAB:
PrintLn("ESTABLISHED\n");
break;
case MIB_TCP_STATE_FIN_WAIT1:
PrintLn("FIN-WAIT-1\n");
break;
case MIB_TCP_STATE_FIN_WAIT2:
PrintLn("FIN-WAIT-2 \n");
break;
case MIB_TCP_STATE_CLOSE_WAIT:
PrintLn("CLOSE-WAIT\n");
break;
case MIB_TCP_STATE_CLOSING:
PrintLn("CLOSING\n");
break;
case MIB_TCP_STATE_LAST_ACK:
PrintLn("LAST-ACK\n");
break;
case MIB_TCP_STATE_TIME_WAIT:
PrintLn("TIME-WAIT\n");
break;
case MIB_TCP_STATE_DELETE_TCB:
PrintLn("DELETE-TCB\n");
break;
default:
PrintLn("UNKNOWN dwState value\n");
break;
}
IpAddr.S_un.S_addr = (u_long)pTcpTable->table[i].dwLocalAddr;
strcpy_s(szLocalAddr, sizeof(szLocalAddr), inet_ntoa(IpAddr));
PrintLn("\tTCP[%d] Local Addr: %s\n", i, szLocalAddr);
PrintLn("\tTCP[%d] Local Port: %d \n", i,
ntohs((u_short)pTcpTable->table[i].dwLocalPort));
*/
IpAddr.S_un.S_addr = (u_long)pTcpTable->table[i].dwRemoteAddr;
strcpy_s(szRemoteAddr, sizeof(szRemoteAddr), inet_ntoa(IpAddr));
if (strstr( "0.0.0.0", szRemoteAddr) == 0) {
//PrintLn("Remote Addr:");
//PrintLn(szRemoteAddr);
//PrintLn(ntohs((u_short)pTcpTable->table[i].dwLocalPort));
//PrintLn(ntohs((u_short)pTcpTable->table[i].dwRemotePort));
//if (strstr("91.199.25.153", szRemoteAddr) != 0) {
size_t len = strlen(szRemoteAddr);
ptAddr = static_cast<PWSTR>(CoTaskMemAlloc(sizeof(wchar_t) * (len + 1)));
MultiByteToWideChar(
CP_ACP,
0,
szRemoteAddr,
-1,
ptAddr,
128);
*IPaddress = ptAddr;
hr = 0;
}
//*IPaddress = szRemoteAddr;
/*
PrintLn("\tTCP[%d] Remote Port: %d\n", i,
ntohs((u_short)pTcpTable->table[i].dwRemotePort));
PrintLn("\tTCP[%d] Owning PID: %d\n", i, pTcpTable->table[i].dwOwningPid);
PrintLn("\tTCP[%d] Offload State: %ld - ", i,
pTcpTable->table[i].dwOffloadState);
switch (pTcpTable->table[i].dwOffloadState) {
case TcpConnectionOffloadStateInHost:
PrintLn("Owned by the network stack and not offloaded \n");
break;
case TcpConnectionOffloadStateOffloading:
PrintLn("In the process of being offloaded\n");
break;
case TcpConnectionOffloadStateOffloaded:
PrintLn("Offloaded to the network interface control\n");
break;
case TcpConnectionOffloadStateUploading:
PrintLn("In the process of being uploaded back to the network stack \n");
break;
default:
PrintLn("UNKNOWN Offload state value\n");
break;
}*/
}
}
}
else {
PrintLn("\tGetTcpTable2 failed with %d\n", dwRetVal);
FREE(pTcpTable);
return 1;
}
if (pTcpTable != NULL) {
FREE(pTcpTable);
pTcpTable = NULL;
}
return hr;
}
CLMSFilter::CLMSFilter() :
_cRef(1)
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter.Create");
DllAddRef();
}
CLMSFilter::~CLMSFilter()
{
if (DEVELOP_MODE) PrintLn("MultiotpProvider::CLMSFilter.Destroy");
DllRelease();
}
void main()
{
PrintLn(class_String, "C++: Hello, eC", null);
GuiApplication::main();
}
