int AutoAdapter::onTryConnectEcu(bool sendReply)
{
int protocol = 0;
connected_ = false;
sts_ = REPLY_NO_DATA;
sampleSent_ = false;
// CAN
protocol = doConnect(ADPTR_CAN, sendReply);
if (protocol > 0)
return protocol;
// CAN 29
return doConnect(ADPTR_CAN_EXT, sendReply);
}
// Constructor
OsDatagramSocket::OsDatagramSocket(int remoteHostPortNum, const char* remoteHost,
int localHostPortNum, const char* localHost)
: mNumTotalWriteErrors(0)
, mNumRecentWriteErrors(0)
, mSimulatedConnect(FALSE) // Simulated connection is off until
// activated in doConnect.
{
int error = ctorCommonCode();
if (error != 0)
{
OsSysLog::add(FAC_KERNEL, PRI_DEBUG,
"OsDatagramSocket::OsDatagramSocket( %s:%d %s:%d) failed w/ errno %d)",
remoteHost, remoteHostPortNum, localHost ? localHost : "NULL",
localHostPortNum, error);
goto EXIT;
}
// Bind to the socket
bind(localHostPortNum, localHost);
if (!isOk())
{
goto EXIT;
}
// Kick off connection
doConnect(remoteHostPortNum, remoteHost, mSimulatedConnect);
EXIT:
return;
}
TCPSocket::TCPSocket(const Address& address, TCPSocketObserver *o)
throw(NetworkException)
: SocketBase(address,true), observer(o)
{
doConnect();
setNoDelay();
}
void CSchedule::Start()
{
if (!m_summer.Initialize())
{
return ;
}
for (int i=0; i< 1; i++)
{
CProcess * p = new CProcess();
if (p->Start())
{
m_process.push_back(p);
}
}
if (g_startType == 0)
{
if (m_accept.OpenAccept(g_remoteIP.c_str(), g_remotePort))
{
LOGI("open server port [" << g_remotePort << "] success");
}
CTcpSocketPtr s(new zsummer::network::CTcpSocket());
s->Initialize(m_process[m_iCurProcess]->GetZSummer());
m_accept.DoAccept(s, std::bind(&CSchedule::OnAccept, this, std::placeholders::_1, std::placeholders::_2, m_process[m_iCurProcess]));
}
else
{
doConnect(g_maxClient);
}
m_thread = std::thread(std::bind(&CSchedule::Run, this));
}
bool DekControl::unlock(string alias, Password *key) {
printf("DekControl::unlock\n");
shared_ptr<SerializedItem> sKey(key->serialize());
sKey->dump("DekControl::unlock");
int sock = doConnect();
if(sock < 0) {
printf("Cannot connect\n");
return false;
}
string cmd = "0 ctl " + std::to_string(CommandCode::CommandUnlock) + " "
+ alias + " " + sKey->toString();
printf("cmd :: %s\n", cmd.c_str());
write(sock, cmd.c_str(), cmd.size() + 1);
shared_ptr<DaemonEvent> event(monitor(sock));
close(sock);
if(event->code == ResponseCode::CommandOkay) {
return true;
}
printf("Failed to unlock [%d]\n", event->code);
return false;
}
void CloudReconnectWorker::doReconnect ( const AbsOptCloudClientWorker::BufferType& data )
{
gvr::communication::ucc::UccMessageCloudReconnect uccCloudReconnect;
if (uccCloudReconnect.parse(data))
{
std::string jsonMessage;
{
uccCloudReconnect.getJson().serialize(jsonMessage);
LOG_VNotice(core, "Received a reconnect command from the UCC [\n%s\n].\n", jsonMessage.c_str());
}
{
std::string decryptedData;
bool replaceOldEncryptedDataFile = false;
bool decryptedDataOK = getDecryptedConnectionData(decryptedData);
bool reconectStartOk = decryptedDataOK && (m_cloudStatus.getDeviceId().compare(uccCloudReconnect.getDeviceId()) == 0);
sendReconnectResponse(uccCloudReconnect.getMessageId(), reconectStartOk);
if(reconectStartOk)
{
LOG_VNotice(core, "Decrypted connection data Ok, doing a connect..\n", jsonMessage.c_str());
doConnect(decryptedData);
}
}
}
else
{
LOG_VError(core, "UccMessageCloudReconnect Error [%s].\n", "Message parsing failed for reset command failed.");
}
}
bool SensorfwSensorBase::doConnectAfterCheck()
{
if (!m_sensorInterface) return false;
// buffer size
int size = bufferSize();
if (size == m_bufferSize) return true;
if (m_bufferingSensors.contains(sensor()->identifier()))
m_sensorInterface->setBufferSize(size);
else
size = 1;
// if multiple->single or single->multiple or if uninitialized
if ((m_bufferSize > 1 && size == 1) || (m_bufferSize == 1 && size > 1) || m_bufferSize == -1) {
m_bufferSize = size;
disconnect(this);
if (!doConnect()) {
qWarning() << "Unable to connect "<< sensorName();
return false;
}
return true;
}
m_bufferSize = size;
return true;
}
Client::Client(IoService& t_ioService, TcpResolverIterator t_endpointIterator,
std::string const& t_path)
: m_ioService(t_ioService), m_socket(t_ioService),
m_endpointIterator(t_endpointIterator), m_path(t_path)
{
doConnect();
openFile(m_path);
}
PacketStorage::PacketStorage(QObject *parent)
: QThread(parent),endThreadFlag(false)
{
//做一些初始化工作，主要是连接信号和槽
doConnect();
//开始线程
start();
}
FmRepair::FmRepair(QWidget *parent)
:QDialog(parent)
{
setupUi(this);
// listItems.clear();
fillLists();
doConnect();
}
Client::Client(boost::asio::io_service& ioService, tcp::resolver::iterator endpointIterator, ClientSettings settings)
: ioService_(ioService), socket_(ioService)
{
// Initialize
settings_ = settings;
// Connect our client
doConnect(endpointIterator);
}
//-----------------------------------------------------------------------------
// 描述: 建立数据库连接并进行相关设置 (若失败则抛出异常)
//-----------------------------------------------------------------------------
void DbConnection::connect()
{
if (!isConnected_)
{
doConnect();
execCmdOnConnected();
isConnected_ = true;
}
}
void Connection::startConnect(const string& host, int port) {
// Create a non-blocking socket.
client_fd_ = socket(AF_INET, SOCK_STREAM, 0);
if (client_fd_ < 0) {
error_string_.append("Socket failed: ");
error_string_.append(strerror(errno));
in_error_ = true;
return;
}
int flags = fcntl(client_fd_, F_GETFL, 0);
fcntl(client_fd_, F_SETFL, flags | O_NONBLOCK);
// Prepare to and start connection to 'host:port'.
struct sockaddr_in serv_addr;
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(port);
inet_pton(AF_INET, host.c_str(), &serv_addr.sin_addr);
int res = connect(client_fd_, (sockaddr*) &serv_addr, sizeof(serv_addr));
// Regardless of the success on connecting, we expect the user's
// 'connDone()' up-call to be issued. Therefore doConnect() is called
// -- directly, if success or failure in connecting is detected
// immediately, or indirectly, otherwise. The acquire() here is
// matched by a release() in doConnect().
acquire();
if (res >= 0) {
doConnect();
} else if ((errno != EINPROGRESS) && (errno != EINTR)) {
::close(client_fd_);
client_fd_ = -1;
error_string_.append("Connect failed: ");
error_string_.append(strerror(errno));
in_error_ = true;
doConnect();
} else {
Callback<void>* write_cb = makeCallableMany(&Connection::doConnect, this);
IOManager* io_manager = io_service_->io_manager();
io_desc_ = io_manager->newDescriptor(client_fd_, NULL, write_cb);
io_desc_->writeWhenReady();
}
}
void
TCPSocket::onResolved()
{
SocketBase::onResolved();
create();
setNonBlocking();
setConfigured();
doConnect();
setNoDelay();
}
EncKey *DekClient::encrypt(string alias, SymKey *key) {
printf("DekClient::encrypt\n");
int sock = doConnect();
if(sock < 0) {
printf("Cannot connect\n");
return false;
}
shared_ptr<SerializedItem> sKey(key->serialize());
sKey->dump("DekClient::encrypt");
string cmd = "0 enc " + std::to_string(CommandCode::CommandEncrypt) + " "
+ alias + " " + sKey->toString();
printf("cmd :: %s\n", cmd.c_str());
write(sock, cmd.c_str(), cmd.size() + 1);
shared_ptr<DaemonEvent> event(monitor(sock));
close(sock);
if(event == NULL) {
printf("Failed to encrypt : %d\n", __LINE__);
return NULL;
}
event->dump("encrypt return event");
if(event->code == ResponseCode::CommandOkay) {
int alg = std::stoi(event->message[0]);
shared_ptr<SerializedItem> sItem;
switch(alg) {
case CryptAlg::AES:
sItem = shared_ptr<SerializedItem> (
new SerializedItem(alg, event->message[1].c_str(),
event->message[2].c_str(), "?"));
break;
case CryptAlg::ECDH:
sItem = shared_ptr<SerializedItem> (
new SerializedItem(alg, event->message[1].c_str(),
event->message[2].c_str(), event->message[3].c_str()));
break;
default:
printf("Failed to encrypt. unknown alg %d\n", alg);
break;
}
return (EncKey *) sItem->deserialize();
} else {
printf("Failed to encrypt [%d]\n",
(event == NULL) ? ResponseCode::CommandFailed : event->code);
return NULL;
}
return NULL;
}
void OpenSSLContext::handleDataFromNetwork(const SafeByteArray& data) {
BIO_write(readBIO_, vecptr(data), data.size());
switch (state_) {
case Connecting:
doConnect();
break;
case Connected:
sendPendingDataToApplication();
break;
case Start: assert(false); break;
case Error: /*assert(false);*/ break;
}
}
/*
* dblink_connect(server text) : boolean
*/
Datum
dblink_connect(PG_FUNCTION_ARGS)
{
text *name = PG_GETARG_TEXT_PP(0);
Conn *conn;
bool isNew;
conn = doConnect(name, name, &isNew);
conn->use_xa = PG_GETARG_BOOL(1);
conn->keep = true;
PG_RETURN_BOOL(isNew);
}
void Initiator::connect()
{
Locker l(m_mutex);
SessionIDs disconnected = m_disconnected;
SessionIDs::iterator i = disconnected.begin();
for ( ; i != disconnected.end(); ++i )
{
Session* pSession = Session::lookupSession( *i );
if ( pSession->isEnabled() && pSession->isSessionTime(UtcTimeStamp()) )
doConnect( *i, m_settings.get( *i ));
}
}
void TcpMediaChannel::Connect(const MediaURL& url) {
my_url_ = url;
is_ready_ = false;
Close();
createSocket();
int ret = doConnect();
if ( ret < 0) {
Close();
SignalChannelOpened(this, false);
}
}
T MysqlConnection_new(URL_T url, char **error) {
T C;
MYSQL *db;
assert(url);
assert(error);
if (! (db = doConnect(url, error)))
return NULL;
NEW(C);
C->db = db;
C->url = url;
C->sb = StringBuffer_create(STRLEN);
C->timeout = SQL_DEFAULT_TIMEOUT;
return C;
}
T OracleConnection_new(URL_T url, char **error) {
T C;
assert(url);
assert(error);
NEW(C);
C->url = url;
C->sb = StringBuffer_create(STRLEN);
C->timeout = SQL_DEFAULT_TIMEOUT;
if (! doConnect(C, url, error)) {
OracleConnection_free(&C);
return NULL;
}
C->txnhp = NULL;
return C;
}
void Device::on_btn_getStatus_clicked()
{
qDebug()<<"btn_getStatus_clicked";
bool ret=false;
//this->dev_ip= "127.0.0.1";
qDebug()<<this->dev_ip;
ret = doConnect(this->dev_ip); ///< call doConnect and passing device's IP
if(ret==false) ///< check for device is present in network or not
{
QErrorMessage *err_msg= new QErrorMessage();
err_msg->setWindowTitle("ERROR!");
err_msg->showMessage("SORRY! Device not found ");
return;
}
}
MainViewWidget::MainViewWidget ( QWidget *parent )
: QWidget ( parent )
{
setupUi ( this );
filterBar->setFilterListLayout(filterListLayout);
filterBar->setCurFilterWidget(curFilterWidget);
curFilterWidget->setVisible(false);
quickSearchWidget->setVisible(false);
quickSearchWait = 4000;
quickSearchTimer = 0;
m_forceReloadSelection = false;
FMFontDb::DB()->clearFilteredFonts();
listView->setNumCol(4);
listView->setModelColumn(1);
listView->setViewMode(QListView::IconMode);
listView->setIconSize(QSize(qRound(listView->width() ), 1.3 * typotek::getInstance()->getPreviewSize() * typotek::getInstance()->getDpiY() / 72.0));
listView->setUniformItemSizes(true);
listView->setMovement(QListView::Static);
previewModel = new FMPreviewModel( this, listView );
previewModel->setSpecString("<family>");
previewModel->setFamilyMode(true);
listView->setModel(previewModel);
iconPS1 = QIcon(":/icon-PS1");
iconTTF = QIcon(":/icon-TTF");
iconOTF = QIcon(":/icon-OTF");
theVeryFont = 0;
typo = typotek::getInstance();
// m_lists = ListDockWidget::getInstance();
// currentFonts = typo->getAllFonts();
FMFontDb::DB()->filterAllFonts();
fontsetHasChanged = true;
QSettings settings;
activateByFamilyOnly = settings.value("ActivateOnlyFamily", false).toBool();
currentOrdering = "family" ;
doConnect();
listView->setFocus(Qt::OtherFocusReason);
}
T SqlServerConnection_new(URL_T url, char **error) {
T C;
SqlServer_T db;
assert(url);
assert(error);
if (! (db = doConnect(url, error)))
return NULL;
NEW(C);
C->db = db;
C->url = url;
C->timeout = SQL_DEFAULT_TIMEOUT;
C->sb = StringBuffer_create(STRLEN);
C->err = StringBuffer_create(STRLEN);
// if (! setProperties(C, error))
// SqlServerConnection_free(&C);
return C;
}
void TcpRpcChannel::serverConnected(const boost::system::error_code& ec, tcp::resolver::iterator iter) {
if (ec) {
if (iter == tcp::resolver::iterator()) {
GOOGLE_LOG(ERROR) << "fail to connect to server " << serverAddr_ << ":" << serverPort_;
connectTried_ = true;
startConnect();
} else {
doConnect(++iter);
}
} else {
//the connection to server is established
GOOGLE_LOG(INFO) << "connect to server " << serverAddr_ << ":" << serverPort_ << " successfully";
boost::system::error_code error;
sock_.set_option(tcp::socket::reuse_address(true), error);
startRead();
connectTried_ = true;
}
}
bool KviHttpRequest::start()
{
// ensure that the file is closed
resetInternalStatus();
resetStatus();
if(m_eProcessingType == StoreToFile)
{
if(m_szFileName.isEmpty())
{
m_szLastError = __tr2qs("No filename specified for the \"StoreToFile\" processing type");
return false;
}
if((m_eExistingFileAction == Resume) && (m_uContentOffset == 0))
{
// determine the content offset automatically
if(KviFile::exists(m_szFileName))
{
// we check it
QFileInfo fi(m_szFileName);
m_uContentOffset = fi.size();
}
}
}
if(m_connectionUrl.host().isEmpty())
{
resetInternalStatus();
m_szLastError = __tr2qs("Invalid URL: missing hostname");
return false;
}
m_p->bIsSSL = KviQString::equalCI(m_connectionUrl.protocol(),"https");
if(!KviQString::equalCI(m_connectionUrl.protocol(),"http") && !m_p->bIsSSL)
{
resetInternalStatus();
m_szLastError=__tr2qs("Unsupported protocol %1").arg(m_connectionUrl.protocol());
return false;
}
return doConnect();
}
SymKey *DekClient::decrypt(string alias, EncKey *key) {
printf("DekClient::decrypt\n");
int sock = doConnect();
if(sock < 0) {
printf("Cannot connect\n");
return false;
}
shared_ptr<SerializedItem> sKey(key->serialize());
sKey->dump("DekClient::decrypt");
string cmd = "0 enc " + std::to_string(CommandCode::CommandDecrypt) + " "
+ alias + " " + sKey->toString();
printf("cmd :: %s\n", cmd.c_str());
write(sock, cmd.c_str(), cmd.size() + 1);
shared_ptr<DaemonEvent> event(monitor(sock));
close(sock);
if(event == NULL) {
printf("Failed to encrypt : %d\n", __LINE__);
return NULL;
}
if(event->code == ResponseCode::CommandOkay) {
int alg = std::stoi(event->message[0]);
if(alg != CryptAlg::PLAIN) {
printf("Failed to decrypt : result is not plain text\n");
return NULL;
}
shared_ptr<SerializedItem> sItem(
new SerializedItem(CryptAlg::PLAIN, event->message[1].c_str(),
"?", "?"));
return (SymKey *) sItem->deserialize();
} else {
printf("Failed to decrypt [%d]\n",
(event == NULL) ? ResponseCode::CommandFailed : event->code);
return NULL;
}
return NULL;
}
TestClient::TestClient()
: KMainWindow( 0 ),
m_status( AppDisconnected ), m_view( new QWidget( this ) )
{
ui.setupUi( m_view );
setCentralWidget(m_view);
networkStatusChanged( Solid::Networking::status() );
appDisconnected();
kDebug() << "About to connect";
connect( Solid::Networking::notifier(), SIGNAL(statusChanged(Solid::Networking::Status)), SLOT(networkStatusChanged(Solid::Networking::Status)) );
kDebug() << "Connected.";
connect( Solid::Networking::notifier(), SIGNAL(shouldConnect()), this, SLOT(doConnect()) );
connect( Solid::Networking::notifier(), SIGNAL(shouldDisconnect()), this, SLOT(doDisconnect()) );
connect( ui.connectButton, SIGNAL(clicked()), SLOT(connectButtonClicked()) );
}
// The connection of found from connection list of same address is returned.
connection* connections::connect(const std::string& hst, const char* port,
handshake f, void* data, bool newConnection, bool clearNRCache)
{
bool namedPipe = false;
connection* c;
std::string host = hst;
unsigned int opt = clearNRCache ? HST_OPTION_CLEAR_CACHE : 0;
char buf[MAX_PATH];
if (m_haNameResolver)
{
m_haNameResolver(hst.c_str(), port, buf, opt);
char* p = strchr(buf, ':');
if (p)
{
*p = 0x00;
port = p + 1;
}
host = buf;
}
mutex::scoped_lock lck(m_mutex);
asio::ip::tcp::endpoint ep = endpoint(host, port, m_e);
if (m_e)
return NULL;
#ifdef USE_PIPE_CLIENT
namedPipe = (m_usePipedLocal && isUseNamedPipe(ep));
if (namedPipe)
c = newConnection ? NULL : getConnectionPipe(ep.port());
else
#endif
c = newConnection ? NULL : getConnection(ep);
if (newConnection || !c)
{
c = createConnection(ep, namedPipe);
c->setUserOptions(opt);
c = doConnect(c);
if (!c || !doHandShake(c, f, data))
return NULL;
m_conns.push_back(c);
}
c->addref();
return c;
}
Inverter::Inverter(bool output)
: m_stdout(output), m_cycle(MSG_DETAIL)
{
// set up our UDP socket
// this is used to find all inverters on the LAN
m_udpsocket = new QUdpSocket(this);
// setup our tcp server
// this is used to send control messages to any inverters that respond to UDP messages
m_server = new QTcpServer(this);
// start the TCP server and listen on the standard samil port
connect(m_server, SIGNAL(newConnection()),this, SLOT(newClient()));
m_server->listen(QHostAddress::Any, TCP_PORT);
// start a new timer that will send out UDP discovery messages on timeout
connect(&m_connectTimer, SIGNAL(timeout()), this, SLOT(doConnect()));
m_connectTimer.start(CONNECTION_TIME);
}
