HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::accept___STATIC__I4__OBJECT( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
CLR_INT32 ret;
CLR_INT32 nonBlocking = 1;
FAULT_ON_NULL(socket);
handle = socket[ 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 == DISPOSED_HANDLE)
{
ThrowError(stack, CLR_E_OBJECT_DISPOSED);
TINYCLR_SET_AND_LEAVE (CLR_E_PROCESS_EXCEPTION);
}
ret = SOCK_accept( handle, NULL, NULL );
if(ret != SOCK_SOCKET_ERROR)
{
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, SOCK_ioctl( ret, SOCK_FIONBIO, &nonBlocking ) ));
}
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
stack.SetResult_I4( ret );
TINYCLR_NOCLEANUP();
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::socket___STATIC__I4__I4__I4__I4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_INT32 family = stack.Arg0().NumericByRef().s4;
CLR_INT32 type = stack.Arg1().NumericByRef().s4;
CLR_INT32 protocol = stack.Arg2().NumericByRef().s4;
CLR_INT32 nonBlocking = 1;
CLR_INT32 sock = SOCK_socket( family, type, protocol );
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, sock ));
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, SOCK_ioctl( sock, SOCK_FIONBIO, &nonBlocking ) ));
stack.SetResult_I4( sock );
TINYCLR_NOCLEANUP();
}
int ssl_pending_internal(int socket) {
SSL* ssl = NULL;
SSL_Conext* sslContext = g_SSL_Driver.GetSSLContextBySocketHandle(socket);
if (sslContext != NULL && sslContext->SslContext != NULL) {
ssl = (SSL*) sslContext->SslContext;
} else {
return SOCK_SOCKET_ERROR;
}
int len = 0;
int sslBufferCount = sslContext->SslBuffer.Count;
//TODO make sure, not using rtip include
const long fionread = (0x40000000UL|(((long)sizeof(unsigned long)&0x7fU)<<16)|(('f')<<8)|(127));
//TODO Check for block see SSL.cpp
int ret = SOCK_ioctl(socket, fionread, &len);
if (ret == 0)
{
MATRIXSSL_PDEBUG_ALL("Bytes in ETH Buffer: %i, in SSL-Buffer: %i\n", len, sslBufferCount);
//return (len > 0);
return (len + sslBufferCount);
}
return 0;
}
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::ioctl___STATIC__VOID__OBJECT__U4__BYREF_U4( CLR_RT_StackFrame& stack )
{
NATIVE_PROFILE_CLR_NETWORK();
TINYCLR_HEADER();
CLR_RT_HeapBlock* socket = stack.Arg0().Dereference();
CLR_INT32 handle;
CLR_INT32 cmd = stack.Arg1().NumericByRef().s4;
CLR_RT_HeapBlock blkArg;
CLR_INT32 ret;
FAULT_ON_NULL(socket);
handle = socket[ FIELD__m_Handle ].NumericByRef().s4;
_SIDE_ASSERTE(SUCCEEDED(blkArg.LoadFromReference( stack.Arg2() )));
ret = SOCK_ioctl( handle, cmd, (CLR_INT32*)&blkArg.NumericByRef().s4 );
TINYCLR_CHECK_HRESULT(ThrowOnError( stack, ret ));
_SIDE_ASSERTE(SUCCEEDED(blkArg.StoreToReference( stack.Arg2(), 0 )));
TINYCLR_NOCLEANUP();
}
int ioctl(int s, unsigned long cmd, ...)
{ struct SocketSettings *lss;
StdFileDes *fp = _lx_fhfromfd(s);
int arglen,inout,rc;
caddr_t data;
va_list va;
if (fp->lx_type == LX_FILE) {
errno = EBADF; return -1;
}
va_start(va, cmd);
inout = va_arg(va, int);
arglen = va_arg(va, int);
data = va_arg(va, caddr_t);
va_end(va);
switch (lss=_lx_get_socket_settings(),lss->lx_network_type) {
case LX_AS225:
/* _SIGH_... they left almost everything neatly as it was in the BSD kernel
* code they used, but for whatever reason they decided they needed their
* own kind of ioctl encoding :-((
*
* Well then, here we go, and map `normal' cmds into CBM cmds:
*/
switch (cmd) {
case SIOCADDRT : cmd = ('r'<<8)|1; break;
case SIOCDELRT : cmd = ('r'<<8)|2; break;
case SIOCSIFADDR : cmd = ('i'<<8)|3; break;
case SIOCGIFADDR : cmd = ('i'<<8)|4; break;
case SIOCSIFDSTADDR : cmd = ('i'<<8)|5; break;
case SIOCGIFDSTADDR : cmd = ('i'<<8)|6; break;
case SIOCSIFFLAGS : cmd = ('i'<<8)|7; break;
case SIOCGIFFLAGS : cmd = ('i'<<8)|8; break;
case SIOCGIFCONF : cmd = ('i'<<8)|9; break;
case SIOCSIFMTU : cmd = ('i'<<8)|10; break;
case SIOCGIFMTU : cmd = ('i'<<8)|11; break;
case SIOCGIFBRDADDR : cmd = ('i'<<8)|12; break;
case SIOCSIFBRDADDR : cmd = ('i'<<8)|13; break;
case SIOCGIFNETMASK : cmd = ('i'<<8)|14; break;
case SIOCSIFNETMASK : cmd = ('i'<<8)|15; break;
case SIOCGIFMETRIC : cmd = ('i'<<8)|16; break;
case SIOCSIFMETRIC : cmd = ('i'<<8)|17; break;
case SIOCSARP : cmd = ('i'<<8)|18; break;
case SIOCGARP : cmd = ('i'<<8)|19; break;
case SIOCDARP : cmd = ('i'<<8)|20; break;
case SIOCATMARK : cmd = ('i'<<8)|21; break;
case FIONBIO : cmd = ('m'<<8)|22; break;
case FIONREAD : cmd = ('m'<<8)|23; break;
case FIOASYNC : cmd = ('m'<<8)|24; break;
case SIOCSPGRP : cmd = ('m'<<8)|25; break;
case SIOCGPGRP : cmd = ('m'<<8)|26; break;
default:
/* we really don't have to bother the library with cmds we can't even
* map over...
*/
break;
}
rc = SOCK_ioctl(fp->lx_sock,cmd,data);
break;
case LX_AMITCP:
rc = TCP_IoctlSocket(fp->lx_sock,cmd,data);
break;
default:
rc = 0;
break;
}
return rc;
}
int ssl_connect_internal(int sd, const char* szTargetHost, int sslContextHandle)
{
int err = SOCK_SOCKET_ERROR;
SSL *ssl = NULL;
int nonblock = 0;
// Retrieve SSL struct from g_SSL_Driver
if((sslContextHandle >= ARRAYSIZE(g_SSL_Driver.m_sslContextArray)) || (sslContextHandle < 0))
{
goto error;
}
// sd should already have been created
// Now do the SSL negotiation
ssl = (SSL*)g_SSL_Driver.m_sslContextArray[sslContextHandle].SslContext;
if (ssl == NULL) goto error;
if (!SSL_set_fd(ssl, sd))
{
goto error;
}
if(ssl->verify_mode != SSL_VERIFY_NONE)
{
SSL_CTX* pCtx = SSL_get_SSL_CTX(ssl);
if(pCtx != NULL)
{
X509_STORE *pStore = SSL_CTX_get_cert_store(pCtx);
if(sk_num(&pStore->objs->stack) == 0)
{
CryptokiSession* pSession;
CK_SLOT_ID slotID;
OBJECT_DATA* pObj;
CK_ATTRIBUTE attribs[2];
CK_OBJECT_CLASS cls = SwapEndianIfBEc32(CKO_CERTIFICATE);
LPSTR label = "CA";
CK_SESSION_HANDLE hSess;
if(CKR_OK == C_OpenSession(0, CKF_SERIAL_SESSION, NULL, NULL, &hSess) &&
CKR_OK == Cryptoki_GetSlotIDFromSession(hSess, &slotID, &pSession))
{
attribs[0].type = CKA_CLASS;
attribs[0].pValue = &cls;
attribs[0].ulValueLen = sizeof(cls);
attribs[1].type = CKA_LABEL;
attribs[1].pValue = label;
attribs[1].ulValueLen = 2;
if(CKR_OK == C_FindObjectsInit(hSess, attribs, ARRAYSIZE(attribs)))
{
CK_OBJECT_HANDLE hObjs[20];
CK_ULONG cnt = 0;
if(CKR_OK == C_FindObjects(hSess, hObjs, ARRAYSIZE(hObjs), &cnt) && cnt > 0)
{
for(int i=0; i<cnt; i++)
{
pObj = PKCS11_Objects_OpenSSL::GetObjectFromHandle(&pSession->Context, hObjs[i]);
if(pObj != NULL && pObj->Type == 3 /*CertificateType*/)
{
CERT_DATA* pCert = (CERT_DATA*)pObj->Data;
X509_STORE_add_cert(pStore, pCert->cert);
}
}
}
C_FindObjectsFinal(hSess);
}
}
if(pStore->objs == NULL || 0 == sk_num(&pStore->objs->stack))
{
ssl->verify_mode = SSL_VERIFY_NONE;
}
C_CloseSession(hSess);
}
}
}
if(szTargetHost != NULL && szTargetHost[0] != 0)
{
SSL_set_tlsext_host_name(ssl, szTargetHost);
}
SOCK_ioctl(sd, SOCK_FIONBIO, &nonblock);
err = SSL_connect (ssl);
nonblock = 1;
SOCK_ioctl(sd, SOCK_FIONBIO, &nonblock);
err = SSL_get_error(ssl,err);
if(err == SSL_ERROR_WANT_READ)
{
err = SOCK_EWOULDBLOCK;
#if !defined(TCPIP_LWIP) && !defined(TCPIP_LWIP_OS)
SOCKET_DRIVER.ClearStatusBitsForSocket( sd, FALSE );
#endif
}
else if(err == SSL_ERROR_WANT_WRITE)
{
err = SOCK_TRY_AGAIN;
#if !defined(TCPIP_LWIP) && !defined(TCPIP_LWIP_OS)
SOCKET_DRIVER.ClearStatusBitsForSocket( sd, TRUE );
#endif
}
SOCKET_DRIVER.SetSocketSslData(sd, (void*)ssl);
error:
return err;
}
