int processWait()
{
logTest("processWait", "Going to wait for the running processes");
for (int i = 0; i < DEFAULT_PROCESS_ENTRIES; i++)
{
if (processes[i] != NULL)
{
logTest("processWait", "Waiting for the process with pid %d",
processes[i] -> getPid());
for (;;)
{
if (processes[i] -> wait() == 1)
{
delete processes[i];
processes[i] = NULL;
break;
}
}
}
}
logTest("processWait", "All children processes exited");
return 1;
}
int processCheck()
{
logTest("processCheck", "Going to check the exited processes");
for (int i = 0; i < DEFAULT_PROCESS_ENTRIES; i++)
{
if (processes[i] != NULL)
{
if (processes[i] -> isRunning() == 0)
{
logTest("processCheck", "Process with pid %d has died",
processes[i] -> getPid());
delete processes[i];
processes[i] = NULL;
}
else
{
logTest("processCheck", "Process with pid %d is running",
processes[i] -> getPid());
}
}
}
return 1;
}
int Process::parseStatus(int result, int status)
{
logTrace("Process::parseStatus");
if (result > 0)
{
if (WIFSTOPPED(status))
{
logTest("Process::parseStatus", "Child %d was stopped "
"with signal %d", pid_, (WSTOPSIG(status)));
}
else
{
#ifdef TEST
if (WIFEXITED(status))
{
logTest("Process::parseStatus", "Child %d exited "
"with status %d", pid_, (WEXITSTATUS(status)));
}
else if (WIFSIGNALED(status))
{
logTest("Process::parseStatus", "Child %d died "
"because of signal %d", pid_, (WTERMSIG(status)));
}
#endif
status_ = status;
return 1;
}
}
else if (result < 0)
{
if (EGET() == ECHILD)
{
//
// The process died but we missed to
// call the waitpid() at the time.
//
logWarning("Process::parseStatus::waitpid", EGET());
return 1;
}
logError("Process::parseStatus::waitpid", EGET());
return -1;
}
return 0;
}
/* *********************************** */
int ProSLIC_testInBattery(proslicChanType *pProslic, proslicTestInObjType *pTstin)
{
proslicMonitorType monitor;
/* Valid device check */
if(TSTIN_INVALID_PART_NUM)
{
return RC_UNSUPPORTED_FEATURE;
}
/* Check if enabled */
if(!pTstin->batteryTest.testEnable)
{
return RC_TEST_DISABLED;
}
/* Invalidate last test results */
pTstin->batteryTest.testDataValid = TSTIN_RESULTS_INVALID;
/* Measure Battery */
ProSLIC_LineMonitor(pProslic,&monitor);
pTstin->batteryTest.vbat.value = monitor.vbat;
pTstin->batteryTest.testResult = logTest(pProslic,&(pTstin->batteryTest.vbat),"Battery : VBAT");
pTstin->batteryTest.testDataValid = TSTIN_RESULTS_VALID; /* New valid results */
return (pTstin->batteryTest.testResult);
}
int Process::waitFork()
{
int limit = RETRY_FORK_LIMIT;
int timeout = RETRY_FORK_INTERVAL;
int pid;
for (int i = 0; i < limit; i++)
{
logTest("Process::waitFork", "Trying at %s",
strMsTimestamp());
//
// It could optionally try again only if the
// error code is 11, 'Resource temporarily
// unavailable'.
//
if ((pid = fork()) >= 0)
{
break;
}
else if (i < limit - 1)
{
logTest("Process::waitFork::fork", "Function "
"fork failed");
logError("Process::waitFork::fork", EGET());
logTest("Process::waitFork", "Trying again");
usleep(timeout * 1000);
}
}
if (pid <= 0)
{
logTest("Process::waitFork", "Returning at %s",
strMsTimestamp());
}
return pid;
}
int Process::addParameter(const char *parameter)
{
logTrace("Process::addParameter");
if (function_ != NULL)
{
logTest("Process::addParameter", "Can't add a parameter "
"to a function");
logError("Process::addParameter", ESET(EPERM));
return -1;
}
else if (nextParameter_ < 2)
{
logTest("Process::addParameter", "Can't add a parameter "
"without a command");
logError("Process::addParameter", ESET(EPERM));
return -1;
}
if (nextParameter_ < parametersLimit_)
{
if (setValue(parameters_[nextParameter_], parameter) > 0)
{
nextParameter_++;
return 1;
}
}
else
{
logTest("Process::addParameter", "No space left in the "
"parameter table");
logError("Process::addParameter", ESET(ENOMEM));
}
return -1;
}
FILE *Process::getNullStream()
{
logTrace("Process::getNullStream");
if (nullStream_ == NULL)
{
logTest("Process::getNullStream", "Creating a "
"fake stream as '%s'", nullStreamName_);
if ((nullStream_ = fopen(nullStreamName_, "a+")) == NULL)
{
logError("Process::getNullStream::fopen", EGET());
logTest("Process::getNullStream", "Can't create "
"a fake stream as '%s'", nullStreamName_);
}
}
return nullStream_;
}
int processHandler(int fd)
{
logTest("processHandler", "Going to run a new process");
for (;;)
{
for (int i = 0; i < DEFAULT_PROCESS_ENTRIES; i++)
{
if (processes[i] == NULL)
{
logTest("processHandler", "Starting process for descriptor %d", fd);
processes[i] = new Process();
processes[i] -> setFunction(requestHandler, NULL);
processes[i] -> setStdin(fd);
processes[i] -> setStdout(fd);
processes[i] -> setStderr(fileno(stderr));
processes[i] -> start();
return 1;
}
}
//
// We were unable to find a slot.
// Wait until a child exits.
//
logTest("processHandler", "No free slots found");
processes[0] -> wait(getTimestamp(10));
processCheck();
}
}
void RunTest()
{
/*
FIXME
extern void InstallSignals();
logTest("RunTest", "Going to install the signal handlers");
InstallSignals();
*/
logTest("RunTest", "Going to run the connection handler");
connectionHandler();
logTest("RunTest", "Going to exit with %d requests handled",
requests);
/*
FIXME
HandleCleanup();
*/
}
int Process::kill(int signal)
{
logTrace("Process::kill");
logTest("Process::kill", "Sending signal %d to process %d",
signal, pid_);
if (::kill(pid_, signal) < 0 && EGET() != ESRCH)
{
logError("Process::kill::kill", EGET());
return -1;
}
return 1;
}
FILE *Process::setDescriptorStream(int &fd, FILE *&stream, char *mode)
{
logTrace("Process::setDescriptorStream");
if ((stream = fdopen(fd, mode)) == NULL)
{
logError("Process::setDescriptorStream::fdopen", EGET());
logTest("Process::setDescriptorStream", "Can't create "
"stream for descriptor %d", fd);
return getNullStream();
}
return stream;
}
int Process::wait(const T_timestamp timeout)
{
logTrace("Process::wait");
if (pid_ < 0)
{
logError("Process::wait", ESET(ECHILD));
return 1;
}
//
// Wait for the process until the timeout.
//
int status;
int options = WUNTRACED;
setTimer(timeout);
int result;
if ((result = waitpid(pid_, &status, options)) == -1)
{
if (EGET() == EINTR)
{
logTest("Process::wait", "Timeout raised waiting "
"for pid %d", pid_);
return 0;
}
else
{
logError("Process::wait", EGET());
return -1;
}
}
resetTimer();
result = parseStatus(result, status);
return result;
}
int Process::isSuccess()
{
logTrace("Process::isSuccess");
if (status_ == -1)
{
logTest("Process::isSuccess", "Child %d is "
"still running", pid_);
logWarning("Process::isSuccess", ESET(EPERM));
return 0;
}
if (WIFEXITED(status_))
{
return (WEXITSTATUS(status_) == 0);
}
return 0;
}
int Process::addEnvironment(const char *environment)
{
logTrace("Process::addEnvironment");
if (nextEnvironment_ < environmentLimit_)
{
if (setValue(environment_[nextEnvironment_], environment) > 0)
{
nextEnvironment_++;
return 1;
}
}
else
{
logTest("Process::addEnvironment", "No space left in the "
"environment table");
logError("Process::addEnvironment", ESET(ENOMEM));
}
return -1;
}
Process::~Process()
{
logTrace("Process::~Process");
//
// Close all the descriptors.
//
end();
if (nullStream_ != NULL)
{
logTest("Process::~Process", "Closing the null stream");
fclose(nullStream_);
nullStream_ = NULL;
}
//
// Free memory from the heap.
//
if (function_ == NULL)
{
for (int i = 0; i < nextParameter_; i++)
{
delete [] parameters_[i];
}
}
for (int i = 0; i < nextEnvironment_; i++)
{
delete [] environment_[i];
}
}
/* *********************************** */
int ProSLIC_testInAudio(proslicChanType *pProslic, proslicTestInObjType *pTstin)
{
uInt8 enhanceRegSave;
uInt8 lf;
int32 data;
int32 gainMeas1,gainMeas2;
int32 gainMeas3 = 0;
ProSLIC_audioGain_Cfg gainCfg;
int32 Pin = -3980; /* -10dBm + 6.02dB (since OHT w/ no AC load) */
/* Valid device check */
if(TSTIN_INVALID_PART_NUM)
{
return RC_UNSUPPORTED_FEATURE;
}
/* Check if enabled */
if(!pTstin->audioTest.testEnable)
{
return RC_TEST_DISABLED;
}
/* Invalidate last test results */
pTstin->audioTest.testDataValid = TSTIN_RESULTS_INVALID;
/* Verify line not in use */
if(ProSLIC_ReadReg(pProslic,34) & 0x02) /* LCR */
{
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("\nProSLIC : TestIn : Audio : Line in Use\n");
}
#endif
if(pTstin->audioTest.abortIfLineInUse == ABORT_LIU_ENABLED)
{
return RC_LINE_IN_USE;
}
}
/* Disable Powersave */
enhanceRegSave = ProSLIC_ReadReg(pProslic,47);
ProSLIC_WriteReg(pProslic,47,0x20);
Delay(pProTimer,10);
/* Setup Audio Filter, enable audio in OHT */
lf = ProSLIC_ReadReg(pProslic,30); /* LINEFEED */
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
Delay(pProTimer,20); /* settle */
setup1kHzBandpass(pProslic);
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_OHT);
/* Setup osc1 for 1kHz -10dBm tone, disable hybrid, enable filters */
ProSLIC_WriteRAM(pProslic,26,0x5A80000L); /* OSC1FREQ */
ProSLIC_WriteRAM(pProslic,27,0x5D8000L); /* OSC1AMP */
ProSLIC_WriteReg(pProslic,48,0x02); /* OMODE */
ProSLIC_WriteReg(pProslic,49,0x01); /* OCON */
ProSLIC_WriteReg(pProslic,44,0x10); /* DIGCON */
ProSLIC_WriteReg(pProslic,71,0x10); /* DIAG1 */
/* Settle */
Delay(pProTimer,800);
/* Read first gain measurement (Gtx + Grx + Gzadj) */
gainMeas1 = readAudioDiagLevel(pProslic,pTstin->audioTest.zerodBm_mVpk);
/* Bypass TXACHPF and set TXACEQ to unity */
gainCfg.acgain = ProSLIC_ReadRAM(pProslic,544); /* TXACGAIN */
gainCfg.aceq_c0 = ProSLIC_ReadRAM(pProslic,540); /* TXACEQ_C0 */
gainCfg.aceq_c1 = ProSLIC_ReadRAM(pProslic,541); /* TXACEQ_C1 */
gainCfg.aceq_c2 = ProSLIC_ReadRAM(pProslic,542); /* TXACEQ_C2 */
gainCfg.aceq_c3 = ProSLIC_ReadRAM(pProslic,543); /* TXACEQ_C3 */
ProSLIC_WriteRAM(pProslic,544,0x8000000L);
ProSLIC_WriteRAM(pProslic,543,0x0L);
ProSLIC_WriteRAM(pProslic,542,0x0L);
ProSLIC_WriteRAM(pProslic,541,0x0L);
ProSLIC_WriteRAM(pProslic,540,0x8000000L);
ProSLIC_WriteReg(pProslic,44,0x18);
/* Settle */
Delay(pProTimer,800);
/* Read second level measurement (RX level only) */
gainMeas2 = readAudioDiagLevel(pProslic,pTstin->audioTest.zerodBm_mVpk);
/* Adjust txgain if TXACGAIN wasn't unity during gainMeas1 */
if(gainCfg.acgain != 0x8000000L)
{
data = (gainCfg.acgain*10)/134217;
gainMeas3 = dBLookup(data);
}
/* Computations */
pTstin->audioTest.rxGain.value = gainMeas2 - Pin;
pTstin->audioTest.txGain.value = gainMeas1 - gainMeas2 + gainMeas3;
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("ProSLIC : TestIn : Audio : gainMeas1 = %d\n", gainMeas1);
LOGPRINT("ProSLIC : TestIn : Audio : gainMeas2 = %d\n", gainMeas2);
LOGPRINT("ProSLIC : TestIn : Audio : gainMeas3 = %d\n", gainMeas3);
}
#endif
pTstin->audioTest.testResult = RC_TEST_PASSED;
pTstin->audioTest.testResult |= logTest(pProslic,&(pTstin->audioTest.rxGain),"RX Path Gain");
pTstin->audioTest.testResult |= logTest(pProslic,&(pTstin->audioTest.txGain),"TX Path Gain");
/*
** Restore
*/
/* Need to store/restore all modified reg/RAM */
ProSLIC_WriteRAM(pProslic,544,gainCfg.acgain);
ProSLIC_WriteRAM(pProslic,540,gainCfg.aceq_c0);
ProSLIC_WriteRAM(pProslic,541,gainCfg.aceq_c1);
ProSLIC_WriteRAM(pProslic,542,gainCfg.aceq_c2);
ProSLIC_WriteRAM(pProslic,543,gainCfg.aceq_c3);
ProSLIC_WriteReg(pProslic,71,0x0); /* DIAG1 */
ProSLIC_WriteReg(pProslic,44,0x0); /* DIGCON */
ProSLIC_WriteReg(pProslic,48,0x0); /* OMODE */
ProSLIC_WriteReg(pProslic,49,0x0); /* OCON */
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
ProSLIC_WriteReg(pProslic,47,enhanceRegSave);
ProSLIC_SetLinefeedStatus(pProslic,lf);
/* Validate last test results */
pTstin->audioTest.testDataValid = TSTIN_RESULTS_VALID;
return pTstin->audioTest.testResult;
}
int Process::start()
{
logTrace("Process::start");
int childIn[2] = { -1, -1 };
int childOut[2] = { -1, -1 };
int childErr[2] = { -1, -1 };
//
// We either have 2 parameters and this process
// will exec() a new command, or we have one or
// none and this process will yield control to
// a function.
//
if (function_ == NULL && (parameters_[0] == NULL ||
parameters_[1] == NULL))
{
logTest("Process::start", "Can't start the process "
"without a command or function");
logError("Process::start", ESET(EPERM));
return -1;
}
#ifdef TEST
if (function_ == NULL)
{
logTest("Process::start", "Executing command '%s'",
parameters_[0]);
for (int i = 1; i < parametersLimit_ &&
parameters_[i] != NULL; i++)
{
logTest("Process::start", "Parameter [%d] is '%s'",
i, parameters_[i]);
}
}
else
{
logTest("Process::start", "Executing function at %p",
function_);
logTest("Process::start", "Passing data as %p",
parameters_[0]);
}
for (int i = 0; i < environmentLimit_ &&
environment_[i] != NULL; i++)
{
logTest("Process::start", "Environment [%d] is '%s'",
i, environment_[i]);
}
#endif
//
// Create the pipes that will be used to replace
// the standard descriptors.
//
if ((in_ == -1 && pipe(childIn) != 0) ||
(out_ == -1 && pipe(childOut) != 0) ||
(err_ == -1 && pipe(childErr) != 0))
{
logError("Process::start::pipe", EGET());
return -1;
}
//
// The fork() on Cygwin can show intermittent
// failures. In this case we try again after
// some time.
//
#ifdef __CYGWIN32__
switch (pid_ = waitFork())
#else
switch (pid_ = fork())
#endif
{
case -1:
{
//
// An error was encountered.
//
logError("Process::start::fork", EGET());
if (in_ == -1)
{
close(childIn[0]);
close(childIn[1]);
}
if (out_ == -1)
{
close(childOut[0]);
close(childOut[1]);
}
if (err_ == -1)
{
close(childErr[0]);
close(childErr[1]);
}
return -1;
}
case 0:
{
//
// We are the child process.
//
logTest("Process::start", "Child running with pid %d", getpid());
//
// Drop the privileges.
//
if (privileged_ != 1)
{
logTest("Process::start", "Child dropping the permissions");
setgid(getgid());
setuid(getuid());
}
//
// Let the input descriptor inherited from the
// parent replace the standard descriptors. The
// descriptor can be either the one set by the
// parent or our end of the pipe we created be-
// fore forking.
//
// Handle the standard input.
//
if (in_ == -1)
{
logTest("Process::start", "Child replacing pipe "
"%d and %d for input", childIn[0], childIn[1]);
if (childIn[0] != 0)
{
dup2(childIn[0], 0);
close(childIn[0]);
}
close(childIn[1]);
}
else if (in_ != 0)
{
logTest("Process::start", "Child replacing input %d", in_);
dup2(in_, 0);
if (in_ != out_ && in_ != err_)
{
close(in_);
}
}
else
{
logTest("Process::start", "Child inherited input");
}
in_ = 0;
//
// Handle the standard output.
//
if (out_ == -1)
{
logTest("Process::start", "Child replacing pipe "
"%d and %d for output", childOut[0], childOut[1]);
if (childOut[1] != 1)
{
dup2(childOut[1], 1);
close(childOut[1]);
}
close(childOut[0]);
}
else if (out_ != 1)
{
logTest("Process::start", "Child replacing output %d", out_);
dup2(out_, 1);
if (out_ != err_)
{
close(out_);
}
}
else
{
logTest("Process::start", "Child inherited output");
}
out_ = 1;
//
// Handle the standard error.
//
if (err_ == -1)
{
logTest("Process::start", "Child replacing pipe "
"%d and %d for error", childErr[0], childErr[1]);
if (childErr[1] != 2)
{
dup2(childErr[1], 2);
close(childErr[1]);
}
close(childErr[0]);
}
else if (err_ != 2)
{
logTest("Process::start", "Child replacing error %d", err_);
dup2(err_, 2);
close(err_);
}
else
{
logTest("Process::start", "Child inherited error");
}
err_ = 2;
//
// Let the pid be our own pid.
//
pid_ = getpid();
logTest("Process::start", "Child has descriptors "
"%d, %d, %d and pid %d", in_, out_, err_, pid_);
//
// Set the new environment for the process.
//
for (int i = 0; i < environmentLimit_ &&
environment_[i] != NULL; i++)
{
putenv(environment_[i]);
}
//
// Either execute the requested command or
// yield control to the function.
//
if (parameters_[1] != NULL)
{
if (execvp(parameters_[0], parameters_ + 1) == -1)
{
logTest("Process::start", "Child failed to execute the command");
logError("Process::start::execvp", EGET());
}
exitStatus(-1);
}
else
{
int result = function_((void *) parameters_[0]);
exitStatus(result);
}
}
default:
{
//
// We are the parent process.
//
logTest("Process::start", "Parent started child with pid %d", pid_);
if (in_ == -1)
{
close(childIn[0]);
in_ = childIn[1];
}
if (out_ == -1)
{
close(childOut[1]);
out_ = childOut[0];
}
if (err_ == -1)
{
close(childErr[1]);
err_ = childErr[0];
}
logTest("Process::start", "Parent using descriptors %d, %d, %d",
in_, out_, err_);
return 1;
}
}
}
int ProSLIC_testInDCFeed(proslicChanType *pProslic, proslicTestInObjType *pTstin)
{
uInt8 enhanceRegSave;
proslicMonitorType monitor;
ramData lcroffhk_save;
ramData lcronhk_save;
/* Valid device check */
if(TSTIN_INVALID_PART_NUM)
{
return RC_UNSUPPORTED_FEATURE;
}
/* Check if enabled */
if(!pTstin->dcFeedTest.testEnable)
{
return RC_TEST_DISABLED;
}
/* Invalidate last test results */
pTstin->dcFeedTest.testDataValid = TSTIN_RESULTS_INVALID;
/* Verify line not in use */
if(ProSLIC_ReadReg(pProslic,34) & 0x02) /* LCR */
{
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("\nProSLIC : TestIn : DC Feed : Line in Use\n");
}
#endif
if(pTstin->dcFeedTest.abortIfLineInUse==ABORT_LIU_ENABLED)
{
return RC_LINE_IN_USE;
}
}
/* Disable Powersave */
enhanceRegSave = ProSLIC_ReadReg(pProslic,47);
ProSLIC_WriteReg(pProslic,47,0x20);
Delay(pProTimer,10);
/* Onhook measurement */
ProSLIC_LineMonitor(pProslic,&monitor);
pTstin->dcFeedTest.dcfeedVtipOnhook.value = monitor.vtip;
pTstin->dcFeedTest.dcfeedVringOnhook.value = monitor.vring;
pTstin->dcFeedTest.dcfeedVloopOnhook.value = monitor.vtr;
pTstin->dcFeedTest.dcfeedVbatOnhook.value = monitor.vbat;
pTstin->dcFeedTest.dcfeedItipOnhook.value = monitor.itip;
pTstin->dcFeedTest.dcfeedIringOnhook.value = monitor.iring;
pTstin->dcFeedTest.dcfeedIloopOnhook.value = monitor.itr;
pTstin->dcFeedTest.dcfeedIlongOnhook.value = monitor.ilong;
/* Modify LCR threshold (optional) before connecting test load */
if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
{
lcroffhk_save = ProSLIC_ReadRAM(pProslic,852);
lcronhk_save = ProSLIC_ReadRAM(pProslic,853);
ProSLIC_WriteRAM(pProslic,852,pTstin->dcFeedTest.altLcrOffThresh);
ProSLIC_WriteRAM(pProslic,853,pTstin->dcFeedTest.altLcrOnThresh);
}
/* Connect internal test load for 2nd dc feed i/v point */
setInternalTestLoad(pProslic,1);
Delay(pProTimer,50);
/* Offhook measurement */
ProSLIC_LineMonitor(pProslic,&monitor);
pTstin->dcFeedTest.dcfeedVtipOffhook.value = monitor.vtip;
pTstin->dcFeedTest.dcfeedVringOffhook.value = monitor.vring;
pTstin->dcFeedTest.dcfeedVloopOffhook.value = monitor.vtr;
pTstin->dcFeedTest.dcfeedVbatOffhook.value = monitor.vbat;
pTstin->dcFeedTest.dcfeedItipOffhook.value = monitor.itip;
pTstin->dcFeedTest.dcfeedIringOffhook.value = monitor.iring;
pTstin->dcFeedTest.dcfeedIloopOffhook.value = monitor.itr;
pTstin->dcFeedTest.dcfeedIlongOffhook.value = monitor.ilong;
pTstin->dcFeedTest.testResult = RC_TEST_PASSED; /* initialize */
/* Read LCR */
if(ProSLIC_ReadReg(pProslic,34) & 0x07) /* LCRRTP */
{
pTstin->dcFeedTest.lcrStatus = 1;
}
else
{
pTstin->dcFeedTest.lcrStatus = 0;
}
/* Only fail check if enabled */
if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
{
pTstin->dcFeedTest.testResult |= !pTstin->dcFeedTest.lcrStatus;
}
/* Disconnect Test Load */
setInternalTestLoad(pProslic,0);
/* Restore LCR thresholds */
if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
{
ProSLIC_WriteRAM(pProslic,852,lcroffhk_save);
ProSLIC_WriteRAM(pProslic,853,lcronhk_save);
}
/* Restore enhance reg */
ProSLIC_WriteReg(pProslic,47,enhanceRegSave);
/* Process Results */
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVtipOnhook),"DcFeed : Vtip Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVringOnhook),"DcFeed : Vring Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVloopOnhook),"DcFeed : Vloop Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVbatOnhook),"DcFeed : Vbat Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedItipOnhook),"DcFeed : Itip Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIringOnhook),"DcFeed : Iring Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIloopOnhook),"DcFeed : Iloop Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIlongOnhook),"DcFeed : Ilong Onhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVtipOffhook),"DcFeed : Vtip Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVringOffhook),"DcFeed : Vring Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVloopOffhook),"DcFeed : Vloop Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedVbatOffhook),"DcFeed : Vbat Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedItipOffhook),"DcFeed : Itip Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIringOffhook),"DcFeed : Iring Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIloopOffhook),"DcFeed : Iloop Offhook");
pTstin->dcFeedTest.testResult |= logTest(pProslic,&(pTstin->dcFeedTest.dcfeedIlongOffhook),"DcFeed : Ilong Offhook");
logStatus(pProslic,pTstin->dcFeedTest.lcrStatus,"DcFeed : LCR");
pTstin->dcFeedTest.testDataValid = 1; /* New valid results */
/* return cumulative pass/fail result */
return (pTstin->dcFeedTest.testResult);
}
int connectionHandler()
{
requests = 0;
logTest("connectionHandler", "Going to create a new dispatcher");
dispatcher = new Dispatcher();
dispatcher -> start();
logTest("connectionHandler", "Going to create a new listener");
listener = new TcpListener();
listener -> setPort(6001);
listener -> setBacklog(32);
//
// Not needed for the early tests.
//
// listener -> setAccept("127.0.0.1");
//
listener -> start();
logTest("connectionHandler", "Going to add the listener to the set");
dispatcher -> addReadFd(listener -> getFd());
logTest("connectionHandler", "Going to enter the main loop");
T_timestamp start = getTimestamp();
T_timestamp now = getTimestamp();
int result;
int fd;
T_timestamp timeout;
while (diffTimestamp(start, now) < 1000000000)
{
logTest("connectionHandler", "Going to wait for new events");
timeout = nullTimestamp();
result = dispatcher -> waitEvent(timeout);
logTest("connectionHandler", "Dispatcher returned %d", result);
while ((fd = dispatcher -> nextReadEvent()) != -1)
{
if ((fd = listener -> accept()) != -1)
{
requests++;
logTest("connectionHandler", "Going to handle request %d",
requests);
processHandler(fd);
}
}
processCheck();
now = getTimestamp();
}
logTest("connectionHandler", "Exiting with %ld seconds elapsed since start",
diffTimestamp(start, now) / 1000);
dispatcher -> removeReadFd(listener -> getFd());
dispatcher -> end();
delete dispatcher;
logTest("connectionHandler", "Deleted the dispatcher");
listener -> end();
delete listener;
logTest("connectionHandler", "Deleted the listener");
processWait();
return requests;
}
int requestHandler(void *)
{
logTest("requestHandler", "Going to handle the new request");
for (int i = 0; i < DEFAULT_PROCESS_ENTRIES; i++)
{
if (processes[i] != NULL)
{
logTest("requestHandler", "Cleaning up process table");
delete processes[i];
processes[i] = NULL;
}
}
logTest("requestHandler", "Cleaning up listener and dispatcher");
delete listener;
listener = NULL;
delete dispatcher;
dispatcher = NULL;
char buffer[DEFAULT_BUFFER_LENGTH];
//
// Create the class for parsing and
// handling the HTTP request.
//
Request *request = new Request();
/*
FIXME
*/
request -> setRootPath("/home/pinzari/NX/apache_1.3.33/htdocs/manual");
/*
request -> setRootPath("/usr/share/doc/HTML");
*/
request -> setProgramPath("/home/pinzari/NX/nxproxy");
request -> setProgramName("nxproxy");
for (;;)
{
logTest("requestHandler", "Reading from descriptor %d",
fileno(stdin));
/*
FIXME: This is temporarily used to dump the content of
data sent by X clients at connection time.
*/
char data[1024];
int result;
while ((result = read(0, data, 1024)) > 0)
{
logDump("requestHandler", data, result);
}
logTest("requestHandler", "Exiting");
exit(0);
if (fgets(buffer, sizeof(buffer), stdin) != NULL)
{
//
// We are waiting for 1, when the request is
// complete, or -1, in the case of an error.
//
if (request -> parse(buffer, strlen(buffer)) != 0)
{
break;
}
}
}
if (request -> isError() != request_error_none)
{
logTest("requestHandler", "Aborting request with error '%s'",
request -> getErrorString());
}
else
{
logTest("requestHandler", "Executing request with URL '%s'",
request -> getUrl());
}
//
// Read from the file and write to the socket.
//
const char *name = request -> getFile();
if (name != NULL)
{
int in = open(name, O_RDONLY);
if (in != -1)
{
int out = fileno(stdout);
write(out, "HTTP/1.1 200 OK", strlen("HTTP/1.1 200 OK"));
write(out, "Content-type: ", strlen("Content-Type: "));
write(out, request -> getMimeString(),
strlen(request -> getMimeString()));
write(out, "\n\n", strlen("\n\n"));
int result;
while ((result = read(in, buffer, sizeof(buffer))) > 0)
{
write(fileno(stdout), buffer, result);
}
}
}
fclose(stdin);
fclose(stdout);
delete request;
logTest("requestHandler", "Exiting from the request handler");
return 1;
}
/* *********************************** */
int ProSLIC_testInRinging(proslicChanType *pProslic, proslicTestInObjType *pTstin)
{
uInt8 ringcon_save,enhance_save;
int32 vtr[MAX_RINGING_SAMPLES];
int i;
uInt8 lf;
uInt32 rtper_save, ringfr_save,ringamp_save,ringof_save,rtacth_save,rtdcth_save;
ProSLIC_DCfeed_Cfg dcfeedCfg;
/* Valid device check */
if(TSTIN_INVALID_PART_NUM)
{
return RC_UNSUPPORTED_FEATURE;
}
/* Check if enabled */
if(!pTstin->ringingTest.testEnable)
{
return RC_TEST_DISABLED;
}
/* Verify line not in use */
if(ProSLIC_ReadReg(pProslic,34) & 0x02) /* LCR */
{
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("\nProSLIC : TestIn : Ringing : Line in Use\n");
}
#endif
if(pTstin->ringingTest.abortIfLineInUse)
{
return RC_LINE_IN_USE;
}
}
/* Invalidate last test results */
pTstin->ringingTest.testDataValid = TSTIN_RESULTS_INVALID;
/* Check sample size/rate */
if(pTstin->ringingTest.numSamples > MAX_RINGING_SAMPLES)
pTstin->ringingTest.numSamples = MAX_RINGING_SAMPLES;
if(pTstin->ringingTest.sampleInterval > MAX_RINGING_SAMPLE_INTERVAL)
pTstin->ringingTest.sampleInterval = MAX_RINGING_SAMPLE_INTERVAL;
if(pTstin->ringingTest.sampleInterval < MIN_RINGING_SAMPLE_INTERVAL)
pTstin->ringingTest.sampleInterval = MIN_RINGING_SAMPLE_INTERVAL;
/* Disable Powersave */
enhance_save = ProSLIC_ReadReg(pProslic,47);
ProSLIC_WriteReg(pProslic,47,0x20);
Delay(pProTimer,10);
/* Disable ring cadencing */
ringcon_save = ProSLIC_ReadReg(pProslic,38); /* RINGCON */
ProSLIC_WriteReg(pProslic,38,ringcon_save&0xE7); /* RINGCON */
/* Must enter ringing through active state */
lf = ProSLIC_ReadReg(pProslic,30); /* LINEFEED */
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
Delay(pProTimer,20); /* settle */
/* Start ringing */
ProSLIC_SetLinefeedStatus(pProslic,LF_RINGING);
Delay(pProTimer,500);
/* Verify Ring Started */
if(ProSLIC_ReadReg(pProslic,30) != 0x44)
{
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
ProSLIC_WriteReg(pProslic,38,ringcon_save);
ProSLIC_WriteReg(pProslic,47,enhance_save);
ProSLIC_SetLinefeedStatus(pProslic,lf);
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("ProSLIC : TestIn : Ringing : Ring Start Fail\n");
}
#endif
pTstin->ringingTest.testResult = RC_TEST_FAILED;
return RC_RING_START_FAIL;
}
/* Capture samples */
pTstin->ringingTest.ringingVdc.value = 0;
for(i=0;i<pTstin->ringingTest.numSamples;i++)
{
vtr[i] = ProSLIC_ReadMADCScaled(pProslic,69,0); /* VDIFF_FILT */
pTstin->ringingTest.ringingVdc.value += vtr[i];
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("ProSLIC : TestIn : Ringing : Vtr[%d] = %d\n",i,vtr[i]);
}
#endif
Delay(pProTimer,pTstin->ringingTest.sampleInterval);
}
/* Restore linefeed */
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
Delay(pProTimer,20);
/* Process Results */
pTstin->ringingTest.ringingVdc.value /= pTstin->ringingTest.numSamples;
for(i=0;i<pTstin->ringingTest.numSamples;i++)
{
vtr[i] -= pTstin->ringingTest.ringingVdc.value;
pTstin->ringingTest.ringingVac.value += ((vtr[i]/100L) * (vtr[i]/100L));
}
pTstin->ringingTest.ringingVac.value /= pTstin->ringingTest.numSamples;
pTstin->ringingTest.ringingVac.value = Isqrt32(pTstin->ringingTest.ringingVac.value);
pTstin->ringingTest.ringingVac.value *= 100L;
pTstin->ringingTest.testResult = RC_TEST_PASSED;
pTstin->ringingTest.testResult |= logTest(pProslic,&(pTstin->ringingTest.ringingVdc),"Ringing : VDC");
pTstin->ringingTest.testResult |= logTest(pProslic,&(pTstin->ringingTest.ringingVac),"Ringing : VAC");
/*
** Optional Ringtrip Test
*/
if(pTstin->ringingTest.ringtripTestEnable == RTP_CHECK_ENABLED)
{
/* Setup low voltage linefeed so low level ringing may be used */
ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
storeDCFeedPreset(pProslic,&dcfeedCfg);
ProSLIC_DCFeedSetupCfg(pProslic,ringtripTestDCFeedPreset,0);
/* Optional Ringtrip Test (modified ringer settings to use test load to trip) */
rtper_save = ProSLIC_ReadRAM(pProslic,755);
ringfr_save = ProSLIC_ReadRAM(pProslic,844);
ringamp_save = ProSLIC_ReadRAM(pProslic,845);
ringof_save = ProSLIC_ReadRAM(pProslic,843);
rtacth_save = ProSLIC_ReadRAM(pProslic,848);
rtdcth_save = ProSLIC_ReadRAM(pProslic,847);
ProSLIC_WriteRAM(pProslic,755,0x50000L); /* RTPER */
ProSLIC_WriteRAM(pProslic,844,0x7EFE000L);/* RINGFR */
ProSLIC_WriteRAM(pProslic,845,0xD6307L); /* RINGAMP */
ProSLIC_WriteRAM(pProslic,843,0x0L); /* RINGOF */
ProSLIC_WriteRAM(pProslic,848,0x7827FL); /* RTACTH */
ProSLIC_WriteRAM(pProslic,847,0xFFFFFFFL);/* RTDCTH */
/* Start ringing from active state */
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
Delay(pProTimer,20);
ProSLIC_SetLinefeedStatus(pProslic,LF_RINGING);
Delay(pProTimer,200);
/* Verify Ring Started */
if(ProSLIC_ReadReg(pProslic,30) != 0x44)
{
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
ProSLIC_WriteReg(pProslic,38,ringcon_save);
ProSLIC_WriteReg(pProslic,47,enhance_save);
ProSLIC_SetLinefeedStatus(pProslic,lf);
#ifdef ENABLE_DEBUG
if(pProslic->debugMode)
{
LOGPRINT("ProSLIC : TestIn : Ringtrip : Ring Start Fail\n");
}
#endif
pTstin->ringingTest.testResult=RC_TEST_FAILED;
return RC_RING_START_FAIL;
}
/* Connect Test Load to cause ringtrip */
setInternalTestLoad(pProslic,1);
Delay(pProTimer,200);
/* Check for RTP */
if(ProSLIC_ReadReg(pProslic,34) & 0x01) /* LCRRTP */
{
pTstin->ringingTest.rtpStatus = 1;
pTstin->ringingTest.testResult |= RC_TEST_PASSED;
}
else
{
pTstin->ringingTest.rtpStatus = 0;
pTstin->ringingTest.testResult |= RC_TEST_FAILED;
ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
}
setInternalTestLoad(pProslic,0);
Delay(pProTimer,20);
logStatus(pProslic,pTstin->ringingTest.rtpStatus,"Ringing : RTP");
/* Restore DC Feed */
ProSLIC_DCFeedSetupCfg(pProslic,&dcfeedCfg,0);
/* Restore Ring Settings */
ProSLIC_WriteRAM(pProslic,755,rtper_save);/* RTPER */
ProSLIC_WriteRAM(pProslic,844,ringfr_save);/*RINGFR */
ProSLIC_WriteRAM(pProslic,845,ringamp_save); /* RINGAMP */
ProSLIC_WriteRAM(pProslic,843,ringof_save); /* RINGOF */
ProSLIC_WriteRAM(pProslic,848,rtacth_save);/* RTACTH */
ProSLIC_WriteRAM(pProslic,847,rtdcth_save);/* RTDCTH */
}/* end of ringtrip test
/* Restore Linefeed */
ProSLIC_SetLinefeedStatus(pProslic,lf);
/* Restore RINGCON and ENHANCE */
ProSLIC_WriteReg(pProslic,38,ringcon_save);
ProSLIC_WriteReg(pProslic,47,enhance_save);
pTstin->ringingTest.testDataValid = TSTIN_RESULTS_VALID;
return (pTstin->ringingTest.testResult);
}
int Process::end()
{
logTrace("Process::end");
if (pid_ == -1)
{
return 0;
}
if (in_ != 0)
{
if (inStream_ != NULL)
{
logTest("Process::end", "Closing the input stream");
fclose(inStream_);
inStream_ = NULL;
in_ = -1;
}
else if (in_ != -1)
{
logTest("Process::end", "Closing the input descriptor");
close(in_);
in_ = -1;
}
}
else
{
logTest("Process::end", "Input is the standard descriptor");
}
if (out_ != 1)
{
if (outStream_ != NULL)
{
logTest("Process::end", "Closing the output stream");
fclose(outStream_);
outStream_ = NULL;
out_ = -1;
}
else if (out_ != -1)
{
logTest("Process::end", "Closing the output descriptor");
close(out_);
out_ = -1;
}
}
else
{
logTest("Process::end", "Output is the standard descriptor");
}
if (err_ != 2)
{
if (errStream_ != NULL)
{
logTest("Process::end", "Closing the error stream");
fclose(errStream_);
errStream_ = NULL;
err_ = -1;
}
else if (err_ != -1)
{
logTest("Process::end", "Closing the error descriptor");
close(err_);
err_ = -1;
}
}
else
{
logTest("Process::end", "Error is the standard descriptor");
}
return 1;
}
