Socket SockServ::waitForData(std::set<Socket>& socketSet) {
fd_set readSet;
int maxFd = -1;
for ( auto it = socketSet.begin(); it != socketSet.end(); ++it) {
FD_SET(it->getFD(), &readSet);
if (it->getFD() > maxFd) {
maxFd = it->getFD();
}
} // End for
int rc = ::select(
maxFd+1, // Number of sockets to scan
&readSet, // Set of read sockets
nullptr, // Set of write sockets
nullptr, // Set of exception sockets
nullptr // Timeout
);
if (rc == -1) {
ESP_LOGE(LOG_TAG, "Error with select");
Socket s;
return s;
}
for ( auto it = socketSet.begin(); it != socketSet.end(); ++it) {
if (FD_ISSET(it->getFD(), &readSet)) {
return *it;
}
} // End for
Socket s;
return s;
}
int
Socket::recv( char* msg,
size_t len,
int flags,
CheckingType check )
{
if( check == DONT_CHECK )
return ::recv( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags );
else
{
for(;;)
{
int received = ::recv( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags );
if( received != -1
|| errno != EINTR )
return received;
}
}
}
int
Process_PipeReader::available()
{
#if defined(ACDK_OS_WIN32) && !defined(ACDK_OS_CYGWIN32)
DWORD avail;
if (PeekNamedPipe((HANDLE)(_get_osfhandle(getFD()->c_fd())), NULL, NULL, NULL, &avail, NULL) == FALSE)
{
DOUT("PeekNamedPipe failed: " << System::getLastError());
return 0;
}
return avail;
#elif defined(ACDK_OS_UNIX) || defined(ACDK_OS_CYGWIN32)
struct stat st;
if ((fstat(getFD()->c_fd(), &st)) < 0)
{
DOUT("Process_PipeReader(): fstat failed");
return 0;
}
return st.st_size;
#else // ACDK_OS_*
#error pipes currently not supported on this platform/OS.
#endif // ACDK_OS_*
}
int
Socket::setNonBlocking( bool on )
{
if( isOpen() )
{
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
u_long tmp = on;
return ioctlsocket( getFD(), FIONBIO, &tmp );
#else
int flags = fcntl( getFD(), F_GETFL, 0 );
if( flags == -1 )
return flags;
if( on )
return fcntl( getFD(), F_SETFL,
O_NONBLOCK | flags );
else
return fcntl( getFD(), F_SETFL,
~O_NONBLOCK & flags );
#endif
}
else
{
errno = EPERM;
return -1;
}
}
void CTLSConnection::initialize() throw(CTCPConnection::CConnectException)
{
//Use ONLY TLS 1.1: this is the latest version supported by libssl
m_TLSContext = SSL_CTX_new(TLSv1_1_method());
if(m_TLSContext == NULL)
{
deallocate();
throw CConnectException(
"Failed to create a new SSL/TLS context");
}
SSL_CTX_set_options(m_TLSContext,
SSL_OP_SINGLE_DH_USE | //docs seem to indicate this improves security
SSL_OP_NO_SSLv2 | //do not use old SSL v2 protocol
SSL_OP_NO_SSLv3 | //do not use old SSL v3 protocol
SSL_OP_NO_TLSv1 | //do not use old TLS v1.0 protocol
SSL_MODE_AUTO_RETRY //send and receive implementations depend on this
); //TODO
m_TLSConnection = SSL_new(m_TLSContext);
if(m_TLSConnection == NULL)
{
deallocate();
throw CConnectException(
"Failed to create a new SSL/TLS connection structure");
}
//TODO:
if(!SSL_set_fd(m_TLSConnection, getFD()))
{
deallocate();
throw CConnectException(
"Failed to connect SSL/TLS object to file descriptor");
}
}
Addr
Socket::getName() const
{
if( isOpen() )
{
Addr::AddrType name;
socklen_t from_len = sizeof( name );
int err = ::getsockname( getFD(),
(struct sockaddr *)&name,
&from_len );
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(CYGWIN)
if( err == SOCKET_ERROR )
{
err = WSAGetLastError();
return Addr();
}
#else
if( err < 0 )
return Addr();
#endif
return Addr( name );
}
else
return Addr();
}
void FuncDeclaration::cppSemantic(::FuncDeclaration *fd, Scope *sc)
{
if (fd->semanticRun >= PASSsemanticdone)
return;
auto FD = getFD(fd);
if (!FD)
{
assert(fd->storage_class & STCdisable); // e.g added @disable this for structs without a C++ default ctor
return;
}
if (FD->getDescribedFunctionTemplate())
{
auto ti = sc->parent->isTemplateInstance();
assert(ti && isCPP(ti->inst));
auto c_ti = static_cast<cpp::TemplateInstance*>(ti->inst);
auto Inst = cast<clang::FunctionDecl>(c_ti->Inst);
assert(isCPP(sc->module));
DeclMapper m(static_cast<cpp::Module*>(sc->module));
m.addImplicitDecls = false;
auto inst = m.VisitInstancedFunctionTemplate(Inst);
assert(inst);
inst->syntaxCopy(fd);
}
}
int
Socket::recv( int timeout,
char* msg,
size_t len,
int flags )
{
#if defined (HAVE_POLL_H)
pollfd fd = { getFD(), POLLIN | POLLPRI, 0 };
int res = poll( &fd, 1, timeout );
if( res == 0 )
{
errno = EAGAIN;
return -1;
}
else if( res == 1 )
{
return recv( msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags );
}
else
{
return res;
}
#else
errno = EPERM;
return -1;
#endif
}
void TcpSocket::bind(const Endpoint& endpoint)
{
int32_t flag = 1;
if(-1 == ::setsockopt(getFD(), SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)))
SYS_EXCEPTION(NetException, "::setsockopt");
struct sockaddr_in serverAddrIn;
std::memset(&serverAddrIn, 0, sizeof(serverAddrIn));
serverAddrIn.sin_family = AF_INET;
serverAddrIn.sin_addr.s_addr = endpoint.ip.value;
serverAddrIn.sin_port = ::htons(endpoint.port);
if(-1 == ::bind(getFD(), (const struct sockaddr*)&serverAddrIn, sizeof(serverAddrIn)))
SYS_EXCEPTION(NetException, "::bind");
}
int
Socket::send( const char* msg,
size_t len,
int flags,
CheckingType check )
{
if( check == DONT_CHECK )
{
return ::send( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags );
}
else
{
int s, sent;
for(sent = 0; sent<len; )
{
s = ::send( getFD(), msg+sent,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)(len-sent),
#else
len-sent,
#endif
flags );
if( s == -1
&& ( errno != EINTR
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
&& errno != WSAEWOULDBLOCK
#else
&& errno != EWOULDBLOCK
#endif
) ){
return s;
}
if ( s > 0 )
sent+=s;
}
return sent;
}
}
void
WatchFD::start (void)
{
std::string path = getPath ();
if ( mWD == 0 )
{
mWD = inotify_add_watch (getFD (), path.c_str (), IN_ALL_EVENTS);
}
}
bool
Socket::accept( Socket& sock )
{
SocketDesc fd = ::accept( getFD(), NULL, 0 );
if( fd == INVALIDSOCKET )
return false;
sock = TCPSocket( fd );
return true;
}
int
Socket::send( const char* msg,
size_t len,
const Addr& dest,
int flags,
CheckingType check )
{
if( check == DONT_CHECK )
{
return ::sendto( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags,
(struct sockaddr *)&( dest.getAddr() ),
sizeof( dest.getAddr() ) );
}
else
{
for(;;)
{
int sent = ::sendto( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags,
(struct sockaddr *)&( dest.getAddr() ),
sizeof( dest.getAddr() ) );
if( sent != -1
|| ( errno != EINTR
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
&& errno != WSAEWOULDBLOCK
#else
&& errno != EWOULDBLOCK
#endif
) )
return sent;
}
}
}
int
Socket::recv( char* msg,
size_t len,
Addr& from,
int flags,
CheckingType check )
{
if( check == DONT_CHECK )
{
Addr::AddrType addr;
socklen_t from_len = sizeof( addr );
int rval = ::recvfrom( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags,
(struct sockaddr *)&addr, &from_len );
from = Addr( addr );
return rval;
}
else
{
for(;;)
{
Addr::AddrType addr;
socklen_t from_len = sizeof( addr );
int received = ::recvfrom( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(int)len,
#else
len,
#endif
flags,
(struct sockaddr *)&addr,
&from_len );
from = Addr( addr );
if( received != -1
|| errno != EINTR )
return received;
}
}
}
// write fault injection data to a fi.csv file
void writeFIData(const char* name, void* d, void* dc, void* bitPos, enum DataType dt, const char* mode){
FILE *ft = getFD(fiStat,mode);
char instrName[1024];
unsigned len = strlen(name);
//write execution key
if(dt == StringTy){
fprintf(ft,"Time;");
} else {
fprintf(ft,"%ld;",execKey);
}
// write instruction name
strcpy(instrName,"\"");
strncpy(instrName+1,name,len);
strcpy(instrName+len,"\"\0");
fprintf(ft,"%s;",instrName);
// write original and corrupted value
if(dt == IntTy1 ||
dt == IntTy16 ||
dt == IntTy32){
fprintf(ft,"%d;",*((int*)d));
fprintf(ft,"%d;",*((int*)dc));
} else if( dt == IntTy8){
fprintf(ft,"%c;",*((char*)d));
fprintf(ft,"%c;",*((char*)dc));
} else if(dt == IntTy64){
fprintf(ft,"%lld;",*((long long*)d));
fprintf(ft,"%lld;",*((long long*)dc));
} else if(dt == FloatTy){
fprintf(ft,"%f;",*((float*)d));
fprintf(ft,"%f;",*((float*)dc));
} else if(dt == DoubleTy){
fprintf(ft,"%lf;",*((double*)d));
fprintf(ft,"%lf;",*((double*)dc));
} else if(dt == StringTy){
fprintf(ft,"%s;",(char*)d);
fprintf(ft,"%s;",(char*)dc);
}
// write bit position
if(dt == StringTy){
fprintf(ft,"%s\n",(char*)bitPos);
} else {
fprintf(ft,"%d\n",*((int*)bitPos));
}
if(ft){fclose(ft);}
}
int
Socket::setAsync( bool on )
{
#ifdef O_ASYNC
if( isOpen() )
{
int flags = fcntl( getFD(), F_GETFL, 0 );
if ( on )
return fcntl ( getFD(), F_SETFL,
O_ASYNC | flags );
else
return fcntl ( getFD(), F_SETFL,
~O_ASYNC & flags );
}
#endif
errno = EPERM;
return -1;
}
void FileOutputStream::flushInternal()
{
if (fileHandle != 0)
{
if (fsync (getFD (fileHandle)) == -1)
status = getResultForErrno();
// This stuff tells the OS to asynchronously update the metadata
// that the OS has cached aboud the file - this metadata is used
// when the device is acting as a USB drive, and unless it's explicitly
// refreshed, it'll get out of step with the real file.
new SingleMediaScanner (file.getFullPathName());
}
}
Socket* Socket::accept(Addr& addr)
{
socklen_t len = sizeof(struct sockaddr);
SocketDesc fd = ::accept( getFD(),
(struct sockaddr *)&( addr.getAddr() ),
&len
);
if (fd == INVALIDSOCKET )
{
return 0;
}
return new TCPSocket(fd);
}
int
Socket::setCloseOnExec( bool on )
{
if( isOpen() )
{
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
errno = EPERM;
return -1;
#else
return fcntl( getFD(), F_SETFD,
( on ? FD_CLOEXEC : ~FD_CLOEXEC ) );
#endif
}
else
{
errno = EPERM;
return -1;
}
}
static int fp(void *param, Dsymbol *s)
{
if (!isCPP(s))
return 0;
auto fd = s->isFuncDeclaration();
auto td = static_cast<cpp::TemplateDeclaration*>(
s->isTemplateDeclaration());
DEquals *p = (DEquals *)param;
decltype(D) s_D = fd ? getFD(fd) : td->TempOrSpec;
if (p->D == getCanonicalDecl(s_D))
{
p->s = s;
return 1;
}
return 0;
}
bool
Socket::bind( const Addr& addr )
{
if( isOpen() )
{
int err = ::bind( getFD(),
(struct sockaddr *)&( addr.getAddr() ),
sizeof( addr.getAddr() ) );
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
if( err == SOCKET_ERROR )
return false;
#else
if( err < 0 )
return false;
#endif
return true;
}
return false;
}
/*
* Class: sun_net_ExtendedOptionsImpl
* Method: setFlowOption
* Signature: (Ljava/io/FileDescriptor;Ljdk/net/SocketFlow;)V
*/
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_setFlowOption
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow) {
int fd = getFD(env, fileDesc);
if (fd < 0) {
NET_ERROR(env, JNU_JAVANETPKG "SocketException", "socket closed");
return;
} else {
sock_flow_props_t props;
jlong bandwidth;
int rv;
jint priority = (*env)->GetIntField(env, flow, sf_priority);
memset(&props, 0, sizeof(props));
props.sfp_version = SOCK_FLOW_PROP_VERSION1;
if (priority != jdk_net_SocketFlow_UNSET) {
props.sfp_mask |= SFP_PRIORITY;
props.sfp_priority = priority;
}
bandwidth = (*env)->GetLongField(env, flow, sf_bandwidth);
if (bandwidth > -1) {
props.sfp_mask |= SFP_MAXBW;
props.sfp_maxbw = (uint64_t) bandwidth;
}
rv = setsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, sizeof(props));
if (rv < 0) {
if (errno == ENOPROTOOPT) {
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
"unsupported socket option");
} else if (errno == EACCES || errno == EPERM) {
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
"Permission denied");
} else {
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
"set option SO_FLOW_SLA failed");
}
return;
}
setStatus(env, flow, props.sfp_status);
}
}
int
Socket::setBroadcast( bool on )
{
#ifdef SO_BROADCAST
if( isOpen() )
{
int ison = on;
return setsockopt( getFD(), SOL_SOCKET,
SO_BROADCAST,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
(const char*)&ison,
#else
(void*)&ison,
#endif
sizeof( int ) );
}
#endif
errno = EPERM;
return -1;
}
/*
* Class: sun_net_ExtendedOptionsImpl
* Method: getFlowOption
* Signature: (Ljava/io/FileDescriptor;Ljdk/net/SocketFlow;)V
*/
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_getFlowOption
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow) {
int fd = getFD(env, fileDesc);
if (fd < 0) {
NET_ERROR(env, JNU_JAVANETPKG "SocketException", "socket closed");
return;
} else {
sock_flow_props_t props;
int status;
socklen_t sz = sizeof(props);
int rv = getsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, &sz);
if (rv < 0) {
if (errno == ENOPROTOOPT) {
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
"unsupported socket option");
} else if (errno == EACCES || errno == EPERM) {
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
"Permission denied");
} else {
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
"set option SO_FLOW_SLA failed");
}
return;
}
/* first check status to see if flow exists */
status = props.sfp_status;
setStatus(env, flow, status);
if (status == 0) { /* OK */
/* can set the other fields now */
if (props.sfp_mask & SFP_PRIORITY) {
(*env)->SetIntField(env, flow, sf_priority, props.sfp_priority);
}
if (props.sfp_mask & SFP_MAXBW) {
(*env)->SetLongField(env, flow, sf_bandwidth,
(jlong)props.sfp_maxbw);
}
}
}
}
TcpConnection::Ptr TcpListener::accept()
{
struct sockaddr_in clientAddrIn;
socklen_t clientAddrInSize = sizeof(clientAddrIn);
int32_t fd = ::accept(getFD(), (struct sockaddr*)&clientAddrIn, &clientAddrInSize);
if(-1 == fd)
{
if(errno == EAGAIN || errno == EWOULDBLOCK)
return nullptr;
SYS_EXCEPTION(NetException, "::accept");
}
Endpoint remoteEndpoint;
remoteEndpoint.ip.value = clientAddrIn.sin_addr.s_addr; //远端ip
remoteEndpoint.port = ::ntohs(clientAddrIn.sin_port); //远端port
TcpConnection::Ptr ret = TcpConnection::create(fd, remoteEndpoint);
return ret;
}
void FuncDeclaration::semantic3reference(::FuncDeclaration *fd, Scope *sc)
{
if (fd->semanticRun >= PASSsemantic3)
return;
fd->semanticRun = PASSsemantic3;
fd->semantic3Errors = false;
auto FD = getFD(fd);
if (!FD)
return;
const clang::FunctionDecl *Def;
if (!FD->isInvalidDecl() && FD->hasBody(Def))
{
auto globalSc = globalScope(sc->instantiatingModule());
declReferencer.Traverse(fd->loc, globalSc, Def->getBody());
if (auto Ctor = dyn_cast<clang::CXXConstructorDecl>(FD))
for (auto& Init: Ctor->inits())
declReferencer.Traverse(fd->loc, globalSc, Init->getInit());
}
fd->semanticRun = PASSsemantic3done;
}
void put_block(int devId, int blk, char buf[]) {
//reverses the get_block algorithm
lseek(getFD(devId), (long)blk*BLKSIZE, 0);
write(getFD(devId), buf, BLKSIZE);
}
void get_block(int devId, int blk, char buf[]) {
lseek(getFD(devId), (long)blk*BLKSIZE, 0);
read(getFD(devId), buf, BLKSIZE);
}
void SQRT_S(unsigned long word)
{ //04 (04)
sprintf(dis_op, "sqrt.s\t%s, %s", fpr_rn[getFD(word)], fpr_rn[getFS(word)]);
}
void DIV_S(unsigned long word)
{ //03 (03)
sprintf(dis_op, "div.s\t%s, %s, %s", fpr_rn[getFD(word)], fpr_rn[getFS(word)], fpr_rn[getFT(word)]);
}
