net_async.h

Go to the documentation of this file.

/*
 * Copyright 2013-2018 Guardtime, Inc.
 *
 * This file is part of the Guardtime client SDK.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES, CONDITIONS, OR OTHER LICENSES OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 * "Guardtime" and "KSI" are trademarks or registered trademarks of
 * Guardtime, Inc., and no license to trademarks is granted; Guardtime
 * reserves and retains all trademark rights.
 */
 
#ifndef KSI_NET_ASYNC_H_
#define KSI_NET_ASYNC_H_
 
#include "types.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
        void KSI_AsyncHandle_free(KSI_AsyncHandle *o);
 
        int KSI_AbstractAsyncHandle_new(KSI_CTX *ctx, KSI_AsyncHandle **o);
 
        int KSI_AsyncAggregationHandle_new(KSI_CTX *ctx, KSI_AggregationReq *req, KSI_AsyncHandle **o);
 
        int KSI_AsyncSigningHandle_new(KSI_CTX *ctx, KSI_DataHash *rootHash, KSI_uint64_t rootLevel, KSI_AsyncHandle **o);
 
        int KSI_AsyncExtendHandle_new(KSI_CTX *ctx, KSI_ExtendReq *req, KSI_AsyncHandle **o);
 
        int KSI_AsyncExtendingHandle_new(KSI_CTX *ctx, const KSI_Signature *sig, const KSI_PublicationRecord *pubRec, KSI_AsyncHandle **o);
 
        KSI_DEFINE_REF(KSI_AsyncHandle);
 
        int KSI_AsyncHandle_setRequestCtx(KSI_AsyncHandle *o, void *reqCtx, void (*reqCtx_free)(void*));
 
        int KSI_AsyncHandle_getRequestCtx(const KSI_AsyncHandle *o, const void **reqCtx);
 
        int KSI_AsyncHandle_getState(const KSI_AsyncHandle *h, int *state);
 
        int KSI_AsyncHandle_getError(const KSI_AsyncHandle *h, int *error);
 
        int KSI_AsyncHandle_getExtError(const KSI_AsyncHandle *h, long *ext);
 
        int KSI_AsyncHandle_getErrorMessage(const KSI_AsyncHandle *h, KSI_Utf8String **msg);
 
        int KSI_AsyncHandle_getRequestId(const KSI_AsyncHandle *h, KSI_uint64_t *id);
 
        int KSI_AsyncHandle_getParentId(const KSI_AsyncHandle *h, size_t *parentId);
 
        int KSI_AsyncHandle_getAggregationReq(const KSI_AsyncHandle *h, KSI_AggregationReq **req);
 
        int KSI_AsyncHandle_getExtendReq(const KSI_AsyncHandle *h, KSI_ExtendReq **req);
 
        int KSI_AsyncHandle_getAggregationResp(const KSI_AsyncHandle *h, KSI_AggregationResp **resp);
 
        int KSI_AsyncHandle_getExtendResp(const KSI_AsyncHandle *h, KSI_ExtendResp **resp);
 
        int KSI_AsyncHandle_getSignature(const KSI_AsyncHandle *h, KSI_Signature **signature);
 
        int KSI_AsyncHandle_getConfig(const KSI_AsyncHandle *h, KSI_Config **config);
 
        void KSI_AsyncClient_free(KSI_AsyncClient *c);
 
        int KSI_AbstractAsyncClient_new(KSI_CTX *ctx, KSI_AsyncClient **c);
 
 
        void KSI_AsyncService_free(KSI_AsyncService *service);
 
        int KSI_SigningAsyncService_new(KSI_CTX *ctx, KSI_AsyncService **service);
 
        int KSI_ExtendingAsyncService_new(KSI_CTX *ctx, KSI_AsyncService **service);
 
        int KSI_AsyncService_addRequest(KSI_AsyncService *service, KSI_AsyncHandle *handle);
 
        int KSI_AsyncService_run(KSI_AsyncService *service, KSI_AsyncHandle **handle, size_t *waiting);
 
        typedef enum KSI_AsyncHandleState_en {
                KSI_ASYNC_STATE_UNDEFINED = 0,
 
                /*
                 * Handle internal states.
                 */
 
                KSI_ASYNC_STATE_WAITING_FOR_DISPATCH,
                KSI_ASYNC_STATE_WAITING_FOR_RESPONSE,
 
 
                /*
                 * Request final states.
                 */
 
                KSI_ASYNC_STATE_RESPONSE_RECEIVED,
                KSI_ASYNC_STATE_PUSH_CONFIG_RECEIVED,
                KSI_ASYNC_STATE_ERROR,
 
                /*
                 * Handle final states.
                 */
 
                KSI_ASYNC_STATE_ERROR_NOTICE
        } KSI_AsyncHandleState;
 
        int KSI_AsyncService_getPendingCount(KSI_AsyncService *s, size_t *count);
 
        int KSI_AsyncService_getReceivedCount(KSI_AsyncService *s, size_t *count);
 
        typedef int (*KSI_AsyncServiceCallback_ConnectState)(KSI_CTX *ctx, size_t id, void *userp, const char *host, int connected);
 
        typedef int (*KSI_AsyncServiceCallback_configConsolidate)(KSI_CTX *ctx, size_t id, void *userp, KSI_Config *haConfig, KSI_Config *respConfig);
 
        typedef enum KSI_AsyncOption_en {
 
                KSI_ASYNC_OPT_CON_TIMEOUT = 0,
 
                KSI_ASYNC_OPT_RCV_TIMEOUT,
 
                KSI_ASYNC_OPT_SND_TIMEOUT,
 
                KSI_ASYNC_OPT_REQUEST_CACHE_SIZE,
 
                KSI_ASYNC_OPT_MAX_REQUEST_COUNT,
 
                KSI_ASYNC_OPT_PUSH_CONF_CALLBACK,
 
                KSI_ASYNC_OPT_CONF_CONSOLIDATE_CALLBACK,
 
                KSI_ASYNC_OPT_HA_SUBSERVICE_LIST,
 
                KSI_ASYNC_OPT_CONNECTION_STATE_CALLBACK,
 
                KSI_ASYNC_OPT_CALLBACK_USERDATA,
 
                KSI_ASYNC_OPT_HMAC_ALGORITHM,
 
                __KSI_ASYNC_OPT_COUNT
        } KSI_AsyncOption;
 
 
        int KSI_AsyncService_setOption(KSI_AsyncService *s, const int option, void *value);
 
        int KSI_AsyncService_getOption(const KSI_AsyncService *s, const int option, void *value);
 
        int KSI_AsyncService_setEndpoint(KSI_AsyncService *service, const char *uri, const char *loginId, const char *key);
 
        int KSI_AsyncService_addEndpoint(KSI_AsyncService *service, const char *uri, const char *loginId, const char *key);
 
#ifdef __cplusplus
}
#endif
 
#endif /* KSI_NET_ASYNC_H_ */