/*******************************************************************************
**
** Function: NfcAdaptation::Initialize()
**
** Description: class initializer
**
** Returns: none
**
*******************************************************************************/
void NfcAdaptation::Initialize ()
{
const char* func = "NfcAdaptation::Initialize";
ALOGD("%s: enter", func);
ALOGE("%s: ver=%s nfa=%s", func, nfca_version_string, nfa_version_string);
unsigned long num;
if ( !GetStrValue ( NAME_NFA_STORAGE, bcm_nfc_location, sizeof ( bcm_nfc_location ) ) )
{
memset (bcm_nfc_location, 0, sizeof(bcm_nfc_location));
strncpy (bcm_nfc_location, "/data/nfc", 9);
}
if ( GetNumValue ( NAME_PROTOCOL_TRACE_LEVEL, &num, sizeof ( num ) ) )
ScrProtocolTraceFlag = num;
if ( GetStrValue ( NAME_NFA_DM_CFG, (char*)nfa_dm_cfg, sizeof ( nfa_dm_cfg ) ) )
p_nfa_dm_cfg = ( tNFA_DM_CFG * ) &nfa_dm_cfg[0];
if ( GetNumValue ( NAME_NFA_MAX_EE_SUPPORTED, &num, sizeof ( num ) ) )
{
nfa_ee_max_ee_cfg = num;
ALOGD("%s: Overriding NFA_EE_MAX_EE_SUPPORTED to use %d", func, nfa_ee_max_ee_cfg);
}
initializeGlobalAppLogLevel ();
verify_stack_non_volatile_store ();
if ( GetNumValue ( NAME_PRESERVE_STORAGE, (char*)&num, sizeof ( num ) ) &&
(num == 1) )
ALOGD ("%s: preserve stack NV store", __FUNCTION__);
else
{
delete_stack_non_volatile_store (FALSE);
}
GKI_init ();
GKI_enable ();
GKI_create_task ((TASKPTR)NFCA_TASK, BTU_TASK, (INT8*)"NFCA_TASK", 0, 0, (pthread_cond_t*)NULL, NULL);
{
AutoThreadMutex guard(mCondVar);
GKI_create_task ((TASKPTR)Thread, MMI_TASK, (INT8*)"NFCA_THREAD", 0, 0, (pthread_cond_t*)NULL, NULL);
mCondVar.wait();
}
mHalDeviceContext = NULL;
mHalCallback = NULL;
memset (&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs));
InitializeHalDeviceContext ();
ALOGD ("%s: exit", func);
}
/*******************************************************************************
**
** Function: configureCrystalFrequency
**
** Description: Configure controller's crystal frequency by reading values from
** .conf file. If .conf file does not define any value, then use
** default values defined in struct nfc_post_reset_cb.
**
** Returns: none
**
*******************************************************************************/
void configureCrystalFrequency ()
{
unsigned long num = 0;
UINT32 hwId = 0;
UINT16 xtalFreq = 0;
UINT8 xtalIndex = 0;
int actualLen = 0;
if (GetNumValue (NAME_XTAL_HARDWARE_ID, &num, sizeof(num)))
hwId = num;
if (GetNumValue (NAME_XTAL_FREQUENCY, &num, sizeof(num)))
xtalFreq = (UINT16) num;
if (GetNumValue (NAME_XTAL_FREQ_INDEX, &num, sizeof(num)))
xtalIndex = (UINT8) num;
actualLen = GetStrValue (NAME_XTAL_PARAMS_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen && (xtalIndex == NFC_HAL_XTAL_INDEX_SPECIAL)) //whether to use custom crystal frequency
{
sXtalCustomParam.append (sConfig, actualLen);
p_nfc_hal_dm_xtal_params_cfg = const_cast<UINT8*> (sXtalCustomParam.getInternalBuffer ());
}
if ((hwId == 0) && (xtalFreq == 0) && (xtalIndex == 0))
return;
ALOGD ("%s: hwId=0x%lX; freq=%u; index=%u", __FUNCTION__, hwId, xtalFreq, xtalIndex);
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].brcm_hw_id = (hwId & BRCM_NFC_GEN_MASK);
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].xtal_freq = xtalFreq;
nfc_post_reset_cb.dev_init_config.xtal_cfg[0].xtal_index = xtalIndex;
nfc_post_reset_cb.dev_init_config.num_xtal_cfg = 1;
}
//读取第nParamIndex个参数，该参数为字符串型
std::string CScript::GetStringParam(char* strCmd, int nParamIndex)
{
int nCmdLen = strlen(strCmd);
int nStartOfParam = __PassCmdName(strCmd, nCmdLen);
if(nStartOfParam == nCmdLen)
return "\0";
int nParamNum = 0;
m_bScanningStr = false;
for(int j=nStartOfParam+1; j<nCmdLen; j++)
{
if(strCmd[j] == '\"')
m_bScanningStr = !m_bScanningStr;
//跳过分隔符
if(__IsDelimiter(strCmd[j]))
nParamNum++;
//读取指定字符串
if(nParamNum == nParamIndex && strCmd[j] == '\"' )
{
return GetStrValue(strCmd, nCmdLen, j);
}
}
return "\0";
}
/*******************************************************************************
**
** Function: postDownloadPatchram
**
** Description: Called after patch download
**
** Returns: none
**
*******************************************************************************/
static void postDownloadPatchram(tHAL_NFC_STATUS status)
{
ALOGD("%s: status=%i", __FUNCTION__, status);
GetStrValue (NAME_SNOOZE_MODE_CFG, (char*)&gSnoozeModeCfg, sizeof(gSnoozeModeCfg));
if (status != HAL_NFC_STATUS_OK)
{
ALOGE("%s: Patch download failed", __FUNCTION__);
if (status == HAL_NFC_STATUS_REFUSED)
{
SpdHelper::setPatchAsBad();
}
else
SpdHelper::incErrorCount();
/* If in SPD Debug mode, fail immediately and obviously */
if (SpdHelper::isSpdDebug())
HAL_NfcPreInitDone (HAL_NFC_STATUS_FAILED);
else
{
/* otherwise, power cycle the chip and let the stack startup normally */
ALOGD("%s: re-init; don't download firmware", __FUNCTION__);
//stop stack from downloading firmware during next initialization
nfc_post_reset_cb.spd_skip_on_power_cycle = TRUE;
USERIAL_PowerupDevice(0);
HAL_NfcReInit ();
}
}
/* Set snooze mode here */
else if (gSnoozeModeCfg.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE)
{
status = HAL_NfcSetSnoozeMode(gSnoozeModeCfg.snooze_mode,
gSnoozeModeCfg.idle_threshold_dh,
gSnoozeModeCfg.idle_threshold_nfcc,
gSnoozeModeCfg.nfc_wake_active_mode,
gSnoozeModeCfg.dh_wake_active_mode,
continueAfterSetSnoozeMode);
if (status != NCI_STATUS_OK)
{
ALOGE("%s: Setting snooze mode failed, status=%i", __FUNCTION__, status);
HAL_NfcPreInitDone(HAL_NFC_STATUS_FAILED);
}
}
else
{
ALOGD("%s: Not using Snooze Mode", __FUNCTION__);
HAL_NfcPreInitDone(HAL_NFC_STATUS_OK);
}
}
/*******************************************************************************
**
** Function findPatchramFile
**
** Description Find the patchram file name specified in the .conf
**
** Returns pointer to the file name
**
*******************************************************************************/
static const char* findPatchramFile(const char * pConfigName, char * pBuffer, int bufferLen)
{
ALOGD("%s: config=%s", __FUNCTION__, pConfigName);
if (pConfigName == NULL)
{
ALOGD("%s No patchfile defined\n", __FUNCTION__);
return NULL;
}
if (GetStrValue(pConfigName, &pBuffer[0], bufferLen))
{
ALOGD("%s found patchfile %s\n", __FUNCTION__, pBuffer);
return (pBuffer[0] == '\0') ? NULL : pBuffer;
}
ALOGD("%s Cannot find patchfile '%s'\n", __FUNCTION__, pConfigName);
return NULL;
}
/*******************************************************************************
**
** Function getNfaValues
**
** Description Get configuration values needed by NFA layer
**
** Returns: None
**
*******************************************************************************/
static void getNfaValues (UINT32 chipid)
{
unsigned long num = 0;
int actualLen = 0;
sStartupConfig.initialize ();
sLptdConfig.initialize ();
sPreDiscoveryConfig.initialize();
actualLen = GetStrValue (NAME_NFA_DM_START_UP_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
sStartupConfig.append (sConfig, actualLen);
// Set antenna tuning configuration if configured.
actualLen = GetStrValue(NAME_PREINIT_DSP_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
sStartupConfig.append (sConfig, actualLen);
if ( GetStrValue ( NAME_NFA_DM_START_UP_VSC_CFG, (char*)nfa_dm_start_up_vsc_cfg, sizeof (nfa_dm_start_up_vsc_cfg) ) )
{
p_nfc_hal_dm_start_up_vsc_cfg = &nfa_dm_start_up_vsc_cfg[0];
ALOGD ( "START_UP_VSC_CFG[0] = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
nfa_dm_start_up_vsc_cfg[0],
nfa_dm_start_up_vsc_cfg[1],
nfa_dm_start_up_vsc_cfg[2],
nfa_dm_start_up_vsc_cfg[3],
nfa_dm_start_up_vsc_cfg[4],
nfa_dm_start_up_vsc_cfg[5],
nfa_dm_start_up_vsc_cfg[6],
nfa_dm_start_up_vsc_cfg[7] );
}
actualLen = GetStrValue(NAME_LPTD_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
{
sLptdConfig.append (sConfig, actualLen);
p_nfc_hal_dm_lptd_cfg = const_cast<UINT8*> (sLptdConfig.getInternalBuffer ());
}
else
{
// Default to not sending any LPTD setting.
p_nfc_hal_dm_lptd_cfg = sDontSendLptd;
}
mayDisableSecureElement (sStartupConfig);
p_nfc_hal_dm_start_up_cfg = const_cast<UINT8*> (sStartupConfig.getInternalBuffer ());
actualLen = GetStrValue(NAME_NFA_DM_PRE_DISCOVERY_CFG, (char*)sConfig, sizeof(sConfig));
if (actualLen)
{
sPreDiscoveryConfig.append (sConfig, actualLen);
mayDisableSecureElement (sPreDiscoveryConfig);
p_nfc_hal_pre_discover_cfg = const_cast<UINT8*> (sPreDiscoveryConfig.getInternalBuffer ());
}
//configure how many secure elements are available for each type of chip
if (p_nfc_hal_cfg->nfc_hal_hci_uicc_support > 0)
{
if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_20791_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_20791_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST;
}
else if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_43341_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_43341_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST;
}
else if ((chipid & BRCM_NFC_GEN_MASK) == BRCM_NFC_20795_GEN)
{
nfc_hal_cb.max_ee = BRCM_NFC_20795_GEN_MAX_EE;
p_nfc_hal_cfg->nfc_hal_hci_uicc_support = HAL_NFC_HCI_UICC0_HOST | HAL_NFC_HCI_UICC1_HOST | HAL_NFC_HCI_UICC2_HOST;
}
//let .conf variable determine how many EE's to discover
if (GetNumValue(NAME_NFA_MAX_EE_SUPPORTED, &num, sizeof(num)))
nfc_hal_cb.max_ee = num;
}
}
CConfigString::operator const char*()
{
return GetStrValue();
}
char* gxConfig::GetStrValue(const char *Name, int fn)
{
gxString buf(Name);
return GetStrValue(buf, fn);
}
/*
* lnd_name:lljz_net_disk_name
*/
void CreateFolderReq(RequestPacket* req,
void* args, ResponsePacket* resp) {
Document req_doc;
/*
Document resp_doc;
Document::AllocatorType& resp_allocator=resp_doc.GetAllocator();
StringBuffer resp_buffer;
Writer<StringBuffer> resp_writer(resp_buffer);
Value resp_json(kObjectType);
Value resp_error_msg(kStringType);
*/
TBSYS_LOG(DEBUG,"-------data:%s",req->data_);
req_doc.Parse(req->data_);
if (!CheckAuth(req,resp))
return;
if (!req_doc.HasMember("folder_name")
|| !req_doc["folder_name"].IsString()
|| !req_doc["folder_name"].GetStringLength()) {
SetErrorMsg(35001,"folder_name is invalid",resp);
return;
}
const char* folder_name=req_doc["folder_name"].GetString();
char value[200];
char file_name[200];
int file_n=0;
int num=GetCharCount(folder_name, '/')+1;
int i=0;
// /a/b//c//d
for (i=0;i<num;i++) {
GetStrValue(folder_name, '/', i+1, value);
if (value[0]=='\0')
continue;
sprintf(file_name,"%s",value);
file_n++;
}
if (0==file_n) {
SetErrorMsg(35003,"path of new folder is invalid",resp);
return;
}
RedisClient* file_rc=g_file_redis->GetRedisClient();
char cmd[512];
redisReply* reply;
int cmd_ret;
//是否存在根目录，父目录，新目录
char father_name[200];
sprintf(father_name,"folder_%s",req_doc["account"].GetString());
sprintf(cmd,"HGET %s %c_%s", father_name,0x02,"create_time");
cmd_ret=Rhget(file_rc,cmd,reply);
if (FAILED_NOT_ACTIVE==cmd_ret) {//网络错误
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
SetErrorMsg(35002,"redis database server is busy",resp);
return;
} else if (FAILED_ACTIVE==cmd_ret) {//没有父目录
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
SetErrorMsg(35003,"path of root folder does not exist",resp);
return;
}
int counter=0;
for (i=0;i<num;i++) {
GetStrValue(folder_name, '/', i+1, value);
if (value[0]=='\0')
continue;
counter++;
if (counter>=file_n)
break;
sprintf(cmd,"HGET %s %s", father_name,value);
cmd_ret=Rhget(file_rc,cmd,reply,false);
if (FAILED_NOT_ACTIVE==cmd_ret) {//网络错误
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
SetErrorMsg(35002,"redis database server is busy",resp);
return;
} else if (FAILED_ACTIVE==cmd_ret) {//没有父目录
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
freeReplyObject(reply);
SetErrorMsg(35003,"path of parent folder does not exist",resp);
return;
}
//
if (0==reply->len) {
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
freeReplyObject(reply);
SetErrorMsg(35003,"path of parent folder does not exist",resp);
return;
}
sprintf(father_name,"%s",reply->str);
freeReplyObject(reply);
}
//增加新文件夹，lnd_name不能冲突
//取得file_id
sprintf(cmd,"SPOP file_id_sets_%s",
req_doc["account"].GetString());
cmd_ret=Rspop(file_rc,cmd,reply,false);
if (FAILED_NOT_ACTIVE==cmd_ret) {//网络错误
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
SetErrorMsg(35002,"get file_id fail,redis database server is busy",resp);
return;
} else if (FAILED_ACTIVE==cmd_ret) {
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,cmd_ret);
freeReplyObject(reply);
SetErrorMsg(35006,"get file_id fail,file_id is used out",resp);
return;
}
//在父目录增加记录
char lnd_name[512];
sprintf(lnd_name,"%d%c%s%c%s", 0,0x01,
req_doc["account"].GetString(),0x01,reply->str);
freeReplyObject(reply);
sprintf(cmd,"HSETNX %s %s %s",father_name,file_name, lnd_name);
cmd_ret=Rhsetnx(file_rc,cmd,reply);
if (FAILED_NOT_ACTIVE==cmd_ret) {//网络错误
g_file_redis->ReleaseRedisClient(file_rc,false);
SetErrorMsg(35002,"redis database server is busy",resp);
return;
} else if (FAILED_ACTIVE==cmd_ret) {
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,true);
SetErrorMsg(35006,"create folder fail,folder has existed",resp);
return;
}
//为新文件夹增加hash表
sprintf(cmd,"HSETNX %s %c_create_time %lld",
lnd_name,0x02, tbsys::CTimeUtil::getTime());
cmd_ret=Rhsetnx(file_rc,cmd,reply);
if (FAILED_NOT_ACTIVE==cmd_ret) {//网络错误
g_file_redis->ReleaseRedisClient(file_rc,false);
SetErrorMsg(35002,"create folder fail,redis database server is busy",resp);
return;
} else if (FAILED_ACTIVE==cmd_ret) {
//记录异常日志
g_file_redis->ReleaseRedisClient(file_rc,true);
SetErrorMsg(35006,"file_id has used,redis database server status error",resp);
return;
}
g_file_redis->ReleaseRedisClient(file_rc,true);
SetErrorMsg(0,"",resp);
}
/* ========================================================================= */
int run_as_sender(struct optbase *ob)
{
/* This used to be char junkbuf[0]; but the compiler complained. junkbuf
is a pointer to the top of the auto variables. The point is to have
a pointer to some data - but nothing of particular value. */
int junk;
char *junkbuf = (char *)&junk;
struct roundtrip *rt;
struct pc_comm *pcomm = NULL;
int go; /* Used multiple times for "event loops" */
char child_message[80];
char mirror_address[MAX_VALUE_SIZE];
char mirror_protocol[MAX_VALUE_SIZE];
char mirror_port[MAX_VALUE_SIZE];
unsigned long multiplier;
unsigned short optimal_block;
unsigned long run_seconds;
char sink_address[MAX_VALUE_SIZE];
char sink_protocol[MAX_VALUE_SIZE];
char sink_port[MAX_VALUE_SIZE];
time_t time_started; /* Really about reporting. */
time_t time_now; /* The most recent time. */
time_t time_stop;
/* Do some basic validation of the expected values */
if ( IsInvalidOption(ob, "MIRROR_ADDRESS", IVO_EXISTS) )
{
ErrorMessage("ERROR: MIRROR_ADDRESS option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "MIRROR_PROTOCOL", IVO_EXISTS) )
{
ErrorMessage("ERROR: MIRROR_PROTOCOL option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "MIRROR_PORT", IVO_EXISTS) )
{
ErrorMessage("ERROR: MIRROR_PORT option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "RETURN_MULTIPLIER", IVO_NNNUMERIC) )
{
ErrorMessage("ERROR: RETURN_MULTIPLIER option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "OPTIMAL_BLOCK", IVO_EXISTS) )
{
optimal_block = DEFAULT_OPTIMAL_BLOCK;
}
else
{
if ( GetUSValue(ob, &optimal_block, "OPTIMAL_BLOCK", 0, 65535) )
{
ErrorMessage("ERROR: Problems parsing OPTIMAL_BLOCK value.\n");
return(1);
}
}
if ( IsInvalidOption(ob, "RUN_FOR", IVO_EXISTS) )
{
run_seconds = 0;
}
else
{
if ( GetTimeValue(ob, &run_seconds, "RUN_FOR", 0, ULONG_MAX) )
{
ErrorMessage("ERROR: Problems parsing RUN_FOR value.\n");
return(1);
}
}
if ( GetULValue(ob, &multiplier, "RETURN_MULTIPLIER", 0, ULONG_MAX) )
{
ErrorMessage("ERROR: Problems parsing RETURN_MULTIPLIER value.\n");
return(1);
}
if ( multiplier > 0 )
{
/* This *could* be derived - it should not be *required* */
if ( IsInvalidOption(ob, "SINK_ADDRESS", IVO_EXISTS) )
{
ErrorMessage("ERROR: SINK_ADDRESS option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "SINK_PORT", IVO_EXISTS) )
{
ErrorMessage("ERROR: SINK_PORT option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "SINK_PROTOCOL", IVO_EXISTS) )
{
ErrorMessage("ERROR: SINK_PROTOCOL option is missing or invalid.\n");
return(1);
}
}
if ( GetStrValue(ob, mirror_address, "MIRROR_ADDRESS", 4, MAX_VALUE_SIZE) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_ADDRESS value.\n");
return(1);
}
if ( GetSTRValue(ob, mirror_protocol, "MIRROR_PROTOCOL", 2, 4) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_PROTOCOL value.\n");
return(1);
}
if ( GetStrValue(ob, mirror_port, "MIRROR_PORT", 2, 5) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_PORT value.\n");
return(1);
}
if ( multiplier > 0 )
{
if ( GetStrValue(ob, sink_address, "SINK_ADDRESS", 4, MAX_VALUE_SIZE) )
{
ErrorMessage("ERROR: Problems parsing SINK_ADDRESS value.\n");
return(1);
}
if ( GetSTRValue(ob, sink_protocol, "SINK_PROTOCOL", 2, 4) )
{
ErrorMessage("ERROR: Problems parsing SINK_PROTOCOL value.\n");
return(1);
}
if ( GetStrValue(ob, sink_port, "SINK_PORT", 2, 5) )
{
ErrorMessage("ERROR: Problems parsing SINK_PORT value.\n");
return(1);
}
}
ReportStart("netmirror", NULL, "A module to bounce packets across the network.");
/* Register signal handlers */
/*
signal(SIGTERM, capture_signal);
signal(SIGQUIT, capture_signal);
signal(SIGINT, capture_signal);
signal(SIGHUP, NULL);
*/
if ( NULL == ( rt = InitRoundTrip() ) )
return(1);
if ( InitSender(rt, mirror_address, mirror_protocol, mirror_port) )
return(1);
if ( InitReceiver(rt, sink_address, sink_protocol, sink_port, multiplier) )
return(1);
DebugMessage("Round trip multiplier is %lu.\n", multiplier);
DebugMessage("Run time (in seconds) is: %lu.\n", run_seconds);
if ( multiplier > 0 )
{
if (NULL == (pcomm = LaunchAsSink("ADDR", "PROTO", "PORT")))
return(1);
}
/* Check for message from the sink (if we started it). */
if (pcomm)
{
if(CheckForChildMessages(pcomm->outof, 250, child_message) > 0)
VerboseMessage("Sink: %s\n", child_message);
/* A sink is present */
}
rt->opt_block = optimal_block;
rt->run_seconds = run_seconds;
/* Start up the sender and send the opening packets */
if(StartSender(rt))
return(1);
/* Take time here - use it or not */
time(&time_started);
time_stop = time_started + run_seconds;
/* Send packets - handle sink messages */
go = 1;
while(go)
{
//DebugMessage("Sending data...");
send(rt->sd, junkbuf, optimal_block, 0);
//DebugMessage("Done.\n");
/* NOTE: This is an oppurtunity to put a delay in the sender. It
can be done here with the CheckForChildMessages() API.
In cases where there is no sink, then that code will not
run, so some other blocking mechanisim might be required
to insert the (optional) delay. */
if (pcomm)
{
/* A sink is present */
if(CheckForChildMessages(pcomm->outof, 0, child_message) > 0)
VerboseMessage("Sink: %s\n", child_message);
}
/* Now time becomes conditional */
if ( run_seconds > 0 )
{
time(&time_now);
if ( time_now >= time_stop )
go = 0;
}
}
DebugMessage("Shutting down the connection...");
close(rt->sd); /* An actual shutdown() is not relevant. */
DebugMessage("Done.\n");
/* There should be a several second pause between shutting down
outbound traffic and sending the stop to the sink. */
DebugMessage("Sending stop to sink process");
go = 3;
while(go)
{
DebugMessage(".");
sleep(1);
go--;
}
SendStopSink(pcomm->into);
DebugMessage("Done.\n");
go = 10;
while ( go )
{
if(CheckForChildMessages(pcomm->outof, 500, child_message) > 0)
{
if ( child_message[0] == '.' )
{
VerboseMessage("Sink exited. Sender exiting now.\n");
return(0);
}
}
go--;
}
ErrorMessage("ERROR: Sink process never exited. Sender exiting.\n");
return(1);
}
/* ========================================================================= */
int run_as_receiver(struct optbase *ob)
{
char listen_address[MAX_VALUE_SIZE];
char listen_protocol[MAX_VALUE_SIZE];
char listen_port[MAX_VALUE_SIZE];
char *local_listen;
/* Do some basic validation of the expected values */
if ( IsInvalidOption(ob, "MIRROR_PROTOCOL", IVO_EXISTS) )
{
/* NOTE: The mirror protocol is not optional. We do not run multiple
listeners at this time. Either you are UDP or TCP, not both,
not mixed (sender --> mirror (tcp); mirror --> sink (udp)). */
ErrorMessage("ERROR: MIRROR_PROTOCOL option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "MIRROR_PORT", IVO_EXISTS) ) /* STUB: Check for numeric */
{
ErrorMessage("ERROR: MIRROR_PORT option is missing or invalid.\n");
return(1);
}
if ( IsInvalidOption(ob, "MIRROR_ADDRESS", IVO_EXISTS) )
{
if ( GetStrValue(ob, listen_address, "MIRROR_ADDRESS", 3, MAX_VALUE_SIZE) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_ADDRESS value.\n");
return(1);
}
local_listen = listen_address;
}
else
local_listen = NULL;
if ( GetSTRValue(ob, listen_protocol, "MIRROR_PROTOCOL", 2, 4) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_PROTOCOL value.\n");
return(1);
}
if ( GetStrValue(ob, listen_port, "MIRROR_PORT", 2, 5) )
{
ErrorMessage("ERROR: Problems parsing MIRROR_PORT value.\n");
return(1);
}
/* Register signal handlers */
/*
signal(SIGTERM, capture_signal);
signal(SIGQUIT, capture_signal);
signal(SIGINT, capture_signal);
signal(SIGHUP, NULL);
*/
RunAsReceiver(local_listen, listen_protocol, listen_port);
return(0);
}
const std::string* GetStrValue(SceneObjectIterator& obj, const char *key) {
return GetStrValue((*obj), key);
}
