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; }