LIB_EXPORT
rc_t CC
XFS_HttpStreamRead_ZHR (
const struct XFSHttpStream * self,
void * Buffer,
size_t Size,
size_t * NumRead
)
{
struct XFSHttpStream * Stream = ( struct XFSHttpStream * ) self;
if ( NumRead != NULL ) {
* NumRead = 0;
}
if ( Stream == NULL || Buffer == NULL || Size == 0 || NumRead == NULL ) {
return XFS_RC ( rcNull );
}
if ( Stream -> last_error != 0 ) {
return Stream -> last_error;
}
if ( Stream -> completed ) {
* NumRead = 0;
return 0;
}
if ( Stream -> str == NULL ) {
_HttpStreamCloseInternals_ZHR ( Stream );
Stream -> last_error = XFS_RC ( rcInvalid );
return Stream -> last_error;
}
Stream -> last_error = KStreamRead (
Stream -> str,
Buffer,
Size,
NumRead
);
if ( Stream -> last_error == 0 ) {
if ( * NumRead == 0 ) {
_HttpStreamCloseInternals_ZHR ( Stream );
Stream -> completed = true;
}
}
else {
_HttpStreamCloseInternals_ZHR ( Stream );
}
return self -> last_error;
} /* XFS_HttpStreamRead_ZHR */
static
rc_t CC KBufferedStreamRead ( const KBufferedStream *cself,
void *buffer, size_t bsize, size_t *num_read )
{
KBufferedStream * self = ( KBufferedStream * ) cself;
size_t avail = self -> in_limit - self -> in_marker;
if ( avail == 0 )
{
size_t limit;
rc_t rc = KStreamRead ( self -> in, self -> in_buffer, self -> buffer_size, & limit );
if ( rc != 0 )
{
* num_read = 0;
return rc;
}
self -> in_marker = 0;
avail = self -> in_limit = limit;
if ( limit == 0 )
{
* num_read = 0;
return 0;
}
}
if ( bsize > avail )
bsize = avail;
memcpy ( buffer, & self -> in_buffer [ self -> in_marker ], bsize );
self -> in_marker += bsize;
* num_read = bsize;
return 0;
}
static rc_t CC KNSManagerNewReleaseVersionImpl(const struct KNSManager *self,
SraReleaseVersion *newVersion)
{
rc_t rc = 0;
KDataBuffer result;
KHttpRequest *req = NULL;
KHttpResult *rslt = NULL;
if (newVersion == NULL) {
return RC(rcNS, rcArgv, rcAccessing, rcParam, rcNull);
}
memset(newVersion, 0, sizeof *newVersion);
if (self == NULL) {
return RC(rcNS, rcArgv, rcAccessing, rcSelf, rcNull);
}
memset(&result, 0, sizeof result);
if (rc == 0) {
rc = KNSManagerMakeRequest(self, &req, 0x01010000, NULL,
"https://ftp-trace.ncbi.nlm.nih.gov/sra/sdk/current/sratoolkit.current.version"
);
}
if (rc == 0) {
rc = KHttpRequestGET(req, &rslt);
}
if (rc == 0) {
uint32_t code = 0;
rc = KHttpResultStatus(rslt, &code, NULL, 0, NULL);
if (rc == 0) {
if (code != 200) {
rc = RC(rcNS, rcFile, rcReading, rcFile, rcInvalid);
}
}
}
if (rc == 0) {
size_t total = 0;
KStream *response = NULL;
rc = KHttpResultGetInputStream(rslt, &response);
if (rc == 0) {
rc = KDataBufferMakeBytes(&result, 1024);
}
while (rc == 0) {
size_t num_read = 0;
uint8_t *base = NULL;
uint64_t avail = result.elem_count - total;
if (avail < 256) {
rc = KDataBufferResize(&result, result.elem_count + 1024);
if (rc != 0) {
break;
}
}
base = result.base;
rc = KStreamRead(response, &base[total], result.elem_count - total,
&num_read);
if (num_read > 0 || rc != 0) {
DBGMSG(DBG_VFS, DBG_FLAG(DBG_VFS), ("KStreamRead"
"(sratoolkit.current.version, %zu) = %R\n", num_read, rc));
}
if (rc != 0) {
/* TBD - look more closely at rc */
if (num_read > 0) {
rc = 0;
}
else {
break;
}
}
if (num_read == 0) {
break;
}
total += num_read;
}
RELEASE(KStream, response);
if (rc == 0) {
DBGMSG(DBG_VFS, DBG_FLAG(DBG_VFS),
("sratoolkit.current.version (%zu)\n", total));
result.elem_count = total;
}
}
if (rc == 0) {
const char *start = (const void*)(result.base);
size_t size = KDataBufferBytes(&result);
DBGMSG(DBG_VFS, DBG_FLAG(DBG_VFS),
("sratoolkit.current.version = '%.*s'\n", (uint32_t)size, start));
rc = SraReleaseVersionInit(newVersion, start, size);
}
KDataBufferWhack(&result);
RELEASE(KHttpResult, rslt);
RELEASE(KHttpRequest, req);
return rc;
}
