// Connects to service server and on success, stores connected socket handle
// in private class member.
// Upon failure, exception is thrown.
void QRBG::Connect() throw(ConnectError) {
if (hSocket != -1) {
// we're already connected
return;
}
if (!*szHostname || !port) {
// server address is not defined
throw ConnectError();
}
int hsock = static_cast<int>( socket(AF_INET, SOCK_STREAM, 0) );
if (hsock == -1) {
// failed to create socket
throw ConnectError();
}
// try to resolve 'hostname', if we fail, assume 'hostname' as an IP address
struct sockaddr_in addr;
struct hostent *hent = gethostbyname(szHostname);
if (hent == NULL)
addr.sin_addr.s_addr = inet_addr(szHostname);
else
memcpy(&addr.sin_addr, hent->h_addr, hent->h_length);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if (connect(hsock, (struct sockaddr *)&addr, sizeof(addr))) {
// failed to connect
throw ConnectError();
}
hSocket = hsock;
}
void TcpConnect::HandleDataWrite(const boost::system::error_code& err, int write_size){
if (state_ == CS_CLOSED){
return;
}
if (err){
//LOG(ERROR) << err.message();
return ConnectError(err);
}
is_writing_ = false;
if (!write_buffer_->Consume(write_size)){
//LOG(ERROR) << "Nver reach here";
return ConnectError(boost::asio::error::invalid_argument);
}
if (write_buffer_->Length() > 0){
// Continue write data
WriteData();
}
else if (write_buffer_->Length() == 0){
// //LOG(INFO) << write_size;
SignalConnectWrite(shared_from_this());
}
else{
BOOST_ASSERT(0);
}
}
/*! opens a connection to a remote server at given \p hostname and \p port number.
*
* \param hostname the hostname of the host to connect to.
* \param port the TCP port number to connect to.
*
* \throw ConnectError if connection to given host failed.
*
* \todo asynchronous/nonblocking connect()
* \todo DNS resolving
*/
void NetMessageSocket::open(const std::string& hostname, int port)
{
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
throw ConnectError("socket", errno);
sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
// TODO support DNS resolving.
int rc;
if ((rc = inet_pton(AF_INET, hostname.c_str(), &sin.sin_addr.s_addr)) <= 0) {
::close(fd);
if (rc == 0)
throw ConnectError("Address not in representation format.");
else
throw ConnectError("inet_pton", errno);
}
rc = connect(fd, (sockaddr*)&sin, sizeof(sin));
if (rc < 0) {
perror("connect");
::close(fd);
throw ConnectError("connect", errno);
}
fd_ = fd;
}
//-------------------------------------------------------------------------
int Handler::Handle( Asev::Event &e ) {
if( e.Info() != typeid( Event ) ) return 0;
#define GETERROR static_cast<ErrorEvent&>(e).GetError()
int result = 0;
Event &stream_event = static_cast<Event&>(e);
switch( stream_event.m_class ) {
case Event::ACCEPTED:
Accepted( stream_event.m_stream );
break;
case Event::ACCEPTERROR:
AcceptError( stream_event.m_stream, GETERROR );
break;
case Event::CONNECTED:
Connected( stream_event.m_stream );
break;
case Event::CONNECTERROR:
ConnectError( stream_event.m_stream, GETERROR );
break;
case Event::DISCONNECTED:
Disconnected( stream_event.m_stream, GETERROR );
break;
case Event::RECEIVE:
Receive( stream_event.m_stream,
static_cast<Event::Receive&>(e).GetMessage() );
break;
case Event::SENDFAILED:
SendFailed( stream_event.m_stream, GETERROR );
break;
}
return result;
}
void Client::connect(std::string hostname, int tcpPort)
{
if (tcpServer->connect(hostname, tcpPort))
{
int tcpSocket = tcpServer->getSocket();
fdManager.add(tcpSocket, this);
}
else
{
throw ConnectError();
}
}
void TcpConnect::HandleReadData(const boost::system::error_code& err, int read_size){
if (state_ == CS_CLOSED){
return;
}
if (err){
//LOG(ERROR) << err.message();
return ConnectError(err);
}
read_buffer_->WriteBytes(pre_read_buffer_, read_size);
// -------------------------------------------------------------------------
while (read_buffer_->Length() >= HEADER_BUFFERR_SIZE){
memcpy(read_header_buffer_, read_buffer_->Data(), HEADER_BUFFERR_SIZE);
if (read_header_buffer_[0] != VZ_HEADER[0] || read_header_buffer_[1] != VZ_HEADER[1]){
//LOG(ERROR) << "The packet header VZ getting error";
return ConnectError(boost::asio::error::invalid_argument);
}
uint16 flag = *((uint16*)(read_header_buffer_ + 2));
uint32 packet_size = *(uint32*)(read_header_buffer_ + 4);
flag = ntohs(flag);
packet_size = ntohl(packet_size);
if (packet_size > MAX_PKT_SIZE){
//LOG(ERROR) << "The packet size large than " << MAX_PKT_SIZE;
return ConnectError(boost::asio::error::invalid_argument);
}
if (packet_size <= (read_buffer_->Length() - HEADER_BUFFERR_SIZE)){
SignalConnectRead(shared_from_this(),
read_buffer_->Data() + HEADER_BUFFERR_SIZE, packet_size, flag);
read_buffer_->Consume(packet_size + HEADER_BUFFERR_SIZE);
}
else{
break;
}
}
AsyncReadData();
}
// 连接数据库
void ConnectorMySQL::connect()
{
if (!is_connected())
{
int reconnect = 1;
mysql_init(&mysql_);
mysql_options(&mysql_, MYSQL_OPT_RECONNECT, &reconnect);
connected_ = mysql_real_connect(&mysql_, host_.c_str(), user_.c_str(), passwd_.c_str(), NULL, port_, NULL, 0) != NULL;
if (mysql_errno(&mysql_) != 0)
{
throw ConnectError(mysql_error(&mysql_));
}
mysql_set_server_option(&mysql_, MYSQL_OPTION_MULTI_STATEMENTS_OFF);
}
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: on_clearButton_clicked(); break;
case 1: on_getLastTempButton_clicked(); break;
case 2: on_getTempButton_clicked(); break;
case 3: on_getTempAllButton_clicked(); break;
case 4: DataReceived((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 5: ConnectError(); break;
case 6: timerEvent((*reinterpret_cast< QTimerEvent*(*)>(_a[1]))); break;
default: ;
}
_id -= 8;
}
return _id;
}
void ReceiveThread::run()
{
std::cout<<"in ReceiveThread:: run ++++++++++++++"<<std::endl;
if(receiveSocket==NULL)
{
receiveSocket = new QTcpSocket;
creatconnect();
}
if(tryNewConnect())
emit connected();
else
{
std::cout<<"in ReceiveThread::run, send ConnectError "<<std::endl;
emit ConnectError();
return ;
}
exec();
//receiveSocket->waitForDisconnected();
//emit receiveData();
}
void ReceiveThread::StartRun(ConnectInfo &robotinfo)
{
std::cout<<"ReceiveThread::StartRun-------- "<<std::endl;
receiveRobot->Copy(robotinfo);
if(receiveSocket==NULL)
{
std::cout<<"in ReceiveThread::StartRun,new QTcpSocket "<<std::endl;
receiveSocket = new QTcpSocket;
creatconnect();
}
if(tryNewConnect())
emit connected();
else
{
std::cout<<"in ReceiveThread::StartRun, ConnectError "<<std::endl;
emit ConnectError();
return ;
}
//exec();
}
//===================
// PRIVATE
//===================
bool WebServer::setupWebSocket(quint16 port){
WSServer = new QWebSocketServer("sysadm-server", QWebSocketServer::SecureMode, this);
//SSL Configuration
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
QFile CF( QStringLiteral(SSLCERTFILE) );
if(CF.open(QIODevice::ReadOnly) ){
QSslCertificate CERT(&CF,QSsl::Pem);
config.setLocalCertificate( CERT );
CF.close();
}else{
qWarning() << "Could not read WS certificate file:" << CF.fileName();
}
QFile KF( QStringLiteral(SSLKEYFILE));
if(KF.open(QIODevice::ReadOnly) ){
QSslKey KEY(&KF, QSsl::Rsa, QSsl::Pem);
config.setPrivateKey( KEY );
KF.close();
}else{
qWarning() << "Could not read WS key file:" << KF.fileName();
}
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(SSLVERSION);
WSServer->setSslConfiguration(config);
//Setup Connections
connect(WSServer, SIGNAL(newConnection()), this, SLOT(NewSocketConnection()) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(NewConnectError(QAbstractSocket::SocketError)) );
// -- websocket specific signals
connect(WSServer, SIGNAL(closed()), this, SLOT(ServerClosed()) );
connect(WSServer, SIGNAL(serverError(QWebSocketProtocol::CloseCode)), this, SLOT(ServerError(QWebSocketProtocol::CloseCode)) );
connect(WSServer, SIGNAL(originAuthenticationRequired(QWebSocketCorsAuthenticator*)), this, SLOT(OriginAuthRequired(QWebSocketCorsAuthenticator*)) );
connect(WSServer, SIGNAL(peerVerifyError(const QSslError&)), this, SLOT(PeerVerifyError(const QSslError&)) );
connect(WSServer, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(SslErrors(const QList<QSslError>&)) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(ConnectError(QAbstractSocket::SocketError)) );
//Now start the server
return WSServer->listen(QHostAddress::Any, port);
}
