void TJConnector::Logon(const char* host, const char* dbName, const char* user, const char* password, int port)
{
ThrowOnError(JP_Logon(*this, host, dbName, user, password, port), JP_MARK);
loggedOn = true;
}
/** Import */
X509Key(const std::string& keystr)
{
int ret = mbedtls_pk_parse_key(get(), reinterpret_cast<const unsigned char*>(keystr.c_str()), keystr.size()+1, NULL, 0);
ThrowOnError(ret, "Unable to import private key");
}
inline
void Myo::setStreamEmg(StreamEmgType type)
{
libmyo_set_stream_emg(_myo, static_cast<libmyo_stream_emg_t>(type), ThrowOnError());
}
inline
void Myo::vibrate(VibrationType type)
{
libmyo_vibrate(_myo, static_cast<libmyo_vibration_type_t>(type), ThrowOnError());
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::InitHelper( CLR_RT_StackFrame& stack, bool isServer )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_INT32 sslContext = -1;
CLR_INT32 sslMode = stack.Arg0().NumericByRef().s4;
CLR_INT32 sslVerify = stack.Arg1().NumericByRef().s4;
CLR_RT_HeapBlock *hbCert = stack.Arg2().Dereference();
CLR_RT_HeapBlock_Array* arrCA = stack.Arg3().DereferenceArray();
CLR_RT_HeapBlock_Array* arrCert = NULL;
CLR_UINT8* sslCert = NULL;
int result;
int i;
bool isFirstCall = false;
LPCSTR szPwd = "";
if(!g_SSL_SeedData.Initialized)
{
BOOL fOK = FALSE;
isFirstCall = true;
#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE)
int i;
if(!HAL_CONFIG_BLOCK::ApplyConfig( g_SSL_SeedData.Config.GetDriverName(), &g_SSL_SeedData.Config, sizeof(g_SSL_SeedData.Config) ))
{
return CLR_E_NOT_SUPPORTED;
}
// validate the security key (make sure it isn't all 0x00 or all 0xFF
for(i=1; i<sizeof(g_SSL_SeedData.Config.SslSeedKey) && !fOK; i++)
{
if( g_SSL_SeedData.Config.SslSeedKey[ i ] != 0 &&
g_SSL_SeedData.Config.SslSeedKey[ i ] != 0xFF &&
g_SSL_SeedData.Config.SslSeedKey[ i-1 ] != g_SSL_SeedData.Config.SslSeedKey[ i ])
{
fOK = TRUE;
}
}
if(!fOK)
{
return CLR_E_NOT_SUPPORTED;
}
#endif
g_SSL_SeedData.m_completion.Initialize();
g_SSL_SeedData.m_completion.InitializeForUserMode( UpdateSslSeedValue, NULL );
g_SSL_SeedData.Initialized = TRUE;
}
if(hbCert != NULL)
{
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);
// If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
if(arrCert == NULL)
{
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
// pass the certificate handle as the cert data parameter
sslCert = arrCert->GetFirstElement();
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
// pass the session handle as the ssl context parameter
sslContext = *(INT32*)arrCert->GetFirstElement();
// the certificate has already been loaded so just pass an empty string
szPwd = "";
}
else
{
arrCert->Pin();
sslCert = arrCert->GetFirstElement();
CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference();// FAULT_ON_NULL(hbPwd);
szPwd = hbPwd->StringText();
}
}
SSL_RegisterTimeCallback( Time_GetDateTime );
if(isServer)
{
result = (SSL_ServerInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
}
else
{
result = (SSL_ClientInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1);
}
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
if(isFirstCall)
{
GenerateNewSslSeed();
}
if(arrCA != NULL)
{
for(i=0; i<(int)arrCA->m_numOfElements; i++)
{
hbCert = (CLR_RT_HeapBlock*)arrCA->GetElement( i ); FAULT_ON_NULL(hbCert);
hbCert = hbCert->Dereference(); FAULT_ON_NULL(hbCert);
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert);
// If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle
if(arrCert == NULL)
{
CLR_INT32 sessionCtx = 0;
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
sslCert = arrCert->GetFirstElement();
arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert);
sessionCtx = *(INT32*)arrCert->GetFirstElement();
// pass the session handle down as the password paramter and the certificate handle as the data parameter
result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, (LPCSTR)&sessionCtx ) ? 0 : -1);
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
else
{
arrCert->Pin();
sslCert = arrCert->GetFirstElement();
CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); FAULT_ON_NULL(hbPwd);
LPCSTR szCAPwd = hbPwd->StringText();
result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szCAPwd ) ? 0 : -1);
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
}
}
stack.SetResult_I4( sslContext );
TINYCLR_CLEANUP();
if(FAILED(hr) && (sslContext != -1))
{
SSL_ExitContext( sslContext );
}
TINYCLR_CLEANUP_END();
}
inline
void Myo::lock()
{
libmyo_myo_lock(_myo, ThrowOnError());
}
/*
* Helper function to unwrap Geofence structures from the Java Runtime calls.
*/
static void TranslateGeofenceFromGeofenceHardwareRequestParcelable(
JNIEnv* env,
jobject geofenceRequestObject,
Geofence& geofence) {
jclass geofenceRequestClass = env->GetObjectClass(geofenceRequestObject);
jmethodID getId = env->GetMethodID(geofenceRequestClass, "getId", "()I");
geofence.geofence_id = env->CallIntMethod(geofenceRequestObject, getId);
jmethodID getType = env->GetMethodID(geofenceRequestClass, "getType", "()I");
// this works because GeofenceHardwareRequest.java and fused_location.h have
// the same notion of geofence types
GeofenceType type = (GeofenceType)env->CallIntMethod(geofenceRequestObject, getType);
if(type != TYPE_CIRCLE) {
ThrowOnError(env, FLP_RESULT_ERROR, __FUNCTION__);
}
geofence.data->type = type;
GeofenceCircle& circle = geofence.data->geofence.circle;
jmethodID getLatitude = env->GetMethodID(
geofenceRequestClass,
"getLatitude",
"()D");
circle.latitude = env->CallDoubleMethod(geofenceRequestObject, getLatitude);
jmethodID getLongitude = env->GetMethodID(
geofenceRequestClass,
"getLongitude",
"()D");
circle.longitude = env->CallDoubleMethod(geofenceRequestObject, getLongitude);
jmethodID getRadius = env->GetMethodID(geofenceRequestClass, "getRadius", "()D");
circle.radius_m = env->CallDoubleMethod(geofenceRequestObject, getRadius);
GeofenceOptions* options = geofence.options;
jmethodID getMonitorTransitions = env->GetMethodID(
geofenceRequestClass,
"getMonitorTransitions",
"()I");
options->monitor_transitions = env->CallIntMethod(
geofenceRequestObject,
getMonitorTransitions);
jmethodID getUnknownTimer = env->GetMethodID(
geofenceRequestClass,
"getUnknownTimer",
"()I");
options->unknown_timer_ms = env->CallIntMethod(geofenceRequestObject, getUnknownTimer);
jmethodID getNotificationResponsiveness = env->GetMethodID(
geofenceRequestClass,
"getNotificationResponsiveness",
"()I");
options->notification_responsivenes_ms = env->CallIntMethod(
geofenceRequestObject,
getNotificationResponsiveness);
jmethodID getLastTransition = env->GetMethodID(
geofenceRequestClass,
"getLastTransition",
"()I");
options->last_transition = env->CallIntMethod(geofenceRequestObject, getLastTransition);
// TODO: set data.sources_to_use when available
env->DeleteLocalRef(geofenceRequestClass);
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::SendRecvHelper( CLR_RT_StackFrame& stack, bool fSend, bool fAddress )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
CLR_RT_HeapBlock_Array* arrData = stack.Arg1().DereferenceArray();
CLR_UINT32 offset = stack.Arg2().NumericByRef().u4;
CLR_UINT32 count = stack.Arg3().NumericByRef().u4;
CLR_INT32 flags = stack.Arg4().NumericByRef().s4;
CLR_INT32 timeout_ms = stack.ArgN(5).NumericByRef().s4;
CLR_RT_HeapBlock hbTimeout;
CLR_INT64* timeout;
CLR_UINT8* buf;
bool fRes = true;
CLR_INT32 totReadWrite;
CLR_INT32 ret = 0;
FAULT_ON_NULL(socket);
handle = socket[ FIELD__m_Handle ].NumericByRef().s4;
FAULT_ON_NULL(arrData);
if(offset + count > arrData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_INDEX_OUT_OF_RANGE);
/* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see
* if our handle has been shutdown before continuing. */
if (handle == DISPOSED_HANDLE)
{
ThrowError( stack, CLR_E_OBJECT_DISPOSED );
TINYCLR_SET_AND_LEAVE (CLR_E_PROCESS_EXCEPTION);
}
hbTimeout.SetInteger( timeout_ms );
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));
//
// Push "totReadWrite" onto the eval stack.
//
if(stack.m_customState == 1)
{
stack.PushValueI4( 0 );
stack.m_customState = 2;
}
totReadWrite = stack.m_evalStack[ 1 ].NumericByRef().s4;
buf = arrData->GetElement( offset + totReadWrite );
count -= totReadWrite;
while(count > 0)
{
CLR_INT32 bytes = 0;
// first make sure we have data to read or ability to write
while(fRes)
{
ret = Helper__SelectSocket( handle, fSend ? 1 : 0 );
if(ret != 0) break;
// non-blocking - allow other threads to run while we wait for handle activity
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
}
// timeout expired
if(!fRes)
{
ret = SOCK_SOCKET_ERROR;
ThrowError( stack, SOCK_ETIMEDOUT );
TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
}
// socket is in the excepted state, so let's bail out
if(SOCK_SOCKET_ERROR == ret)
{
break;
}
if(fAddress)
{
struct SOCK_sockaddr addr;
CLR_UINT32 addrLen = sizeof(addr);
CLR_RT_HeapBlock& blkAddr = stack.ArgN( 6 );
if(fSend)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, blkAddr ));
bytes = SOCK_sendto( handle, (const char*)buf, count, flags, &addr, addrLen );
}
else
{
CLR_RT_HeapBlock* pBlkAddr = blkAddr.Dereference();
TINYCLR_CHECK_HRESULT(MarshalSockAddress( &addr, addrLen, *pBlkAddr ));
bytes = SOCK_recvfrom( handle, (char*)buf, count, flags, &addr, (int*)&addrLen );
if(bytes != SOCK_SOCKET_ERROR)
{
TINYCLR_CHECK_HRESULT(MarshalSockAddress( blkAddr, &addr, addrLen ));
}
}
}
else
{
if(fSend)
{
bytes = SOCK_send( handle, (const char*)buf, count, flags );
}
else
{
bytes = SOCK_recv( handle, (char*)buf, count, flags );
}
}
// send/recv/sendto/recvfrom failed
if(bytes == SOCK_SOCKET_ERROR)
{
CLR_INT32 err = SOCK_getlasterror();
if(err != SOCK_EWOULDBLOCK)
{
ret = SOCK_SOCKET_ERROR;
break;
}
continue;
}
// zero recv bytes indicates the handle has been closed.
else if(!fSend && (bytes == 0))
{
break;
}
buf += bytes;
totReadWrite += bytes;
count -= bytes;
stack.m_evalStack[ 1 ].NumericByRef().s4 = totReadWrite;
// receive returns immediately after receiving bytes.
if(!fSend && (totReadWrite > 0))
{
break;
}
}
stack.PopValue(); // totReadWrite
stack.PopValue(); // Timeout
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
stack.SetResult_I4( totReadWrite );
TINYCLR_NOCLEANUP();
}
void TJConnector::Rollback()
{
if (LoggedOn == 0 || JP_Rollback(*this))
ThrowOnError("Rollback");
}
void TJConnector::Error(char *Msg, int MsgLen)
{
if (JP_Error(*this, Msg, MsgLen))
ThrowOnError("Error");
LoggedOn = 0;
}
void TJConnector::Commit()
{
if (LoggedOn == 0 || JP_Commit(*this))
ThrowOnError("Commit");
}
void TJConnector::Logoff()
{
if (LoggedOn == 0 || JP_Logoff(*this))
ThrowOnError("Logoff");
LoggedOn = 0;
}
void TJConnector::Logon(const char* User, const char* Password, const char* Server)
{
if (JP_Logon(*this, (text*)User, (text*)Password, (text*)Server))
ThrowOnError("Logon");
LoggedOn = 1;
}
/** Import */
X509CRL(const std::string& crlstr)
{
int ret = gnutls_x509_crl_import(get(), Datum(crlstr).get(), GNUTLS_X509_FMT_PEM);
ThrowOnError(ret, "Unable to load certificate revocation list");
}
inline
void Hub::setLockingPolicy(LockingPolicy lockingPolicy)
{
libmyo_set_locking_policy(_hub, static_cast<libmyo_locking_policy_t>(lockingPolicy), ThrowOnError());
}
CertCredentials()
{
ThrowOnError(gnutls_certificate_allocate_credentials(&cred), "Cannot allocate certificate credentials");
}
bool
FavoritesMenu::AddNextItem()
{
// run the next chunk of code for a given item adding state
if (fState == kStart) {
fState = kAddingFavorites;
fSectionItemCount = 0;
fAddedSeparatorForSection = false;
// set up adding the GoTo menu items
try {
BPath path;
ThrowOnError(find_directory(B_USER_SETTINGS_DIRECTORY,
&path, true));
path.Append(kGoDirectory);
mkdir(path.Path(), 0777);
BEntry entry(path.Path());
Model startModel(&entry, true);
ThrowOnInitCheckError(&startModel);
if (!startModel.IsContainer())
throw B_ERROR;
if (startModel.IsQuery())
fContainer = new QueryEntryListCollection(&startModel);
else if (startModel.IsVirtualDirectory())
fContainer = new VirtualDirectoryEntryList(&startModel);
else {
fContainer = new DirectoryEntryList(*dynamic_cast<BDirectory*>
(startModel.Node()));
}
ThrowOnInitCheckError(fContainer);
ThrowOnError( fContainer->Rewind() );
} catch (...) {
delete fContainer;
fContainer = NULL;
}
}
if (fState == kAddingFavorites) {
entry_ref ref;
if (fContainer != NULL && fContainer->GetNextRef(&ref) == B_OK) {
Model model(&ref, true);
if (model.InitCheck() != B_OK)
return true;
if (!ShouldShowModel(&model))
return true;
BMenuItem* item = BNavMenu::NewModelItem(&model,
model.IsDirectory() ? fOpenFolderMessage : fOpenFileMessage,
fTarget);
if (item == NULL)
return true;
item->SetLabel(ref.name);
// this is the name of the link in the Go dir
if (!fAddedSeparatorForSection) {
fAddedSeparatorForSection = true;
AddItem(new TitledSeparatorItem(B_TRANSLATE("Favorites")));
}
fUniqueRefCheck.push_back(*model.EntryRef());
AddItem(item);
fSectionItemCount++;
return true;
}
// done with favorites, set up for adding recent files
fState = kAddingFiles;
fAddedSeparatorForSection = false;
app_info info;
be_app->GetAppInfo(&info);
fItems.MakeEmpty();
int32 apps, docs, folders;
TrackerSettings().RecentCounts(&apps, &docs, &folders);
BRoster().GetRecentDocuments(&fItems, docs, NULL, info.signature);
fIndex = 0;
fSectionItemCount = 0;
}
if (fState == kAddingFiles) {
// if this is a Save panel, not an Open panel
// then don't add the recent documents
if (!fIsSavePanel) {
for (;;) {
entry_ref ref;
if (fItems.FindRef("refs", fIndex++, &ref) != B_OK)
break;
Model model(&ref, true);
if (model.InitCheck() != B_OK)
return true;
if (!ShouldShowModel(&model))
return true;
BMenuItem* item = BNavMenu::NewModelItem(&model,
fOpenFileMessage, fTarget);
if (item) {
if (!fAddedSeparatorForSection) {
fAddedSeparatorForSection = true;
AddItem(new TitledSeparatorItem(
B_TRANSLATE("Recent documents")));
}
AddItem(item);
fSectionItemCount++;
return true;
}
}
}
// done with recent files, set up for adding recent folders
fState = kAddingFolders;
fAddedSeparatorForSection = false;
app_info info;
be_app->GetAppInfo(&info);
fItems.MakeEmpty();
int32 apps, docs, folders;
TrackerSettings().RecentCounts(&apps, &docs, &folders);
BRoster().GetRecentFolders(&fItems, folders, info.signature);
fIndex = 0;
}
if (fState == kAddingFolders) {
for (;;) {
entry_ref ref;
if (fItems.FindRef("refs", fIndex++, &ref) != B_OK)
break;
// don't add folders that are already in the GoTo section
if (find_if(fUniqueRefCheck.begin(), fUniqueRefCheck.end(),
bind2nd(std::equal_to<entry_ref>(), ref))
!= fUniqueRefCheck.end()) {
continue;
}
Model model(&ref, true);
if (model.InitCheck() != B_OK)
return true;
if (!ShouldShowModel(&model))
return true;
BMenuItem* item = BNavMenu::NewModelItem(&model,
fOpenFolderMessage, fTarget, true);
if (item != NULL) {
if (!fAddedSeparatorForSection) {
fAddedSeparatorForSection = true;
AddItem(new TitledSeparatorItem(
B_TRANSLATE("Recent folders")));
}
AddItem(item);
item->SetEnabled(true);
// BNavMenu::NewModelItem returns a disabled item here -
// need to fix this in BNavMenu::NewModelItem
return true;
}
}
}
return false;
}
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::ReadWriteHelper( CLR_RT_StackFrame& stack, bool isWrite )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_RT_HeapBlock_Array* arrData = stack.Arg1().DereferenceArray();
CLR_INT32 offset = stack.Arg2().NumericByRef().s4;
CLR_INT32 count = stack.Arg3().NumericByRef().s4;
CLR_INT32 timeout_ms = stack.Arg4().NumericByRef().s4;
CLR_UINT8* buffer;
CLR_RT_HeapBlock hbTimeout;
CLR_INT32 totReadWrite;
bool fRes = true;
CLR_INT64 *timeout;
int result = 0;
CLR_INT32 handle;
if(count == 0)
{
stack.SetResult_I4( 0 );
TINYCLR_SET_AND_LEAVE(S_OK);
}
FAULT_ON_NULL(socket);
handle = socket[ Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::FIELD__m_Handle ].NumericByRef().s4;
/* Because we could have been a rescheduled call due to a prior call that would have blocked, we need to see
* if our handle has been shutdown before continuing. */
if (handle == Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::DISPOSED_HANDLE)
{
ThrowError( stack, CLR_E_OBJECT_DISPOSED );
TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION);
}
FAULT_ON_NULL(arrData);
hbTimeout.SetInteger( timeout_ms );
TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout ));
//
// Push "totReadWrite" onto the eval stack.
//
if(stack.m_customState == 1)
{
stack.PushValueI4( 0 );
stack.m_customState = 2;
}
totReadWrite = stack.m_evalStack[ 1 ].NumericByRef().s4;
buffer = arrData->GetElement( offset + totReadWrite );
count -= totReadWrite;
if((offset + count + totReadWrite) > (int)arrData->m_numOfElements) TINYCLR_SET_AND_LEAVE(CLR_E_INDEX_OUT_OF_RANGE);
while(count > 0)
{
// first make sure we have data to read or ability to write
while(fRes)
{
if(!isWrite)
{
// check SSL_DataAvailable() in case SSL has already read and buffered socket data
result = SSL_DataAvailable(handle);
if((result > 0) || ((result < 0) && (SOCK_getlasterror() != SOCK_EWOULDBLOCK)))
{
break;
}
}
result = Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::Helper__SelectSocket( handle, isWrite ? 1 : 0 );
if((result > 0) || ((result < 0) && (SOCK_getlasterror() != SOCK_EWOULDBLOCK)))
{
break;
}
// non-blocking - allow other threads to run while we wait for socket activity
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes ));
// timeout expired
if(!fRes)
{
result = SOCK_SOCKET_ERROR;
ThrowError(stack, SOCK_ETIMEDOUT);
TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION );
}
}
// socket is in the excepted state, so let's bail out
if(SOCK_SOCKET_ERROR == result)
{
break;
}
if(isWrite)
{
result = SSL_Write( handle, (const char*)buffer, count );
}
else
{
result = SSL_Read( handle, (char*)buffer, count );
if(result == SSL_RESULT__WOULD_BLOCK)
{
continue;
}
}
// ThrowOnError expects anything other than 0 to be a failure - so return 0 if we don't have an error
if(result <= 0)
{
break;
}
buffer += result;
totReadWrite += result;
count -= result;
// read is non-blocking if we have any data
if(!isWrite && (totReadWrite > 0))
{
break;
}
stack.m_evalStack[ 1 ].NumericByRef().s4 = totReadWrite;
}
stack.PopValue(); // totReadWrite
stack.PopValue(); // Timeout
if(result < 0)
{
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result ));
}
stack.SetResult_I4( totReadWrite );
TINYCLR_NOCLEANUP();
}
DHParams()
{
ThrowOnError(gnutls_dh_params_init(&dh_params), "gnutls_dh_params_init() failed");
}
inline
void Myo::unlock(UnlockType type)
{
libmyo_myo_unlock(_myo, static_cast<libmyo_unlock_type_t>(type), ThrowOnError());
}
/** Generate */
static std::auto_ptr<DHParams> Generate(unsigned int bits)
{
std::auto_ptr<DHParams> dh(new DHParams);
ThrowOnError(gnutls_dh_params_generate2(dh->dh_params, bits), "Unable to generate DH params");
return dh;
}
inline
void Myo::notifyUserAction()
{
libmyo_myo_notify_user_action(_myo, libmyo_user_action_single, ThrowOnError());
}
RAIIKey()
{
ThrowOnError(gnutls_x509_privkey_init(&key), "gnutls_x509_privkey_init() failed");
}
inline
void Myo::requestRssi() const
{
libmyo_request_rssi(_myo, ThrowOnError());
}
/** Import */
X509Key(const std::string& keystr)
{
int ret = gnutls_x509_privkey_import(key.key, Datum(keystr).get(), GNUTLS_X509_FMT_PEM);
ThrowOnError(ret, "Unable to import private key");
}
void
BDirMenu::Populate(const BEntry* startEntry, BWindow* originatingWindow,
bool includeStartEntry, bool select, bool reverse, bool addShortcuts,
bool navMenuEntries)
{
try {
if (!startEntry)
throw (status_t)B_ERROR;
Model model(startEntry);
ThrowOnInitCheckError(&model);
ModelMenuItem* menu = new ModelMenuItem(&model, this, true, true);
if (fMenuBar)
fMenuBar->AddItem(menu);
BEntry entry(*startEntry);
bool showDesktop, showDisksIcon;
{
TrackerSettings settings;
showDesktop = settings.DesktopFilePanelRoot();
showDisksIcon = settings.ShowDisksIcon();
}
// might start one level above startEntry
if (!includeStartEntry) {
BDirectory parent;
BDirectory dir(&entry);
if (!showDesktop && dir.InitCheck() == B_OK
&& dir.IsRootDirectory()) {
// if we're at the root directory skip "mnt" and
// go straight to "/"
parent.SetTo("/");
} else
entry.GetParent(&parent);
parent.GetEntry(&entry);
}
BDirectory desktopDir;
FSGetDeskDir(&desktopDir);
BEntry desktopEntry;
desktopDir.GetEntry(&desktopEntry);
for (;;) {
BNode node(&entry);
ThrowOnInitCheckError(&node);
PoseInfo info;
ReadAttrResult result = ReadAttr(&node, kAttrPoseInfo,
kAttrPoseInfoForeign, B_RAW_TYPE, 0, &info, sizeof(PoseInfo),
&PoseInfo::EndianSwap);
BDirectory parent;
entry.GetParent(&parent);
bool hitRoot = false;
BDirectory dir(&entry);
if (!showDesktop && dir.InitCheck() == B_OK
&& dir.IsRootDirectory()) {
// if we're at the root directory skip "mnt" and
// go straight to "/"
hitRoot = true;
parent.SetTo("/");
}
if (showDesktop) {
BEntry root("/");
// warp from "/" to Desktop properly
if (entry == root) {
if (showDisksIcon)
AddDisksIconToMenu(reverse);
entry = desktopEntry;
}
if (entry == desktopEntry)
hitRoot = true;
}
if (result == kReadAttrFailed || !info.fInvisible
|| (showDesktop && desktopEntry == entry)) {
AddItemToDirMenu(&entry, originatingWindow, reverse,
addShortcuts, navMenuEntries);
}
if (hitRoot) {
if (!showDesktop && showDisksIcon && *startEntry != "/")
AddDisksIconToMenu(reverse);
break;
}
parent.GetEntry(&entry);
}
// select last item in menu
if (!select)
return;
ModelMenuItem* item
= dynamic_cast<ModelMenuItem*>(ItemAt(CountItems() - 1));
if (item) {
item->SetMarked(true);
if (menu) {
entry.SetTo(item->TargetModel()->EntryRef());
ThrowOnError(menu->SetEntry(&entry));
}
}
} catch (status_t err) {
PRINT(("BDirMenu::Populate: caught error %s\n", strerror(err)));
if (!CountItems()) {
BString error;
error << "Error [" << strerror(err) << "] populating menu";
AddItem(new BMenuItem(error.String(), 0));
}
}
}
RAIICRL()
{
ThrowOnError(gnutls_x509_crl_init(&crl), "gnutls_x509_crl_init() failed");
}
void TJConnector::Logoff()
{
if (loggedOn == true)
ThrowOnError(JP_Logoff(*this), JP_MARK);
loggedOn = false;
}
void set(const std::string& dhstr)
{
// Last parameter is buffer size, must include the terminating null
int ret = mbedtls_dhm_parse_dhm(get(), reinterpret_cast<const unsigned char*>(dhstr.c_str()), dhstr.size()+1);
ThrowOnError(ret, "Unable to import DH params");
}
