FskErr KprCoAPClientResolverDispose(KprCoAPClientResolver self)
{
FskErr err = kFskErrNone;
if (self) {
KprMemPtrDispose((char *) self->host);
KprCoAPMessageQueueDispose(self->waiting);
if (self->resolver) FskResolverCancel(self->resolver);
KprMemPtrDispose(self);
}
return err;
}
void KprDBStatementDispose(KprDBStatement self)
{
if (self) {
if (self->data) {
sqlite3_finalize(self->data);
self->data = NULL;
}
KprMemPtrDispose(self->bindFormat);
KprMemPtrDispose(self->rowFormat);
KprMemPtrDispose(self->keys);
KprMemPtrDispose(self->values);
FskInstrumentedItemDispose(self);
KprMemPtrDispose(self);
}
}
void KprLibraryServerDispose(KprLibraryServer self)
{
if (self) {
KprLibraryServerStop(self);
FskMutexDispose(self->queryMutex);
FskInstrumentedItemDispose(self);
KprMemPtrDispose(self);
gLibraryServer = NULL;
}
}
void KprDBDispose(KprDB self)
{
if (self) {
if (self->data) {
sqlite3_close(self->data);
gDBCount--;
if (!gDBCount)
sqlite3_shutdown();
}
FskInstrumentedItemDispose(self);
KprMemPtrDispose(self);
}
}
FskErr KprCoAPClientRequestDispose(KprCoAPClientRequest self)
{
FskErr err = kFskErrNone;
if (self) {
FskDebugStr("CoAP ClientRequest Disposed: %x", (int) self);
KprCoAPMessageDispose(self->message);
KprCoAPEndpointDispose(self->endpoint);
KprMemPtrDispose(self);
}
return err;
}
FskErr KprCoAPServerSessionDispose(KprCoAPServerSession self)
{
FskErr err = kFskErrNone;
if (self && KprRetainableRelease(self->retainable)) {
KprCoAPMessageDispose(self->request);
KprCoAPMessageDispose(self->lastResponse);
KprCoAPEndpointDispose(self->endpoint);
KprRetainableDispose(self->retainable);
KprMemPtrDispose(self);
}
return err;
}
static FskErr KprSocketListenerDispose(KprSocketListener self)
{
if (self) {
FskThreadRemoveDataHandler(&self->dataHandler);
FskNetSocketClose(self->socket);
if (self->owner) {
FskListRemove(&self->owner->listeners, self);
}
KprMemPtrDispose(self);
}
return kFskErrNone;
}
FskErr KprDBExecuteFile(KprDB self, char* path)
{
FskErr err = kFskErrNone;
FskFileInfo info;
FskFile fref = NULL;
char *buffer = NULL;;
bailIfError(FskFileGetFileInfo(path, &info));
bailIfError(KprMemPtrNew(info.filesize + 1, &buffer));
bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref));
bailIfError(FskFileRead(fref, info.filesize, buffer, NULL));
buffer[info.filesize] = 0;
sqlite3_exec(self->data, buffer, NULL, NULL, NULL);
bail:
KprMemPtrDispose(buffer);
FskFileClose(fref);
return err;
}
void KprLibrarySessionDispose(KprLibrarySession self)
{
if (self) {
if (self->file.file)
KprFileServerClose(self);
else if (self->http.client)
KprProxyServerClose(self);
else
KprDataServerClose(self);
FskMemPtrDispose(self->authorization);
FskMemPtrDispose(self->url);
FskMemPtrDispose(self->mime);
FskMemPtrDispose(self->info);
FskHTTPServerRequestSetRefcon(self->request, NULL);
FskInstrumentedItemDispose(self);
KprMemPtrDispose(self);
}
}
FskErr KprCoAPClientDispose(KprCoAPClient self)
{
FskErr err = kFskErrNone;
if (self) {
KprCoAPClientResolver resolver;
KprCoAPClientRequest request;
KprCoAPEndpoint endpoint;
resolver = self->resolvers;
while (resolver) {
KprCoAPClientResolver next = resolver->next;
KprCoAPClientResolverDispose(resolver);
resolver = next;
}
request = self->requests;
while (request) {
KprCoAPClientRequest next = request->next;
KprCoAPClientRequestDispose(request);
request = next;
}
endpoint = self->endpoints;
while (endpoint) {
KprCoAPEndpoint next = endpoint->next;
KprCoAPEndpointDispose(endpoint);
endpoint = next;
}
KprMemoryBlockDispose(self->recycleTokens);
KprCoAPReceiverDispose(self->receiver);
FskNetSocketClose(self->socket);
KprMemPtrDispose(self);
FskDebugStr("CoAP Client disposed: %p", self);
}
return err;
}
FskErr KprHTTPClientResetTarget(KprHTTPTarget target)
{
FskErr err = kFskErrNone;
KprMessage message = target->message;
KprMessageClearRequestHeader(message, kprHTTPHeaderIfModifiedSince);
KprMessageClearRequestHeader(message, kprHTTPHeaderIfNoneMatch);
if (target->cached) {
target->cached = NULL;
}
else {
FskAssociativeArrayDispose(message->response.headers);
KprMemPtrDispose(message->response.body);
}
message->error = 0;
message->response.headers = NULL;
message->response.body = NULL;
message->response.size = 0;
target->responseOffset = 0;
FskInstrumentedItemSendMessageDebug(message, kprInstrumentedMessageHTTPContinue, message);
//bail:
return err;
}
Boolean KprHTTPClientPutTargetCache(KprHTTPTarget target)
{
FskErr err = kFskErrNone;
char* control = NULL;
KprHTTPClient self = gKprHTTPClient;
KprMessage message = target->message;
UInt32 date = 0;
UInt32 maxAge = 0;
UInt32 lifetime = 0;
char* start;
char* next;
char* end;
Boolean foundAge = false;
Boolean revalidate = false;
KprHTTPCacheValue cached = NULL;
bailIfError(message->error
|| !FskStrCompareCaseInsensitiveWithLength(message->url, "https://", 8)
|| ((message->status != 200) && (message->status != 203))
|| (message->method && FskStrCompare(message->method, "GET")) // only caching GET method
|| (message->user != NULL) // do not cache request with credentials
|| (message->password != NULL) // do not cache request with credentials
|| (message->response.size == 0) // only caching something
|| (message->response.size > 384000)); // not caching big files
if ((control = KprMessageGetResponseHeader(message, kFskStrCacheControl))) {
start = control;
end = control + FskStrLen(control);
// split
while (start < end) {
if (*start == ',') *start = 0;
start++;
}
start = control;
while (start <= end) {
next = start + FskStrLen(start) + 1;
start = FskStrStripHeadSpace(start);
if (!FskStrCompareCaseInsensitiveWithLength(start, "max-age", 7)) {
bailIfError(!(start = FskStrStripHeadSpace(start + 7)));
bailIfError(*start != '=');
bailIfError(!(start = FskStrStripHeadSpace(start + 1)));
maxAge = FskStrToNum(start);
foundAge = true;
}
else if (!FskStrCompareCaseInsensitiveWithLength(start, "no-cache", 8)) {
revalidate = true;
}
else if (!FskStrCompareCaseInsensitiveWithLength(start, "no-store", 8)) {
BAIL(kFskErrInvalidParameter);
}
else if (!FskStrCompareCaseInsensitiveWithLength(start, "must-revalidate", 15)) {
revalidate = true;
}
start = next;
}
}
KprDateFromHTTP(KprMessageGetResponseHeader(message, kprHTTPHeaderDate), &date);
if (foundAge)
lifetime = maxAge;
else {
UInt32 expire = 0;
KprDateFromHTTP(KprMessageGetResponseHeader(message, kFskStrExpires), &expire);
if (date && expire)
lifetime = (expire > date) ? expire - date : 0;
else if (!KprMessageGetResponseHeader(message, kprHTTPHeaderETag)
&& !KprMessageGetResponseHeader(message, kprHTTPHeaderLastModified))
BAIL(kFskErrInvalidParameter); // not cached
}
if (KprMessageGetResponseHeader(message, kprHTTPHeaderVary))
revalidate = true;
if (!revalidate)
lifetime += 180; // guess 3 minutes
// put in cache
// fprintf(stderr, "%p: CACHE %s for %d (%d)\n", message, message->url, lifetime, revalidate);
bailIfError(KprHTTPCacheValueNew(&cached));
KprDateFromHTTP(KprMessageGetResponseHeader(message, kprHTTPHeaderAge), &cached->age);
cached->date = date;
cached->lifetime = lifetime;
cached->requestDate = target->requestDate;
cached->responseDate = target->responseDate;
cached->status = message->status;
cached->headers = FskAssociativeArrayNew();
{
FskAssociativeArrayIterator iterate = FskAssociativeArrayIteratorNew(message->response.headers);
while (iterate) {
FskAssociativeArrayElementSet(cached->headers, iterate->name, iterate->value, 0, kFskStringType);
iterate = FskAssociativeArrayIteratorNext(iterate);
}
FskAssociativeArrayIteratorDispose(iterate);
}
KprHTTPCacheValueCleanupHeaders(cached);
cached->size = message->response.size;
cached->body = message->response.body;
target->cached = cached;
bailIfError(KprHTTPCachePut(self->cache, message->url, cached));
bail:
if (control) {
// unsplit
start = control;
while (start < end) {
if (*start == 0) *start = ',';
start++;
}
}
if (err == kFskErrNone) return true;
target->cached = NULL;
if (cached)
KprMemPtrDispose(cached);
return false;
}
