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