// buffer can stay in RAM of Flash
// ret -1 = error, ret 0 = disconnected
int32_t MTD_FLASHMEM Socket::write(void const *buffer, uint32_t length) {
static uint32_t const MAXCHUNKSIZE = 128;
if (!checkConnection())
return -1;
int32_t bytesSent = 0;
// send in chunks of up to MAXCHUNKSIZE bytes
uint8_t rambuf[min(length, MAXCHUNKSIZE)];
uint8_t const *src = (uint8_t const *)buffer;
while (bytesSent < length) {
uint32_t bytesToSend = min(MAXCHUNKSIZE, length - bytesSent);
f_memcpy(rambuf, src, bytesToSend);
int32_t chunkBytesSent =
m_remoteAddress.sin_len == 0
? lwip_send(m_socket, rambuf, bytesToSend, MSG_DONTWAIT)
: lwip_sendto(m_socket, rambuf, bytesToSend, 0, (sockaddr *)&m_remoteAddress, sizeof(m_remoteAddress));
int32_t lasterr = getLastError();
if (lasterr == EAGAIN || lasterr == EWOULDBLOCK) {
chunkBytesSent = 0;
} else if (chunkBytesSent <= 0 || lasterr != 0) {
// error
bytesSent = -1;
break;
}
bytesSent += chunkBytesSent;
src += chunkBytesSent;
}
if (length > 0)
m_connected = (bytesSent > 0);
return bytesSent;
}
void * readClient(void *fd) //thread function to read client input
{
int sd = *(int*)fd;
char clibuff[BUFFSIZE]="";
char *token="";
while(strcmp(token,"exit\n\0")!=0) //while exit condition is not provided by the user
{
bzero(clibuff, BUFFSIZE); //clearing out the buffer to recieve the command
int size_input=read(0, clibuff, BUFFSIZE);
if(!checkConnection(sd)) exit(0);
//update information if command is start
if(strncmp(clibuff,"start",5)==0){
strncpy(startedsession,clibuff+6,size_input-6); // store the name of session
startedsession[size_input-4]=='\0';
finished=0; //session started, not finished
sockd=sd; //update global variable
}
else if(strncmp(clibuff,"finish",6)==0) //update finished flag to 1
finished=1;
write(sd, clibuff, size_input);
sleep(2);
if(!checkConnection(sd)) exit(0);
token=strtok(clibuff, "0");
}
commandControl=1; //thread sync
exit(0);
return 0;
}
/*!
* Very important function, allows all modules to sleep/start from
* send commands. Also if the module has been designated as a interupt
* module then it will send back false for failure also can have
* additional data on how well the module has done
*/
void SamgarModule::SucceedFail( bool Awns, double additionaldata ) {
if( modulemode == ModeInterupt ) {// only send it when you got
// worthwhile data
Bottle &MyBottle = prepare();
MyBottle.clear();
MyBottle.addInt( ActivationCode ); // so it knows its a log report
MyBottle.addString(MyName.c_str());
MyBottle.addDouble(additionaldata);
if(getOutputCount()>0)
write();
currentmode = StateStoped;
}
long i;
while( currentmode != StateRunning)
{
yarp::os::Time::delay(0.01);
i++;
if (i%100==0)
{
checkConnection();
//return;
}
}
checkConnection();
}
bool Ubidots::sendAll(){
bool connected = checkConnection();
char* _packet = (char *) malloc(sizeof(char) * PACKETSIZE);
populatePacket(_packet);
if (strstr(_packet, "ERROR") != NULL || strlen(_packet) > PACKETSIZE){
free(_packet);
return false; // Could not populate the array or max bytes size exceed
}
while (!connected){
connected = checkConnection();
loraConnect(_band); //Attempts to connect
delay(1000);
}
if (!connected){
free(_packet);
return false; // The device is not connected
}
Serial.print("AT+SEND=");
Serial.print(_packet);
Serial.print("\r\n");
if(!readGateway(1000)){
free(_packet);
return false;
}
Serial.flush();
free(_packet);
delay(100);
return true;
}
void Simonoid::init() {
kDebug() << "Restoring";
KConfigGroup lconfig = config();
m_layouttype = ( LayoutType ) lconfig.readEntry ( "LayoutType", ( int ) LayoutTiny);
m_interval = lconfig.readEntry ( "RefreshInterval", 3 );
kDebug() << "Restored to: " << m_layouttype << m_interval;
kDebug() << "Init called";
Plasma::Applet::init();
if ( m_icon.isNull() ) {
setFailedToLaunch ( true, i18n ( "Could not load Simon icon." ) );
exit ( -1 );
}
m_meter = new Plasma::Meter;
m_meter->setVisible ( true );
m_meter->setMeterType ( Plasma::Meter::BarMeterHorizontal );
// m_meter->setMaximumWidth ( 32 );
// m_meter->setSizePolicy ( QSizePolicy::Maximum, QSizePolicy::Expanding );
m_meter->setMaximum ( 100 );
m_meter->setValue ( 0 );
m_lb_status = new Plasma::Label;
m_lb_status->setText ( i18n ( "Status:" ) );
m_lb_status_value = new Plasma::Label;
m_lb_status_value->setText ( "1" );
m_lb_peak = new Plasma::Label;
m_lb_peak->setText ( i18n ( "Peak:" ) );
m_lb_peak_value = new Plasma::Label;
m_lb_peak_value->setText ( "2" );
m_simonicon = new Plasma::IconWidget();
// m_simonicon->setSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Maximum );
m_simonicon->setIcon ( m_icon );
m_simonicon->setOrientation ( Qt::Vertical );
m_simonicon->setDrawBackground ( true );
//m_simonicon->setMaximumHeight(36);
m_simonicon->setAcceptDrops ( false );
initLayout ( m_layouttype );
m_interval = m_interval;
connect ( &m_checkConnectionTimer, SIGNAL (timeout()), this, SLOT (checkConnection()) );
m_checkConnectionTimer.start ( 1000*m_interval );
checkConnection();
update();
}
// (PHP)
folly::Future<folly::Optional<folly::dynamic>> watchmanFlush(
std::chrono::milliseconds timeout
) {
return !checkConnection() || m_unsubcribeInProgress || !m_subscriptionPtr
? folly::makeFuture(folly::Optional<folly::dynamic>())
: m_watchmanClient->flushSubscription(m_subscriptionPtr, timeout);
}
void ClientConnection::socketError(QAbstractSocket::SocketError pSocketError)
{
switch(pSocketError)
{
case QAbstractSocket::ConnectionRefusedError:
_socketError = "Connection Refused";
break;
case QAbstractSocket::RemoteHostClosedError:
_socketError = "Remote Host Closed Connection";
break;
case QAbstractSocket::HostNotFoundError:
_socketError = "Host Not Found";
break;
case QAbstractSocket::SocketAccessError:
_socketError = "Error Accessing Socket";
break;
case QAbstractSocket::SocketResourceError:
_socketError = "Socket Resource Error";
break;
case QAbstractSocket::SocketTimeoutError:
_socketError = "Timeout";
break;
case QAbstractSocket::DatagramTooLargeError:
_socketError = "Datagram Too Large";
break;
case QAbstractSocket::NetworkError:
_socketError = "Network Error";
break;
case QAbstractSocket::AddressInUseError:
_socketError = "Address already in use";
break;
case QAbstractSocket::SocketAddressNotAvailableError:
_socketError = "Address Not Available";
break;
case QAbstractSocket::UnsupportedSocketOperationError:
_socketError = "Unsupported Socket Operation";
break;
case QAbstractSocket::UnfinishedSocketOperationError:
_socketError = "Socket Operation Unfinished";
break;
case QAbstractSocket::ProxyAuthenticationRequiredError:
_socketError = "Proxy Authentication Requierd";
break;
case QAbstractSocket::SslHandshakeFailedError:
_socketError = "Failed SSL Handshake";
break;
case QAbstractSocket::UnknownSocketError:
_socketError = "Unknown Error";
break;
}
if(_status == Connection_Connecting && _connectTimer)
{
checkConnection();
}
else
{
setStatus(MaraClient::Connection_Error);
}
}
void PollServerThread::run()
{
extern volatile bool gPhoneScreenSyncOn;
while ( !m_exit && gPhoneScreenSyncOn ) {
if ( !connecting() ) {
int n = WaitForMessage(m_rfbClient, 500);
if ( n < 0 ) {
m_exit = true;
break;
} else if ( n > 0 ) {
emit messageArrived();
m_lastMessageReceivedTimer.start();
} else if ( checkConnection() ) {
if ( ((ConnectionWindow *)parent())->connected() && m_lastMessageReceivedTimer.elapsed() > QVNCVIEWER_CONNPEND_TIMEOUT ) {
setCheckConnection(false);
m_rfbClient->updateRect.x = m_rfbClient->updateRect.y = 0;
m_rfbClient->updateRect.w = m_rfbClient->width;
m_rfbClient->updateRect.h = m_rfbClient->height;
SendIncrementalFramebufferUpdateRequest(m_rfbClient);
}
}
QTest::qWait(0);
} else if ( connecting() ) {
setCheckConnection(true);
qApp->processEvents(QEventLoop::AllEvents, 10);
}
}
emit connectionClosed();
}
//----------------------------------------------------------------------------
void ctkPluginStorageSQL::cleanupDB()
{
checkConnection();
QSqlDatabase database = QSqlDatabase::database(m_connectionName);
QSqlQuery query(database);
beginTransaction(&query, Write);
try
{
// remove all plug-ins marked as UNINSTALLED
QString statement = "DELETE FROM " PLUGINS_TABLE " WHERE StartLevel==-2";
executeQuery(&query, statement);
// remove all old plug-in generations
statement = "DELETE FROM " PLUGINS_TABLE
" WHERE K NOT IN (SELECT K FROM (SELECT K, MAX(Generation) FROM " PLUGINS_TABLE " GROUP BY ID))";
}
catch (...)
{
rollbackTransaction(&query);
throw;
}
commitTransaction(&query);
}
//----------------------------------------------------------------------------
void ctkPluginStorageSQL::initNextFreeIds()
{
checkConnection();
QSqlDatabase database = QSqlDatabase::database(m_connectionName);
QSqlQuery query(database);
QString statement = "SELECT ID,MAX(Generation) FROM " PLUGINS_TABLE " GROUP BY ID";
executeQuery(&query, statement);
while (query.next())
{
m_generations.insert(query.value(EBindIndex).toInt(),
query.value(EBindIndex1).toInt()+1);
}
query.finish();
query.clear();
statement = "SELECT MAX(ID) FROM " PLUGINS_TABLE;
executeQuery(&query, statement);
QVariant id = query.next() ? query.value(EBindIndex) : QVariant();
if (id.isValid())
{
m_nextFreeId = id.toInt() + 1;
}
else
{
m_nextFreeId = 1;
}
}
void ofxCanonConnection::update() {
if(ofGetElapsedTimeMillis() > should_check_on) {
OFXLOG("ofxCanonConnection: update -> go and check connection.");
checkConnection();
should_check_on = ofGetElapsedTimeMillis() + timeout;
}
}
std::unique_ptr<mongo::DBClientCursor> MockDBClientConnection::query(const string& ns,
mongo::Query query,
int nToReturn,
int nToSkip,
const BSONObj* fieldsToReturn,
int queryOptions,
int batchSize) {
checkConnection();
try {
mongo::BSONArray result(_remoteServer->query(_remoteServerInstanceID,
ns,
query,
nToReturn,
nToSkip,
fieldsToReturn,
queryOptions,
batchSize));
std::unique_ptr<mongo::DBClientCursor> cursor;
cursor.reset(new MockDBClientCursor(this, result));
return cursor;
} catch (const mongo::SocketException&) {
_isFailed = true;
throw;
}
std::unique_ptr<mongo::DBClientCursor> nullPtr;
return nullPtr;
}
/**
* @brief Processes toxcore events and ensure we stay connected, called by its own timer
*/
void Core::process()
{
if (!isReady())
{
av->stop();
return;
}
static int tolerance = CORE_DISCONNECT_TOLERANCE;
tox_iterate(tox);
#ifdef DEBUG
//we want to see the debug messages immediately
fflush(stdout);
#endif
if (checkConnection())
{
tolerance = CORE_DISCONNECT_TOLERANCE;
}
else if (!(--tolerance))
{
bootstrapDht();
tolerance = 3*CORE_DISCONNECT_TOLERANCE;
}
unsigned sleeptime = qMin(tox_iteration_interval(tox), CoreFile::corefileIterationInterval());
toxTimer->start(sleeptime);
}
TcpComm::TcpComm(const char* ip, int port, int maxPackageSendSize, int maxPackageReceiveSize) :
createSocket(0),
transferSocket(0),
overallBytesSent(0),
overallBytesReceived(0),
maxPackageSendSize(maxPackageSendSize),
maxPackageReceiveSize(maxPackageReceiveSize),
wasConnected(false)
{
address.sin_family = AF_INET;
address.sin_port = htons(port);
if(ip) // connect as client?
address.sin_addr.s_addr = inet_addr(ip);
else
{
createSocket = socket(AF_INET, SOCK_STREAM, 0);
ASSERT(createSocket > 0);
int val = 1;
setsockopt(createSocket, SOL_SOCKET, SO_REUSEADDR, (char*) &val, sizeof(val));
address.sin_addr.s_addr = INADDR_ANY;
VERIFY(bind(createSocket, (sockaddr*) &address, sizeof(sockaddr_in)) == 0);
VERIFY(listen(createSocket, SOMAXCONN) == 0);
NON_BLOCK(createSocket);
}
checkConnection();
}
Receiver::Receiver(Rsa *r) : rsa(r)
{
#ifdef REN_DEBUG
qWarning("Receiver::Receiver(Rsa *r) : rsa(r)");
#endif
setName("Receiver");
working = false;
received = false;
if ((inputBuffer = (char *)malloc(IN_BUFSIZE))==NULL)
throw Error(Error::IHU_ERR_MEMORY);
if ((streamBuffer = (char *)malloc(MAXBUFSIZE))==NULL)
throw Error(Error::IHU_ERR_MEMORY);
s = -1;
notifier = NULL;
calen = sizeof(ca);
blowfish = NULL;
outFile = NULL;
checkTimer = new QTimer(this);
reset();
resetStream();
// renyang-modify - 初始化primaddr
primaddr = "";
// renyang-modify - end
connect(checkTimer, SIGNAL(timeout()), this, SLOT(checkConnection()));
}
TcpComm::TcpComm(const char* ip, int port, int maxPackageSendSize, int maxPackageReceiveSize) :
maxPackageSendSize(maxPackageSendSize), maxPackageReceiveSize(maxPackageReceiveSize)
{
address.sin_family = AF_INET;
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wconversion"
#endif
address.sin_port = htons(static_cast<unsigned short>(port));
#ifdef __clang__
#pragma clang diagnostic pop
#endif
if(ip) // connect as client?
address.sin_addr.s_addr = inet_addr(ip);
else
{
createSocket = socket(AF_INET, SOCK_STREAM, 0);
ASSERT(createSocket > 0);
int val = 1;
setsockopt(createSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
address.sin_addr.s_addr = INADDR_ANY;
VERIFY(bind(createSocket, (sockaddr*)&address, sizeof(sockaddr_in)) == 0);
VERIFY(listen(createSocket, SOMAXCONN) == 0);
NON_BLOCK(createSocket);
}
checkConnection();
}
void Core::process()
{
if (!isReady())
return;
static int tolerance = CORE_DISCONNECT_TOLERANCE;
tox_iterate(tox);
toxav_do(toxav);
#ifdef DEBUG
//we want to see the debug messages immediately
fflush(stdout);
#endif
if (checkConnection())
{
tolerance = CORE_DISCONNECT_TOLERANCE;
}
else if (!(--tolerance))
{
bootstrapDht();
tolerance = 3*CORE_DISCONNECT_TOLERANCE;
}
toxTimer->start(qMin(tox_iteration_interval(tox), toxav_do_interval(toxav)));
}
void loop() {
checkConnection();
processAcDisplayData();
// process display data here
delay(5000); // Sleep 1 second
}
void Core::process()
{
tox_do(tox);
#ifdef DEBUG
//we want to see the debug messages immediately
fflush(stdout);
#endif
checkConnection();
}
void Mpris::setPid(quint64 pid)
{
if (m_pid != pid) {
m_pid = pid;
emit targetChanged();
setValid(false);
checkConnection();
}
}
void DBClientConnection::say( Message &toSend ) {
checkConnection();
try {
port().say( toSend );
} catch( SocketException & ) {
failed = true;
throw;
}
}
void Server::setUrl(const QString& url) {
if ("http://" == url.left(7) || "https://" == url.left(8)) {
url_ = url;
} else {
url_ = "http://" + url;
}
checkConnection();
}
OceanServerReader::OceanServerReader( const string &serialPort,
gbxutilacfr::Tracer &tracer )
: serial_( serialPort, BAUDRATE, gbxserialacfr::Serial::Timeout(TIMEOUT_SEC,0) ),
tracer_(tracer),
parser_(tracer),
firstTime_(true)
{
checkConnection();
reset();
}
void Connection::idle()
{
checkConnection();
if (!m_idle)
{
mpd_send_idle(m_connection.get());
checkErrors();
}
m_idle = true;
}
SimpleHttpResult* SimpleHttpClient::request (
int method,
const std::string& location,
const char* body,
size_t bodyLength,
const map<string, string>& headerFields) {
SimpleHttpResult* result = new SimpleHttpResult();
SimpleHttpResult::resultTypes type = SimpleHttpResult::UNKNOWN;
size_t retries = 0;
// build request
stringstream requestBuffer;
fillRequestBuffer(requestBuffer, method, location, body, bodyLength, headerFields);
LOGGER_TRACE << "Request: " << requestBuffer.str();
double start = now();
double runtime = 0.0;
// TODO requestTimeout
while (++retries < _retries && runtime < _requestTimeout) {
// check connection
if (!checkConnection()) {
type = SimpleHttpResult::COULD_NOT_CONNECT;
// LOGGER_WARNING << "could not connect to '" << _connection->getHostname() << ":" << _connection->getPort() << "'";
}
// write
else if (!write(requestBuffer, _requestTimeout - runtime)) {
closeConnection();
type = SimpleHttpResult::WRITE_ERROR;
// LOGGER_WARNING << "write error";
}
// read
else if (!read(result, _requestTimeout - runtime)) {
closeConnection();
type = SimpleHttpResult::READ_ERROR;
// LOGGER_WARNING << "read error";
}
else {
type = SimpleHttpResult::COMPLETE;
break;
}
runtime = now() - start;
}
result->setResultType(type);
return result;
}
void Core::process()
{
tox_do(tox);
#ifdef DEBUG
//we want to see the debug messages immediately
fflush(stdout);
#endif
checkConnection();
//int toxInterval = tox_do_interval(tox);
//qDebug() << QString("Tox interval %1").arg(toxInterval);
toxTimer->start(50);
}
void terrama2::services::view::core::Service::updateAdditionalInfo(const QJsonObject& obj) noexcept
{
if(!obj.contains("maps_server"))
TERRAMA2_LOG_ERROR() << tr("Missing the Maps Server URI in service additional info!");
else
{
mapsServerUri_ = te::core::URI(obj["maps_server"].toString().toStdString());
auto mapsServer = MapsServerFactory::getInstance().make(mapsServerUri_, "GEOSERVER");
mapsServerConnectionStatus_ = mapsServer->checkConnection();
}
}
void * readServer(void *fd) //thread function to read the messages from the server for the user
{
int sd = *(int*)fd;
char servbuff[BUFFSIZE]="";
while(commandControl!=1) //thread sync
{
if(!checkConnection(sd)) exit(0);
bzero(servbuff, BUFFSIZE);
while(read(sd, servbuff,BUFFSIZE)==0 && commandControl!=1)
{
if(!checkConnection(sd)) exit(0); //chilling while waiting instruction to be put in
sleep(5);
}
if(commandControl==1)
break;
printf("Message from server: %s\n",servbuff); //output message from server
if(!checkConnection(sd)) exit(0);
}
close(sd);
return 0;
}
std::pair<rpc::UniqueReply, DBClientBase*> MockDBClientConnection::runCommandWithTarget(
OpMsgRequest request) {
checkConnection();
try {
return {_remoteServer->runCommand(_remoteServerInstanceID, request), this};
} catch (const mongo::SocketException&) {
_isFailed = true;
throw;
}
}
//This function will constantly listen for the server sending new data
void ListenThread::run()
{
connect(this, SIGNAL(tryConnection()), NetworkHandler::networkHandler, SLOT(checkConnection()));
while(true){
this->sleep(1);
//emit a signal to tell the NetworkHandler to check the connection
//emit tryConnection();
}
}
