bool
DCStartd::requestClaim( ClaimType cType, const ClassAd* req_ad,
ClassAd* reply, int timeout )
{
setCmdStr( "requestClaim" );
std::string err_msg;
switch( cType ) {
case CLAIM_COD:
case CLAIM_OPPORTUNISTIC:
break;
default:
err_msg = "Invalid ClaimType (";
err_msg += (int)cType;
err_msg += ')';
newError( CA_INVALID_REQUEST, err_msg.c_str() );
return false;
}
ClassAd req( *req_ad );
char buf[1024];
// Add our own attributes to the request ad we're sending
sprintf( buf, "%s = \"%s\"", ATTR_COMMAND,
getCommandString(CA_REQUEST_CLAIM) );
req.Insert( buf );
sprintf( buf, "%s = \"%s\"", ATTR_CLAIM_TYPE, getClaimTypeString(cType) );
req.Insert( buf );
return sendCACmd( &req, reply, true, timeout );
}
bool
DCStartd::locateStarter( const char* global_job_id,
const char *claimId,
const char *schedd_public_addr,
ClassAd* reply,
int timeout )
{
setCmdStr( "locateStarter" );
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign(ATTR_COMMAND,getCommandString( CA_LOCATE_STARTER ));
req.Assign(ATTR_GLOBAL_JOB_ID,global_job_id);
req.Assign(ATTR_CLAIM_ID, claimId);
if ( schedd_public_addr ) {
req.Assign(ATTR_SCHEDD_IP_ADDR,schedd_public_addr);
}
// if this claim is associated with a security session
ClaimIdParser cidp( claimId );
return sendCACmd( &req, reply, false, timeout, cidp.secSessionId() );
}
bool
DCStartd::releaseClaim( VacateType vType, ClassAd* reply,
int timeout )
{
setCmdStr( "releaseClaim" );
if( ! checkClaimId() ) {
return false;
}
if( ! checkVacateType(vType) ) {
return false;
}
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign( ATTR_COMMAND, getCommandString(CA_RELEASE_CLAIM) );
req.Assign( ATTR_CLAIM_ID, claim_id );
req.Assign( ATTR_VACATE_TYPE, getVacateTypeString(vType) );
// since release could take a while, if we didn't already get
// told what timeout to use, set the timeout to 0 so we don't
// bail out prematurely...
if( timeout < 0 ) {
return sendCACmd( &req, reply, true, 0 );
} else {
return sendCACmd( &req, reply, true, timeout );
}
}
bool
DCStartd::updateMachineAd( const ClassAd * update, ClassAd * reply, int timeout ) {
setCmdStr( "updateMachineAd" );
ClassAd u( * update );
u.Assign( ATTR_COMMAND, getCommandString( CA_UPDATE_MACHINE_AD ) );
return sendCACmd( & u, reply, true, timeout );
}
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;
}
/*
如何使用此对像：
１、构造对像
isend("dddd");
2、发送数据：
trigerSend("dddd"); //这个dddd表示要发送出去的完整内容。注意不是关键字
如果不管结果的话，到此就ＯＫ了
３、如果要看最后发送的情况，就要设置一个for语句：
*step 1
psender->trigerSend(dat);
for(;;) {
*step 2
ret = psender->isResultOk();
if (ret == 1) {
printf("send datas ok:");
*step 3
break;
} else if (ret == 2) {
printf("send datas fail\n");
break;
} else {
usleep(100000);
}
}
２、设置要发送的命令字符串
３、在远程返回结果的地方加入自己的代码
*/
ISend::ISend(const char *cmdstr, void (*cb)(unsigned char *dat, unsigned char len))
{
trys = 0;
_type = 0;
setStatus(S_I);
setSendResult(RLT_INIT);
clearAckData();
setCmdStr(cmdstr);
_keywordlen = strlen(cmdstr);
_cb = cb;
creat_send_thread();
}
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;
}
unsigned char ISend::trigerSend(unsigned char *s)
{
if (status == S_I) {
clearReceiveData();
setCmdStr(s);
status = S_S;
setindex();
setSendResult(RLT_INIT);
sendRfDatas();
return 1;
} else {
return 0;
}
}
bool
DCStartd::resumeClaim( ClassAd* reply, int timeout )
{
setCmdStr( "resumeClaim" );
if( ! checkClaimId() ) {
return false;
}
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign( ATTR_COMMAND, getCommandString(CA_RESUME_CLAIM) );
req.Assign( ATTR_CLAIM_ID, claim_id );
return sendCACmd( &req, reply, true, timeout );
}
bool
DCStartd::activateClaim( const ClassAd* job_ad, ClassAd* reply,
int timeout )
{
setCmdStr( "activateClaim" );
if( ! checkClaimId() ) {
return false;
}
ClassAd req( *job_ad );
// Add our own attributes to the request ad we're sending
req.Assign( ATTR_COMMAND, getCommandString(CA_ACTIVATE_CLAIM) );
req.Assign( ATTR_CLAIM_ID, claim_id );
return sendCACmd( &req, reply, true, timeout );
}
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;
}
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;
}
bool
DCStarter::reconnect( ClassAd* req, ClassAd* reply, ReliSock* rsock,
int timeout, char const *sec_session_id )
{
setCmdStr( "reconnectJob" );
std::string line;
// Add our own attributes to the request ad we're sending
line = ATTR_COMMAND;
line += "=\"";
line += getCommandString( CA_RECONNECT_JOB );
line += '"';
req->Insert( line.c_str() );
return sendCACmd( req, reply, rsock, false, timeout, sec_session_id );
}
unsigned char ISend::trigerSend(const char *s)
{
if (getStatus() == S_I) {
clearAckData();
setCmdStr(s);
setStatus(S_S);
setindex();
setSendResult(RLT_INIT);
if (_type == 1) {
setStatus(S_I);
setSendResult(RLT_OK);
}
sendRfDatas();
return 1;
} else {
return 0;
}
}
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;
}
void
DCStartd::asyncSwapClaims(const char * claim_id, char const *src_descrip, const char * dest_slot_name, int timeout, classy_counted_ptr<DCMsgCallback> cb)
{
dprintf(D_FULLDEBUG|D_PROTOCOL,"Swapping claim %s into slot %s\n", src_descrip, dest_slot_name);
setCmdStr( "swapClaims" );
ASSERT( checkClaimId() );
ASSERT( checkAddr() );
classy_counted_ptr<SwapClaimsMsg> msg = new SwapClaimsMsg( claim_id, src_descrip, dest_slot_name );
ASSERT( msg.get() );
msg->setCallback(cb);
msg->setSuccessDebugLevel(D_ALWAYS|D_PROTOCOL);
// if this claim is associated with a security session
ClaimIdParser cid(claim_id);
msg->setSecSessionId(cid.secSessionId());
msg->setTimeout(timeout);
//msg->setDeadlineTimeout(deadline_timeout);
sendMsg(msg.get());
}
void
DCStartd::asyncRequestOpportunisticClaim( ClassAd const *req_ad, char const *description, char const *scheduler_addr, int alive_interval, int timeout, int deadline_timeout, classy_counted_ptr<DCMsgCallback> cb )
{
dprintf(D_FULLDEBUG|D_PROTOCOL,"Requesting claim %s\n",description);
setCmdStr( "requestClaim" );
ASSERT( checkClaimId() );
ASSERT( checkAddr() );
classy_counted_ptr<ClaimStartdMsg> msg = new ClaimStartdMsg( claim_id, extra_ids, req_ad, description, scheduler_addr, alive_interval );
ASSERT( msg.get() );
msg->setCallback(cb);
msg->setSuccessDebugLevel(D_ALWAYS|D_PROTOCOL);
// if this claim is associated with a security session
ClaimIdParser cid(claim_id);
msg->setSecSessionId(cid.secSessionId());
msg->setTimeout(timeout);
msg->setDeadlineTimeout(deadline_timeout);
sendMsg(msg.get());
}
int
DCStartd::delegateX509Proxy( const char* proxy, time_t expiration_time, time_t *result_expiration_time )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::delegateX509Proxy()\n" );
setCmdStr( "delegateX509Proxy" );
if( ! claim_id ) {
newError( CA_INVALID_REQUEST,
"DCStartd::delegateX509Proxy: Called with NULL claim_id" );
return CONDOR_ERROR;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
//
// 1) begin the DELEGATE_GSI_CRED_STARTD command
//
ReliSock* tmp = (ReliSock*)startCommand( DELEGATE_GSI_CRED_STARTD,
Stream::reli_sock,
20, NULL, NULL, false,
cidp.secSessionId() );
if( ! tmp ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send command DELEGATE_GSI_CRED_STARTD to the startd" );
return CONDOR_ERROR;
}
//
// 2) get reply from startd - OK means continue, NOT_OK means
// don't bother (the startd doesn't require a delegated
// proxy
//
tmp->decode();
int reply;
if( !tmp->code(reply) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: failed to receive reply from startd (1)" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: end of message error from startd (1)" );
delete tmp;
return CONDOR_ERROR;
}
if( reply == NOT_OK ) {
delete tmp;
return NOT_OK;
}
//
// 3) send over the claim id and delegate (or copy) the given proxy
//
tmp->encode();
int use_delegation =
param_boolean( "DELEGATE_JOB_GSI_CREDENTIALS", true ) ? 1 : 0;
if( !tmp->code( claim_id ) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send claim id to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->code( use_delegation ) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send use_delegation flag to the startd" );
delete tmp;
return CONDOR_ERROR;
}
int rv;
filesize_t dont_care;
if( use_delegation ) {
rv = tmp->put_x509_delegation( &dont_care, proxy, expiration_time, result_expiration_time );
}
else {
dprintf( D_FULLDEBUG,
"DELEGATE_JOB_GSI_CREDENTIALS is False; using direct copy\n");
if( ! tmp->get_encryption() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Cannot copy: channel does not have encryption enabled" );
delete tmp;
return CONDOR_ERROR;
}
rv = tmp->put_file( &dont_care, proxy );
}
if( rv == -1 ) {
newError( CA_FAILURE,
"DCStartd::delegateX509Proxy: Failed to delegate proxy" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_FAILURE,
"DCStartd::delegateX509Proxy: end of message error to startd" );
delete tmp;
return CONDOR_ERROR;
}
// command successfully sent; now get the reply
tmp->decode();
if( !tmp->code(reply) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: failed to receive reply from startd (2)" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: end of message error from startd (2)" );
delete tmp;
return CONDOR_ERROR;
}
delete tmp;
dprintf( D_FULLDEBUG,
"DCStartd::delegateX509Proxy: successfully sent command, reply is: %d\n",
reply );
return reply;
}
bool
DCStartd::deactivateClaim( bool graceful, bool *claim_is_closing )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::deactivateClaim(%s)\n",
graceful ? "graceful" : "forceful" );
if( claim_is_closing ) {
*claim_is_closing = false;
}
setCmdStr( "deactivateClaim" );
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 = graceful ? DEACTIVATE_CLAIM : DEACTIVATE_CLAIM_FORCIBLY;
dprintf (D_COMMAND, "DCStartd::deactivateClaim(%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::deactivateClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd;
if( graceful ) {
cmd = DEACTIVATE_CLAIM;
} else {
cmd = DEACTIVATE_CLAIM_FORCIBLY;
}
result = startCommand( cmd, (Sock*)&reli_sock, 20, NULL, NULL, false, sec_session );
if( ! result ) {
std::string err = "DCStartd::deactivateClaim: ";
err += "Failed to send command ";
if( graceful ) {
err += "DEACTIVATE_CLAIM";
} else {
err += "DEACTIVATE_CLAIM_FORCIBLY";
}
err += " to the startd";
newError( CA_COMMUNICATION_ERROR, err.c_str() );
return false;
}
// Now, send the ClaimId
if( ! reli_sock.put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::deactivateClaim: Failed to send ClaimId to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::deactivateClaim: Failed to send EOM to the startd" );
return false;
}
reli_sock.decode();
ClassAd response_ad;
if( !getClassAd(&reli_sock, response_ad) || !reli_sock.end_of_message() ) {
dprintf( D_FULLDEBUG, "DCStartd::deactivateClaim: failed to read response ad.\n");
// The response ad is not critical and is expected to be missing
// if the startd is from before 7.0.5.
}
else {
bool start = true;
response_ad.LookupBool(ATTR_START,start);
if( claim_is_closing ) {
*claim_is_closing = !start;
}
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::deactivateClaim: "
"successfully sent command\n" );
return true;
}
int
DCStartd::activateClaim( ClassAd* job_ad, int starter_version,
ReliSock** claim_sock_ptr )
{
int reply;
dprintf( D_FULLDEBUG, "Entering DCStartd::activateClaim()\n" );
setCmdStr( "activateClaim" );
if( claim_sock_ptr ) {
// our caller wants a pointer to the socket we used to
// successfully activate the claim. right now, set it to
// NULL to signify error, and if everything works out,
// we'll give them a pointer to the real object.
*claim_sock_ptr = NULL;
}
if( ! claim_id ) {
newError( CA_INVALID_REQUEST,
"DCStartd::activateClaim: called with NULL claim_id, failing" );
return CONDOR_ERROR;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
char const *sec_session = cidp.secSessionId();
Sock* tmp;
tmp = startCommand( ACTIVATE_CLAIM, Stream::reli_sock, 20, NULL, NULL, false, sec_session );
if( ! tmp ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send command ACTIVATE_CLAIM to the startd" );
return CONDOR_ERROR;
}
if( ! tmp->put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send ClaimId to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! tmp->code(starter_version) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send starter_version to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! putClassAd(tmp, *job_ad) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send job ClassAd to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send EOM to the startd" );
delete tmp;
return CONDOR_ERROR;
}
// Now, try to get the reply
tmp->decode();
if( !tmp->code(reply) || !tmp->end_of_message()) {
std::string err = "DCStartd::activateClaim: ";
err += "Failed to receive reply from ";
err += _addr ? _addr : "NULL";
newError( CA_COMMUNICATION_ERROR, err.c_str() );
delete tmp;
return CONDOR_ERROR;
}
dprintf( D_FULLDEBUG, "DCStartd::activateClaim: "
"successfully sent command, reply is: %d\n", reply );
if( reply == OK && claim_sock_ptr ) {
*claim_sock_ptr = (ReliSock*)tmp;
} else {
// in any other case, we're going to leak this ReliSock
// object if we don't delete it here...
delete tmp;
}
return reply;
}
