JNIEXPORT jstring JNICALL Java_com_beegfs_JBeeGFS_getMountID(JNIEnv* env, jobject obj) {
char* mountID;
bool res = beegfs_getMountID(getFd(env, obj), &mountID);
if (res) {
jstring jret = env->NewStringUTF(mountID);
free(mountID);
return jret;
} else {
return NULL;
}
}
JNIEXPORT jstring JNICALL Java_com_beegfs_JBeeGFS_getRuntimeConfigPath(JNIEnv* env, jobject obj) {
char* runtimeConfigPath;
bool res = beegfs_getRuntimeConfigFile(getFd(env, obj), &runtimeConfigPath);
if (res) {
jstring jret = env->NewStringUTF(runtimeConfigPath);
free(runtimeConfigPath);
return jret;
} else {
return NULL;
}
}
void SslServerConn::createSsl()
{
if (_ssl)
{
PARROT_ASSERT(false);
}
_ssl = SslHelper::genSsl(_sslCtx);
PARROT_ASSERT(_ssl);
BIO* bio = BIO_new_socket(getFd(), BIO_NOCLOSE);
SSL_set_bio(_ssl, bio, bio);
}
void Stream::connect(const std::string& ipaddr, unsigned short int port)
{
log_debug("connect to " << ipaddr << " port " << port);
Addrinfo ai(ipaddr, port);
log_debug("do connect");
for (Addrinfo::const_iterator it = ai.begin(); it != ai.end(); ++it)
{
try
{
Socket::create(it->ai_family, SOCK_STREAM, 0);
}
catch (const Exception&)
{
continue;
}
if (::connect(getFd(), it->ai_addr, it->ai_addrlen) == 0)
{
// save our information
memmove(&peeraddr, it->ai_addr, it->ai_addrlen);
return;
}
if (errno == EINPROGRESS && getTimeout() > 0)
{
poll(POLLOUT);
if (::connect(getFd(), it->ai_addr, it->ai_addrlen) == 0)
{
// save our information
memmove(&peeraddr, it->ai_addr, it->ai_addrlen);
return;
}
}
}
throw Exception("connect");
}
bool PlainFile::closeImpl() {
bool ret = true;
s_pcloseRet = 0;
if (!isClosed()) {
if (m_stream) {
s_pcloseRet = fclose(m_stream);
m_stream = nullptr;
} else if (getFd() >= 0) {
s_pcloseRet = ::close(getFd());
}
if (m_buffer) {
free(m_buffer);
m_buffer = nullptr;
}
ret = (s_pcloseRet == 0);
setIsClosed(true);
setFd(-1);
}
File::closeImpl();
return ret;
}
int64_t PlainFile::readImpl(char *buffer, int64_t length) {
assert(valid());
assert(length > 0);
// use read instead of fread to handle EOL in stdin
size_t ret = ::read(getFd(), buffer, length);
if (ret == 0
|| (ret == (size_t)-1
&& errno != EWOULDBLOCK && errno != EINTR && errno != EBADF)) {
setEof(true);
}
return ret == (size_t)-1 ? 0 : ret;
}
void Stream::accept(const Server& server)
{
close();
socklen_t peeraddr_len;
peeraddr_len = sizeof(peeraddr);
log_debug("accept " << server.getFd());
int fd = ::accept(server.getFd(), reinterpret_cast <struct sockaddr *> (&peeraddr), &peeraddr_len);
if (fd < 0)
throw Exception("accept");
setFd(fd);
log_debug("accepted " << server.getFd() << " => " << getFd());
}
bool SSLSocket::checkLiveness() {
if (getFd() == -1) {
return false;
}
pollfd p;
p.fd = getFd();
p.events = POLLIN | POLLERR | POLLHUP | POLLPRI;
p.revents = 0;
if (poll(&p, 1, 0) > 0 && p.revents > 0) {
char buf;
if (m_data->m_ssl_active) {
while (true) {
int n = SSL_peek(m_data->m_handle, &buf, sizeof(buf));
if (n <= 0) {
int err = SSL_get_error(m_data->m_handle, n);
if (err == SSL_ERROR_SYSCALL) {
return errno == EAGAIN;
}
if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
/* re-negotiate */
continue;
}
/* any other problem is a fatal error */
return false;
}
/* either peek succeeded or there was an error; we
* have set the alive flag appropriately */
break;
}
} else if (0 == recv(getFd(), &buf, sizeof(buf), MSG_PEEK) &&
errno != EAGAIN) {
return false;
}
}
return true;
}
void Quorum::start(boost::shared_ptr<sys::Poller> p) {
poller = p;
QPID_LOG(debug, "Connecting to quorum service.");
cman = cman_init(0);
if (cman == 0) throw ErrnoException("Can't connect to cman service");
if (!cman_is_quorate(cman)) {
QPID_LOG(notice, "Waiting for cluster quorum.");
while(!cman_is_quorate(cman)) sys::sleep(5);
}
int err = cman_start_notification(cman, cmanCallbackFn);
if (err != 0) throw ErrnoException("Can't register for cman notifications");
watch(getFd());
}
JNIEXPORT void JNICALL Java_org_lirc_socket_UnixSocketImpl_close
(JNIEnv *env, jobject obj) {
int fd = getFd(env, obj);
#ifdef DEBUG
printf("junixsocket: Closing %i\n", fd);
#endif
if (close(fd) < 0) {
throwIOExc(env, strerror(errno));
return;
}
}
void TcpClientBase::realConnect(bool useSsl){
if(::connect(m_socket.get(), static_cast<const ::sockaddr *>(SockAddr::getData()), SockAddr::getSize()) != 0){
if(errno != EINPROGRESS){
DEBUG_THROW(SystemException);
}
}
if(useSsl){
LOG_POSEIDON_INFO("Initiating SSL handshake...");
AUTO(ssl, g_clientSslFactory.createSsl());
boost::scoped_ptr<SslFilterBase> filter(new SslFilter(STD_MOVE(ssl), getFd()));
initSsl(STD_MOVE(filter));
}
}
static void openAndLockNameFile(const std::string &nameFile, T &fstream)
{
fstream.open(nameFile);
if (!fstream.is_open()) {
LogError("Unable to open file" << nameFile << ": " << GetErrnoString(errno));
ThrowMsg(PermissibleSetException::FileOpenError, "Unable to open file ");
}
int ret = TEMP_FAILURE_RETRY(flock(getFd(fstream), LOCK_EX));
if (ret == -1) {
LogError("Unable to lock file " << nameFile << ": " << GetErrnoString(errno));
ThrowMsg(PermissibleSetException::FileLockError, "Unable to lock file");
}
}
void jsTTY_t :: onCtrlC( void )
{
exitStatus_ = 3 ;
exitRequested_ = true ;
tcsetattr( getFd(), TCSANOW, &oldTermState_ );
// flag <Ctrl-C> for menu code
FILE *fCtrlc = fopen( "/tmp/ctrlc", "wb" );
if( fCtrlc )
{
fprintf( fCtrlc, "<Ctrl-C> hit\n" );
fclose( fCtrlc );
}
}
JNIEXPORT void JNICALL Java_org_lirc_socket_UnixSocketImpl_shutdownOutput
(JNIEnv *env, jobject obj) {
int fd;
fd = getFd(env, obj);
#ifdef DEBUG
printf("junixsocket: Shutting down output for %i\n", fd);
#endif
if (shutdown(fd, 1) < 0) {
throwIOExc(env, strerror(errno));
return;
}
}
void GnuTlsStream::handshake(const GnuTlsServer& server)
{
log_debug("gnutls_init(session, GNUTLS_SERVER)");
int ret = gnutls_init(&_session, GNUTLS_SERVER);
if (ret != 0)
throw GnuTlsException("gnutls_init", ret);
log_debug("gnutls_set_default_priority");
ret = gnutls_set_default_priority(_session);
if (ret != 0)
throw GnuTlsException("gnutls_set_default_priority", ret);
log_debug("gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, "
<< server.getCred() << ')');
ret = gnutls_credentials_set(_session, GNUTLS_CRD_CERTIFICATE, server.getCred());
if (ret != 0)
throw GnuTlsException("gnutls_credentials_set", ret);
log_debug("gnutls_dh_set_prime_bits(session, 1024)");
gnutls_dh_set_prime_bits(_session, 1024);
_fdInfo.fd = getFd();
_fdInfo.timeout = getTimeout();
log_debug("gnutls_transport_set_ptr(ptr)");
gnutls_transport_set_ptr(_session, static_cast<gnutls_transport_ptr_t>(&_fdInfo));
log_debug("gnutls_transport_set_pull_function()");
gnutls_transport_set_pull_function(_session, pull_func);
log_debug("gnutls_transport_set_push_function()");
gnutls_transport_set_push_function(_session, push_func);
// non-blocking/with timeout
_fdInfo.timeout = 10000;
log_debug("gnutls_handshake");
ret = gnutls_handshake(_session);
log_debug("gnutls_handshake => " << ret);
if (ret != 0)
throw GnuTlsException("gnutls_handshake", ret);
_connected = true;
_fdInfo.timeout = getTimeout();
log_debug("ssl-handshake was completed");
}
/*
* public native void sync()
*/
static void fd_sync(JNIEnv* env, jobject obj) {
int fd = getFd(env, obj);
if (fsync(fd) != 0) {
/*
* If fd is a socket, then fsync(fd) is defined to fail with
* errno EINVAL. This isn't actually cause for concern.
* TODO: Look into not bothering to call fsync() at all if
* we know we are dealing with a socket.
*/
if (errno != EINVAL) {
jniThrowException(env, "java/io/SyncFailedException", "");
}
}
}
JNIEXPORT void JNICALL Java_org_lirc_socket_UnixSocketImpl_listen
(JNIEnv *env, jobject obj, jint backlog) {
// get fd
int fd = getFd(env, obj);
#ifdef DEBUG
printf("junixsocket: listen(%i, %i)\n", fd, backlog);
#endif
// listen
if (listen(fd, backlog) < 0) {
close(fd);
throwIOExc(env, strerror(errno));
return;
}
}
JNIEXPORT jobject JNICALL Java_com_beegfs_JBeeGFS_getStripeInfo(JNIEnv* env, jobject obj) {
unsigned patternType;
unsigned chunkSize;
uint16_t numTargets;
if (beegfs_getStripeInfo(getFd(env, obj), &patternType, &chunkSize, &numTargets) ) {
jclass jstripeinfo = env->FindClass("com/beegfs/JBeeGFS$StripeInfo");
if (!jstripeinfo) return NULL;
jmethodID jstripeinfoconstructor = env->GetMethodID(jstripeinfo, "<init>", "(IJI)V");
if (!jstripeinfoconstructor) return NULL;
jobject jstripeinfoobject = env->NewObject(jstripeinfo, jstripeinfoconstructor,
patternType, chunkSize, numTargets);
return jstripeinfoobject;
} else {
return NULL;
}
}
static unsigned long volatile *getReg(unsigned long addr){
static void *map = 0 ;
static unsigned prevPage = -1U ;
unsigned page = addr & ~MAP_MASK ;
if( page != prevPage ){
if( map ){
munmap(map,MAP_SIZE);
}
map = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, getFd(), page );
if( MAP_FAILED == map ){
perror("mmap");
exit(1);
}
prevPage = page ;
}
unsigned offs = addr & MAP_MASK ;
return (unsigned long volatile *)((char *)map+offs);
}
bool PlainFile::open(const String& filename, const String& mode) {
int fd;
FILE *f;
assert(m_stream == nullptr);
assert(getFd() == -1);
// For these definded in php fopen but C stream have different modes
switch (mode[0]) {
case 'x':
if (mode.find('+') == -1) {
fd = ::open(filename.data(), O_WRONLY|O_CREAT|O_EXCL, 0666);
if (fd < 0) return false;
f = fdopen(fd, "w");
} else {
fd = ::open(filename.data(), O_RDWR|O_CREAT|O_EXCL, 0666);
if (fd < 0) return false;
f = fdopen(fd, "w+");
}
break;
case 'c':
if (mode.find('+') == -1) {
fd = ::open(filename.data(), O_WRONLY|O_CREAT, 0666);
if (fd < 0) return false;
f = fdopen(fd, "w");
} else {
fd = ::open(filename.data(), O_RDWR|O_CREAT, 0666);
if (fd < 0) return false;
f = fdopen(fd, "w+");
}
break;
default:
f = fopen(filename.data(), mode.data());
}
if (!f) {
return false;
}
m_stream = f;
setFd(fileno(f));
m_buffer = (char *)malloc(BUFSIZ);
setName(filename.toCppString());
if (m_buffer)
setbuffer(f, m_buffer, BUFSIZ);
return true;
}
int Sequencer_oss::transmitVoiceMessage(void) {
synth_write_message[0] = EV_CHN_VOICE;
synth_write_message[1] = synth_message_curr_device;
synth_write_message[2] = synth_message_buffer[0] & 0xf0;
synth_write_message[3] = synth_message_buffer[0] & 0x0f;
synth_write_message[4] = synth_message_buffer[1];
synth_write_message[5] = synth_message_buffer[2];
synth_write_message[6] = 0;
synth_write_message[7] = 0;
int status;
status = ::write(getFd(), synth_write_message, sizeof(synth_write_message));
if (status > 0) {
return 1;
} else {
return 0;
}
}
static void startOperation(asyncOp *op,
IoActionTy action,
uint64_t usTimeout)
{
selectBase *localBase = (selectBase*)op->info.object->base;
op->info.currentAction = action;
if (op->info.currentAction == ioMonitor)
op->info.status = aosMonitoring;
else
op->info.status = aosPending;
if (op->useInternalBuffer && (action == ioWrite || action == ioWriteMsg)) {
if (op->internalBuffer == 0) {
op->internalBuffer = malloc(op->info.transactionSize);
op->internalBufferSize = op->info.transactionSize;
} else if (op->internalBufferSize < op->info.transactionSize) {
op->internalBufferSize = op->info.transactionSize;
op->internalBuffer = realloc(op->internalBuffer,
op->info.transactionSize);
}
memcpy(op->internalBuffer, op->info.buffer, op->info.transactionSize);
}
OpLinksMap &links = isWriteOperation(action) ?
localBase->writeOps : localBase->readOps;
switch (action) {
case ioMonitorStop :
asyncOpUnlink(op);
break;
default :
asyncOpLink(getFdOperations(links, getFd(op)), op);
break;
}
if (action == ioMonitorStop || action == ioMonitor)
selectPostEmptyOperation((asyncBase*)localBase);
if (usTimeout)
startTimer(op, usTimeout, 0);
}
void TCPPipe::initializePipe(TCPPipe::Endianness sEndianness)
{
/* Set socket options: */
TCPSocket::setNoDelay(true);
if(sEndianness==LittleEndian)
{
#if __BYTE_ORDER==__BIG_ENDIAN
readMustSwapEndianness=writeMustSwapEndianness=true;
#endif
}
else if(sEndianness==BigEndian)
{
#if __BYTE_ORDER==__LITTLE_ENDIAN
readMustSwapEndianness=writeMustSwapEndianness=true;
#endif
}
else if(sEndianness==Automatic)
{
/* Exchange a magic value to test for endianness on the other end: */
unsigned int magic=0x12345678U;
blockingWrite(&magic,sizeof(unsigned int));
blockingRead(&magic,sizeof(unsigned int));
if(magic==0x78563412U)
readMustSwapEndianness=true;
else if(magic!=0x12345678U)
Misc::throwStdErr("Comm::TCPPipe: Unable to establish connection with host %s on port %d",getPeerHostname().c_str(),getPeerPortId());
}
/* Allocate the read and write buffers: */
int maxSegSize=-1;
socklen_t maxSegLen=sizeof(int);
if(getsockopt(getFd(),IPPROTO_TCP,TCP_MAXSEG,&maxSegSize,&maxSegLen)<0)
Misc::throwStdErr("Comm::TCPPipe: Unable to determine maximum TCP segment size");
bufferSize=size_t(maxSegSize);
readBuffer=new char[bufferSize];
rbPos=readBuffer;
readSize=0;
writeBuffer=new char[bufferSize];
wbPos=writeBuffer;
writeSize=bufferSize;
}
int SerialImpl::write(void * buf, int size)
{
if ( (NULL == buf) || (0 >= size) ) {
kuDebug (kuERR, "[SerialImpl::read] input is invalid \n");
return (kuNOK);
}
if (kuTRUE == kuCanPrint (kuDATA)) {
kuDebug (kuMON, "[SerialImpl::write] dev(%s) ----------------------\n", m_strDevName.c_str());
kuStd::dump (size, (char *)buf);
}
if (size != writeWithControl (getFd(), (char *)buf, size)) {
return (kuNOK);
}
kuDebug (kuTRACE, "[SerialImpl::write] dev(%s) : writes(%d)\n", getDevName(), size);
return (kuOK);
}
static jlong android_os_ParcelFileDescriptor_getStatSize(JNIEnv* env,
jobject clazz)
{
jint fd = getFd(env, clazz);
if (fd < 0) {
jniThrowException(env, "java/lang/IllegalArgumentException", "bad file descriptor");
return -1;
}
struct stat st;
if (fstat(fd, &st) != 0) {
return -1;
}
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
return st.st_size;
}
return -1;
}
int Sequencer_oss::write(int device, int aByte) {
int status = 0;
switch (getOutputType(device)) {
case MIDI_EXTERNAL:
midi_write_packet[1] = (uchar) (0xff & aByte);
midi_write_packet[2] = getOutDeviceValue(device);
status = ::write(getFd(), midi_write_packet,sizeof(midi_write_packet));
break;
case MIDI_INTERNAL:
status = writeInternal(getOutDeviceValue(device), aByte);
break;
}
if (status > 0) {
return 1;
} else {
return 0;
}
}
void udpRxPoll_t :: onDataAvail( void )
{
sockaddr_in fromAddr ;
deviceMsg_t msg ;
socklen_t fromSize = sizeof( fromAddr );
int numRead = recvfrom( getFd(),
(char *)&msg, sizeof( msg ), 0,
(struct sockaddr *)&fromAddr,
&fromSize );
if( offsetof( deviceMsg_t, data_ ) <= numRead )
{
// check message lengths
if( deviceMsg_t :: audio_e == msg.type_ )
{
unsigned const expected = sizeof( msg )-sizeof( msg.data_ )+msg.length_ ;
if( expected != numRead )
{
fprintf( stderr, "Weird size : len %lu, expected %lu, read %u\n", msg.length_, expected, numRead );
return ;
}
}
else if( deviceMsg_t :: unlock_e == msg.type_ )
{
}
else if( deviceMsg_t :: lock_e == msg.type_ )
{
}
else
{
printf( "unknown msgtype %d\n", msg.type_ );
return ;
}
onMsg( msg );
}
else
{
fprintf( stderr, "udpRecvfrom:%d:%d:%m\n", numRead, errno );
}
}
int Sequencer_oss::transmitCommonMessage(void) {
synth_write_message[0] = EV_CHN_COMMON;
synth_write_message[1] = synth_message_curr_device;
synth_write_message[2] = synth_message_buffer[0] & 0xf0;
synth_write_message[3] = synth_message_buffer[0] & 0x0f;
switch (synth_write_message[2]) {
case 0xB0: // Control change
synth_write_message[4] = synth_message_buffer[1];
synth_write_message[5] = 0;
synth_write_message[6] = synth_message_buffer[2];
synth_write_message[7] = 0;
break;
case 0xC0: // Patch change
case 0xD0: // Channel pressure
synth_write_message[4] = synth_message_buffer[1];
synth_write_message[5] = 0;
synth_write_message[6] = 0;
synth_write_message[7] = 0;
break;
case 0xE0: // Pitch wheel
synth_write_message[4] = 0;
synth_write_message[5] = 0;
synth_write_message[6] = synth_message_buffer[1];
synth_write_message[7] = synth_message_buffer[2];
break;
default:
std::cerr << "Unknown Common MIDI message" << std::endl;
exit(1);
}
int status;
status = ::write(getFd(), synth_write_message, sizeof(synth_write_message));
if (status > 0) {
return 1;
} else {
return 0;
}
}
std::string Server::getStatsDocument() const {
std::ostringstream doc;
doc << "clear();" << std::endl;
for (auto it = _connections.begin(); it != _connections.end(); ++it) {
doc << "connection({";
auto connection = it->first;
jsonKeyPairToStream(doc,
"since", EpochTimeAsLocal(it->second),
"fd", connection->getFd(),
"id", reinterpret_cast<uint64_t>(connection),
"uri", connection->getRequestUri(),
"addr", formatAddress(connection->getRemoteAddress()),
"user", connection->credentials() ?
connection->credentials()->username : "******",
"input", connection->inputBufferSize(),
"read", connection->bytesReceived(),
"output", connection->outputBufferSize(),
"written", connection->bytesSent()
);
doc << "});" << std::endl;
}
return doc.str();
}
touchPoll_t :: touchPoll_t
( pollHandlerSet_t &set,
char const *devName )
: pollHandler_t( openTouchDev( getTouchDev(devName) ), set )
, timer_( 0 )
, isSerial_( isSerial(getTouchDev(devName)) )
, state_( findStart )
, iVal_( 0 )
, jVal_( 0 )
, nextTrace_( 0 )
, lastRead_( 0 )
, lastChar_( 0 )
{
debugPrint( "touchPoll constructed, dev = %s, fd == %d\n", getTouchDev(devName), getFd() );
if( isOpen() )
{
fcntl( fd_, F_SETFD, FD_CLOEXEC );
fcntl( fd_, F_SETFL, O_NONBLOCK );
setMask( POLLIN );
set.add( *this );
if( isSerial_ )
timer_ = new touchPollTimer_t( *this );
}
}