/* REParseAbbrev - parse and expand an abbreviation
*
* Note that since the abbreviations are in Z syntax, we must change syntax
* temporarily to Z. We are careful to do this so that we do not mess up
* advancign the pointers.
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseAbbrev (PACT pAction, register char *p)
{
int i;
flagType fZSTmp;
DEBOUT (("REParseAbbrev (%04x, %s)\n", pAction, p));
p += RECharLen (p);
fZSTmp = fZSyntax;
fZSyntax = TRUE;
if (p[-1] == '\0') {
DEBOUT (("REParseAbbrev expecting abbrev char, ERROR\n"));
fZSyntax = fZSTmp;
return NULL;
}
for (i = 0; pAbbrev[i]; i++)
if (p[-1] == *pAbbrev[i])
if (REParseSE (pAction, pAbbrev[i] + 1) == NULL) {
fZSyntax = fZSTmp;
return NULL;
}
else {
fZSyntax = fZSTmp;
return p;
}
DEBOUT (("REParseAbbrev found invalid abbrev char %s, ERROR\n", p - 1));
fZSyntax = fZSTmp;
return NULL;
}
STATIC int
complete_pars(negotiation_state_t *state, pdu_t *pdu)
{
int len;
uint8_t *bp;
#ifdef ISCSI_TEST_MODE
test_pars_t *tp = pdu->connection->test_pars;
neg_desc_t *nd = NULL;
#endif
len = total_size(state->pars, state->num_pars);
#ifdef ISCSI_TEST_MODE
if (tp != NULL) {
while ((nd = TAILQ_FIRST(&pdu->connection->test_pars->negs)) != NULL &&
nd->entry.state < state->auth_state) {
TAILQ_REMOVE(&tp->negs, nd, link);
free(nd, M_TEMP);
}
if (nd != NULL && nd->entry.state == state->auth_state) {
if (nd->entry.flags & ISCSITEST_NEGOPT_REPLACE)
len = 0;
len += nd->entry.size;
} else
nd = NULL;
}
#endif
DEB(10, ("complete_pars: n=%d, len=%d\n", state->num_pars, len));
if ((bp = malloc(len, M_TEMP, M_WAITOK)) == NULL) {
DEBOUT(("*** Out of memory in complete_pars\n"));
return ISCSI_STATUS_NO_RESOURCES;
}
pdu->temp_data = bp;
#ifdef ISCSI_TEST_MODE
if (nd == NULL || !(nd->entry.flags & ISCSITEST_NEGOPT_REPLACE))
if ((bp = put_par_block(pdu->temp_data, len,
state->pars, state->num_pars)) == NULL) {
DEBOUT(("Bad parameter in complete_pars\n"));
return ISCSI_STATUS_PARAMETER_INVALID;
}
if (nd != NULL) {
memcpy(bp, nd->entry.value, nd->entry.size);
TAILQ_REMOVE(&tp->negs, nd, link);
free(nd, M_TEMP);
}
#else
if (put_par_block(pdu->temp_data, len, state->pars,
state->num_pars) == 0) {
DEBOUT(("Bad parameter in complete_pars\n"));
return ISCSI_STATUS_PARAMETER_INVALID;
}
#endif
pdu->temp_data_len = len;
return 0;
}
void
iscsi_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
void *arg)
{
struct scsipi_adapter *adapt = chan->chan_adapter;
struct scsipi_xfer *xs;
session_t *session;
int flags;
struct scsipi_xfer_mode *xm;
session = (session_t *) adapt; /* adapter is first field in session */
switch (req) {
case ADAPTER_REQ_RUN_XFER:
DEB(9, ("ISCSI: scsipi_request RUN_XFER\n"));
xs = arg;
flags = xs->xs_control;
if ((flags & XS_CTL_POLL) != 0) {
xs->error = XS_DRIVER_STUFFUP;
DEBOUT(("Run Xfer request with polling\n"));
scsipi_done(xs);
return;
}
/*
* NOTE: It appears that XS_CTL_DATA_UIO is not actually used anywhere.
* Since it really would complicate matters to handle offsets
* into scatter-gather lists, and a number of other drivers don't
* handle uio-based data as well, XS_CTL_DATA_UIO isn't
* implemented in this driver (at least for now).
*/
if (flags & XS_CTL_DATA_UIO) {
xs->error = XS_DRIVER_STUFFUP;
DEBOUT(("Run Xfer with data in UIO\n"));
scsipi_done(xs);
return;
}
send_run_xfer(session, xs);
DEB(9, ("scsipi_req returns\n"));
return;
case ADAPTER_REQ_GROW_RESOURCES:
DEBOUT(("ISCSI: scsipi_request GROW_RESOURCES\n"));
return;
case ADAPTER_REQ_SET_XFER_MODE:
DEB(5, ("ISCSI: scsipi_request SET_XFER_MODE\n"));
xm = (struct scsipi_xfer_mode *)arg;
xm->xm_mode = PERIPH_CAP_TQING;
scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
return;
default:
break;
}
DEBOUT(("ISCSI: scsipi_request with invalid REQ code %d\n", req));
}
GpType::GpType(const GpType& rhs)
{
DEBOUT("GpType::GpType");
mType = rhs.Type();
DEBOUT(mType);
mStatic = rhs.Static();
mConst = rhs.Const();
mDirec = rhs.Direc();
}
const GpType& GpType::operator=(const GpType& rhs)
{
DEBOUT("GpType::operator=");
mType = rhs.Type();
DEBOUT(mType);
mStatic = rhs.Static();
mConst = rhs.Const();
mDirec = rhs.Direc();
return *this;
}
/* REParseRE - parse a general RE up to but not including the pEnd set
* of chars. Apply a particular action to each node in the parse tree.
*
* pAction Parse action routine to call at particluar points in the
* parse tree. This routine returns an unsigned quantity that
* is expected to be passed on to other action calls within the
* same node.
* p character pointer to string being parsed
* pEnd pointer to set of char types that end the current RE.
* External callers will typically use NULL for this value.
* Internally, however, we need to break on the ALT-terminating
* types or on arg-terminating types.
*
* Returns: pointer to delimited character if successful parse
* NULL if unsuccessful parse (syntax error).
*
*/
char * INTERNAL REParseRE (PACT pAction, register char *p, int *pEnd)
{
int *pe;
UINT_PTR u;
DEBOUT (("REParseRE (%04x, %s)\n", pAction, p));
while (TRUE) {
/* If we're at end of input
*/
if (*p == '\0')
/* If we're not in the midst of an open expression
*/
if (pEnd == NULL)
/* return the current parse position
*/
return p;
else {
/* End of input, but expecting more, ERROR
*/
DEBOUT (("REParse expecting more, ERROR\n"));
return NULL;
}
/* If there is an open expression
*/
if (pEnd != NULL)
/* Find a matching character
*/
for (pe = pEnd; *pe != -1; pe++)
if (RECharType (p) == *pe)
return p;
/* If we are looking at a left argument
*/
if (RECharType (p) == SR_LEFTARG) {
/* Parse LEFTARG .re. RIGHTARG
*/
u = (*pAction) (LEFTARG, 0, 0, 0);
if ((p = REParseRE (pAction, p + RECharLen (p), EndArg)) == NULL)
return NULL;
(*pAction) (RIGHTARG, u, 0, 0);
cArg++;
p += RECharLen (p);
}
else
/* Parse .e.
*/
if ((p = REParseE (pAction, p)) == NULL)
return NULL;
}
}
/* REParsePrev - parse a previous-match item
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParsePrev (PACT pAction, char *p)
{
UINT_PTR i = *(p + 1) - '0';
DEBOUT (("REParsePrev (%04x, %s)\n", pAction, p));
if (i < 1 || i > (unsigned) cArg) {
DEBOUT (("REParsePrev invalid previous number, ERROR\n"));
return NULL;
}
(*pAction) (PREV, i, 0, 0);
return p + RECharLen (p);
}
STATIC uint8_t *
get_bignumval(uint8_t *buf, negotiation_parameter_t *par)
{
int val;
char c;
uint8_t *dp = buf;
par->val.sval = buf;
if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
buf += 2;
while ((c = *buf) != 0x0) {
buf++;
val = (hexdig(c) << 4) | hexdig(*buf);
if (val < 0) {
return NULL;
}
*dp++ = (uint8_t) val;
if (*buf) {
buf++;
}
}
buf++;
par->list_num = dp - par->val.sval;
} else if (buf[0] == '0' && (buf[1] == 'b' || buf[1] == 'B')) {
buf = base64_decode(&buf[2], par->val.sval, &par->list_num);
} else {
DEBOUT(("Ill-formatted large number <%s>\n", buf));
return NULL;
}
return buf;
}
int
assemble_send_targets(pdu_t *pdu, uint8_t *val)
{
negotiation_parameter_t par;
uint8_t *buf;
int len;
par.key = K_SendTargets;
par.list_num = 1;
par.val.sval = val;
len = parameter_size(&par);
if ((buf = malloc(len, M_TEMP, M_WAITOK)) == NULL) {
DEBOUT(("*** Out of memory in assemble_send_targets\n"));
return ISCSI_STATUS_NO_RESOURCES;
}
pdu->temp_data = buf;
pdu->temp_data_len = len;
if (put_parameter(buf, len, &par) == 0)
return ISCSI_STATUS_PARAMETER_INVALID;
return 0;
}
void GpType::WriteAsXml(ofstream& ofstr)
{
DEBOUT("GpType::WriteAsXml");
// if(Type().length() != 0)
// {
// DEBOUT("mType.length() != 0");
ofstr << "<type";
if (mConst)
{
ofstr << " const=\"true\"";
}
if (mStatic)
{
ofstr << " static=\"true\"";
}
switch (mDirec)
{
case POINTER:
ofstr << " direc=\"ptr\"";
break;
case REFERENCE:
ofstr << " direc=\"ref\"";
break;
default:
break;
}
ofstr << ">" << mType << "</type>\n";
// }
}
void HIMoCapOfflineTimer::Notify(){
try{
vector<RotationInt> values = _fileMCD->getFrame(_slider->GetValue());
if(this->IsOneShot()){
_slider->SetValue(_slider->GetValue());
}
else{
_slider->SetValue((_slider->GetValue()+1)%_slider->GetMax());
}
_status->SetStatusText(wxString::Format(_T("Frame\t%d/%d"), _slider->GetValue(),_slider->GetMax()-1),1);
bool changeState = false;
int dir = SensorsAttributes::VIRTUALJOINTS;
vector<int> jointsIDs, sensorsIDs, sensorsRot;
vector<int> valuesURad;
vector<double> valuesDegree;
vector<AxesRotations> jointsDirs;
// DEBOUT(("frame size = %d\n",values.size()));
for(unsigned int i=0; i<values.size();++i){
try{
sensorsIDs.push_back(values[i].id);
sensorsRot.push_back(values[i].rot);
//ricavo gli id del joint dagli id dei sensori
jointsIDs.push_back(_sensSys->getAssociatedIDJoint(values[i].id));
//ricavo le direzioni corrispondenti al joint
jointsDirs.push_back( _sensSys->getJointAxes(jointsIDs[i],dir));
valuesDegree.push_back(VALUETODEGREE(values[i].rot));
valuesURad.push_back(static_cast<int>(VALUETOURADIANTS(values[i].rot)));
// corrispondenza tra jointsIDs[i] e values[i].id
//muovo i joints nel frame
changeState =(_frame3d->getObject3D()->rotatePartAngle(jointsIDs[i],
valuesDegree[i],
jointsDirs[i])||changeState);
// DEBOUT(("joint %d: %.2f x (%d,%d,%d)\n",jointsIDs[i],valuesDegree[i],jointsDirs[i].X,jointsDirs[i].Y,jointsDirs[i].Z));
}//end try
catch(runtime_error e) {
// DEBOUT(("%s\n",e.what()));
}
} //end for(unsigned int i=0; i<value.size();++i)
//aggiorno il frame
_frame3d->changeState(changeState);
// if(_frame3d->IsShown() && _frame3d->isStateChanged()){
// _frame3d->Render();
// }
_gridPanel->setColText(HIGridPanel::ID_COLUMN,sensorsIDs);
_gridPanel->setColText(HIGridPanel::JOINTID_COLUMN,jointsIDs);
_gridPanel->setColText(HIGridPanel::CLEANEDVALUE_COLUMN,sensorsRot);
_gridPanel->setColText(HIGridPanel::DEGREEVALUE_COLUMN,valuesDegree);
_gridPanel->setColText(HIGridPanel::URADIANTSVALUE_COLUMN,valuesURad);
}//end try
catch(runtime_error e) {
DEBOUT(("Exception %s\n",e.what()));
}
}//end Notify()
/* REParseSE - parse a simple regular expression
*
* pAction Action to apply at special parse nodes
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseSE (register PACT pAction, register char *p)
{
DEBOUT (("REParseSE (%04x, %s)\n", pAction, p));
switch (RECharType (p)) {
case SR_CCLBEG:
return REParseClass (pAction, p);
case SR_ANY:
return REParseAny (pAction, p);
case SR_BOL:
return REParseBOL (pAction, p);
case SR_EOL:
return REParseEOL (pAction, p);
case SR_PREV:
return REParsePrev (pAction, p);
case SR_LEFTOR:
return REParseAlt (pAction, p);
case SR_NOTSIGN:
return REParseNot (pAction, p);
case SR_ABBREV:
return REParseAbbrev (pAction, p);
default:
return REParseChar (pAction, p);
}
}
/* REParseNot - parse a guard-against match
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseNot (PACT pAction, register char *p)
{
UINT_PTR u;
DEBOUT (("REParseNot (%04x, %s)\n", pAction, p));
p += RECharLen (p);
if (*p == '\0') {
DEBOUT (("REParseNot expecting more, ERROR\n"));
return NULL;
}
u = (*pAction) (NOTSIGN, 0, 0, 0);
p = REParseSE (pAction, p);
(*pAction) (NOTSIGN1, u, 0, 0);
return p;
}
/* REParseEOL - parse an end-of-line match
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseEOL (PACT pAction, char *p)
{
DEBOUT (("REParseEOL (%04x, %s)\n", pAction, p));
(*pAction) (EOL, 0, 0, 0);
return p + RECharLen (p);
}
/* REParseE - parse a simple regular expression with potential closures.
*
* pAction Action to apply at special parse nodes
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseE (PACT pAction, register char *p)
{
DEBOUT (("REParseE (%04x, %s)\n", pAction, p));
switch (REClosureChar (p)) {
case CC_SMPLUS:
if (REParseSE (pAction, p) == NULL)
return NULL;
case CC_SMCLOSURE:
return REParseClosure (pAction, p);
case CC_PLUS:
if (REParseSE (pAction, p) == NULL)
return NULL;
case CC_CLOSURE:
return REParseGreedy (pAction, p);
case CC_POWER:
return REParsePower (pAction, p);
case CC_EMPTY:
return REParseSE (pAction, p);
default:
return NULL;
}
}
/* REParseChar - parse a single character match
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseChar (PACT pAction, register char *p)
{
DEBOUT (("REParseChar (%04x, %s)\n", pAction, p));
if (*p == '\\')
p++;
if (*p == '\0') {
DEBOUT (("REParseChar expected more, ERROR\n"));
return NULL;
}
if ( IsDBCSLeadByte ((BYTE)*p) ) {
(*pAction) (LETTER, 0, *p, *(p+1));
return p+2;
}
else {
(*pAction) (LETTER, 0, *p, 0);
return p+1;
}
}
/* REParseGreedy - parse a maximal-match closure. The match occurs by
* matching the maximal number and then backing off as failures occur.
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseGreedy (PACT pAction, register char *p)
{
UINT_PTR u;
DEBOUT (("REParseGreedy (%04x, %s)\n", pAction, p));
u = (*pAction) (STAR, 0, 0, 0);
if ((p = REParseSE (pAction, p)) == NULL)
return NULL;
(*pAction) (STAR1, u, 0, 0);
return p + REClosureLen (p);
}
/* REParsePower - parse a power-closure. This is merely the simple pattern
* repeated the number of times specified by the exponent.
*
* pAction Action to apply
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParsePower (PACT pAction, char *p)
{
register char *p1;
int exp;
DEBOUT (("REParsePower (%04x, %s)\n", pAction, p));
/* We have .se. POWER something. Skip over the .se. and POWER
* to make sure that what follows is a valid number
*/
p1 = REParseSE (NullAction, p);
if (p1 == '\0')
/* Parse of .se. failed
*/
return NULL;
/* skip POWER
*/
p1 += REClosureLen (p1);
if (*p1 == '\0') {
DEBOUT (("REParsePower expecting more, ERROR\n"));
return NULL;
}
/* try to parse off number */
if (sscanf (p1, "%d", &exp) != 1) {
DEBOUT (("REParsePower expecting number, ERROR\n"));
return NULL;
}
p1 = strbskip (p1, digits);
/* iterate the pattern the exponent number of times */
while (exp--)
if (REParseSE (pAction, p) == NULL)
return NULL;
return p1;
}
void Actuators::setActuatorValue(vector<RotationInt>& values) throw (ExceptionIdOutOfRange,ExceptionConnectionInvalid,ExceptionChannelNotPresent){
for(unsigned int i=0; i<_activeChannels.size(); ++i){
switch(_activeChannels[i]){
case(ActuatorType::VIRTUALSTICKJOINTS):
{
bool changeState = false;
for(unsigned int id = 0; id<values.size();++id){
changeState = (_virtualChannels[_activeChannels[i]]->getObject3D()->rotatePartAngle(values[id].id,
VALUETODEGREE(values[id].rot),
_axes[_activeChannels[i]][id])|| changeState);
// DEBOUT(("jointid=%d value=%d (%d,%d,%d)*(%.2f,%.2f,%.2f)\n",values[id].id,values[id].rot,
// (_axes[_activeChannels[i]][id].X),
// (_axes[_activeChannels[i]][id].Y),
// (_axes[_activeChannels[i]][id].Z),
// VALUETODEGREE(_axes[_activeChannels[i]][id].X*values[id].rot),
// VALUETODEGREE(_axes[_activeChannels[i]][id].Y*values[id].rot),
// VALUETODEGREE(_axes[_activeChannels[i]][id].Z*values[id].rot)
// ));
}
_virtualChannels[_activeChannels[i]]->changeState(changeState);
// DEBOUT(("Stato %d\n",changeState));
}
break;
case(ActuatorType::NAISJOINTS):
{
string stringToSend;
// DEBOUT(("Prova1\n"));
setActuatorValueCommInterface(values, stringToSend);
if(_physicalChannels.find(_activeChannels[i])==_physicalChannels.end()){
DEBOUT(("Not Valid\n"));
}
else {
// // DEBOUT(("Send %s\n\n",stringToSend.c_str()));
(_physicalChannels[_activeChannels[i]])->sendData(stringToSend);
}
// DEBOUT(("Prova6\n"));
// DEBOUT(("Send %s\n\n",stringToSend.c_str()));
}
break;
default:
break;
}
}
}
Font* Font_Factory::create_font(Font_Type type)
{
std::string m_res_factory(Resource_Factory::instance()->get_resource_path());
Font* font = new Font();
switch(type)
{
case GAME_FONT:
m_res_factory += "/gfx/game_font.bmp";
break;
case TIME_FONT:
m_res_factory += "/gfx/time_font.bmp";
break;
case CREDITS_FONT:
m_res_factory += "/gfx/credits_font.bmp";
break;
case MENU_FONT:
m_res_factory += "/gfx/menu_font.bmp";
break;
default:
assert(!"Error: Selected non-existing font type.");
}
DEBOUT("Loading font: "<<m_res_factory<<"...\n");
SDL_Surface* temp = SDL_LoadBMP(m_res_factory.c_str());
SDL_Surface* temp2 = SDL_DisplayFormat(temp);
if(temp2!=NULL)
{
font->init(SFont_InitFont (temp2));
}
else
{
DEBOUT("Error: "<<m_res_factory<<" is not a valid font: "<<SDL_GetError()<<"\n");
}
SDL_FreeSurface(temp);
return font;
}
/*
* iscsi_detach:
* Cleanup.
*/
static int
iscsi_detach(device_t self, int flags)
{
DEBOUT(("ISCSI: detach\n"));
kill_all_sessions();
iscsi_detaching = TRUE;
while (iscsi_cleanproc != NULL) {
wakeup(&iscsi_cleanupc_list);
tsleep(&iscsi_cleanupc_list, PWAIT, "detach_wait", 20 * hz);
}
return 0;
}
/*
* iscsi_attach:
* One-time inits go here. Not much for now, probably even less later.
*/
static void
iscsi_attach(device_t parent, device_t self, void *aux)
{
DEBOUT(("ISCSI: iscsi_attach, parent=%p, self=%p, aux=%p\n", parent,
self, aux));
sc = (iscsi_softc_t *) device_private(self);
sc->sc_dev = self;
if (kthread_create(PRI_NONE, 0, NULL, iscsi_cleanup_thread,
NULL, &iscsi_cleanproc, "Cleanup") != 0) {
panic("Can't create cleanup thread!");
}
aprint_normal("%s: attached. major = %d\n", iscsi_cd.cd_name,
cdevsw_lookup_major(&iscsi_cdevsw));
}
/* REParseAlt - parse a series of alternatives
*
* pAction Action to apply before and after each alternative
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseAlt (PACT pAction, register char *p)
{
UINT_PTR u = 0;
DEBOUT (("REParseAlt (%04x, %s)\n", pAction, p));
while (RECharType (p) != SR_RIGHTOR) {
p += RECharLen (p);
u = (*pAction) (LEFTOR, u, 0, 0);
if ((p = REParseRE (pAction, p, EndAltRE)) == NULL)
return NULL;
u = (*pAction) (ORSIGN, u, 0, 0);
}
(*pAction) (RIGHTOR, u, 0, 0);
return p + RECharLen (p);
}
STATIC negotiation_parameter_t *
set_key_n(negotiation_state_t *state, text_key_t key, uint32_t val)
{
negotiation_parameter_t *par;
if (state->num_pars >= MAX_NEG) {
DEBOUT(("set_key_n: num_pars (%d) >= MAX_NEG (%d)\n",
state->num_pars, MAX_NEG));
return NULL;
}
par = &state->pars[state->num_pars];
par->key = key;
par->list_num = 1;
par->val.nval[0] = val;
state->num_pars++;
state->kflags[key] |= NS_SENT;
return par;
}
int
init_text_parameters(connection_t *conn, ccb_t *ccb)
{
negotiation_state_t *state;
state = malloc(sizeof(*state), M_TEMP, M_WAITOK | M_ZERO);
if (state == NULL) {
DEBOUT(("*** Out of memory in init_text_params\n"));
return ISCSI_STATUS_NO_RESOURCES;
}
ccb->temp_data = state;
state->HeaderDigest = conn->HeaderDigest;
state->DataDigest = conn->DataDigest;
state->MaxRecvDataSegmentLength = conn->MaxRecvDataSegmentLength;
init_session_parameters(conn->session, state);
return 0;
}
int
map_session(session_t *session)
{
struct scsipi_adapter *adapt = &session->sc_adapter;
struct scsipi_channel *chan = &session->sc_channel;
const quirktab_t *tgt;
if (sc == NULL) {
/* we haven't gone through the config process */
/* (shouldn't happen) */
DEBOUT(("Map: No device pointer!\n"));
return 0;
}
/*
* Fill in the scsipi_adapter.
*/
adapt->adapt_dev = sc->sc_dev;
adapt->adapt_nchannels = 1;
adapt->adapt_request = iscsi_scsipi_request;
adapt->adapt_minphys = iscsi_minphys;
adapt->adapt_openings = CCBS_PER_SESSION;
adapt->adapt_max_periph = CCBS_PER_SESSION;
/*
* Fill in the scsipi_channel.
*/
if ((tgt = getquirks(chan->chan_name)) == NULL) {
tgt = getquirks("unknown");
}
chan->chan_name = tgt->tgt;
chan->chan_defquirks = tgt->quirks;
chan->chan_adapter = adapt;
chan->chan_bustype = &scsi_bustype;
chan->chan_channel = 0;
chan->chan_flags = SCSIPI_CHAN_NOSETTLE;
chan->chan_ntargets = 1;
chan->chan_nluns = 16; /* ToDo: ??? */
chan->chan_id = session->id;
session->child_dev = config_found(sc->sc_dev, chan, scsiprint);
return session->child_dev != NULL;
}
/* RECompile - compile a pattern into the internal machine. Return a
* pointer to the match machine.
*
* p character pointer to pattern being compiled
*
* Returns: pointer to the internal machine if compilation was successful
* NULL if syntax error or not enough memory for malloc
*/
struct patType *RECompile (char *p, flagType fCase, flagType fZS)
{
if (!RE__hasBeenInitialized) { RE__ModuleInitialize(); }
fZSyntax = fZS;
REEstimate (p);
DEBOUT (("Length is %04x\n", RESize));
if (RESize == -1)
return NULL;
if ((REPat = (struct patType *) REmalloc (RESize)) == NULL)
return NULL;
Fill ((char far *) REPat, -1, RESize);
Fill ((char far *) REPat->pArgBeg, 0, sizeof (REPat->pArgBeg));
Fill ((char far *) REPat->pArgEnd, 0, sizeof (REPat->pArgEnd));
REip = REPat->code;
REArg = 1;
REPat->fCase = fCase;
REPat->fUnix = (flagType) !fZS;
cArg = 0;
CompileAction (PROLOG, 0, 0, 0);
if (REParseRE (CompileAction, p, NULL) == NULL)
return NULL;
CompileAction (EPILOG, 0, 0, 0);
#if DEBUG
REDump (REPat);
#endif
return REPat;
}
/* REParseClass - parse a class membership match
*
* pAction Action to apply at beginning of parse and at each range
* p character pointer to spot where parsing occurs
*
* Returns pointer past parsed text if successful
* NULL otherwise (syntax error)
*/
char * INTERNAL REParseClass (PACT pAction, register char *p)
{
char c;
char c2, c3, c4;
UINT_PTR u;
DEBOUT (("REParseClass (%04x, %s)\n", pAction, p));
p += RECharLen (p);
if ((fZSyntax && *p == '~') || (!fZSyntax && *p == '^')) {
u = (*pAction) (CCLNOT, 0, 0, 0);
p += RECharLen (p);
}
else
u = (*pAction) (CCLBEG, 0, 0, 0);
while (RECharType (p) != SR_CCLEND) {
if (*p == '\\')
p++;
if (*p == '\0') {
DEBOUT (("REParseClass expecting more, ERROR\n"));
return NULL;
}
c = *p++;
if (IsDBCSLeadByte((BYTE)c))
c2 = *p++;
else {
c2 = c;
c = 0;
}
if (*p == '-') {
p++;
if (*p == '\\')
p++;
if (*p == '\0') {
DEBOUT (("REParseClass expecting more, ERROR\n"));
return NULL;
}
c3 = *p;
if (IsDBCSLeadByte(*(unsigned char *)p))
c4 = *++p;
else {
c4 = c3;
c3 = 0;
}
if ( (c == 0 && c3 == 0) || (c != 0 && c3 != 0) ) {
u = (*pAction) (RANGEDBCS1, 0, c, c2);
(*pAction) (RANGEDBCS2, u, c3, c4);
}
else
return NULL;
p++;
}
else
#if defined(KANJI)
{
u = (*pAction) (RANGEJ1, 0, c, c2);
(*pAction) (RANGEJ2, u, c, c2);
}
#else
(*pAction) (RANGE, u, c, c);
#endif
}
c = 0;
u = (*pAction) (RANGEDBCS1, 0, c, c);
(*pAction) (RANGEDBCS2, u, c, c);
return p + RECharLen (p);
}
Filter::~Filter() {
DEBOUT(("Filter::~Filter()\n"));
}
int
/*ARGSUSED*/
main(int argc, char **argv)
{
int req_temp, rsp_temp, c;
ssize_t ret;
size_t len;
struct sockaddr_un from;
socklen_t fromlen;
iscsid_request_t *req;
iscsid_response_t *rsp;
struct timeval seltout = { 2, 0 }; /* 2 second poll interval */
char *p;
while ((c = getopt(argc, argv, "d:n")) != -1)
switch (c) {
case 'n':
nothreads++;
break;
case 'd':
debug_level=(int)strtol(optarg, &p, 10);
if (*p)
errx(EXIT_FAILURE, "illegal debug level -- %s",
optarg);
break;
default:
usage();
}
client_sock = init_daemon();
if (client_sock < 0)
exit(1);
printf("iSCSI Daemon loaded\n");
if (!debug_level)
daemon(0, 1);
if (nothreads)
setsockopt(client_sock, SOL_SOCKET, SO_RCVTIMEO, &seltout,
sizeof(seltout));
else {
ret = pthread_create(&event_thread, NULL, event_handler, NULL);
if (ret) {
printf("Thread creation failed (%zd)\n", ret);
close(client_sock);
unlink(ISCSID_SOCK_NAME);
deregister_event_handler();
pthread_mutex_destroy(&sesslist_lock);
return -1;
}
}
/* ---------------------------------------------------------------------- */
for (;;) {
/* First, get size of request */
req = (iscsid_request_t *)(void *)req_buf;
fromlen = sizeof(from);
len = sizeof(iscsid_request_t);
if (nothreads) {
do {
ret = recvfrom(client_sock, req, len, MSG_PEEK |
MSG_WAITALL, (struct sockaddr *)(void *)&from,
&fromlen);
if (ret == -1)
event_handler(NULL);
} while (ret == -1 && errno == EAGAIN);
} else {
do {
ret = recvfrom(client_sock, req, len, MSG_PEEK |
MSG_WAITALL, (struct sockaddr *) &from,
&fromlen);
if (ret == -1)
event_handler(NULL);
} while (ret == -1 && errno == EAGAIN);
}
if ((size_t)ret != len) {
perror("Receiving from socket");
break;
}
DEB(98, ("Request %d, parlen %d\n",
req->request, req->parameter_length));
len += req->parameter_length;
/* now that we know the size, get the buffer for it */
req_temp = (len > REQ_BUFFER_SIZE);
if (req_temp) {
req = malloc(len);
if (!req) {
printf("Can't alloc %zu bytes\n", len);
break;
}
}
/* read the complete request */
fromlen = sizeof(from);
ret = recvfrom(client_sock, req, len, MSG_WAITALL,
(struct sockaddr *)(void *)&from, &fromlen);
if ((size_t)ret != len) {
DEBOUT(("Error receiving from socket!\n"));
if (req_temp)
free(req);
continue;
}
/* terminate? then go die. */
if (req->request == ISCSID_DAEMON_TERMINATE)
break;
/* No reply required to test message */
if (req->request == ISCSID_DAEMON_TEST) {
if (req_temp)
free(req);
continue;
}
/* no return path? then we can't send a reply, */
/* so don't process the command */
if (!from.sun_path[0]) {
if (req_temp)
free(req);
DEBOUT(("No Return Address!\n"));
continue;
}
/* process the request */
process_message(req, &rsp, &rsp_temp);
if (rsp == NULL) {
if (req_temp)
free(req);
DEBOUT(("Invalid message!\n"));
continue;
}
DEB(98, ("Sending reply: status %d, len %d\n",
rsp->status, rsp->parameter_length));
/* send the response */
len = sizeof(iscsid_response_t) + rsp->parameter_length;
ret = sendto(client_sock, rsp, len, 0,
(struct sockaddr *)(void *)&from, fromlen);
if (len != (size_t)ret) {
DEBOUT(("Error sending reply!\n"));
}
/* free temp buffers if we needed them */
if (req_temp)
free(req);
if (rsp_temp)
free(rsp);
}
exit_daemon();
/* we never get here */
return 0;
}
