pwr_tStatus
wb_dbs::writeSectVolref(size_t size)
{
pwr_tStatus sts;
if (fseek(m_fp, m_sect[dbs_eSect_volref].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
// Search trhough all found volumes and get their volrefs
sVentry *vep;
vep = (sVentry*)tree_Minimum(&sts, m_vol_th);
while (vep) {
if (vep->env.file.cookie == 0) {
printf(" volume not found: %d\n", vep->v.vid);
} else {
vep->v.offset = dbs_dAlign(size);
size += vep->v.size = dbs_dAlign(vep->v.size);
char v[dbs_dAlign(sizeof(dbs_sVolRef))];
dbs_sVolRef *vp = (dbs_sVolRef*)v;
*vp = vep->v;
if (fwrite(v, sizeof(v), 1, m_fp) < 1)
return LDH__FILEWRITE;
}
vep = (sVentry*)tree_Successor(&sts, m_vol_th, vep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_volref].offset + m_sect[dbs_eSect_volref].size));
return LDH__SUCCESS;
}
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;
}
pwr_tStatus
wb_dbs::writeSectFile(size_t size)
{
char f[dbs_dAlign(sizeof(dbs_sFile))];
dbs_sFile *fp = (dbs_sFile*)f;
PDR pdrs;
co_GetOwnFormat(&fp->format);
fp->cookie = dbs_cMagicCookie;
fp->size = size;
fp->offset = dbs_dAlign(sizeof(*fp));
fp->formatVersion = dbs_cVersionFormat;
fp->version = dbs_cVersionFile;
fp->sectVersion = dbs_cVersionDirectory;
fp->pwrVersion = 1;
fp->time = m_volume.time;
fp->fileType = dbs_eFile_volume;
strcpy(fp->userName, "");
strcpy(fp->comment, "");
pdrmem_create(&pdrs, (char *) fp, sizeof(*fp), PDR_DECODE, fp->format, fp->format);
if (!pdr_dbs_sFile(&pdrs, fp))
return LDH__XDR;
if (fseek(m_fp, 0, SEEK_SET) != 0)
return LDH__FILEPOS;
if (fwrite(f, sizeof(f) , 1, m_fp) < 1) return LDH__FILEWRITE;
return LDH__SUCCESS;
}
dbs_sVolRef *
dbs_VolRef(pwr_tStatus *sts, pwr_tUInt32 index, dbs_sVolRef *vp, const dbs_sEnv *ep)
{
dbs_sSect sect;
int nVolref = 0;
fseek(ep->f, ep->file.offset + (dbs_eSect_volref * dbs_dAlign(sizeof(sect))), SEEK_SET);
if (fread(§, sizeof(sect), 1, ep->f) == 0) {
*sts = errno_GetStatus();
return NULL;
}
nVolref = sect.size / dbs_dAlign(sizeof(*vp));
if (index >= nVolref)
return NULL;
fseek(ep->f, sect.offset + (index * dbs_dAlign(sizeof(*vp))), SEEK_SET);
if (fread(vp, sizeof(*vp), 1, ep->f) == 0) {
*sts = errno_GetStatus();
return NULL;
}
return vp;
}
void
wb_dbs::buildSectName()
{
sNentry *nep;
/* allocate space for all name entries in name section*/
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
nep->ref = dbs_dMakeRef(dbs_eSect_name, m_sect[dbs_eSect_name].size);
m_sect[dbs_eSect_name].size += dbs_dAlign(sizeof(dbs_sName));
m_nNameObjects++;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
if (nep != NULL) {
m_volume.name_bt.start = nep->ref;
nep = (sNentry*)tree_Maximum(NULL, m_name_th);
m_volume.name_bt.end = nep->ref;
m_volume.name_bt.rsize = dbs_dAlign(sizeof(dbs_sName));
}
}
dbs_sBody *
dbs_NextDbody(pwr_tStatus *sts, const dbs_sVenv *vep, dbs_sBody *bp)
{
dbs_sBody *ebp = (dbs_sBody*)(vep->base + vep->sect[dbs_eSect_dbody].offset + vep->sect[dbs_eSect_dbody].size);
if (bp == NULL)
bp = (dbs_sBody*)(vep->base + vep->sect[dbs_eSect_dbody].offset);
else
bp = (dbs_sBody*)((char *)bp + dbs_dAlign(sizeof(dbs_sBody)) + dbs_dAlign(bp->size));
if (bp >= ebp)
return NULL;
return bp;
}
pwr_tStatus
wb_dbs::writeSectOid()
{
sOentry *oep;
char o[dbs_dAlign(sizeof(dbs_sOid))];
dbs_sOid *op = (dbs_sOid*)o;
if (m_sect[dbs_eSect_oid].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_oid].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(o, 0, sizeof(o));
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
op->oid = oep->o.oid;
op->ref = oep->ref;
if (fwrite(o, sizeof(o), 1, m_fp) < 1)
return LDH__FILEWRITE;
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_oid].offset + m_sect[dbs_eSect_oid].size));
return LDH__SUCCESS;
}
pwr_tStatus
wb_dbs::writeSectName()
{
sNentry *nep;
if (m_sect[dbs_eSect_name].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_name].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
nep->n.ref = nep->oep->ref;
if (fwrite(&nep->n, dbs_dAlign(sizeof(nep->n)), 1, m_fp) < 1)
return LDH__FILEWRITE;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_name].offset + m_sect[dbs_eSect_name].size));
return LDH__SUCCESS;
}
dbs_sEnv *
dbs_Open(pwr_tStatus *sts, dbs_sEnv *ep, const char *filename)
{
FILE *f;
co_mFormat srcFormat, ownFormat;
PDR pdrs;
dbs_sSect sect;
*sts = DBS__SUCCESS;
memset(ep, 0, sizeof(*ep));
f = fopen(filename, "r");
if (f == NULL) {
*sts = errno_GetStatus();
return NULL;
}
if (fread(&ep->file, sizeof(ep->file), 1, f) == 0) {
*sts = errno_GetStatus();
fclose(f);
return NULL;
}
fseek(f, ep->file.offset, SEEK_SET);
if (fread(§, sizeof(sect), 1, f) == 0) {
*sts = errno_GetStatus();
fclose(f);
return NULL;
}
ep->nSect = sect.size / dbs_dAlign(sizeof(sect));
#if 0
srcFormat.m = ntohl(ep->file.format.m);
#else
srcFormat.m = ep->file.format.m;
#endif
co_GetOwnFormat(&ownFormat);
if (srcFormat.m != ownFormat.m) {
pdrmem_create(&pdrs, &ep->file, sizeof(ep->file), PDR_DECODE, srcFormat, ownFormat);
if (!pdr_dbs_sFile(&pdrs, &ep->file)) {
*sts = DBS__PDRFILE;
fclose(f);
return NULL;
}
}
fseek(f, 0, SEEK_SET);
ep->f = f;
return ep;
}
void
wb_dbs::buildSectOid()
{
sOentry *oep;
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
oep->oidref = dbs_dMakeRef(dbs_eSect_oid, m_sect[dbs_eSect_oid].size);
m_sect[dbs_eSect_oid].size += dbs_dAlign(sizeof(dbs_sOid));
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
if (oep != NULL) {
m_volume.oid_bt.start = oep->oidref;
oep = (sOentry*)tree_Maximum(NULL, m_oid_th);
m_volume.oid_bt.end = oep->oidref;
m_volume.oid_bt.rsize = dbs_dAlign(sizeof(dbs_sOid));
}
}
void
wb_dbs::buildSectClass()
{
pwr_tStatus sts;
sCentry *cep;
dbs_tRef ref;
dbs_sQlink *o_lh;
dbs_sQlink *o_ll;
sOentry *oep;
/* allocate space for all name entries in name section*/
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
ref = cep->ref = dbs_dMakeRef(dbs_eSect_class, m_sect[dbs_eSect_class].size);
m_sect[dbs_eSect_class].size += dbs_dAlign(sizeof(dbs_sClass));
dbs_Qinit(&sts, &cep->c.o_lh, ref + offsetof(dbs_sClass, o_lh));
// Link all object instances to this class
o_lh = o_ll = &cep->c.o_lh;
for (oep = cep->o_lh; oep != 0; oep = oep->o_ll) {
cep->c.nObjects++;
m_nClassObjects++;
dbs_Qinsert(&sts, o_ll, &oep->o.o_ll, o_lh);
o_ll = &oep->o.o_ll;
}
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
if (cep != NULL) {
m_volume.class_bt.start = cep->ref;
cep = (sCentry*)tree_Maximum(NULL, m_class_th);
m_volume.class_bt.end = cep->ref;
m_volume.class_bt.rsize = dbs_dAlign(sizeof(dbs_sClass));
}
}
dbs_sObject *
dbs_NextHead(pwr_tStatus *sts, const dbs_sVenv *vep, dbs_sObject *op)
{
dbs_sObject *eop = (dbs_sObject*)(vep->base + vep->sect[dbs_eSect_object].offset + vep->sect[dbs_eSect_object].size);
if (op == NULL)
op = (dbs_sObject*)(vep->base + vep->sect[dbs_eSect_object].offset);
else
op = (dbs_sObject*)((char *)op + dbs_dAlign(sizeof(dbs_sObject)));
if (op >= eop)
return NULL;
return op;
}
pwr_tStatus
wb_dbs::writeSectVolume()
{
char v[dbs_dAlign(sizeof(dbs_sVolume))];
if (fseek(m_fp, m_sect[dbs_eSect_volume].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(v, 0, sizeof(v));
memcpy(v, &m_volume, sizeof(m_volume));
if (fwrite(v, sizeof(v), 1, m_fp) < 1)
return LDH__FILEWRITE;
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_volume].offset + m_sect[dbs_eSect_volume].size));
return LDH__SUCCESS;
}
dbs_sVolume *
dbs_Volume(pwr_tStatus *sts, dbs_sVolume *vp, const dbs_sEnv *ep)
{
dbs_sSect sect;
fseek(ep->f, ep->file.offset + (dbs_eSect_volume * dbs_dAlign(sizeof(sect))), SEEK_SET);
if (fread(§, sizeof(sect), 1, ep->f) == 0) {
*sts = errno_GetStatus();
return NULL;
}
fseek(ep->f, sect.offset, SEEK_SET);
if (fread(vp, sizeof(*vp), 1, ep->f) == 0) {
*sts = errno_GetStatus();
return NULL;
}
return vp;
}
static pwr_tStatus
writeTree(wb_dbs::sOentry *oep, FILE *fp)
{
pwr_tStatus sts;
if (!oep)
return 1;
if (oep->poep)
oep->o.flags.b.devOnly |= oep->poep->o.flags.b.devOnly;
if (fwrite(&oep->o, dbs_dAlign(sizeof(oep->o)), 1, fp) < 1)
return LDH__FILEWRITE;
sts = writeTree(oep->foep, fp);
if (EVEN(sts))
return sts;
sts = writeTree(oep->aoep, fp);
if (EVEN(sts))
return sts;
return 1;
}
pwr_tStatus
wb_dbs::writeSectClass()
{
sCentry *cep;
if (m_sect[dbs_eSect_class].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_class].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
if (fwrite(&cep->c, dbs_dAlign(sizeof(cep->c)), 1, m_fp) < 1)
return LDH__FILEWRITE;
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_class].offset + m_sect[dbs_eSect_class].size));
return LDH__SUCCESS;
}
void
wb_dbs::checkObject(sOentry *oep)
{
int nChild = 0;
pwr_tStatus sts;
dbs_sQlink *sib_lh;
dbs_sQlink *sib_ll;
sOentry *sep;
dbs_sName n;
sNentry *nep;
// Check object
if (!oep->flags.b.exist) {
printf("** Object does not exist!\n");
}
m_nTreeObjects++;
oep->ref = dbs_dMakeRef(dbs_eSect_object, m_sect[dbs_eSect_object].size);
m_sect[dbs_eSect_object].size += dbs_dAlign(sizeof(dbs_sObject));
dbs_Qinit(&sts, &oep->o.sib_lh, oep->ref + offsetof(dbs_sObject, sib_lh));
dbs_Qinit(&sts, &oep->o.sib_ll, oep->ref + offsetof(dbs_sObject, sib_ll));
dbs_Qinit(&sts, &oep->o.o_ll, oep->ref + offsetof(dbs_sObject, o_ll));
classInsert(oep);
switch (oep->o.cid) {
case pwr_eClass_ClassDef:
// Version is dependent of attribute objects
m_v->merep()->classVersion(&sts, cdh_ClassObjidToId(oep->o.oid), &oep->o.time);
break;
case pwr_eClass_LibHier:
if ( !cdh_isClassVolumeClass( m_volume.cid))
oep->o.flags.b.devOnly = 1;
break;
case pwr_eClass_Alias:
if ( !cdh_isClassVolumeClass( m_volume.cid))
oep->o.flags.b.isAliasClient = 1;
break;
case pwr_eClass_MountVolume:
case pwr_eClass_CreateVolume:
case pwr_eClass_MountObject:
if (m_volume.cid == pwr_eClass_RootVolume || m_volume.cid == pwr_eClass_VolatileVolume) {
// Root volume or cloned volume
oep->o.flags.b.isMountClient = 1;
}
break;
default:
break;
}
oep->o.flags.b.isMountClean = 1;
// Check all children
sib_lh = sib_ll = &oep->o.sib_lh;
for (sep = oep->foep; sep != 0; sep = sep->aoep) {
if (sep->poep != oep) {
printf("** Object not linked to right parent!\n");
}
checkObject(sep);
sep->o.pref = oep->ref;
dbs_Qinsert(&sts, sib_ll, &sep->o.sib_ll, sib_lh);
sib_ll = &sep->o.sib_ll;
oep->o.flags.b.isMountClean |= sep->o.flags.b.isMountClean && !sep->o.flags.b.isMountClient;
nChild++;
}
/* Check name table, get reference to first and last child in name order. */
memset(&n, 0, sizeof(n));
n.poix = oep->o.oid.oix;
nep = (sNentry*)tree_FindSuccessor(&sts, m_name_th, &n);
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.start = nep->ref;
}
n.poix += 1;
nep = (sNentry*)tree_FindPredecessor(&sts, m_name_th, &n);
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.end = nep->ref;
}
oep->o.name_bt.rsize = dbs_dAlign(sizeof(dbs_sName));
}
dbs_sMenv *
dbs_Map(pwr_tStatus *sts, const char *filename)
{
struct stat sb;
int ret;
int fd;
int tfd;
int i;
dbs_sSect *sect;
void *base = 0;
int nVolRef;
dbs_sVolRef *vrp;
dbs_sMenv *mep = 0;
dbs_sVenv *vep = 0;
char buf[512];
char tfname[] = "/tmp/loadfile.dbs_XXXXXX";
*sts = DBS__SUCCESS;
if ((ret = stat(filename, &sb)) != 0) {
*sts = errno_GetStatus();
return NULL;
}
fd = open(filename, O_RDWR);
tfd = mkstemp(tfname);
while (1) {
int count;
count = read(fd, buf, sizeof(buf));
if (count <= 0)
break;
write(tfd, buf, count);
}
ret = close(fd);
errno = 0;
base = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, tfd, 0);
if (base == NULL) {
*sts = errno_GetStatus();
perror("mmap");
ret = close(tfd);
return NULL;
}
ret = close(tfd);
#if !defined OS_CYGWIN
unlink(tfname);
#endif
sect = (dbs_sSect*)(base + dbs_dAlign(sizeof(dbs_sFile)));
vrp = (dbs_sVolRef*)(base + sect[dbs_eSect_volref].offset);
nVolRef = sect[dbs_eSect_volref].size / dbs_dAlign(sizeof(dbs_sVolRef));
mep = (dbs_sMenv *)calloc(1, sizeof(dbs_sMenv) + (nVolRef * sizeof(dbs_sVenv)));
mep->size = sb.st_size;
mep->flags.b.isMapped = 1;
mep->vrp = vrp;
mep->nVolRef = nVolRef;
mep->base = base;
strncpy(mep->tfname, tfname, sizeof(tfname));
vep = mep->venv;
vep->mp = mep;
vep->index = 0;
vep->base = base;
vep->sect = (dbs_sSect*)(vep->base + dbs_dAlign(sizeof(dbs_sFile)));
vep->vp = (dbs_sVolume*)(vep->base + vep->sect[dbs_eSect_volume].offset);
vep->name_bt = &vep->vp->name_bt;
vep->oid_bt = &vep->vp->oid_bt;
vep->class_bt = &vep->vp->class_bt;
for (i = 0; i < nVolRef; i++) {
vep = &mep->venv[i + 1];
vep->mp = mep;
vep->index = i + 1;
vep->base = base + vrp[i].offset;
vep->sect = (dbs_sSect*)(vep->base + dbs_dAlign(sizeof(dbs_sFile)));
vep->vp = (dbs_sVolume*)(vep->base + vep->sect[dbs_eSect_volume].offset);
vep->name_bt = &vep->vp->name_bt;
vep->oid_bt = &vep->vp->oid_bt;
vep->class_bt = &vep->vp->class_bt;
vep->size = ((dbs_sFile*)vep->base)->size;
}
return mep;
}
bool wb_dbs::importHead(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid,
pwr_tOid boid, pwr_tOid aoid, pwr_tOid foid, pwr_tOid loid,
const char *name, const char *normname, pwr_mClassDef flags,
pwr_tTime time, pwr_tTime rbTime, pwr_tTime dbTime,
size_t rbSize, size_t dbSize)
{
sNentry *nep;
sOentry *oep;
pwr_tStatus sts;
if (cdh_ObjidIsNull(oid))
printf("** Error: object is null!\n");
oep = (sOentry *)tree_Insert(&sts, m_oid_th, &oid);
if (sts == TREE__INSERTED) {
} else if (oep->flags.b.exist) {
printf("** Error: object is already inserted!\n");
}
if (oid.oix == pwr_cNOix) {
// this is the volume object
m_oep = oep;
}
oep->flags.b.exist = 1;
// Link objects to its relatives
if (cdh_ObjidIsNotNull(poid))
oep->poep = (sOentry *)tree_Insert(&sts, m_oid_th, &poid);
if (cdh_ObjidIsNotNull(boid))
oep->boep = (sOentry *)tree_Insert(&sts, m_oid_th, &boid);
if (cdh_ObjidIsNotNull(aoid))
oep->aoep = (sOentry *)tree_Insert(&sts, m_oid_th, &aoid);
if (cdh_ObjidIsNotNull(foid))
oep->foep = (sOentry *)tree_Insert(&sts, m_oid_th, &foid);
if (cdh_ObjidIsNotNull(loid))
oep->loep = (sOentry *)tree_Insert(&sts, m_oid_th, &loid);
m_nObjects++;
m_volume.cardinality++;
if (flags.b.DevOnly)
oep->o.flags.b.devOnly = 1;
if (flags.b.RtReadOnly)
oep->o.flags.b.readOnly = 1;
oep->o.oid = oid;
oep->o.cid = cid;
oep->o.poid = poid;
oep->o.boid = boid;
oep->o.aoid = aoid;
oep->o.foid = foid;
oep->o.loid = loid;
strcpy(oep->o.name, name);
strcpy(oep->o.normname, normname);
oep->o.time = time;
if (cdh_ObjidIsNotNull(poid)) {
dbs_sName n;
/* insert into name table */
memset(&n, 0, sizeof(n));
n.poix = poid.oix;
strcpy(n.normname, normname);
nep = (sNentry*)tree_Insert(&sts, m_name_th, &n);
nep->oep = oep;
}
oep->o.ohFlags.m = flags.m;
// classInsert(oep);
oep->o.rbody.time = rbTime;
oep->o.rbody.size = rbSize;
if (rbSize > 0) {
oep->rbody.oid = oid;
oep->rbody.size = dbs_dAlign(rbSize);
m_volume.rbodySize += oep->rbody.size;
}
oep->o.dbody.time = dbTime;
oep->o.dbody.size = dbSize;
if (oep->o.dbody.size > 0) {
oep->dbody.oid = oid;
oep->dbody.size = dbs_dAlign(oep->o.dbody.size);
}
if ( cid == pwr_eClass_ClassDef) {
// Version is dependent of attribute objects
// m_v->merep()->classVersion(&sts, cdh_ClassObjidToId(oid), &oep->o.time);
}
return true;
}
pwr_tBoolean
wb_dbs::createFile()
{
pwr_tStatus sts;
int size;
printf("-- Working with load file volume '%s'...\n", m_v->name());
printf("-- Open file...\n");
sts = openFile();
if (EVEN(sts)) goto error_handler;
size = dbs_dAlign(sizeof(dbs_sFile));
m_sect[dbs_eSect_dir].size = sizeof(m_sect);
m_sect[dbs_eSect_dir].offset = size;
size += m_sect[dbs_eSect_dir].size;
m_sect[dbs_eSect_volume].size = dbs_dAlign(sizeof(dbs_sVolume));
m_sect[dbs_eSect_volume].offset = size;
sts = writeSectVolume();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_volume].size;
m_sect[dbs_eSect_volref].offset = size;
sts = prepareSectVolref();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_volref].size;
m_sect[dbs_eSect_oid].offset = size;
sts = writeSectOid();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_oid].size;
m_sect[dbs_eSect_rbody].offset = size;
sts = writeSectRbody();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_rbody].size;
m_sect[dbs_eSect_dbody].offset = size;
// if ( !m_rtonly) {
sts = writeSectDbody();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_dbody].size;
m_sect[dbs_eSect_object].offset = size;
// }
sts = writeSectObject();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_object].size;
m_sect[dbs_eSect_name].offset = size;
sts = writeSectName();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_name].size;
m_sect[dbs_eSect_class].offset = size;
sts = writeSectClass();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_class].size;
sts = writeSectDirectory();
if (EVEN(sts)) goto error_handler;
sts = writeSectFile(size);
if (EVEN(sts)) goto error_handler;
sts = writeSectVolref(size);
if (EVEN(sts)) goto error_handler;
if ( !m_rtonly) {
sts = writeReferencedVolumes();
if (EVEN(sts)) goto error_handler;
}
sts = closeFile(0);
if (EVEN(sts)) goto error_handler;
printf("-- Successfully created load file for volume '%s'\n", m_v->name());
printf("-- %d objects with a total body size of %d bytes were written to new file.\n",
m_volume.cardinality, m_volume.rbodySize);
return 1;
error_handler:
/* Clean up the mess. */
printf("-- Load file was not created for volume '%s'\n", m_v->name());
closeFile(1);
return 0;
}
pwr_tStatus
wb_dbs::prepareSectVolref()
{
char v[dbs_dAlign(sizeof(dbs_sVolRef))];
dbs_sVolRef *vp = (dbs_sVolRef*)v;
cdh_uTid cid;
sCentry *cep;
pwr_tStatus sts;
pwr_tUInt32 dvVersion;
if (fseek(m_fp, m_sect[dbs_eSect_volref].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(v, 0, sizeof(v));
cid.pwr = pwr_cNCid;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
while (cep) {
cdh_uVid vid;
vid.pwr = pwr_cNVid;
cid.pwr = cep->c.cid;
vid.v.vid_0 = cid.c.vid_0;
vid.v.vid_1 = cid.c.vid_1;
if (vid.pwr != m_volume.vid) {
wb_mvrep *mvrep = m_v->merep()->volume(&sts, vid.pwr);
if ( EVEN(sts)) throw wb_error_str("Metavolume not found");
dvVersion = getDvVersion( mvrep);
sVentry *vep;
vep = (sVentry*)tree_Insert(&sts, m_vol_th, &vid.pwr);
if (sts == TREE__INSERTED) {
/* was inserted now */
dbs_Open(&sts, &vep->env, mvrep->fileName());
strcpy(vep->v.name, mvrep->name());
vep->v.cid = mvrep->cid();
if ( m_volume.cid == pwr_eClass_DetachedClassVolume) {
vep->v.time.tv_sec = dvVersion;
vep->v.time.tv_nsec = 0;
}
else
vep->v.time = vep->env.file.time;
vep->v.size = vep->env.file.size;
vep->v.offset = 0;
int i = 0;
while ((vp = dbs_VolRef(&sts, i, (dbs_sVolRef *)v, &vep->env)) != NULL) {
sVentry *nvep;
i++;
nvep = (sVentry*)tree_Insert(&sts, m_vol_th, &vp->vid);
if (sts == TREE__INSERTED) {
wb_mvrep *nmvrep = m_v->merep()->volume(&sts, vp->vid);
if ( EVEN(sts)) {
printf( "** Classvolume %s referenced but not loaded\n", vp->name);
throw wb_error_str("Metavolume not loaded");
}
dvVersion = getDvVersion( mvrep);
dbs_Open(&sts, &nvep->env, nmvrep->fileName());
strcpy(nvep->v.name, vp->name);
nvep->v.cid = vp->cid;
if ( m_volume.cid == pwr_eClass_DetachedClassVolume) {
nvep->v.time.tv_sec = dvVersion;
nvep->v.time.tv_nsec = 0;
}
else
nvep->v.time = vp->time;
// nvep->v.dvVersion = vp->dvVersion;
nvep->v.size = vp->size;
nvep->v.offset = 0;
}
}
}
}
vid.pwr++;
cid.pwr = pwr_cNCid;
cid.c.vid_0 = vid.v.vid_0;
cid.c.vid_1 = vid.v.vid_1;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
}
// Search trhough all found volumes and get their volrefs
int nVolume = 0;
sVentry *vep;
vep = (sVentry*)tree_Minimum(&sts, m_vol_th);
while (vep) {
if (vep->env.file.cookie == 0) {
printf(" volume not found: %d\n", vep->v.vid);
} else {
nVolume++;
m_sect[dbs_eSect_volref].size += sizeof(v);
}
vep = (sVentry*)tree_Successor(&sts, m_vol_th, vep);
}
return LDH__SUCCESS;
}
