void Connection::commandReady(Command *command) {
m_queuedCommand = command;
if (m_page->isLoading())
m_commandWaiting = true;
else
startCommand();
}
void WinConsole::SavePrefs()
{
DWORD val;
HKEY hKey;
RegCreateKey(HKEY_CURRENT_USER, "Software\\NZBGet", &hKey);
val = m_showTrayIcon;
RegSetValueEx(hKey, "ShowTrayIcon", 0, REG_DWORD, (BYTE*)&val, sizeof(val));
val = m_showConsole;
RegSetValueEx(hKey, "ShowConsole", 0, REG_DWORD, (BYTE*)&val, sizeof(val));
val = m_showWebUI;
RegSetValueEx(hKey, "ShowWebUI", 0, REG_DWORD, (BYTE*)&val, sizeof(val));
val = m_doubleClick;
RegSetValueEx(hKey, "TrayDoubleClick", 0, REG_DWORD, (BYTE*)&val, sizeof(val));
RegCloseKey(hKey);
// Autostart-setting
RegCreateKey(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", &hKey);
if (m_autostart)
{
char filename[MAX_PATH + 1];
GetModuleFileName(nullptr, filename, sizeof(filename));
BString<1024> startCommand("\"%s\" -s -app -auto", filename);
RegSetValueEx(hKey, "NZBGet", 0, REG_SZ, (BYTE*)(char*)startCommand, strlen(startCommand) + 1);
}
else
{
RegDeleteValue(hKey, "NZBGet");
}
RegCloseKey(hKey);
}
bool
DCCollector::initiateTCPUpdate( int cmd, ClassAd* ad1, ClassAd* ad2, bool nonblocking )
{
if( update_rsock ) {
delete update_rsock;
update_rsock = NULL;
}
if(nonblocking) {
UpdateData *ud = new UpdateData(cmd, Sock::reli_sock, ad1, ad2, this);
// Note that UpdateData automatically adds itself to the pending_update_list.
if (this->pending_update_list.size() == 1)
{
startCommand_nonblocking(cmd, Sock::reli_sock, 20, NULL, UpdateData::startUpdateCallback, ud );
}
return true;
}
Sock *sock = startCommand(cmd, Sock::reli_sock, 20);
if(!sock) {
newError( CA_COMMUNICATION_ERROR,
"Failed to send TCP update command to collector" );
dprintf(D_ALWAYS,"Failed to send update to %s.\n",idStr());
return false;
}
update_rsock = (ReliSock *)sock;
return finishUpdate( this, update_rsock, ad1, ad2 );
}
bool attackDeauth::start(const QString &BSSID, QString MAC)
{
if (this->isRunning())
this->stop();
if (!utils::validMAC(BSSID)){
utils::mostrarError("Invalid BSSID");
this->stop();
return false;
}
if (!MAC.isEmpty()) {
if (!utils::validMAC(BSSID)){
utils::mostrarError("Invalid MAC DESTINATION");
this->stop();
return false;
}
else
MAC = " -c " + MAC; //add flag to mac
}
const QString command = AIREPLAY_COM + " -0 10 -a " +
BSSID + MAC + " " + GLOBALS::INTERFACE;
return startCommand(command);
}
void setAutoScroll(unsigned char on) {
startCommand();
if(on){
sendByte(GLK12232_AUTO_SCROLL_ON);
} else {
sendByte(GLK12232_AUTO_SCROLL_OFF);
}
}
void setAutoTransmitKeypresses(unsigned char on) {
startCommand();
if(on){
sendByte(GLK12232_AUTO_TRANSMIT_KEYS_ON);
} else {
sendByte(GLK12232_AUTO_TRANSMIT_KEYS_OFF);
}
}
void drawLine(unsigned char x1, unsigned char y1,
unsigned char x2, unsigned char y2) {
startCommand();
sendByte(GLK12232_DRAW_LINE);
sendByte(x1);
sendByte(y1);
sendByte(x2);
sendByte(y2);
}
void setAutoRepeat(unsigned char on, unsigned char mode) {
startCommand();
if(on){
sendByte(GLK12232_AUTO_REPEAT_ON);
sendByte(mode);
} else {
sendByte(GLK12232_AUTO_REPEAT_OFF);
}
}
void drawSolidRectangle(unsigned char color, unsigned char x1, unsigned char y1,
unsigned char x2, unsigned char y2) {
startCommand();
sendByte(GLK12232_DRAW_SOLID_RECT);
sendByte(x1);
sendByte(y1);
sendByte(x2);
sendByte(y2);
}
void drawOutlineRectangle(unsigned char color, unsigned char x1, unsigned char y1,
unsigned char x2, unsigned char y2) {
startCommand();
sendByte(GLK12232_DRAW_OUTLINE_RECT);
sendByte(x1);
sendByte(y1);
sendByte(x2);
sendByte(y2);
}
bool
DCStartd::_suspendClaim( )
{
setCmdStr( "suspendClaim" );
if( ! checkClaimId() ) {
return false;
}
if( ! checkAddr() ) {
return false;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
char const *sec_session = cidp.secSessionId();
if (IsDebugLevel(D_COMMAND)) {
int cmd = SUSPEND_CLAIM;
dprintf (D_COMMAND, "DCStartd::_suspendClaim(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::_suspendClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = SUSPEND_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock, 20, NULL, NULL, false, sec_session );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send command " );
return false;
}
// Now, send the ClaimId
if( ! reli_sock.put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send ClaimId to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
bool
DCStartd::drainJobs(int how_fast,bool resume_on_completion,char const *check_expr,char const *start_expr,std::string &request_id)
{
std::string error_msg;
ClassAd request_ad;
Sock *sock = startCommand( DRAIN_JOBS, Sock::reli_sock, 20 );
if( !sock ) {
formatstr(error_msg,"Failed to start DRAIN_JOBS command to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
request_ad.Assign(ATTR_HOW_FAST,how_fast);
request_ad.Assign(ATTR_RESUME_ON_COMPLETION,resume_on_completion);
if( check_expr ) {
request_ad.AssignExpr(ATTR_CHECK_EXPR,check_expr);
}
if( start_expr ) {
request_ad.AssignExpr(ATTR_START_EXPR,start_expr);
}
if( !putClassAd(sock, request_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to compose DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
sock->decode();
ClassAd response_ad;
if( !getClassAd(sock, response_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to get response to DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
response_ad.LookupString(ATTR_REQUEST_ID,request_id);
bool result = false;
int error_code = 0;
response_ad.LookupBool(ATTR_RESULT,result);
if( !result ) {
std::string remote_error_msg;
response_ad.LookupString(ATTR_ERROR_STRING,remote_error_msg);
response_ad.LookupInteger(ATTR_ERROR_CODE,error_code);
formatstr(error_msg,
"Received failure from %s in response to DRAIN_JOBS request: error code %d: %s",
name(),error_code,remote_error_msg.c_str());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
delete sock;
return true;
}
void Connection::commandReady(QString commandName, QStringList arguments) {
m_commandName = commandName;
m_arguments = arguments;
if (m_page->isLoading())
m_commandWaiting = true;
else
startCommand();
}
// when a transferd registers itself, it identifies who it is. The connection
// is then held open and the schedd periodically might send more transfer
// requests to the transferd. Also, if the transferd dies, the schedd is
// informed quickly and reliably due to the closed connection.
bool
DCTransferD::setup_treq_channel(ReliSock **treq_sock_ptr,
int timeout, CondorError *errstack)
{
ReliSock *rsock;
if (treq_sock_ptr != NULL) {
// Our caller wants a pointer to the socket we used to succesfully
// register the claim. The NULL pointer will represent failure and
// this will only be set to something real if everything was ok.
*treq_sock_ptr = NULL;
}
/////////////////////////////////////////////////////////////////////////
// Connect to the transfer daemon
/////////////////////////////////////////////////////////////////////////
// This call with automatically connect to _addr, which was set in the
// constructor of this object to be the transferd in question.
rsock = (ReliSock*)startCommand(TRANSFERD_CONTROL_CHANNEL,
Stream::reli_sock, timeout, errstack);
if( ! rsock ) {
dprintf( D_ALWAYS, "DCTransferD::setup_treq_channel: "
"Failed to send command (TRANSFERD_CONTROL_CHANNEL) "
"to the schedd\n" );
errstack->push("DC_TRANSFERD", 1,
"Failed to start a TRANSFERD_CONTROL_CHANNEL command.");
return false;
}
/////////////////////////////////////////////////////////////////////////
// Make sure we are authenticated.
/////////////////////////////////////////////////////////////////////////
// First, if we're not already authenticated, force that now.
if (!forceAuthentication( rsock, errstack )) {
dprintf( D_ALWAYS, "DCTransferD::setup_treq_channel() authentication "
"failure: %s\n", errstack->getFullText().c_str() );
errstack->push("DC_TRANSFERD", 1,
"Failed to authenticate properly.");
return false;
}
rsock->encode();
/////////////////////////////////////////////////////////////////////////
// At this point, the socket passed all of the authentication protocols
// so it is ready for use.
/////////////////////////////////////////////////////////////////////////
if (treq_sock_ptr)
*treq_sock_ptr = rsock;
return true;
}
bool
DCShadow::getUserCredential( const char* user, const char* domain, MyString& credential)
{
ReliSock reli_sock;
bool result;
// For now, if we have to ensure that the update gets
// there, we use a ReliSock (TCP).
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
dprintf( D_ALWAYS, "getUserCredential: Failed to connect to shadow "
"(%s)\n", _addr );
return false;
}
result = startCommand( CREDD_GET_PASSWD, (Sock*)&reli_sock );
if( ! result ) {
dprintf( D_FULLDEBUG,
"Failed to send CREDD_GET_PASSWD command to shadow\n" );
return false;
}
// Enable encryption if available. If it's not available, our peer
// will close the connection.
reli_sock.set_crypto_mode(true);
MyString senduser = user;
MyString senddomain = domain;
MyString recvcredential;
if(!reli_sock.code(senduser)) {
dprintf( D_FULLDEBUG, "Failed to send user (%s) to shadow\n", senduser.c_str() );
return false;
}
if(!reli_sock.code(senddomain)) {
dprintf( D_FULLDEBUG, "Failed to send domain (%s) to shadow\n", senddomain.c_str() );
return false;
}
if(!reli_sock.end_of_message()) {
dprintf( D_FULLDEBUG, "Failed to send EOM to shadow\n" );
return false;
}
reli_sock.decode();
if(!reli_sock.code(recvcredential)) {
dprintf( D_FULLDEBUG, "Failed to receive credential from shadow\n");
return false;
}
if(!reli_sock.end_of_message()) {
dprintf( D_FULLDEBUG, "Failed to receive EOM from shadow\n");
return false;
}
credential = recvcredential;
return true;
}
void DCMessenger::startCommandAfterDelay_alarm()
{
QueuedCommand *qc = (QueuedCommand *)daemonCore->GetDataPtr();
ASSERT(qc);
startCommand(qc->msg);
delete qc;
decRefCount();
}
void setFontMetrics(unsigned char leftMargin, unsigned char topMargin,
unsigned char xSpc, unsigned char ySpc, unsigned char scrollRow) {
startCommand();
sendByte(GLK12232_SET_FONT_METRICS);
sendByte(leftMargin);
sendByte(topMargin);
sendByte(xSpc);
sendByte(ySpc);
sendByte(scrollRow);
}
void SHT1x::reset() {
// Wait for sensor sleep state
delayTimer.mDelay(11);
startCommand();
sendByte(CMD_SOFT_RESET);
// Wait for sensor sleep state
delayTimer.mDelay(11);
}
void initBarGraph(unsigned char num, unsigned char type,
unsigned char x1, unsigned char y1,
unsigned char x2, unsigned char y2) {
startCommand();
sendByte(GLK12232_INIT_BAR_GRAPH);
sendByte(num);
sendByte(type);
sendByte(x1);
sendByte(y1);
sendByte(x2);
sendByte(y2);
}
bool
DCStarter::createJobOwnerSecSession(int timeout,char const *job_claim_id,char const *starter_sec_session,char const *session_info,MyString &owner_claim_id,MyString &error_msg,MyString &starter_version,MyString &starter_addr)
{
ReliSock sock;
if (IsDebugLevel(D_COMMAND)) {
dprintf (D_COMMAND, "DCStarter::createJobOwnerSecSession(%s,...) making connection to %s\n",
getCommandStringSafe(CREATE_JOB_OWNER_SEC_SESSION), _addr ? _addr : "NULL");
}
if( !connectSock(&sock, timeout, NULL) ) {
error_msg = "Failed to connect to starter";
return false;
}
if( !startCommand(CREATE_JOB_OWNER_SEC_SESSION, &sock,timeout,NULL,NULL,false,starter_sec_session) ) {
error_msg = "Failed to send CREATE_JOB_OWNER_SEC_SESSION to starter";
return false;
}
ClassAd input;
input.Assign(ATTR_CLAIM_ID,job_claim_id);
input.Assign(ATTR_SESSION_INFO,session_info);
sock.encode();
if( !putClassAd(&sock, input) || !sock.end_of_message() ) {
error_msg = "Failed to compose CREATE_JOB_OWNER_SEC_SESSION to starter";
return false;
}
sock.decode();
ClassAd reply;
if( !getClassAd(&sock, reply) || !sock.end_of_message() ) {
error_msg = "Failed to get response to CREATE_JOB_OWNER_SEC_SESSION from starter";
return false;
}
bool success = false;
reply.LookupBool(ATTR_RESULT,success);
if( !success ) {
reply.LookupString(ATTR_ERROR_STRING,error_msg);
return false;
}
reply.LookupString(ATTR_CLAIM_ID,owner_claim_id);
reply.LookupString(ATTR_VERSION,starter_version);
// get the full starter address from the starter in case it contains
// extra CCB info that we don't already know about
reply.LookupString(ATTR_STARTER_IP_ADDR,starter_addr);
return true;
}
bool
DCStartd::checkpointJob( const char* name_ckpt )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::checkpointJob(%s)\n",
name_ckpt );
setCmdStr( "checkpointJob" );
if (IsDebugLevel(D_COMMAND)) {
int cmd = PCKPT_JOB;
dprintf (D_COMMAND, "DCStartd::checkpointJob(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::checkpointJob: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = PCKPT_JOB;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send command PCKPT_JOB to the startd" );
return false;
}
// Now, send the name
if( ! reli_sock.put(name_ckpt) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send EOM to the startd" );
return false;
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::checkpointJob: "
"successfully sent command\n" );
return true;
}
bool
DCStartd::cancelDrainJobs(char const *request_id)
{
std::string error_msg;
ClassAd request_ad;
Sock *sock = startCommand( CANCEL_DRAIN_JOBS, Sock::reli_sock, 20 );
if( !sock ) {
formatstr(error_msg,"Failed to start CANCEL_DRAIN_JOBS command to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
if( request_id ) {
request_ad.Assign(ATTR_REQUEST_ID,request_id);
}
if( !putClassAd(sock, request_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to compose CANCEL_DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
sock->decode();
ClassAd response_ad;
if( !getClassAd(sock, response_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to get response to CANCEL_DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
bool result = false;
int error_code = 0;
response_ad.LookupBool(ATTR_RESULT,result);
if( !result ) {
std::string remote_error_msg;
response_ad.LookupString(ATTR_ERROR_STRING,remote_error_msg);
response_ad.LookupInteger(ATTR_ERROR_CODE,error_code);
formatstr(error_msg,
"Received failure from %s in response to CANCEL_DRAIN_JOBS request: error code %d: %s",
name(),error_code,remote_error_msg.c_str());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
delete sock;
return true;
}
void Connection::processArgument(const char *data) {
if (m_argumentsExpected == -1) {
m_argumentsExpected = QString(data).toInt();
} else if (m_expectingDataSize == -1) {
m_expectingDataSize = QString(data).toInt();
} else {
m_arguments.append(QString::fromUtf8(data));
}
if (m_arguments.length() == m_argumentsExpected) {
if (m_page->isLoading())
m_commandWaiting = true;
else
startCommand();
}
}
bool
DCStartd::checkpointJob( const char* name_ckpt )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::checkpointJob(%s)\n",
name_ckpt );
setCmdStr( "checkpointJob" );
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::checkpointJob: ";
err += "Failed to connect to startd (";
err += _addr;
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = PCKPT_JOB;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send command PCKPT_JOB to the startd" );
return false;
}
// Now, send the name
if( ! reli_sock.code((unsigned char *)const_cast<char*>(name_ckpt)) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send EOM to the startd" );
return false;
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::checkpointJob: "
"successfully sent command\n" );
return true;
}
DCStarter::X509UpdateStatus
DCStarter::delegateX509Proxy( const char * filename, time_t expiration_time, char const *sec_session_id, time_t *result_expiration_time)
{
ReliSock rsock;
rsock.timeout(60);
if( ! rsock.connect(_addr) ) {
dprintf(D_ALWAYS, "DCStarter::delegateX509Proxy: "
"Failed to connect to starter %s\n", _addr);
return XUS_Error;
}
CondorError errstack;
if( ! startCommand(DELEGATE_GSI_CRED_STARTER, &rsock, 0, &errstack, NULL, false, sec_session_id) ) {
dprintf( D_ALWAYS, "DCStarter::delegateX509Proxy: "
"Failed send command to the starter: %s\n",
errstack.getFullText().c_str());
return XUS_Error;
}
// Send the gsi proxy
filesize_t file_size = 0; // will receive the size of the file
if ( rsock.put_x509_delegation(&file_size,filename,expiration_time,result_expiration_time) < 0 ) {
dprintf(D_ALWAYS,
"DCStarter::delegateX509Proxy "
"failed to delegate proxy file %s (size=%ld)\n",
filename, (long int)file_size);
return XUS_Error;
}
// Fetch the result
rsock.decode();
int reply = 0;
rsock.code(reply);
rsock.end_of_message();
switch(reply) {
case 0: return XUS_Error;
case 1: return XUS_Okay;
case 2: return XUS_Declined;
}
dprintf(D_ALWAYS, "DCStarter::delegateX509Proxy: "
"remote side returned unknown code %d. Treating "
"as an error.\n", reply);
return XUS_Error;
}
bool
DCStartd::vacateClaim( const char* name_vacate )
{
setCmdStr( "vacateClaim" );
if (IsDebugLevel(D_COMMAND)) {
int cmd = VACATE_CLAIM;
dprintf (D_COMMAND, "DCStartd::vacateClaim(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::vacateClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = VACATE_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send command PCKPT_JOB to the startd" );
return false;
}
if( ! reli_sock.put(name_vacate) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
integer ServiceApp::start(const Args & args)
{
StdError serr;
if (args.length() < 3) return onCommandLineError(args);
try {
appname = args[0];
String instanceName = args[1];
if (instanceName == defaultInstanceName) instanceName = getDefaultInstanceName(appname);
StringA command = String::getUtf8(args[2]);;
instance = ProgInstance(instanceName);
Args rmargs(const_cast<ConstStrW *>(args.data()+3),args.length()-3);
stopCommand = false;
return startCommand(command,rmargs,serr);
} catch (...) {
return onStartError(serr);
}
}
bool
DCCollector::sendUDPUpdate( int cmd, ClassAd* ad1, ClassAd* ad2, bool nonblocking )
{
// with UDP it's pretty straight forward. We always want to
// use Daemon::startCommand() so we get all the security stuff
// in every update. In fact, we want to recreate the SafeSock
// itself each time, since it doesn't seem to work if we reuse
// the SafeSock object from one update to the next...
dprintf( D_FULLDEBUG,
"Attempting to send update via UDP to collector %s\n",
update_destination );
bool raw_protocol = false;
if( cmd == UPDATE_COLLECTOR_AD || cmd == INVALIDATE_COLLECTOR_ADS ) {
// we *never* want to do security negotiation with the
// developer collector.
raw_protocol = true;
}
if(nonblocking) {
UpdateData *ud = new UpdateData(cmd, Sock::safe_sock, ad1, ad2, this);
if (this->pending_update_list.size() == 1)
{
startCommand_nonblocking(cmd, Sock::safe_sock, 20, NULL, UpdateData::startUpdateCallback, ud, NULL, raw_protocol );
}
return true;
}
Sock *ssock = startCommand(cmd, Sock::safe_sock, 20, NULL, NULL, raw_protocol);
if(!ssock) {
newError( CA_COMMUNICATION_ERROR,
"Failed to send UDP update command to collector" );
return false;
}
bool success = finishUpdate( this, ssock, ad1, ad2 );
delete ssock;
return success;
}
bool
DCStartd::vacateClaim( const char* name_vacate )
{
setCmdStr( "vacateClaim" );
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::vacateClaim: ";
err += "Failed to connect to startd (";
err += _addr;
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = VACATE_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send command PCKPT_JOB to the startd" );
return false;
}
if( ! reli_sock.code((unsigned char *)name_vacate) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
uint16_t SHT1x::readCommand(uint8_t command) {
reset();
// Send command
startCommand();
bool ok = sendByte(command);
if(!ok)
console.print(Error, "Error writing byte to sensor !!!");
// Wait for competition
delayTimer.mDelay(320);
// Receive result
union {
uint16_t value;
uint8_t bytes[2];
} result;
result.bytes[1] = receiveByte();
result.bytes[0] = receiveByte();
receiveByte();
return result.value;
}
