// creates a connection and destroys it again
enum TVerdict TE_RConnectionTest301::doTestStepL(void)
{
TInt err;
RConnection activeConn;
RConnection conn;
RSocketServ ss;
TRequestStatus status;
TInterfaceNotificationBuf info;
err = OpenSocketServer(ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(ss);
err = OpenConnection(conn, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(conn);
err = OpenConnection(activeConn, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(activeConn);
err = StartConnectionWithOverrides(conn, 1);
TESTEL(KErrNone == err, err);
// issue request
AllInterfaceNotification(conn, status, info);
// start another different connection to complete request if it hasn't already done so
err = StartConnectionWithOverrides(activeConn, 6);
TESTEL(KErrNone == err, err);
// wait for completion
User::WaitForRequest(status);
// check for correct value
TESTEL(status.Int() == KErrInUse, status.Int());
CloseConnection(activeConn);
CleanupStack::Pop();
CloseConnection(conn);
CleanupStack::Pop();
CloseSocketServer(ss);
CleanupStack::Pop();
return TestStepResult();
} // TE_RConnectionTest301
// creates a connection and destroys it again
enum TVerdict TE_RConnectionTest304::doTestStepL(void)
{
TInt err;
RSocketServ socketServer;
RConnection connection;
RConnection monitor;
TRequestStatus status;
TInterfaceNotificationBuf info;
err = OpenSocketServer(socketServer);
TESTEL(KErrNone == err, err);
CleanupClosePushL(socketServer);
err = OpenConnection(connection, socketServer);
TESTEL(KErrNone == err, err);
CleanupClosePushL(connection);
err = OpenConnection(monitor, socketServer);
TESTEL(KErrNone == err, err);
CleanupClosePushL(monitor);
// issue request
AllInterfaceNotification(monitor, status, info);
// start connection to complete request
err = StartConnection(connection);
TESTEL(KErrNone == err, err);
CheckInterfaceNotificationL(status, info, EInterfaceUp, &connection);
// issue request
AllInterfaceNotification(monitor, status, info);
CloseConnection(connection);
CleanupStack::Pop();
CheckInterfaceNotificationL(status, info, EInterfaceDown);
CloseConnection(monitor);
CleanupStack::Pop();
CloseSocketServer(socketServer);
CleanupStack::Pop();
return TestStepResult();
} // TE_RConnectionTest304
//重新连接
bool __cdecl CDataBase::TryConnectAgain(bool bFocusConnect, CComError * pComError)
{
try
{
//判断重连
bool bReConnect = bFocusConnect;
if (bReConnect == false)
{
DWORD dwNowTime = (DWORD)time(NULL);
if ((m_dwConnectErrorTime + m_dwResumeConnectTime) > dwNowTime) bReConnect = true;
}
if ((bReConnect == false) && (m_dwConnectCount > m_dwResumeConnectCount)) bReConnect = true;
//设置变量
m_dwConnectCount++;
m_dwConnectErrorTime = (DWORD)time(NULL);
if (bReConnect == false)
{
if (pComError != NULL) SetErrorInfo(SQLException_Connect, GetComErrorDescribe(*pComError));
return false;
}
//重新连接
OpenConnection();
return true;
}
catch (IDataBaseException * pIDataBaseException)
{
//重新连接错误
if (pComError != NULL) SetErrorInfo(SQLException_Connect, GetComErrorDescribe(*pComError));
else throw pIDataBaseException;
}
return false;
}
//---------------------------------------------------------------------------
void
DagmanClassad::GetAcctInfo( MyString &group, MyString &user )
{
if ( !_valid ) {
debug_printf( DEBUG_VERBOSE,
"Skipping ClassAd query -- DagmanClassad object is invalid\n" );
return;
}
Qmgr_connection *queue = OpenConnection();
if ( !queue ) {
return;
}
GetDagAttribute( ATTR_ACCT_GROUP, group, false );
debug_printf( DEBUG_VERBOSE, "Workflow accounting_group: <%s>\n",
group.Value() );
GetDagAttribute( ATTR_ACCT_GROUP_USER, user, false );
debug_printf( DEBUG_VERBOSE, "Workflow accounting_group_user: <%s>\n",
user.Value() );
CloseConnection( queue );
return;
}
void InputImpl::setMousePosition(const Vector2i& position, const Window& relativeTo)
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
WindowHandle handle = relativeTo.getSystemHandle();
if (handle)
{
ScopedXcbPtr<xcb_generic_error_t> error(xcb_request_check(
connection,
xcb_warp_pointer(
connection,
None, // Source window
handle, // Destination window
0, 0, // Source position
0, 0, // Source size
position.x, position.y // Destination position
)
));
if (error)
err() << "Failed to set mouse position" << std::endl;
xcb_flush(connection);
}
// Close the connection with the X server
CloseConnection(connection);
}
//---------------------------------------------------------------------------
void
DagmanClassad::Update( int total, int done, int pre, int submitted,
int post, int ready, int failed, int unready,
Dag::dag_status dagStatus, bool recovery, const DagmanStats &stats )
{
if ( !_valid ) {
debug_printf( DEBUG_VERBOSE,
"Skipping ClassAd update -- DagmanClassad object is invalid\n" );
return;
}
Qmgr_connection *queue = OpenConnection();
if ( !queue ) {
return;
}
SetDagAttribute( ATTR_DAG_NODES_TOTAL, total );
SetDagAttribute( ATTR_DAG_NODES_DONE, done );
SetDagAttribute( ATTR_DAG_NODES_PRERUN, pre );
SetDagAttribute( ATTR_DAG_NODES_QUEUED, submitted );
SetDagAttribute( ATTR_DAG_NODES_POSTRUN, post );
SetDagAttribute( ATTR_DAG_NODES_READY, ready );
SetDagAttribute( ATTR_DAG_NODES_FAILED, failed );
SetDagAttribute( ATTR_DAG_NODES_UNREADY, unready );
SetDagAttribute( ATTR_DAG_STATUS, (int)dagStatus );
SetDagAttribute( ATTR_DAG_IN_RECOVERY, recovery );
// Publish DAGMan stats to a classad, then update those also
ClassAd stats_ad;
stats.Publish( stats_ad );
SetDagAttribute( ATTR_DAG_STATS, stats_ad );
CloseConnection( queue );
}
void InputImpl::setMousePosition(const Vector2i& position)
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
ScopedXcbPtr<xcb_generic_error_t> error(xcb_request_check(
connection,
xcb_warp_pointer(
connection,
None, // Source window
XCBDefaultRootWindow(connection), // Destination window
0, 0, // Source position
0, 0, // Source size
position.x, position.y // Destination position
)
));
if (error)
err() << "Failed to set mouse position" << std::endl;
xcb_flush(connection);
// Close the connection with the X server
CloseConnection(connection);
}
Vector2i InputImpl::getMousePosition()
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
ScopedXcbPtr<xcb_generic_error_t> error(NULL);
ScopedXcbPtr<xcb_query_pointer_reply_t> pointer(
xcb_query_pointer_reply(
connection,
xcb_query_pointer(
connection,
XCBDefaultRootWindow(connection)
),
&error
)
);
// Close the connection with the X server
CloseConnection(connection);
if (error)
{
err() << "Failed to query pointer" << std::endl;
return Vector2i(0, 0);
}
return Vector2i(pointer->root_x, pointer->root_y);
}
I2cConnection::I2cConnection(QString DevPath, int DevId):
i_DevPath(DevPath),
i_DevId(DevId),
i_BusFd(0)
{
OpenConnection();
}
//////////////////////////////////////////////////////////////////////
// OpenConnection
// return: 0 success
// -1 error
//
int CAsyncPort::OpenConnection(const char * pszPortName, DWORD dwBaudRate, BYTE bByteSize, BYTE bParity, BYTE bStopBits)
{
// setup connection properties
DCB dcb;
dcb.DCBlength = sizeof (DCB) ;
// common settings
dcb.BaudRate = dwBaudRate;
dcb.ByteSize = bByteSize;
dcb.Parity = bParity;
dcb.StopBits = bStopBits;
// setup hardware flow control
dcb.fDtrControl = DTR_CONTROL_DISABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
// setup software flow control
dcb.fInX = FALSE;
dcb.fOutX = FALSE;
dcb.XonChar = 0x11;
dcb.XoffChar = 0x13;
dcb.XonLim = 100;
dcb.XoffLim = 100;
// other
dcb.fBinary = TRUE;
dcb.fParity = TRUE;
return OpenConnection(pszPortName, dcb);
}
//---------------------------------------------------------------------------
void
DagmanClassad::GetSetBatchName( const MyString &primaryDagFile,
MyString &batchName )
{
if ( !_valid ) {
debug_printf( DEBUG_VERBOSE,
"Skipping ClassAd query -- DagmanClassad object is invalid\n" );
return;
}
Qmgr_connection *queue = OpenConnection();
if ( !queue ) {
return;
}
if ( !GetDagAttribute( ATTR_JOB_BATCH_NAME, batchName, false ) ) {
// Default batch name is top-level DAG's primary
// DAG file (base name only).
batchName = condor_basename( primaryDagFile.Value() );
batchName += "+";
batchName += IntToStr( _dagmanId._cluster );
SetDagAttribute( ATTR_JOB_BATCH_NAME, batchName );
}
CloseConnection( queue );
debug_printf( DEBUG_VERBOSE, "Workflow batch-name: <%s>\n",
batchName.Value() );
}
void EngineClient::sendLevelData(LevelData _data)
{
if(!_data.ReadFileValid) return;
if(!engine->isOpen())
OpenConnection();
QString sendLvlx;
if(!_data.path.isEmpty())
sendLvlx = QString("SEND_LVLX: %1/%2").arg(_data.path).arg(_data.filename);
else
sendLvlx = QString("SEND_LVLX: %1/%2").arg(ApplicationPath).arg("_untitled.lvlx");
qDebug() << sendLvlx;
sendCommand(sendLvlx);
qApp->processEvents();
if(engine->waitForReadyRead(1000))
{
QByteArray data = engine->readAll();
QString acceptedData = QString::fromUtf8(data);
if(!acceptedData.isEmpty())
{
QStringList StrData = acceptedData.split("\n\n");
foreach(QString x, StrData)
{
if(x=="READY")
{
qDebug() << "Engine is ready to accept data";
readyToSendLvlx = true;
}
}
}
/*---------------------------------------------------------------------*/
bool MakeSSLRequest(const char* hostname, int port,
ClientFunction client_func, void* client_data)
{
// Set up context
SSL_CTX* ctx = InitCTX();
CHECK_CALL(ctx);
// Connect to server
int server = OpenConnection(hostname, port);
if(server < 0) return false;
CHECK_CALL(server);
SSL* ssl = SSL_new(ctx);
SSL_set_fd(ssl, server);
// Do handshake
if ( SSL_connect(ssl) == FAIL ) {
ERR_print_errors_fp(stderr);
return false;
}
client_func(ssl, client_data);
fprintf(stderr, "Connected with %s encryption\n", SSL_get_cipher(ssl));
SSL_free(ssl);
close(server);
SSL_CTX_free(ctx);
ERR_free_strings();
EVP_cleanup();
return true;
}
//---------------------------------------------------------------------------
void
DagmanClassad::GetInfo( MyString &owner, MyString &nodeName )
{
if ( !_valid ) {
debug_printf( DEBUG_VERBOSE,
"Skipping ClassAd query -- DagmanClassad object is invalid\n" );
return;
}
Qmgr_connection *queue = OpenConnection();
if ( !queue ) {
return;
}
if ( !GetDagAttribute( ATTR_OWNER, owner ) ) {
check_warning_strictness( DAG_STRICT_1 );
owner = "undef";
}
if ( !GetDagAttribute( ATTR_DAG_NODE_NAME, nodeName ) ) {
// We should only get this value if we're a sub-DAG.
nodeName = "undef";
}
CloseConnection( queue );
return;
}
int
GetUrl(char *url, char **reply_ret, int *len_ret)
{
char *hostname, *path;
int port;
XtransConnInfo trans;
int status = 0;
if (ParseHttpUrl(url, &hostname, &port, &path) != 0)
return 1; /* invalid URL */
trans = OpenConnection(hostname, port);
if (trans == NULL) {
status = 1; /* connection failed */
goto end;
}
SendGetRequest(trans, path);
*len_ret = ReadGetReply(trans, reply_ret);
CloseConnection(trans);
end:
Free(hostname);
Free(path);
return status;
}
//---------------------------------------------------------------------------
void __fastcall TfrmEditFTP::Label6Click(TObject *Sender)
{
Screen->Cursor = crHourGlass;
if(OpenConnection())
{
MessageBox(Handle,"测试成功完成.","信息",MB_OK | MB_ICONINFORMATION);
}
Screen->Cursor = crDefault;
}
CConn_IOStream* CId2Reader::x_GetConnection(TConn conn)
{
_ASSERT(m_Connections.count(conn));
CReaderServiceConnector::SConnInfo& conn_info = m_Connections[conn];
if ( conn_info.m_Stream.get() ) {
return conn_info.m_Stream.get();
}
OpenConnection(conn);
return m_Connections[conn].m_Stream.get();
}
void QPlc::init(QString ip,QString strPath, Plc_Type PlcType, int Network, int Node)
{
ParsePath(strPath);
m_ip = ip;
m_PlcType = PlcType;
m_Network=Network;
m_Node=Node;
m_time_out=10000;
OpenConnection();
}
// creates a connection and destroys it again
// Implicitly detect a single connection using SendTo()
enum TVerdict TE_RConnectionTest306::doTestStepL(void)
{
TInt err;
RSocketServ ss;
RSocket sock;
RConnection monitor;
TRequestStatus status;
TInterfaceNotificationBuf info;
err = OpenSocketServer(ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(ss);
err = OpenConnection(monitor, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(monitor);
err = OpenTcpSocket(sock, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(sock);
// issue request
AllInterfaceNotification(monitor, status, info);
err = ConnectTcpSocket(sock, iEchoServerAddr); // this will use Connect()
TESTEL(KErrNone == err, err);
err = TestTcpDataPathL(sock);
TESTEL(KErrNone == err, err);
// check for interface up...
CheckInterfaceNotificationL(status, info, EInterfaceUp);
// issue request
AllInterfaceNotification(monitor, status, info);
err = DestroyTcpSocket(sock);
TESTEL(KErrNone == err, err);
CleanupStack::Pop();
// check for interface down...
CheckInterfaceNotificationL(status, info, EInterfaceDown);
CloseConnection(monitor);
CleanupStack::Pop();
CloseSocketServer(ss);
CleanupStack::Pop();
return TestStepResult();
} // TE_RConnectionTest306
/** Send a JWM message to the root window. */
void SendJWMMessage(const char *message)
{
XEvent event;
OpenConnection();
memset(&event, 0, sizeof(event));
event.xclient.type = ClientMessage;
event.xclient.window = rootWindow;
event.xclient.message_type = JXInternAtom(display, message, False);
event.xclient.format = 32;
JXSendEvent(display, rootWindow, False, SubstructureRedirectMask, &event);
CloseConnection();
}
//////////////////////////////////////////////////////////////////////
// OpenConnection
// return: 0 success
// -1 error
//
int CAsyncPort::OpenConnection(const char * pszPortName, const char * pszSetupString)
{
DWORD dwBaudRate;
BYTE bByteSize;
BYTE bParity;
BYTE bStopBits;
if (! ParseSetupString(pszSetupString, & dwBaudRate, & bByteSize, & bParity, & bStopBits)) {
return OpenConnection(pszPortName, dwBaudRate, bByteSize, bParity, bStopBits);
}
return (-1);
}
// Implicitly create a single connection using GetByName()
enum TVerdict TE_RConnectionTest307::doTestStepL(void)
{
TInt err;
RSocketServ ss;
RHostResolver hr;
RConnection monitor;
TRequestStatus status;
TInterfaceNotificationBuf info;
err = OpenSocketServer(ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(ss);
err = OpenConnection(monitor, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(monitor);
err = OpenHostResolver(hr, ss);
TESTEL(KErrNone == err, err);
CleanupClosePushL(hr);
// issue request
AllInterfaceNotification(monitor, status, info);
err = MakeNameRequest(hr, iTestName); // this will use GetByName()
TESTEL(KErrNone == err, err);
// check for interface up...
CheckInterfaceNotificationL(status, info, EInterfaceUp);
// issue request
AllInterfaceNotification(monitor, status, info);
DestroyHostResolver(hr);
CleanupStack::Pop();
// check for interface down...
CheckInterfaceNotificationL(status, info, EInterfaceDown);
CloseConnection(monitor);
CleanupStack::Pop();
CloseSocketServer(ss);
CleanupStack::Pop();
return TestStepResult();
} // TE_RConnectionTest307
CNearFieldTag * CNearFieldTag::CastToTag()
{
BEGIN
TInt error = KErrNone;
if (!IsConnectionOpened())
{
error = OpenConnection();
LOG("open connection, error is "<<error);
}
END
return (error == KErrNone) ? const_cast<CNearFieldTag *>(this)
: reinterpret_cast<CNearFieldTag *>(0);
}
int Server::_OpenConnection()
{
//set the log dest
_log->Init(EMPTY_STRING);
_log->SetLogLevel(LOG_LEVEL_DEBUG);
_log->SetPrinterMethod(printf);
Init(_log);
const char* userName = GetEIBUserName();
const char* userPassword = GetPassword();
const char* encryptKey = GetEncryptKey();
CString local_ip;
START_TRY
local_ip = Socket::LocalAddress(GetLocalNetworkIf());
END_TRY_START_CATCH_SOCKET(e)
_log->Log(LOG_LEVEL_ERROR, e.what());
return ERR_NETWORK_ERROR;
END_CATCH
_log->Log(LOG_LEVEL_DEBUG, "Trying to connect to EIBServer...");
CString serverIP = GetEIBServerAddress();
int serverPort = GetEIBServerPort();
DiscoverEIBServer(local_ip,
encryptKey,
serverIP,
serverPort);
ConnectionResult res;
res = OpenConnection("Generic",
userName,
serverPort,
encryptKey,
local_ip.GetBuffer(),
userName,
userPassword);
if(res == STATUS_CONN_OK) {
start();
}
return (int)res;
}
int ReOpenConnection(stream_t* s)
{
//printf("Reopening connection\n");fflush(stdout);
struct stream_priv_s* p = (struct stream_priv_s*)s->priv;
if (!p->url) return 0;
unlock_fd(p);
close(s->fd);
s->fd = 0;
if (OpenConnection(s))
{
lock_fd(p);
return 1;
}
return 0;
}
HTTPInputStream::HTTPInputStream(const string & url) {
host = "";
port = 80;
path = "/";
sockfd = -1;
contentLength = -1;
numRead = 0;
ParseURL(url);
//***cout << "[host=" << host << ", port=" << port << ", path=" << path << "]" << endl;
OpenConnection();
//***cout << "[connection established]" << endl;
SendRequest();
ParseHTTPHeader();
}
void Cedrus::XIDDevice::SetBaudRate(unsigned char rate)
{
if (m_config->IsMPod())
return;
static unsigned char change_baud_cmd[3] = { 'f', '1' };
change_baud_cmd[2] = rate;
DWORD bytes_written = 0;
m_xidCon->Write(change_baud_cmd, 3, &bytes_written);
m_xidCon->SetBaudRate(rate);
CloseConnection();
OpenConnection();
}
void EngineClient::run()
{
working=true;
//Set default values
readyToSendLvlx = false;
_busy = false;
OpenConnection();
_connected=true;
msleep(100);
alreadyRequested=false;
exec();
emit closed();
_connected=false;
working=false;
}
bool MySQLConnection::HandleMySQLError(uint32 errNo)
{
switch (errNo)
{
case CR_SERVER_GONE_ERROR:
case CR_SERVER_LOST:
case CR_INVALID_CONN_HANDLE:
case CR_SERVER_LOST_EXTENDED:
{
uint64 oldThreadId = mysql_thread_id(mMysql);
mysql_close(mMysql);
if (OpenConnection(true))
{
FreePreparedStatements(); // We need to prepare everything again!
sLog.outString("Reconnection attempt to database %s (on %s)", m_database.c_str(), m_host.c_str());
if (oldThreadId != mysql_thread_id(mMysql))
sLog.outString("Successfully reconnected to %s @%s:%u.",
m_database.c_str(), m_host.c_str(), m_port);
return true;
}
return false; // Failed to reconnect
}
case ER_LOCK_DEADLOCK:
return false;
// Query related errors - skip query
case ER_WRONG_VALUE_COUNT:
case ER_DUP_ENTRY:
return false;
// Outdated table or database structure - terminate core
case ER_BAD_FIELD_ERROR:
case ER_NO_SUCH_TABLE:
sLog.outErrorDb("Your database structure is not up to date. Please make sure you have executed all the queries in the sql/updates folders.");
ASSERT(false);
return false;
case ER_PARSE_ERROR:
sLog.outErrorDb("Error while parsing SQL. Core fix required.");
ASSERT(false);
return false;
default:
sLog.outErrorDb("Unhandled MySQL errno %u. Unexpected behaviour possible.", errNo);
return false;
}
}
bool InputImpl::isMouseButtonPressed(Mouse::Button button)
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
ScopedXcbPtr<xcb_generic_error_t> error(NULL);
// Get pointer mask
ScopedXcbPtr<xcb_query_pointer_reply_t> pointer(
xcb_query_pointer_reply(
connection,
xcb_query_pointer(
connection,
XCBDefaultRootWindow(connection)
),
&error
)
);
// Close the connection with the X server
CloseConnection(connection);
if (error)
{
err() << "Failed to query pointer" << std::endl;
return false;
}
uint16_t buttons = pointer->mask;
switch (button)
{
case Mouse::Left:
return buttons & XCB_BUTTON_MASK_1;
case Mouse::Right:
return buttons & XCB_BUTTON_MASK_3;
case Mouse::Middle:
return buttons & XCB_BUTTON_MASK_2;
case Mouse::XButton1:
return false; // not supported by X
case Mouse::XButton2:
return false; // not supported by X
default:
return false;
}
}
