bool
wb_dbs::importDbody(pwr_tOid oid, size_t size, void *body)
{
pwr_tStatus sts;
sOentry *oep;
char b[dbs_dAlign(sizeof(dbs_sBody))];
m_nDbodyObjects++;
memset(b, 0, sizeof(b));
oep = (sOentry *)tree_Find(&sts, m_oid_th, &oid);
if (EVEN(sts)) {
}
if (oep->dbody.size == 0) {
if (size != 0) printf("error dbody size %zd %s\n", size, cdh_ObjidToString(0,oid,0));
return true;
}
oep->o.dbody.ref = dbs_dMakeRef(dbs_eSect_dbody, m_sect[dbs_eSect_dbody].size + dbs_dAlign(sizeof(dbs_sBody)));
m_sect[dbs_eSect_dbody].size += oep->dbody.size + sizeof(b);
memcpy(b, &oep->dbody, sizeof(oep->dbody));
if (fwrite(b, sizeof(b), 1, m_fp) < 1)
return false;
/* @todo!!! objdid_self */
if (fwrite(body, oep->dbody.size, 1, m_fp) < 1)
return false;
return true;
}
static void
create_thread (
plc_sThread *tp,
plc_sProctbl *ptp,
plc_sProcess *pp
)
{
pwr_tStatus sts;
long int phase;
tp->aref.Objid = ptp->thread;
tp->init = ptp->init;
tp->exec = ptp->exec;
tp->first_scan = 1;
tp->PlcThread = pwrb_PlcThread_Init(&sts, tp);
tp->csup_lh = csup_Init(&sts, ptp->thread, tp->f_scan_time);
tp->i_scan_time = tp->f_scan_time * 1000.0 + 0.5;
time_FloatToD(&tp->scan_time, tp->f_scan_time);
tp->pp = pp;
plc_inittimer(tp);
tp->exit = FALSE;
link_io_copy_areas(tp);
que_Create(&sts, &tp->q_in);
que_Create(&sts, &tp->q_out);
sts = gdh_ObjidToName(ptp->thread, tp->name, sizeof(tp->name), cdh_mNName);
if (EVEN(sts)) {
errh_Error("Get name of thread object %s, %m", cdh_ObjidToString(NULL, ptp->thread, 1), sts);
return;
}
sts = gdh_ObjidToPointer(ptp->thread, (void *)&tp->PlcThread);
if (EVEN(sts)) {
errh_Error("Direct link to thread object \"%s\", %m", tp->name, sts);
return;
}
#if defined OS_LYNX && USE_RT_TIMER
sem_init(&tp->ScanSem, 0, 0);
tp->ScanMultiple = tp->i_scan_time / (CLK_TCK/1000);
tp->IntervalCount = tp->ScanMultiple;
#endif
sts = thread_Create(&tp->tid, tp->name, (void *(*)())&plc_thread, tp);
if (EVEN(sts)) {
errh_Error("Creating thread \"%s\", %m", tp->name, sts);
return;
}
/* Wait for thread to initialize. */
phase = (long int)que_Get(&sts, &tp->q_out, NULL, NULL);
pwr_Assert(phase == 1);
}
static pwr_tStatus ConnectAttribute (
ldh_sMenuCall *ip
) {
pwr_tStatus sts;
pwr_sMenuButton mb;
pwr_sAttrRef PattrRef;
sts = ldh_ReadObjectBody(ip->PointedSession,
ip->ItemList[ip->ChosenItem].MenuObject,
"SysBody", &mb, sizeof(pwr_sMenuButton));
if (EVEN(sts)) return sts;
// Assume RtBody or SysBody
char *aname_p;
pwr_tAName aname;
int size;
sts = ldh_AttrRefToName( ip->PointedSession, &ip->Pointed, ldh_eName_ArefVol, &aname_p, &size);
if ( EVEN(sts)) return 0;
strncpy( aname, aname_p, sizeof(aname));
strncat( aname, ".", sizeof(aname));
strncat( aname, mb.MethodArguments[0], sizeof(aname));
sts = ldh_NameToAttrRef( ip->PointedSession, aname, &PattrRef);
if (ODD(sts))
sts = ldh_WriteAttribute(ip->PointedSession, &PattrRef, &ip->Selected[0],
sizeof(pwr_tAttrRef));
if ( ip->message_cb) {
char msg[200];
if ( ODD(sts)) {
pwr_tOName name;
sts = ldh_AttrRefToName( ip->PointedSession, &ip->Selected[0], ldh_eName_Hierarchy,
&aname_p, &size);
if ( ODD(sts))
strncpy( name, aname_p, sizeof(name));
else
cdh_ObjidToString( name, ip->Selected[0].Objid, 1);
snprintf( msg, sizeof(msg), "%s connected to: %s", mb.MethodArguments[0], name);
ip->wtt->message( 'I', msg);
}
else {
msg_GetMsg( sts, msg, sizeof(msg));
ip->wtt->message( 'E', msg);
}
}
return LDH__SUCCESS;
}
static void lockMountServers(gdb_sNode* np)
{
pwr_tStatus sts;
pool_sQlink* msl;
pool_sQlink* vl;
gdb_sVolume* vp;
gdb_sMountServer* msp;
gdb_sObject* op;
gdb_AssumeLocked;
for (vl = pool_Qsucc(NULL, gdbroot->pool, &np->own_lh); vl != &np->own_lh;
vl = pool_Qsucc(NULL, gdbroot->pool, vl)) {
vp = pool_Qitem(vl, gdb_sVolume, l.own_ll);
if (vl->self == vl->flink) {
/* Connection lost and volume removed from own list */
errh_Error("Volume not owned any more, %s", vp->g.name.orig);
return;
}
if (!vp->l.flags.b.isConnected) {
/* !!! Todo !!! How do we make this known ? */
errh_Error("Volume not connected, %s", vp->g.name.orig);
continue;
}
for (msl = pool_Qsucc(NULL, gdbroot->pool, &vp->l.volms_lh);
msl != &vp->l.volms_lh; msl = pool_Qsucc(NULL, gdbroot->pool, msl)) {
msp = pool_Qitem(msl, gdb_sMountServer, volms_ll);
op = hash_Search(&sts, gdbroot->oid_ht, &msp->oid);
if (op == NULL) {
op = cvolc_OidToObject(
&sts, vp, msp->oid, vol_mTrans_none, cvol_eHint_none);
if (op == NULL) {
errh_Error("Can't fetch the mount server's object, %s",
cdh_ObjidToString(msp->oid, 0));
/* !!! Todo !!! How do we make this error known ? */
continue;
}
}
msp->msor = pool_ItemReference(NULL, gdbroot->pool, op);
op->l.flags.b.isMountServer = 1;
if (msp->nodms_ll.self == msp->nodms_ll.flink
&& msp->nodms_ll.self == msp->nodms_ll.blink)
pool_QinsertPred(NULL, gdbroot->pool, &msp->nodms_ll, &np->nodms_lh);
/* if (0)
errh_Info("Locking object %s", op->g.f.name.orig); */
cvolc_LockObject(&sts, op);
}
}
}
static pwr_tStatus Connect (
ldh_sMenuCall *ip
) {
pwr_tStatus sts;
pwr_sMenuButton mb;
pwr_sAttrRef PattrRef;
pwr_sAttrRef aref = ip->Selected[0];
sts = ldh_ReadObjectBody(ip->PointedSession,
ip->ItemList[ip->ChosenItem].MenuObject,
"SysBody", &mb, sizeof(pwr_sMenuButton));
if (EVEN(sts)) return sts;
if ( strcmp( mb.MethodArguments[1], "") != 0) {
char arg_cid_str[20][32];
int arg_cid_cnt;
int i;
int cid_ok = 0;
pwr_tCid cid;
pwr_tCid arg_cid;
// arg 1 holds the allowed class or classes to connect to
arg_cid_cnt = dcli_parse( mb.MethodArguments[1], ",", "", (char *) arg_cid_str,
sizeof( arg_cid_str) / sizeof( arg_cid_str[0]),
sizeof( arg_cid_str[0]), 0);
sts = ldh_GetAttrRefTid( ip->PointedSession, &ip->Selected[0], &cid);
if ( EVEN(sts)) return 0;
for ( i = 0; i < arg_cid_cnt; i++) {
sts = ldh_ClassNameToId( ip->PointedSession, &arg_cid, arg_cid_str[i]);
if ( EVEN(sts)) return 0;
if ( cid == arg_cid) {
cid_ok = 1;
break;
}
}
if ( !cid_ok)
return 0;
}
if ( strcmp( mb.MethodArguments[2], "") != 0)
// Body in MethodArguments 2, probably DevBody
sts = ldh_SetObjectPar( ip->PointedSession, ip->Pointed.Objid, mb.MethodArguments[2],
mb.MethodArguments[0], (char *) &ip->Selected[0], sizeof(ip->Selected[0]));
else {
char *name_p;
pwr_tAName name;
int size;
pwr_tCid cid;
// If Selected is a Template object in a classvolume, replace with
// symbol $IoConnect
if ( cdh_IsClassVolume( aref.Objid.vid)) {
sts = ldh_ObjidToName( ip->PointedSession, aref.Objid, ldh_eName_Object,
name, sizeof(name), &size);
if ( ODD(sts) && strcmp( name, "Template") == 0) {
sts = ldh_GetObjectClass( ip->PointedSession, aref.Objid, &cid);
if ( EVEN(sts)) return sts;
aref.Objid.vid = ldh_cIoConnectVolume;
aref.Objid.oix = cid;
}
}
// Assume RtBody or SysBody
sts = ldh_AttrRefToName(ip->PointedSession, &ip->Pointed, ldh_eName_VolPath,
&name_p, &size);
if ( ODD(sts)) {
strcpy( name, name_p);
strcat( name, ".");
strcat( name, mb.MethodArguments[0]);
sts = ldh_NameToAttrRef( ip->PointedSession, name, &PattrRef);
if (ODD(sts))
sts = ldh_WriteAttribute(ip->PointedSession, &PattrRef, &aref,
sizeof(aref));
}
}
char msg[500];
if ( ODD(sts)) {
pwr_tAName name;
char *name_p;
int len;
sts = ldh_AttrRefToName( ip->PointedSession, &aref, ldh_eName_Hierarchy,
&name_p, &len);
if ( EVEN(sts))
cdh_ObjidToString( name, aref.Objid, 1);
else
strcpy( name, name_p);
sprintf( msg, "%s connected to: %s", mb.MethodArguments[0], name);
ip->wtt->message( 'I', msg);
}
else {
msg_GetMsg( sts, msg, sizeof(msg));
ip->wtt->message( 'E', msg);
}
return PWRS__SUCCESS;
}
static pwr_tStatus IoConnect (
ldh_sMenuCall *ip
) {
pwr_tStatus sts;
pwr_sMenuButton mb;
pwr_sAttrRef aref = ip->Selected[0];
pwr_sAttrRef PattrRef;
char *name_p;
pwr_tAName name;
int size;
sts = ldh_ReadObjectBody(ip->PointedSession,
ip->ItemList[ip->ChosenItem].MenuObject,
"SysBody", &mb, sizeof(pwr_sMenuButton));
if (EVEN(sts)) return sts;
if ( strcmp( mb.MethodArguments[0], "") != 0) {
char arg_cid_str[20][32];
int arg_cid_cnt;
int i;
int cid_ok = 0;
pwr_tCid cid;
pwr_tCid arg_cid;
// arg 0 holds the allowed class or classes to connect to
arg_cid_cnt = dcli_parse( mb.MethodArguments[0], ",", "", (char *) arg_cid_str,
sizeof( arg_cid_str) / sizeof( arg_cid_str[0]),
sizeof( arg_cid_str[0]), 0);
sts = ldh_GetAttrRefTid( ip->PointedSession, &ip->Selected[0], &cid);
if ( EVEN(sts)) return 0;
for ( i = 0; i < arg_cid_cnt; i++) {
sts = ldh_ClassNameToId( ip->PointedSession, &arg_cid, arg_cid_str[i]);
if ( EVEN(sts)) return 0;
if ( cid == arg_cid) {
cid_ok = 1;
break;
}
}
if ( !cid_ok)
return 0;
}
#if 0
printf( "Here in IoConnect\n");
wb_session *sp = (wb_session *)ip->PointedSession;
wb_object o = sp->object( ip->Pointed.Objid);
if ( !o) return o.sts();
wb_attribute oa = sp->attribute( &ip->Pointed);
if ( !oa) return oa.sts();
replaceClass( sp, oa, &ip->Selected[0]);
#endif
sts = ldh_AttrRefToName(ip->PointedSession, &ip->Pointed, ldh_eName_VolPath,
&name_p, &size);
if ( ODD(sts)) {
strcpy( name, name_p);
strcat( name, ".IoConnect");
sts = ldh_NameToAttrRef( ip->PointedSession, name, &PattrRef);
if (ODD(sts))
sts = ldh_WriteAttribute(ip->PointedSession, &PattrRef, &aref,
sizeof(aref));
}
char msg[500];
if ( ODD(sts)) {
pwr_tAName name;
char *name_p;
int len;
sts = ldh_AttrRefToName( ip->PointedSession, &aref, ldh_eName_Hierarchy,
&name_p, &len);
if ( EVEN(sts))
cdh_ObjidToString( name, aref.Objid, 1);
else
strcpy( name, name_p);
sprintf( msg, "Io connected to: %s", name);
ip->wtt->message( 'I', msg);
}
else {
msg_GetMsg( sts, msg, sizeof(msg));
ip->wtt->message( 'E', msg);
}
return PWRS__SUCCESS;
}
void
ivol_BuildNode (
pwr_tStatus *status,
ivol_sNode *lnp,
const co_mFormat *formatp
)
{
gdb_sVolume *vp;
pwr_sMountObject *MountObject;
cdh_uVolumeId sys_vid;
pwr_tObjid sys_oid;
pwr_tObjid oid;
gdb_sObject *op;
gdb_sObject *vop;
gdb_sObject *mop;
pool_sQlink *vl;
gdb_sClass *cp;
pool_sQlink *cl;
co_mFormat fm;
pwr_tTime time;
pwr_dStatus(sts, status, GDH__SUCCESS);
/* Fill in remaining node information. */
gdbroot->db->nod_oid = lnp->nod_oid;
gdbroot->my_node->nod_oid = gdbroot->db->nod_oid;
gdbroot->my_node->vol_oid = gdbroot->db->vol_oid;
/* Create the system volume and mount it in the root voulme. */
sys_vid.pwr = gdbroot->db->vid;
sys_vid.v.vid_3 = cdh_eVid3_local;
sys_oid.vid = sys_vid.pwr;
sys_oid.oix = pwr_cNObjectIx;
time_GetTime(&time);
vp = gdb_LoadVolume(sts, sys_vid.pwr, "", pwr_eClass_SystemVolume, gdbroot->db->nid,
time, gdb_mLoad_build, co_GetOwnFormat(&fm));
if (vp == NULL) errh_Bugcheck(*sts, "");
/* Create the volume object. */
vop = loadObject(sts, vp, vp->g.name.orig, sys_oid, pwr_eClass_SystemVolume,
sizeof(pwr_sSystemVolume), pwr_cNObjid, net_mGo__, pwr_cNObjid);
if (vop == NULL) errh_Bugcheck(*sts, "");
vop->u.n.flags.b.bodyDecoded = 1;
/* Create the 'pwrNode' object. */
oid = vol_Oid(sts, vp, pwr_eClass_NodeHier);
op = loadObject(sts, vp, "pwrNode", oid, pwr_eClass_NodeHier,
sizeof(pwr_sNodeHier), sys_oid, net_mGo__, pwr_cNObjid);
if (op == NULL) errh_Bugcheck(*sts, "");
op->u.n.flags.b.bodyDecoded = 1;
errh_Info("Created pwrNode, oid: %s", cdh_ObjidToString(NULL, oid, 1));
/* Create a mount object in the root volume, to mount the 'pwrNode' object. */
pwr_Assert(gdbroot->my_volume != NULL);
oid = vol_Oid(sts, gdbroot->my_volume, pwr_eClass_MountObject);
mop = loadObject(sts, gdbroot->my_volume, "pwrNode", oid, pwr_eClass_MountObject,
sizeof(pwr_sMountObject), gdbroot->db->vol_oid, net_mGo_isMountClient, op->g.oid);
if (mop == NULL) errh_Bugcheck(*sts, "");
mop->u.n.flags.b.bodyDecoded = 1;
MountObject = pool_Address(NULL, gdbroot->rtdb, mop->u.n.body);
strcpy(MountObject->Description, "Mounts the system volume object pwr_Node.");
MountObject->Object = op->g.oid;
/* Build all native volumes. */
for (
vl = pool_Qsucc(sts, gdbroot->pool, &gdbroot->db->vol_lh);
vl != &gdbroot->db->vol_lh;
vl = pool_Qsucc(sts, gdbroot->pool, vl)
) {
vp = pool_Qitem(vl, gdb_sVolume, l.vol_ll);
if (vp->l.flags.b.isNative) ivol_BuildVolume(sts, vp);
}
/* Link class definitions. */
for (
cl = pool_Qsucc(sts, gdbroot->pool, &gdbroot->db->class_lh);
cl != &gdbroot->db->class_lh;
) {
cp = pool_Qitem(cl, gdb_sClass, class_ll);
/* NOTA BENE !! mvol_LinkClass will change the linkage. */
cl = pool_Qsucc(sts, gdbroot->pool, cl);
mvol_LinkClass(sts, cp, gdb_mAdd__);
}
/* Link Sub classes to attributes. */
for (
cl = pool_Qsucc(sts, gdbroot->pool, &gdbroot->db->class_lh);
cl != &gdbroot->db->class_lh;
) {
cp = pool_Qitem(cl, gdb_sClass, class_ll);
cl = pool_Qsucc(sts, gdbroot->pool, cl);
if (cp->hasSc)
mvol_LinkSubClassToAttribute(sts, cp);
}
/* Build ScObjects for native volumes. */
for (
vl = pool_Qsucc(sts, gdbroot->pool, &gdbroot->db->vol_lh);
vl != &gdbroot->db->vol_lh;
vl = pool_Qsucc(sts, gdbroot->pool, vl)
) {
vp = pool_Qitem(vl, gdb_sVolume, l.vol_ll);
if (vp->l.flags.b.isNative)
buildScObjects(sts, vp);
}
/* Build class attribute tree */
mvol_BuildCatt(sts);
convFctn = dvms_GetFctns(formatp);
if (convFctn != NULL)
decodeObjects(formatp->b.bo);
convFctn = NULL;
mountClients(sts, gdbroot->my_volume);
}
//
// printValue
//
bool wb_print_wbl::printValue (wb_volume& v,
wb_adef& adef,
void *val,
int varSize,
char **svalp)
{
unsigned long sts;
char timbuf[24];
static char sval[512];
bool retval = true;
pwr_tOid oid;
wb_object o;
sval[0] = '\0';
if (adef.flags() & PWR_MASK_POINTER) {
sprintf(sval, "%u", *(unsigned int *) val);
*svalp = sval;
return TRUE;
}
switch (adef.type()) {
case pwr_eType_Boolean:
sprintf(sval, "%d", *(pwr_tBoolean *) val);
break;
case pwr_eType_Float32:
if ( *(pwr_tFloat32 *)val == FLT_MIN)
strcpy( sval, "FLT_MIN");
else if ( *(pwr_tFloat32 *)val == FLT_MAX)
strcpy( sval, "FLT_MAX");
else
sprintf(sval, "%.*e", FLT_DIG, *(pwr_tFloat32 *) val);
break;
case pwr_eType_Float64:
sprintf(sval, "%.*e", DBL_DIG, *(pwr_tFloat64 *) val);
break;
case pwr_eType_Char:
if (*(pwr_tChar *) val == 0)
sprintf(sval, "\"\"");
else
sprintf(sval, "\"%c\"", *(pwr_tChar *) val);
break;
case pwr_eType_Int8:
sprintf(sval, "%d", *(pwr_tInt8 *) val);
break;
case pwr_eType_Int16:
sprintf(sval, "%d", *(pwr_tInt16 *) val);
break;
case pwr_eType_Int32:
if ( *(pwr_tInt32 *)val == INT_MIN)
strcpy( sval, "INT_MIN");
else if ( *(pwr_tInt32 *)val == INT_MAX)
strcpy( sval, "INT_MAX");
else
sprintf(sval, "%d", *(pwr_tInt32 *) val);
break;
case pwr_eType_Int64:
sprintf(sval, pwr_dFormatInt64, *(pwr_tInt64 *) val);
break;
case pwr_eType_UInt8:
sprintf(sval, "%u", *(pwr_tUInt8 *) val);
break;
case pwr_eType_UInt16:
sprintf(sval, "%u", *(pwr_tUInt16 *) val);
break;
case pwr_eType_UInt32:
case pwr_eType_DisableAttr:
sprintf(sval, "%u", *(pwr_tUInt32 *) val);
break;
case pwr_eType_UInt64:
sprintf(sval, pwr_dFormatUInt64, *(pwr_tUInt64 *) val);
break;
case pwr_eType_Mask:
sprintf(sval, "%u", *(pwr_tUInt32 *) val);
break;
case pwr_eType_Enum:
sprintf(sval, "%u", *(pwr_tUInt32 *) val);
break;
case pwr_eType_RefId:
sprintf(sval, "0");
break;
case pwr_eType_Objid:
if (cdh_ObjidIsNull(*(pwr_tOid *) val))
sprintf(sval, "\"_O0.0.0.0:0\"");
else {
o = v.object(*(pwr_tOid *)val);
if (o) {
if ( o.oid().vid >= cdh_cUserVolMin && o.oid().vid != v.vid() && !m_keepName)
// Other user volume. Loadfile might not be created yet at load time.
sprintf(sval, "\"%s\"", cdh_ObjidToString(NULL, *(pwr_tObjid *)val, 1));
else
sprintf(sval, "\"%s\"", o.longName().c_str());
}
else
sprintf(sval, "\"%s\"", cdh_ObjidToString(NULL, *(pwr_tObjid *)val, 1));
}
break;
case pwr_eType_ObjectIx:
if ( *(pwr_tObjectIx *) val == 0)
sprintf(sval, "0");
else
sprintf(sval, "\"%s\"", cdh_ObjectIxToString(NULL, *(pwr_tObjectIx *) val,1));
break;
case pwr_eType_VolumeId:
if ( *(pwr_tVolumeId *) val == 0)
sprintf(sval, "0");
else
sprintf(sval, "\"%s\"", cdh_VolumeIdToString(NULL, *(pwr_tVolumeId *) val,1,0));
break;
case pwr_eType_ClassId:
if (*(pwr_tClassId *) val == 0)
sprintf(sval, "0");
else {
wb_cdef cdef = v.cdef(*(pwr_tCid *)val);
if (cdef)
sprintf(sval, "\"%s\"", cdef.longName().c_str());
else {
sprintf(sval, "Unknown class, identity: %d", (*(pwr_tClassId *) val));
m_errCnt++;
retval = false;
}
}
break;
case pwr_eType_TypeId: /** @todo Modify when wb_tdef is OK q*/
case pwr_eType_CastId:
if (*(pwr_tTypeId *) val == 0)
sprintf(sval, "0");
else {
oid = cdh_TypeIdToObjid(*(pwr_tTid *)val);
o = v.object(oid);
if (o)
sprintf(sval, "\"%s\"", o.longName().c_str());
else {
sprintf(sval, "Unknown type, identity: %d", (*(pwr_tTypeId *) val));
m_errCnt++;
retval = false;
}
}
break;
case pwr_eType_AttrRef: /** @todo */
if (cdh_ObjidIsNull(((pwr_sAttrRef*)val)->Objid))
sprintf(sval, "\"_O0.0.0.0:0\"");
else {
try {
wb_attribute a = v.attribute((pwr_sAttrRef*)val);
if (a)
sprintf(sval, "\"%s\"", a.longName().c_str());
else {
sprintf(sval, "\"%s\"", cdh_ArefToString(NULL, (pwr_sAttrRef*)val, 1));
}
} catch ( wb_error &e) {
if ( ldh_isSymbolicVid( ((pwr_sAttrRef *)val)->Objid.vid))
sprintf(sval, "\"%s\"", cdh_ArefToString(NULL, (pwr_sAttrRef*)val, 1));
else {
sprintf(sval, "Unknown attribute reference");
m_errCnt++;
retval = FALSE;
}
}
}
#if 0
} else {
int ItemLocal::open_attributes( TblNav *tblnav, double x, double y)
{
double node_x, node_y;
brow_GetNodePosition( node, &node_x, &node_y);
if ( brow_IsOpen( node)) {
// Close
brow_SetNodraw( tblnav->brow->ctx);
brow_CloseNode( tblnav->brow->ctx, node);
brow_SetAnnotPixmap( node, 0, tblnav->brow->pixmap_leaf);
brow_ResetOpen( node, tblnav_mOpen_All);
brow_ResetNodraw( tblnav->brow->ctx);
brow_Redraw( tblnav->brow->ctx, node_y);
}
else {
char value[256];
char txt[80];
brow_SetNodraw( tblnav->brow->ctx);
new ItemLocalAttr( tblnav, "Description", item.description, node, flow_eDest_IntoLast);
strcpy( value, "");
cdh_ObjidToString( value, item.oid, 1);
new ItemLocalAttr( tblnav, "Oid", value, node, flow_eDest_IntoLast);
new ItemLocalAttr( tblnav, "Object", item.oname, node, flow_eDest_IntoLast);
time_DtoAscii( &item.storagetime, 0, value, sizeof(value));
new ItemLocalAttr( tblnav, "StorageTime", value, node, flow_eDest_IntoLast);
time_AtoAscii( &item.creatime, time_eFormat_DateAndTime, value, sizeof(value));
new ItemLocalAttr( tblnav, "CreationTime", value, node, flow_eDest_IntoLast);
time_AtoAscii( &item.modtime, time_eFormat_DateAndTime, value, sizeof(value));
new ItemLocalAttr( tblnav, "ModificationTime", value, node, flow_eDest_IntoLast);
sprintf( value, "%f", item.scantime);
new ItemLocalAttr( tblnav, "ScanTime", value, node, flow_eDest_IntoLast);
strcpy( value, "");
if ( item.options & pwr_mSevOptionsMask_PosixTime)
strcat( value, " PosixTime");
if ( item.options & pwr_mSevOptionsMask_HighTimeResolution)
strcat( value, " HighTimeResolution");
if ( item.options & pwr_mSevOptionsMask_ReadOptimized)
strcat( value, " ReadOptimized");
if ( item.options & pwr_mSevOptionsMask_UseDeadBand)
strcat( value, " UseDeadBand");
new ItemLocalAttr( tblnav, "Options", value, node, flow_eDest_IntoLast);
sprintf( value, "%f", item.deadband);
new ItemLocalAttr( tblnav, "Deadband", value, node, flow_eDest_IntoLast);
for ( int i = 0; i < (int)item.objectattrlist.size(); i++) {
sprintf( txt, "Attr[%d].Name", i);
new ItemLocalAttr( tblnav, txt, item.objectattrlist[i].aname, node, flow_eDest_IntoLast);
switch ( item.objectattrlist[i].type) {
case pwr_eType_Int64: strcpy( value, "Int64"); break;
case pwr_eType_Int32: strcpy( value, "Int32"); break;
case pwr_eType_Int16: strcpy( value, "Int16"); break;
case pwr_eType_Int8: strcpy( value, "Int8"); break;
case pwr_eType_UInt64: strcpy( value, "UInt64"); break;
case pwr_eType_UInt32: strcpy( value, "UInt32"); break;
case pwr_eType_UInt16: strcpy( value, "UInt16"); break;
case pwr_eType_UInt8: strcpy( value, "UInt8"); break;
case pwr_eType_Boolean: strcpy( value, "Boolean"); break;
case pwr_eType_Char: strcpy( value, "Char"); break;
case pwr_eType_Float32: strcpy( value, "Float32"); break;
case pwr_eType_Float64: strcpy( value, "Float64"); break;
case pwr_eType_String: strcpy( value, "String"); break;
case pwr_eType_Time: strcpy( value, "Time"); break;
case pwr_eType_DeltaTime: strcpy( value, "DeltaTime"); break;
default: strcpy( value, "Unknown");
}
sprintf( txt, "Attr[%d].DataType", i);
new ItemLocalAttr( tblnav, txt, value, node, flow_eDest_IntoLast);
sprintf( txt, "Attr[%d].DataSize", i);
sprintf( value, "%d", item.objectattrlist[i].size);
new ItemLocalAttr( tblnav, txt, value, node, flow_eDest_IntoLast);
sprintf( txt, "Attr[%d].Unit", i);
new ItemLocalAttr( tblnav, txt, item.objectattrlist[i].unit, node, flow_eDest_IntoLast);
}
brow_SetOpen( node, tblnav_mOpen_Attributes);
brow_ResetNodraw( tblnav->brow->ctx);
brow_Redraw( tblnav->brow->ctx, node_y);
}
return 1;
}
pwr_tStatus bck_dump( ldh_tSession ldhses, char *filename, char *out)
{
pwr_tFileName fname;
FILE *f, *fout;
BCK_FILEHEAD_STRUCT fh;
bck_t_cycleheader ch;
bck_t_writeheader dh;
char timstr [24];
int c, d;
unsigned char *datap, *p;
int i;
pwr_tStatus sts;
int csts;
char *namep;
pwr_tAName aname;
int size;
int dump = 0;
// Open file
dcli_translate_filename( fname, filename);
f = fopen( fname, "rb");
if ( !f)
return LDH__NOSUCHFILE;
dcli_translate_filename( fname, out);
fout = fopen( fname, "w");
if ( !fout)
return LDH__NOSUCHFILE;
// Read header and print it
fseek (f, 0, 0);
fread (&fh, sizeof fh, 1, f);
fprintf( fout, "Layout version: %d\n", fh.version);
if (fh.version != BCK_FILE_VERSION) {
printf ("This program is built with header version %d\n", BCK_FILE_VERSION);
return LDH__BCKVERSION;
}
time_AtoAscii(&fh.creationtime, time_eFormat_DateAndTime, timstr, sizeof(timstr));
fprintf( fout, "Created: %s\n", timstr);
for (c=0; c<2; c++) {
fseek(f, fh.curdata [c], 0);
fread(&ch, sizeof ch, 1, f);
/* Work thru the data segments */
for ( d = 0; d < (int)ch.segments; d++) {
csts = fread(&dh, sizeof dh, 1, f);
if (csts != 0) {
if (dh.namesize > 0) {
namep = (char *)malloc(dh.namesize + 1);
csts = fread(namep, dh.namesize + 1, 1, f);
} else
namep = NULL;
datap = (unsigned char *)malloc(dh.size);
csts = fread(datap, dh.size, 1, f);
}
if (csts == 0) {
fprintf( fout, "Read error\n");
break;
}
if (dh.valid) {
if ( dump) {
fprintf( fout, "%s%s", cdh_ObjidToString(0, dh.objid, 1), namep);
p = datap;
for ( i = 0; i < (int)dh.size; i++, p++) {
if ((i % 16) == 0) fprintf( fout, "\n ");
fprintf( fout, "%02x ", *p);
}
fprintf( fout, "\n");
}
else {
sts = ldh_ObjidToName( ldhses, dh.objid, cdh_mName_volumeStrict, aname, sizeof(aname), &size);
if ( EVEN(sts))
strcpy( aname, cdh_ObjidToString(0, dh.objid, 1));
strncat( aname, namep, sizeof(aname));
fprintf( fout, "%s", aname);
char str[1024];
pwr_tAttrRef aref;
pwr_eType atype;
int printed = 0;
sts = ldh_NameToAttrRef( ldhses, aname, &aref);
if ( ODD(sts)) {
sts = ldh_GetAttrRefType( ldhses, &aref, &atype);
if ( ODD(sts)) {
sts = cdh_AttrValueToString( atype, datap, str, sizeof(str));
if ( ODD(sts)) {
fprintf( fout, "\n %s\n", str);
printed = 1;
}
}
}
if ( !printed) {
// Print as hex code
p = datap;
for ( i = 0; i < (int)dh.size; i++, p++) {
if ((i % 16) == 0) fprintf( fout, "\n ");
fprintf( fout, "%02x ", *p);
}
fprintf( fout, "\n");
}
}
}
free(datap);
free(namep);
}
}
fclose (f);
fclose (fout);
return LDH__SUCCESS;
}
pwr_tStatus wb_bck_list::read() {
FILE *f;
BCK_FILEHEAD_STRUCT fh;
bck_t_cycleheader ch;
bck_t_writeheader dh;
int c, d;
unsigned char *datap;
pwr_tStatus sts;
int csts;
char *namep;
pwr_tAName aname;
int size;
m_type = bck_eType_File;
// Open file
f = fopen( m_filename, "rb");
if ( !f)
return LDH__NOSUCHFILE;
// Read header
fseek (f, 0, 0);
fread (&fh, sizeof fh, 1, f);
if (fh.version != BCK_FILE_VERSION) {
printf ("This program is built with header version %d\n", BCK_FILE_VERSION);
return LDH__BCKVERSION;
}
for (c=0; c<2; c++) {
fseek(f, fh.curdata [c], 0);
fread(&ch, sizeof ch, 1, f);
/* Work thru the data segments */
for ( d = 0; d < (int)ch.segments; d++) {
csts = fread(&dh, sizeof dh, 1, f);
if (csts != 0) {
if (dh.namesize > 0) {
namep = (char *)malloc(dh.namesize + 1);
csts = fread(namep, dh.namesize + 1, 1, f);
} else
namep = NULL;
datap = (unsigned char *)malloc(dh.size);
csts = fread(datap, dh.size, 1, f);
}
if (csts == 0) {
printf( "** Read error\n");
break;
}
if (dh.valid) {
sts = ldh_ObjidToName( m_ldhses, dh.objid, cdh_mName_volumeStrict, aname, sizeof(aname), &size);
if ( EVEN(sts)) {
printf( "** Error, %s%s not found in this environment",
cdh_ObjidToString(0, dh.objid, 1), aname);
}
else {
strncat( aname, namep, sizeof(aname));
pwr_tAttrRef aref;
sts = ldh_NameToAttrRef( m_ldhses, aname, &aref);
if ( EVEN(sts))
printf("**Error, %s, no such attribute\n", aname);
else
add( &aref, datap, dh.size);
}
}
free(datap);
free(namep);
}
}
fclose (f);
return LDH__SUCCESS;
}
void wb_dbs::getAliasServer(sOentry *oep, void *p)
{
pwr_tStatus sts;
pwr_sAlias *alias = (pwr_sAlias *)p;
sOentry *aep;
oep->o.flags.b.isAliasClient = 0;
if (cdh_ObjidIsNull(alias->Object)) {
printf("!! Alias does not refer to any object!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
}
if (alias->Object.vid != m_volume.vid) {
printf("!! Alias refers to object outside own volume!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Object: %s\n", cdh_ObjidToString(NULL, alias->Object, 1));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
}
aep = (sOentry *)tree_Find(&sts, m_oid_th, &alias->Object);
if (!aep) {
printf("!! Alias refers to a non existing object!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
}
if (aep->o.flags.b.devOnly) {
printf("!! An alias may not refer to a non runtime object!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Object: %s\n", pathName(aep));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
}
switch (aep->o.cid) {
case pwr_eClass_Alias:
printf("!! An alias may not refer to another alias!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Object: %s\n", pathName(aep));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
break;
case pwr_eClass_MountVolume:
case pwr_eClass_CreateVolume:
case pwr_eClass_MountObject:
printf("!! An alias may not refer to a mount object!\n");
printf(" Alias: %s\n", pathName(oep));
printf(" Object: %s\n", pathName(aep));
printf(" Alias will not be loaded.\n");
m_warnings++;
return;
break;
}
oep->o.flags.b.isAliasClient = 1;
oep->o.soid = aep->o.oid;
}
void
wb_dbs::cidInsert(pwr_tStatus *sts, pwr_tCid cid, pwr_sAttrRef *arp, sCentry **cep)
{
*cep = (sCentry*)tree_Insert(sts, m_class_th, &cid);
if ( !arp)
return;
if (*sts == TREE__INSERTED) {
// Insert depending classes
pwr_tCid *lst;
pwr_sAttrRef *arlst;
sCentry *entry;
int cnt;
pwr_tStatus lsts;
pwr_sAttrRef aref;
pwr_sAttrRef cast_aref;
pwr_tCid cast_cid;
m_v->merep()->classDependency( &lsts, cid, &lst, &arlst, &cnt);
for ( int i = 0; i < cnt; i++) {
aref = cdh_ArefAdd( arp, &arlst[i]);
cidInsert(&lsts, lst[i], &aref, &entry);
if ( aref.Flags.b.CastAttr) {
cast_aref = cdh_ArefToCastAref( &aref);
wb_volume v(m_v);
wb_attribute a = v.attribute( &cast_aref);
if ( a) {
a.value( &cast_cid);
if ( cast_cid != pwr_cNCid) {
wb_cdef cd = v.cdef( cast_cid);
if ( cd)
cidInsert(&lsts, cast_cid, 0, &entry);
else
printf("** Invalid cast class %s\n", cdh_ObjidToString( 0, aref.Objid, 1));
}
}
}
}
free(lst);
free(arlst);
}
else if ( !(cdh_CidToVid(cid) == 1 && cdh_CidToVid(cid) == 2)) {
// Check class of casted attribute for every instance
pwr_tCid *lst;
pwr_sAttrRef *arlst;
sCentry *entry;
int cnt;
pwr_tStatus lsts;
pwr_sAttrRef aref;
pwr_sAttrRef cast_aref;
pwr_tCid cast_cid;
m_v->merep()->classDependency( &lsts, cid, &lst, &arlst, &cnt);
for ( int i = 0; i < cnt; i++) {
aref = cdh_ArefAdd( arp, &arlst[i]);
if ( aref.Flags.b.CastAttr) {
cast_aref = cdh_ArefToCastAref( &aref);
wb_volume v(m_v);
wb_attribute a = v.attribute( &cast_aref);
if ( a) {
a.value( &cast_cid);
if ( cast_cid != pwr_cNCid) {
wb_cdef cd = v.cdef( cast_cid);
if ( cd)
cidInsert(&lsts, cast_cid, 0, &entry);
else
printf("** Invalid cast class %s\n", cdh_ObjidToString( 0, aref.Objid, 1));
}
}
}
}
free(lst);
free(arlst);
}
}
pwr_tStatus
bck_LoadBackup ()
{
pwr_tStatus sts;
pwr_tInt32 csts;
pwr_tObjid objid;
pwr_sClass_Backup_Conf *backup_confp; /* Backup_Conf object pointer */
FILE *f;
BCK_FILEHEAD_STRUCT fh; /* File header */
BCK_CYCLEHEAD_STRUCT ch_old;
bck_t_cycleheader ch;
BCK_DATAHEAD_STRUCT dh_old;
bck_t_writeheader dh;
pwr_tUInt32 c;
pwr_tUInt32 d;
char *strp;
char *datap;
char *namep;
char fname[200];
pwr_tAName objectname;
#if defined OS_VMS || defined OS_ELN
short msglen;
struct dsc$descriptor tmpstrdsc;
char tmpstr [256];
#endif
/* Find the local Backup_Conf object. */
sts = gdh_GetClassList(pwr_cClass_Backup_Conf, &objid);
while (ODD(sts)) {
sts = gdh_ObjidToPointer(objid, (pwr_tAddress *)&backup_confp);
if (ODD(sts)) break;
sts = gdh_GetNextObject(objid, &objid);
}
if (EVEN(sts)) return sts;
/* Open the backup file. */
dcli_translate_filename( fname, backup_confp->BackupFile);
f = fopen( fname, "r+" A_MODE);
if (f == NULL) {
SET_ERRNO_STS;
errh_Error("Load Backup: Failed to open %s, errno = %d",
backup_confp->BackupFile, sts);
return sts;
}
errh_Info("BACKUP loading information from %s", FGETNAME);
sts = 1; /* Guess all ok */
/* Read the header. */
csts = fread(&fh, sizeof fh, 1, f);
if (csts == 0) {
SET_ERRNO_STS;
} else {
if (fh.version < BCK_FILE_VERSION - 1) {
errh_Info("BACKUP Loading old file version : %d", fh.version);
/* Read the cycle data. */
for (c=0; c<2; c++) {
fseek(f, fh.curdata [c], 0);
fread(&ch_old, sizeof ch_old, 1, f);
/* Work thru the data segments */
for (d=0; d<ch_old.segments; d++) {
csts = fread(&dh_old, sizeof dh_old, 1, f);
if (csts != 0) {
datap = malloc(dh_old.attrref.Size);
csts = fread(datap, dh_old.attrref.Size, 1, f);
}
if (csts == 0) {
SET_ERRNO_STS;
break;
}
if (dh_old.valid) {
/* Find object */
if (dh_old.dynamic) {
strp = strchr(dh_old.dataname, '.'); /* always is a full object! */
if (strp != NULL) *strp = '\0'; /* Just make sure... */
sts = gdh_CreateObject(dh_old.dataname, dh_old.cid, dh_old.attrref.Size,
&objid, dh_old.attrref.Objid, 0, pwr_cNObjid);
if (strp != NULL) *strp = '.';
if (ODD (sts))
sts = gdh_SetObjectInfo(dh_old.dataname, datap, dh_old.attrref.Size);
} /* Dynamic object */
else {
sts = gdh_SetObjectInfoAttrref(&dh_old.attrref, datap, dh_old.attrref.Size);
}
} /* valid segment */
free(datap);
if (EVEN (sts)) {
errh_Error("BACKUP error reloading %s, reason:\n%m", dh_old.dataname, sts);
sts = 1;
}
} /* For all data segments */
if (EVEN (sts)) break; /* Fatal! Get out! */
} /* For each cycle */
} else if (fh.version == BCK_FILE_VERSION - 1) {
/* Read the cycle data. */
for (c=0; c<2; c++) {
fseek(f, fh.curdata [c], 0);
fread(&ch_old, sizeof ch_old, 1, f);
/* Work thru the data segments */
for (d=0; d<ch_old.segments; d++) {
csts = fread(&dh, sizeof dh, 1, f);
if (csts != 0) {
if (dh.namesize > 0) {
namep = malloc(dh.namesize + 1);
csts = fread(namep, dh.namesize + 1, 1, f);
} else
namep = NULL;
datap = malloc(dh.size);
csts = fread(datap, dh.size, 1, f);
}
if (csts == 0) {
SET_ERRNO_STS;
break;
}
if (dh.valid) {
/* Find object */
if (dh.dynamic) {
strp = strchr(namep, '.'); /* always is a full object! */
if (strp != NULL) *strp = '\0'; /* Just make sure... */
sts = gdh_CreateObject(namep, dh.cid, dh.size,
&objid, dh.objid, 0, pwr_cNObjid);
if (strp != NULL) *strp = '.';
if (ODD (sts))
sts = gdh_SetObjectInfo(namep, datap, dh.size);
strncpy(objectname, namep, pwr_cSizAName);
} /* Dynamic object */
else {
sts = gdh_ObjidToName (dh.objid, objectname, sizeof(objectname),
cdh_mNName);
if (ODD(sts)) {
strcat(objectname, namep);
sts = gdh_SetObjectInfo(objectname, datap, dh.size);
}
}
} /* valid segment */
if (EVEN (sts)) {
errh_Error("BACKUP error reloading %s, reason:\n%m", objectname, sts);
sts = 1;
}
free(datap);
free(namep);
} /* For all data segments */
if (EVEN (sts)) break; /* Fatal! Get out! */
} /* For each cycle */
} else if (fh.version == BCK_FILE_VERSION) {
/* Read the cycle data. */
for (c=0; c<2; c++) {
fseek(f, fh.curdata [c], 0);
fread(&ch, sizeof ch, 1, f);
/* Work thru the data segments */
for (d=0; d<ch.segments; d++) {
csts = fread(&dh, sizeof dh, 1, f);
if (csts != 0) {
if (dh.namesize > 0) {
namep = malloc(dh.namesize + 1);
csts = fread(namep, dh.namesize + 1, 1, f);
} else
namep = NULL;
datap = malloc(dh.size);
csts = fread(datap, dh.size, 1, f);
}
if (csts == 0) {
SET_ERRNO_STS;
break;
}
if (dh.valid) {
/* Find object */
strcpy(objectname, "");
if (dh.dynamic) {
strp = strchr(namep, '.'); /* always is a full object! */
if (strp != NULL) *strp = '\0'; /* Just make sure... */
sts = gdh_CreateObject(namep, dh.cid, dh.size,
&objid, dh.objid, 0, pwr_cNObjid);
if (strp != NULL) *strp = '.';
if (ODD (sts))
sts = gdh_SetObjectInfo(namep, datap, dh.size);
strncpy(objectname, namep, pwr_cSizAName);
} /* Dynamic object */
else {
sts = gdh_ObjidToName (dh.objid, objectname, sizeof(objectname),
cdh_mNName);
if (ODD(sts)) {
strcat(objectname, namep);
sts = gdh_SetObjectInfo(objectname, datap, dh.size);
}
else
strcpy(objectname, cdh_ObjidToString( 0, dh.objid, 1));
}
} /* valid segment */
if (EVEN (sts)) {
errh_Error("BACKUP error reloading %s, reason:\n%m", objectname, sts);
sts = 1;
}
free(datap);
free(namep);
} /* For all data segments */
if (EVEN (sts)) break; /* Fatal! Get out! */
} /* For each cycle */
} /* File version format ok */
else {
errh_Error("BACKUP Cannot load backup file with version %d", fh.version);
}
} /* Successful header read */
fclose (f);
return sts;
}
