mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-12-21 08:39:46 +08:00
49737888ca
## Improvements to S3 Documentation * Create a new document *quickstart_paths.md* that give a summary of the legal path formats used by netcdf-c. This includes both file paths and URL paths. * Modify *nczarr.md* to remove most of the S3 related text. * Move the S3 text from *nczarr.md* to a new document *cloud.md*. * Add some S3-related text to the *byterange.md* document. Hopefully, this will make it easier for users to find the information they want. ## Rebuild NCZarr Testing In order to avoid problems with running make check in parallel, two changes were made: 1. The *nczarr_test* test system was rebuilt. Now, for each test. any generated files are kept in a test-specific directory, isolated from all other test executions. 2. Similarly, since the S3 test bucket is shared, any generated S3 objects are isolated using a test-specific key path. ## Other S3 Related Changes * Add code to ensure that files created on S3 are reclaimed at end of testing. * Used the bash "trap" command to ensure S3 cleanup even if the test fails. * Cleanup the S3 related configure.ac flag set since S3 is used in several places. So now one should use the option *--enable-s3* instead of *--enable-nczarr-s3*, although the latter is still kept as a deprecated alias for the former. * Get some of the github actions yml to work with S3; required fixing various test scripts adding a secret to access the Unidata S3 bucket. * Cleanup S3 portion of libnetcdf.settings.in and netcdf_meta.h.in and test_common.in. * Merge partial S3 support into dhttp.c. * Create an experimental s3 access library especially for use with Windows. It is enabled by using the options *--enable-s3-internal* (automake) or *-DENABLE_S3_INTERNAL=ON* (CMake). Also add a unit-test for it. * Move some definitions from ncrc.h to ncs3sdk.h ## Other Changes * Provide a default implementation of strlcpy and move this and similar defaults into *dmissing.c*.
211 lines
4.4 KiB
C
211 lines
4.4 KiB
C
/* Copyright 2018, UCAR/Unidata and OPeNDAP, Inc.
|
|
See the COPYRIGHT file for more information. */
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "ncbytes.h"
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
#define DEFAULTALLOC 1024
|
|
#define ALLOCINCR 1024
|
|
|
|
#define NCBYTESDEBUG 1
|
|
|
|
static int
|
|
ncbytesfail(void)
|
|
{
|
|
fflush(stdout);
|
|
fprintf(stderr,"bytebuffer failure\n");
|
|
fflush(stderr);
|
|
#ifdef NCBYTESDEBUG
|
|
abort();
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
|
|
NCbytes*
|
|
ncbytesnew(void)
|
|
{
|
|
NCbytes* bb = (NCbytes*)malloc(sizeof(NCbytes));
|
|
if(bb == NULL) return (ncbytesfail(),NULL);
|
|
bb->alloc=0;
|
|
bb->length=0;
|
|
bb->content=NULL;
|
|
bb->nonextendible = 0;
|
|
return bb;
|
|
}
|
|
|
|
int
|
|
ncbytessetalloc(NCbytes* bb, unsigned long sz)
|
|
{
|
|
char* newcontent;
|
|
if(bb == NULL) return ncbytesfail();
|
|
if(sz == 0) {sz = (bb->alloc?2*bb->alloc:DEFAULTALLOC);}
|
|
if(bb->alloc >= sz) return TRUE;
|
|
if(bb->nonextendible) return ncbytesfail();
|
|
newcontent=(char*)calloc(sz,sizeof(char));
|
|
if(newcontent == NULL) ncbytesfail();
|
|
if(bb->alloc > 0 && bb->length > 0 && bb->content != NULL) {
|
|
memcpy((void*)newcontent,(void*)bb->content,sizeof(char)*bb->length);
|
|
}
|
|
if(bb->content != NULL) free(bb->content);
|
|
bb->content=newcontent;
|
|
bb->alloc=sz;
|
|
return TRUE;
|
|
}
|
|
|
|
EXTERNL void
|
|
ncbytesfree(NCbytes* bb)
|
|
{
|
|
if(bb == NULL) return;
|
|
if(!bb->nonextendible && bb->content != NULL) free(bb->content);
|
|
free(bb);
|
|
}
|
|
|
|
int
|
|
ncbytessetlength(NCbytes* bb, unsigned long sz)
|
|
{
|
|
if(bb == NULL) return ncbytesfail();
|
|
if(bb->length < sz) {
|
|
if(sz > bb->alloc) {if(!ncbytessetalloc(bb,sz)) return ncbytesfail();}
|
|
}
|
|
bb->length = sz;
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
ncbytesfill(NCbytes* bb, char fill)
|
|
{
|
|
unsigned long i;
|
|
if(bb == NULL) return ncbytesfail();
|
|
for(i=0;i<bb->length;i++) bb->content[i] = fill;
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
ncbytesget(NCbytes* bb, unsigned long index)
|
|
{
|
|
if(bb == NULL) return -1;
|
|
if(index >= bb->length) return -1;
|
|
return bb->content[index];
|
|
}
|
|
|
|
int
|
|
ncbytesset(NCbytes* bb, unsigned long index, char elem)
|
|
{
|
|
if(bb == NULL) return ncbytesfail();
|
|
if(index >= bb->length) return ncbytesfail();
|
|
bb->content[index] = elem;
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
ncbytesappend(NCbytes* bb, char elem)
|
|
{
|
|
char s[2];
|
|
if(bb == NULL) return ncbytesfail();
|
|
s[0] = elem;
|
|
s[1] = '\0';
|
|
ncbytesappendn(bb,s,1);
|
|
return TRUE;
|
|
}
|
|
|
|
/* This assumes s is a null terminated string*/
|
|
int
|
|
ncbytescat(NCbytes* bb, const char* s)
|
|
{
|
|
if(s == NULL) return 1;
|
|
ncbytesappendn(bb,(void*)s,strlen(s)+1); /* include trailing null*/
|
|
/* back up over the trailing null*/
|
|
if(bb->length == 0) return ncbytesfail();
|
|
bb->length--;
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
ncbytesappendn(NCbytes* bb, const void* elem, unsigned long n)
|
|
{
|
|
if(bb == NULL || elem == NULL) return ncbytesfail();
|
|
if(n == 0) {n = strlen((char*)elem);}
|
|
ncbytessetalloc(bb,bb->length+n);
|
|
memcpy((void*)&bb->content[bb->length],(void*)elem,n);
|
|
bb->length += n;
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
ncbytesprepend(NCbytes* bb, char elem)
|
|
{
|
|
int i; /* do not make unsigned */
|
|
if(bb == NULL) return ncbytesfail();
|
|
if(bb->length >= bb->alloc) if(!ncbytessetalloc(bb,0)) return ncbytesfail();
|
|
/* could we trust memcpy? instead */
|
|
for(i=(int)bb->alloc;i>=1;i--) {bb->content[i]=bb->content[i-1];}
|
|
bb->content[0] = elem;
|
|
bb->length++;
|
|
return TRUE;
|
|
}
|
|
|
|
char*
|
|
ncbytesdup(NCbytes* bb)
|
|
{
|
|
char* result = (char*)malloc(bb->length+1);
|
|
memcpy((void*)result,(const void*)bb->content,bb->length);
|
|
result[bb->length] = '\0'; /* just in case it is a string*/
|
|
return result;
|
|
}
|
|
|
|
char*
|
|
ncbytesextract(NCbytes* bb)
|
|
{
|
|
char* result = bb->content;
|
|
bb->alloc = 0;
|
|
bb->length = 0;
|
|
bb->content = NULL;
|
|
return result;
|
|
}
|
|
|
|
int
|
|
ncbytessetcontents(NCbytes* bb, void* contents, unsigned long alloc)
|
|
{
|
|
if(bb == NULL) return ncbytesfail();
|
|
ncbytesclear(bb);
|
|
if(!bb->nonextendible && bb->content != NULL) free(bb->content);
|
|
bb->content = (char*)contents;
|
|
bb->length = alloc;
|
|
bb->alloc = alloc;
|
|
bb->nonextendible = 1;
|
|
return 1;
|
|
}
|
|
|
|
/* Null terminate the byte string without extending its length */
|
|
int
|
|
ncbytesnull(NCbytes* bb)
|
|
{
|
|
ncbytesappend(bb,'\0');
|
|
bb->length--;
|
|
return 1;
|
|
}
|
|
|
|
/* Remove char at position i */
|
|
int
|
|
ncbytesremove(NCbytes* bb, unsigned long pos)
|
|
{
|
|
if(bb == NULL) return ncbytesfail();
|
|
if(bb->length <= pos) return ncbytesfail();
|
|
if(pos < (bb->length - 1)) {
|
|
int copylen = (bb->length - pos) - 1;
|
|
memmove(bb->content+pos,bb->content+pos+1,copylen);
|
|
}
|
|
bb->length--;
|
|
return TRUE;
|
|
}
|