NCerror
freeNCDAPCOMMON(NCDAPCOMMON* dapcomm)
{
/* abort the metadata file */
(void)nc_abort(getncid(dapcomm));
freenccache(dapcomm,dapcomm->cdf.cache);
nclistfree(dapcomm->cdf.projectedvars);
nullfree(dapcomm->cdf.recorddimname);
/* free the trees */
freecdfroot34(dapcomm->cdf.ddsroot);
dapcomm->cdf.ddsroot = NULL;
freecdfroot34(dapcomm->cdf.fullddsroot);
dapcomm->cdf.fullddsroot = NULL;
if(dapcomm->oc.ocdasroot != NULL)
oc_root_free(dapcomm->oc.conn,dapcomm->oc.ocdasroot);
dapcomm->oc.ocdasroot = NULL;
oc_close(dapcomm->oc.conn); /* also reclaims remaining OC trees */
ncurifree(dapcomm->oc.url);
nullfree(dapcomm->oc.urltext);
nullfree(dapcomm->oc.rawurltext);
dcefree((DCEnode*)dapcomm->oc.dapconstraint);
dapcomm->oc.dapconstraint = NULL;
free(dapcomm);
return NC_NOERR;
}
static bool match(UChar **items, int32_t *item_lengths, uint32_t item_count, UChar *needle, Match *match_results, int32_t *final_positions, int32_t needle_char_len, UChar *level1, UChar *level2, UChar *level3) {
Stack stack = {0};
int32_t i = 0, maxhl = 0;
int32_t r = 0, *positions = NULL;
MatchInfo *matches = NULL;
bool ok = FALSE;
MemoryItem ***memo = NULL;
int32_t needle_len = u_strlen(needle);
if (needle_len <= 0 || item_count <= 0) {
for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0;
ok = TRUE;
goto end;
}
matches = (MatchInfo*)calloc(item_count, sizeof(MatchInfo));
positions = (int32_t*)calloc(2*needle_len, sizeof(int32_t)); // One set of positions is the final answer and one set is working space
if (matches == NULL || positions == NULL) {PyErr_NoMemory(); goto end;}
for (i = 0; i < (int32_t)item_count; i++) {
matches[i].haystack = items[i];
matches[i].haystack_len = item_lengths[i];
matches[i].needle = needle;
matches[i].needle_len = needle_len;
matches[i].max_score_per_char = (1.0 / matches[i].haystack_len + 1.0 / needle_len) / 2.0;
matches[i].level1 = level1;
matches[i].level2 = level2;
matches[i].level3 = level3;
maxhl = MAX(maxhl, matches[i].haystack_len);
}
if (maxhl <= 0) {
for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0;
ok = TRUE;
goto end;
}
alloc_stack(&stack, needle_len, maxhl);
memo = alloc_memory(needle_len, maxhl);
if (stack.items == NULL || memo == NULL) {PyErr_NoMemory(); goto end;}
for (i = 0; i < (int32_t)item_count; i++) {
for (r = 0; r < needle_len; r++) {
positions[r] = -1;
}
stack_clear(&stack);
clear_memory(memo, needle_len, matches[i].haystack_len);
matches[i].memo = memo;
match_results[i].score = process_item(&matches[i], &stack, positions);
convert_positions(positions, final_positions + i, matches[i].haystack, needle_char_len, needle_len, match_results[i].score);
}
ok = TRUE;
end:
nullfree(positions);
nullfree(stack.items);
nullfree(matches);
nullfree(memo);
return ok;
}
static void
freestringvec(char** list)
{
if(list != NULL) {
char** p;
for(p=list;*p;p++) {nullfree(*p);}
nullfree(list);
}
}
int
NCDISPATCH_finalize(void)
{
int status = NC_NOERR;
nullfree(ncrc_globalstate.tempdir);
nullfree(ncrc_globalstate.home);
NC_rcclear(&ncrc_globalstate.rcinfo);
memset(&ncrc_globalstate,0,sizeof(NCRCglobalstate));
return status;
}
/* Free up a single node, but not any
nodes it points to.
*/
static void
free1cdfnode(CDFnode* node)
{
unsigned int j,k;
if(node == NULL) return;
nullfree(node->ocname);
nullfree(node->ncbasename);
nullfree(node->ncfullname);
if(node->attributes != NULL) {
for(j=0;j<nclistlength(node->attributes);j++) {
NCattribute* att = (NCattribute*)nclistget(node->attributes,j);
nullfree(att->name);
for(k=0;k<nclistlength(att->values);k++)
nullfree((char*)nclistget(att->values,k));
nclistfree(att->values);
nullfree(att);
}
}
nullfree(node->dodsspecial.dimname);
nclistfree(node->subnodes);
nclistfree(node->attributes);
nclistfree(node->array.dimsetplus);
nclistfree(node->array.dimsetall);
nclistfree(node->array.dimset0);
nclistfree(node->array.dimsettrans);
/* Clean up the ncdap4 fields also */
nullfree(node->typename);
nullfree(node->vlenname);
nullfree(node);
}
// Matcher.calculate_scores {{{
static PyObject *
Matcher_calculate_scores(Matcher *self, PyObject *args) {
int32_t *final_positions = NULL, *p;
Match *matches = NULL;
bool ok = FALSE;
uint32_t i = 0, needle_char_len = 0, j = 0;
PyObject *items = NULL, *score = NULL, *positions = NULL, *pneedle = NULL;
UChar *needle = NULL;
if (!PyArg_ParseTuple(args, "O", &pneedle)) return NULL;
needle = python_to_icu(pneedle, NULL);
if (needle == NULL) return NULL;
needle_char_len = u_countChar32(needle, -1);
items = PyTuple_New(self->item_count);
positions = PyTuple_New(self->item_count);
matches = (Match*)calloc(self->item_count, sizeof(Match));
final_positions = (int32_t*) calloc(needle_char_len * self->item_count, sizeof(int32_t));
if (items == NULL || matches == NULL || final_positions == NULL || positions == NULL) {PyErr_NoMemory(); goto end;}
for (i = 0; i < self->item_count; i++) {
score = PyTuple_New(needle_char_len);
if (score == NULL) { PyErr_NoMemory(); goto end; }
PyTuple_SET_ITEM(positions, (Py_ssize_t)i, score);
}
Py_BEGIN_ALLOW_THREADS;
ok = match(self->items, self->item_lengths, self->item_count, needle, matches, final_positions, needle_char_len, self->collator, self->level1, self->level2, self->level3);
Py_END_ALLOW_THREADS;
if (ok) {
for (i = 0; i < self->item_count; i++) {
score = PyFloat_FromDouble(matches[i].score);
if (score == NULL) { PyErr_NoMemory(); goto end; }
PyTuple_SET_ITEM(items, (Py_ssize_t)i, score);
p = final_positions + (i * needle_char_len);
for (j = 0; j < needle_char_len; j++) {
score = PyLong_FromLong((long)p[j]);
if (score == NULL) { PyErr_NoMemory(); goto end; }
PyTuple_SET_ITEM(PyTuple_GET_ITEM(positions, (Py_ssize_t)i), (Py_ssize_t)j, score);
}
}
} else { PyErr_NoMemory(); goto end; }
end:
nullfree(needle);
nullfree(matches);
nullfree(final_positions);
if (PyErr_Occurred()) { Py_XDECREF(items); items = NULL; Py_XDECREF(positions); positions = NULL; return NULL; }
return Py_BuildValue("NN", items, positions);
} // }}}
static NCerror
mapnodesr(CDFnode* connode, CDFnode* fullnode, int depth)
{
unsigned int i,j;
NCerror ncstat = NC_NOERR;
ASSERT((simplenodematch(connode,fullnode)));
#ifdef DEBUG
{
char* path1 = makecdfpathstring(fullnode,".");
char* path2 = makecdfpathstring(connode,".");
fprintf(stderr,"mapnode: %s->%s\n",path1,path2);
nullfree(path1); nullfree(path2);
}
#endif
/* Map node */
mapfcn(connode,fullnode);
#if 0
{
int i;
for(i=0;i<nclistlength(fullnode->subnodes);i++) {
CDFnode* n = (CDFnode*)nclistget(fullnode->subnodes,i);
fprintf(stderr,"fullnode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
}
for(i=0;i<nclistlength(connode->subnodes);i++) {
CDFnode* n = (CDFnode*)nclistget(connode->subnodes,i);
fprintf(stderr,"connode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
}
}
#endif
/* Try to match connode subnodes against fullnode subnodes */
ASSERT(nclistlength(connode->subnodes) <= nclistlength(fullnode->subnodes));
for(i=0;i<nclistlength(connode->subnodes);i++) {
CDFnode* consubnode = (CDFnode*)nclistget(connode->subnodes,i);
/* Search full subnodes for a matching subnode from con */
for(j=0;j<nclistlength(fullnode->subnodes);j++) {
CDFnode* fullsubnode = (CDFnode*)nclistget(fullnode->subnodes,j);
if(simplenodematch(fullsubnode,consubnode)) {
ncstat = mapnodesr(consubnode,fullsubnode,depth+1);
if(ncstat) goto done;
}
}
}
done:
return THROW(ncstat);
}
/* Exceptions: anonymous dimensions. */
static NCerror
fix1node(NCDAPCOMMON* nccomm, CDFnode* node)
{
if(node->nctype == NC_Dimension && node->ocname == NULL) return NC_NOERR;
ASSERT((node->ocname != NULL));
nullfree(node->ncbasename);
node->ncbasename = cdflegalname(node->ocname);
if(node->ncbasename == NULL) return NC_ENOMEM;
nullfree(node->ncfullname);
node->ncfullname = makecdfpathstring(node,nccomm->cdf.separator);
if(node->ncfullname == NULL) return NC_ENOMEM;
if(node->nctype == NC_Atomic)
node->externaltype = nctypeconvert(nccomm,node->etype);
return NC_NOERR;
}
/* Replace the protocol */
int
ncurisetprotocol(NCURI* duri,const char* protocol)
{
nullfree(duri->protocol);
duri->protocol = strdup(protocol);
return (NCU_OK);
}
/* Parse a mode string at the commas nul terminate each tag */
static int
parseurlmode(const char* modestr0, char** listp)
{
int stat = NC_NOERR;
char* modestr = NULL;
char* p = NULL;
char* endp = NULL;
/* Make modifiable copy */
if((modestr=strdup(modestr0)) == NULL)
{stat=NC_ENOMEM; goto done;}
/* Split modestr at the commas or EOL */
p = modestr;
for(;;) {
endp = strchr(p,',');
if(endp == NULL) break;
/* Null terminate each comma-separated string */
*endp++ = '\0';
p = endp;
}
if(listp) *listp = modestr;
modestr = NULL;
done:
if(stat) {nullfree(modestr);}
return stat;
}
/* Parse url fragment for format etc. */
static int
url_getmodel(const char* modestr, NCmode* model)
{
int stat = NC_NOERR;
char* args = NULL;
char* p = NULL;
model->format = 0;
model->implementation = 0;
if((stat=parseurlmode(modestr,&args))) goto done;
p = args;
for(;*p;) {
struct LEGALMODES* legal = legalmodes;
while(legal->tag) {
if(strcmp(legal->tag,p)==0) {
if(model->format != 0 && legal->format != 0)
{stat = NC_EINVAL; goto done;}
if(model->implementation != 0 && legal->implementation != 0)
{stat = NC_EINVAL; goto done;}
if(model->iosp != 0 && legal->iosp != 0)
{stat = NC_EINVAL; goto done;}
if(legal->format != 0) model->format = legal->format;
if(legal->implementation != 0)
model->implementation = legal->implementation;
if(legal->iosp != 0) model->iosp = legal->iosp;
}
}
}
done:
nullfree(args);
return stat;
}
static int
printAttribute(D4printer* out, NCD4node* attr, int depth)
{
int ret = NC_NOERR;
int i = 0;
char* fqn = NULL;
INDENT(depth); CAT("<Attribute");
printXMLAttributeName(out,"name",attr->name);
if(attr->basetype->subsort <= NC_MAX_ATOMIC_TYPE)
printXMLAttributeName(out,"type",attr->basetype->name);
else {
printXMLAttributeName(out,"type",(fqn = NCD4_makeFQN(attr->basetype)));
}
CAT(">\n");
depth++;
for(i=0;i<nclistlength(attr->attr.values);i++) {
printValue(out,(const char*)nclistget(attr->attr.values,i),depth);
CAT("\n");
}
depth--;
INDENT(depth);
CAT("</Attribute>");
nullfree(fqn);
return THROW(ret);
}
/* Parse incoming url constraints, if any,
to check for syntactic correctness */
NCerror
parsedapconstraints(NCDAPCOMMON* dapcomm, char* constraints,
DCEconstraint* dceconstraint)
{
NCerror ncstat = NC_NOERR;
char* errmsg;
ASSERT(dceconstraint != NULL);
nclistclear(dceconstraint->projections);
nclistclear(dceconstraint->selections);
ncstat = dapceparse(constraints,dceconstraint,&errmsg);
if(ncstat) {
nclog(NCLOGWARN,"DCE constraint parse failure: %s",errmsg);
nullfree(errmsg);
nclistclear(dceconstraint->projections);
nclistclear(dceconstraint->selections);
} else {
#ifdef IGNORE
int i;
#ifdef DEBUG
NClist* allnodes;
fprintf(stderr,"constraint: %s",dumpconstraint(dceconstraint));
#endif
/* Go thru each node and add annotation */
allnodes = dceallnodes((DCEnode*)dceconstraint,CES_NIL);
for(i=0;i<nclistlength(allnodes);i++) {
DCEnode* node = (DCEnode*)nclistget(allnodes,i);
}
#endif
}
return ncstat;
}
CDFnode*
makecdfnode(NCDAPCOMMON* nccomm, char* ocname, OCtype octype,
/*optional*/ OCddsnode ocnode, CDFnode* container)
{
CDFnode* node;
assert(nccomm != NULL);
node = (CDFnode*)calloc(1,sizeof(CDFnode));
if(node == NULL) return (CDFnode*)NULL;
node->ocname = NULL;
if(ocname) {
size_t len = strlen(ocname);
if(len >= NC_MAX_NAME) len = NC_MAX_NAME-1;
node->ocname = (char*)malloc(len+1);
if(node->ocname == NULL) { nullfree(node); return NULL;}
memcpy(node->ocname,ocname,len);
node->ocname[len] = '\0';
}
node->nctype = octypetonc(octype);
node->ocnode = ocnode;
node->subnodes = nclistnew();
node->container = container;
if(ocnode != NULL) {
oc_dds_atomictype(nccomm->oc.conn,ocnode,&octype);
node->etype = octypetonc(octype);
}
if(container != NULL)
node->root = container->root;
else if(node->nctype == NC_Dataset)
node->root = node;
return node;
}
static void
defdimensions(OCddsnode ocnode, CDFnode* cdfnode, NCDAPCOMMON* nccomm, CDFtree* tree)
{
size_t i,ocrank;
oc_dds_rank(nccomm->oc.conn,ocnode,&ocrank);
assert(ocrank > 0);
for(i=0;i<ocrank;i++) {
CDFnode* cdfdim;
OCddsnode ocdim;
char* ocname;
size_t declsize;
oc_dds_ithdimension(nccomm->oc.conn,ocnode,i,&ocdim);
oc_dimension_properties(nccomm->oc.conn,ocdim,&declsize,&ocname);
cdfdim = makecdfnode(nccomm,ocname,OC_Dimension,
ocdim,cdfnode->container);
nullfree(ocname);
nclistpush(tree->nodes,(void*)cdfdim);
/* Initially, constrained and unconstrained are same */
cdfdim->dim.declsize = declsize;
cdfdim->dim.array = cdfnode;
if(cdfnode->array.dimset0 == NULL)
cdfnode->array.dimset0 = nclistnew();
nclistpush(cdfnode->array.dimset0,(void*)cdfdim);
}
}
/*
Given a das attribute walk it to see if it
has at least 1 actual attribute (no recursion)
*/
static int
hasattribute3(OCconnection conn, OCobject dasnode)
{
int i;
OCerror ocstat = OC_NOERR;
int tf = 0; /* assume false */
unsigned int nsubnodes;
OCtype ocsubtype;
OCobject* subnodes = NULL;
OCHECK(oc_inq_class(conn,dasnode,&ocsubtype));
if(ocsubtype == OC_Attribute) return 1; /* this is an attribute */
ASSERT((ocsubtype == OC_Attributeset));
OCHECK(oc_inq_nsubnodes(conn,dasnode,&nsubnodes));
OCHECK(oc_inq_subnodes(conn,dasnode,&subnodes));
for(i=0;i<nsubnodes;i++) {
OCobject subnode = subnodes[i];
OCHECK(oc_inq_class(conn,subnode,&ocsubtype));
if(ocsubtype == OC_Attribute) {tf=1; break;}
}
done:
nullfree(subnodes);
return tf;
}
void
freegetvara(Getvara* vara)
{
if(vara == NULL) return;
dcefree((DCEnode*)vara->varaprojection);
nullfree(vara);
}
static int
printVariable(D4printer* out, NCD4node* var, int depth)
{
int ret = NC_NOERR;
NCD4node* basetype = var->basetype;
char* fqn = NULL;
INDENT(depth); CAT("<");
switch (var->subsort) {
default:
CAT(basetype->name);
printXMLAttributeName(out, "name", var->name);
break;
case NC_ENUM:
CAT("Enum");
printXMLAttributeName(out, "name", var->name);
printXMLAttributeName(out, "enum", (fqn=NCD4_makeFQN(basetype)));
break;
case NC_OPAQUE:
CAT("Opaque");
printXMLAttributeName(out, "name", var->name);
printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype)));
break;
case NC_SEQ:
CAT("Seq");
printXMLAttributeName(out, "name", var->name);
printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype)));
break;
case NC_STRUCT:
CAT("Struct");
printXMLAttributeName(out, "name", var->name);
printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype)));
break;
}
if(hasMetaData(var)) {
CAT(">\n");
depth++;
if((ret=printMetaData(out,var,depth))) goto done;
depth--;
INDENT(depth); CAT("</");
if(basetype->subsort == NC_ENUM)
CAT("Enum");
else if(basetype->subsort == NC_OPAQUE)
CAT("Opaque");
else if(basetype->subsort == NC_STRUCT)
CAT("Struct");
else if(basetype->subsort == NC_SEQ)
CAT("Sequence");
else
CAT(basetype->name);
CAT(">");
} else
CAT("/>");
done:
nullfree(fqn);
return THROW(ret);
}
NCerror
fetchtemplatemetadata3(NCDAPCOMMON* dapcomm)
{
NCerror ncstat = NC_NOERR;
OCerror ocstat = OC_NOERR;
OCddsnode ocroot = NULL;
CDFnode* ddsroot = NULL;
char* ce = NULL;
/* Temporary hack: we need to get the selection string
from the url
*/
/* Get (almost) unconstrained DDS; In order to handle functions
correctly, those selections must always be included
*/
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE))
ce = NULL;
else
ce = nulldup(dapcomm->oc.url->selection);
/* Get selection constrained DDS */
ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDDS,&ocroot);
if(ocstat != OC_NOERR) {
/* Special Hack. If the protocol is file, then see if
we can get the dds from the .dods file
*/
if(strcmp(dapcomm->oc.url->protocol,"file") != 0) {
THROWCHK(ocstat); goto done;
}
/* Fetch the data dds */
ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDATADDS,&ocroot);
if(ocstat != OC_NOERR) {
THROWCHK(ocstat); goto done;
}
/* Note what we did */
nclog(NCLOGWARN,"Cannot locate .dds file, using .dods file");
}
/* Get selection constrained DAS */
ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDAS,&dapcomm->oc.ocdasroot);
if(ocstat != OC_NOERR) {
/* Ignore but complain */
nclog(NCLOGWARN,"Could not read DAS; ignored");
dapcomm->oc.ocdasroot = NULL;
ocstat = OC_NOERR;
}
/* Construct the netcdf cdf tree corresponding to the dds tree*/
ncstat = buildcdftree34(dapcomm,ocroot,OCDDS,&ddsroot);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
dapcomm->cdf.fullddsroot = ddsroot;
done:
nullfree(ce);
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
return ncstat;
}
static NCerror
buildattribute3a(NCDAPCOMMON* dapcomm, NCattribute* att, nc_type vartype, int varid)
{
int i;
NCerror ncstat = NC_NOERR;
unsigned int nvalues = nclistlength(att->values);
NC* drno = dapcomm->controller;
/* If the type of the attribute is string, then we need*/
/* to convert to a single character string by concatenation.
modified: 10/23/09 to insert newlines.
modified: 10/28/09 to interpret escapes
*/
if(att->etype == NC_STRING || att->etype == NC_URL) {
char* newstring;
size_t newlen = 0;
for(i=0;i<nvalues;i++) {
char* s = (char*)nclistget(att->values,i);
newlen += (1+strlen(s));
}
newstring = (char*)malloc(newlen);
MEMCHECK(newstring,NC_ENOMEM);
newstring[0] = '\0';
for(i=0;i<nvalues;i++) {
char* s = (char*)nclistget(att->values,i);
if(i > 0) strcat(newstring,"\n");
strcat(newstring,s);
}
dapexpandescapes(newstring);
if(newstring[0]=='\0')
ncstat = nc_put_att_text(drno->substrate,varid,att->name,1,newstring);
else
ncstat = nc_put_att_text(drno->substrate,varid,att->name,strlen(newstring),newstring);
free(newstring);
} else {
nc_type atype;
unsigned int typesize;
void* mem;
/* It turns out that some servers upgrade the type
of _FillValue in order to correctly preserve the
original value. However, since the type of the
underlying variable is not changes, we get a type
mismatch. So, make sure the type of the fillvalue
is the same as that of the controlling variable.
*/
if(varid != NC_GLOBAL && strcmp(att->name,"_FillValue")==0)
atype = nctypeconvert(dapcomm,vartype);
else
atype = nctypeconvert(dapcomm,att->etype);
typesize = nctypesizeof(atype);
mem = malloc(typesize * nvalues);
ncstat = dapcvtattrval3(atype,mem,att->values);
ncstat = nc_put_att(drno->substrate,varid,att->name,atype,nvalues,mem);
nullfree(mem);
}
return THROW(ncstat);
}
static int
printMap(D4printer* out, NCD4node* mapref, int depth)
{
char* fqn = NULL;
INDENT(depth);
CAT("<Map");
printXMLAttributeName(out, "name", (fqn=NCD4_makeFQN(mapref)));
CAT("/>");
nullfree(fqn);
return THROW(NC_NOERR);
}
void
ncurifree(NCURI* duri)
{
if(duri == NULL) return;
nullfree(duri->uri);
nullfree(duri->protocol);
nullfree(duri->user);
nullfree(duri->password);
nullfree(duri->host);
nullfree(duri->port);
nullfree(duri->path);
nullfree(duri->query);
nullfree(duri->fragment);
freestringvec(duri->querylist);
freestringvec(duri->fraglist);
free(duri);
}
NCerror
fetchconstrainedmetadata3(NCDAPCOMMON* dapcomm)
{
NCerror ncstat = NC_NOERR;
OCerror ocstat = OC_NOERR;
OCddsnode ocroot;
CDFnode* ddsroot; /* constrained */
char* ce = NULL;
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE))
ce = NULL;
else
ce = buildconstraintstring3(dapcomm->oc.dapconstraint);
{
ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDDS,&ocroot);
if(ocstat != OC_NOERR) {THROWCHK(ocstat); goto fail;}
/* Construct our parallel dds tree; including attributes*/
ncstat = buildcdftree34(dapcomm,ocroot,OCDDS,&ddsroot);
if(ncstat) goto fail;
ocroot = NULL; /* avoid duplicate reclaim */
dapcomm->cdf.ddsroot = ddsroot;
ddsroot = NULL; /* to avoid double reclamation */
if(!FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) {
/* fix DAP server problem by adding back any inserting needed structure nodes */
ncstat = restruct3(dapcomm->cdf.ddsroot,dapcomm->cdf.fullddsroot,dapcomm->oc.dapconstraint->projections);
if(ncstat) goto fail;
}
#ifdef DEBUG
fprintf(stderr,"constrained:\n%s",dumptree(dapcomm->cdf.ddsroot));
#endif
/* Combine DDS and DAS */
if(dapcomm->oc.ocdasroot != NULL) {
ncstat = dapmerge3(dapcomm,dapcomm->cdf.ddsroot->ocnode,
dapcomm->oc.ocdasroot);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto fail;}
}
/* map the constrained DDS to the unconstrained DDS */
ncstat = mapnodes3(dapcomm->cdf.ddsroot,dapcomm->cdf.fullddsroot);
if(ncstat) goto fail;
}
fail:
nullfree(ce);
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
return ncstat;
}
static void
freestringlist(NClist* list)
{
if(list != NULL) {
int i;
for(i=0;i<nclistlength(list);i++) {
void* p = nclistget(list,i);
nullfree(p);
}
nclistfree(list);
}
}
void
freenccache(NCDAPCOMMON* nccomm, NCcache* cache)
{
int i;
if(cache == NULL) return;
freenccachenode(nccomm,cache->prefetch);
for(i=0;i<nclistlength(cache->nodes);i++) {
freenccachenode(nccomm,(NCcachenode*)nclistget(cache->nodes,i));
}
nclistfree(cache->nodes);
nullfree(cache);
}
static int
readpacket(NCD4INFO* state, NCURI* url, NCbytes* packet, NCD4mode dxx, long* lastmodified)
{
int stat = NC_NOERR;
int fileprotocol = 0;
const char* suffix = dxxextension(dxx);
CURL* curl = state->curl->curl;
#ifdef HAVE_GETTIMEOFDAY
struct timeval time0;
struct timeval time1;
#endif
fileprotocol = (strcmp(url->protocol,"file")==0);
if(fileprotocol) {
/* Short circuit file://... urls*/
/* We do this because the test code always needs to read files*/
stat = readfile(state, url,suffix,packet);
} else {
char* fetchurl = NULL;
int flags = NCURIBASE;
if(!fileprotocol) flags |= NCURIQUERY;
flags |= NCURIENCODE;
fetchurl = ncuribuild(url,NULL,suffix,flags);
MEMCHECK(fetchurl);
if(FLAGSET(state->controls.flags,NCF_SHOWFETCH)) {
nclog(NCLOGDBG,"fetch url=%s",fetchurl);
#ifdef HAVE_GETTIMEOFDAY
gettimeofday(&time0,NULL);
#endif
}
stat = NCD4_fetchurl(curl,fetchurl,packet,lastmodified);
nullfree(fetchurl);
if(stat) goto fail;
if(FLAGSET(state->controls.flags,NCF_SHOWFETCH)) {
double secs = 0;
#ifdef HAVE_GETTIMEOFDAY
gettimeofday(&time1,NULL);
secs = deltatime(time0,time1);
#endif
nclog(NCLOGDBG,"fetch complete: %0.3f",secs);
}
}
#ifdef D4DEBUG
{
fprintf(stderr,"readpacket: packet.size=%lu\n",
(unsigned long)ncbyteslength(packet));
}
#endif
fail:
return THROW(stat);
}
void
freenccachenode(NCDAPCOMMON* nccomm, NCcachenode* node)
{
if(node == NULL) return;
oc_data_free(nccomm->oc.conn,node->content);
#ifdef IGNORE
oc_root_free(nccomm->oc.conn,node->ocroot);
#endif
dcefree((DCEnode*)node->constraint);
freecdfroot34(node->datadds);
nclistfree(node->vars);
nullfree(node);
}
static void free_matcher(Matcher *self) {
uint32_t i = 0;
if (self->items != NULL) {
for (i = 0; i < self->item_count; i++) { nullfree(self->items[i]); }
}
nullfree(self->items); nullfree(self->item_lengths);
nullfree(self->level1); nullfree(self->level2); nullfree(self->level3);
}
void
freenccachenode(NCDAPCOMMON* nccomm, NCcachenode* node)
{
if(node == NULL) return;
#ifdef DEBUG
fprintf(stderr,"freecachenode: %s\n",
dumpcachenode(node));
#endif
oc_data_free(nccomm->oc.conn,node->content);
dcefree((DCEnode*)node->constraint);
freecdfroot34(node->datadds);
nclistfree(node->vars);
nullfree(node);
}
static int
printXMLAttributeName(D4printer* out, char* name, const char* value)
{
int ret = NC_NOERR;
char* escaped = NULL;
if(name == NULL) return THROW(ret);
if(value == NULL) value = "";
CAT(" "); CAT(name); CAT("=\"");
/* add xml entity escaping */
escaped = NCD4_entityescape(value);
CAT(escaped);
CAT("\"");
nullfree(escaped);
return THROW(ret);
}
