bsl_sal.h

浏览该文件的文档.

/*---------------------------------------------------------------------------------------------
 *  This file is part of the openHiTLS project.
 *  Copyright © 2023 Huawei Technologies Co.,Ltd. All rights reserved.
 *  Licensed under the openHiTLS Software license agreement 1.0. See LICENSE in the project root
 *  for license information.
 *---------------------------------------------------------------------------------------------
 */
 
#ifndef BSL_SAL_H
#define BSL_SAL_H
 
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MemCallback {
    void *(*pfMalloc)(uint32_t size);
 
    void (*pfFree)(void *addr);
} BSL_SAL_MemCallback;
 
typedef void *BSL_SAL_ThreadLockHandle;
 
typedef void *BSL_SAL_ThreadId;
 
typedef void *BSL_SAL_Mutex;
 
typedef void *BSL_SAL_CondVar;
 
typedef struct ThreadCallback {
    int32_t (*pfThreadLockNew)(BSL_SAL_ThreadLockHandle *lock);
 
    void (*pfThreadLockFree)(BSL_SAL_ThreadLockHandle lock);
 
    int32_t (*pfThreadReadLock)(BSL_SAL_ThreadLockHandle lock);
 
    int32_t (*pfThreadWriteLock)(BSL_SAL_ThreadLockHandle lock);
 
    int32_t (*pfThreadUnlock)(BSL_SAL_ThreadLockHandle lock);
 
    uint64_t (*pfThreadGetId)(void);
} BSL_SAL_ThreadCallback;
 
int32_t BSL_SAL_RegMemCallback(BSL_SAL_MemCallback *cb);
 
int32_t BSL_SAL_RegThreadCallback(BSL_SAL_ThreadCallback *cb);
 
void *BSL_SAL_Malloc(uint32_t size);
 
void *BSL_SAL_Calloc(uint32_t num, uint32_t size);
 
void *BSL_SAL_Dump(const void *src, uint32_t size);
 
void BSL_SAL_Free(void *value);
 
void *BSL_SAL_Realloc(void *addr, uint32_t newSize, uint32_t oldSize);
 
void BSL_SAL_CleanseData(void *ptr, uint32_t size);
 
void BSL_SAL_ClearFree(void *ptr, uint32_t size);
 
#define BSL_SAL_FREE(value_)                        \
    do {                                        \
        if ((value_) != NULL) {                 \
            BSL_SAL_Free((void *)(value_));         \
            (value_) = NULL;                    \
        }                                       \
    } while (0)
 
#define BSL_SAL_ONCE_INIT 0 // equal to PTHREAD_ONCE_INIT, the pthread symbol is masked.
 
int32_t BSL_SAL_ThreadLockNew(BSL_SAL_ThreadLockHandle *lock);
 
int32_t BSL_SAL_ThreadReadLock(BSL_SAL_ThreadLockHandle lock);
 
int32_t BSL_SAL_ThreadWriteLock(BSL_SAL_ThreadLockHandle lock);
 
int32_t BSL_SAL_ThreadUnlock(BSL_SAL_ThreadLockHandle lock);
 
void BSL_SAL_ThreadLockFree(BSL_SAL_ThreadLockHandle lock);
 
uint64_t BSL_SAL_ThreadGetId(void);
 
typedef void (*BSL_SAL_ThreadInitRoutine)(void);
 
int32_t BSL_SAL_ThreadRunOnce(uint32_t *onceControl, BSL_SAL_ThreadInitRoutine initFunc);
 
int32_t BSL_SAL_ThreadCreate(BSL_SAL_ThreadId *thread, void *(*startFunc)(void *), void *arg);
 
void BSL_SAL_ThreadClose(BSL_SAL_ThreadId thread);
 
int32_t BSL_SAL_CreateCondVar(BSL_SAL_CondVar *condVar);
 
int32_t BSL_SAL_CondSignal(BSL_SAL_CondVar condVar);
 
int32_t BSL_SAL_CondTimedwaitMs(BSL_SAL_Mutex condMutex, BSL_SAL_CondVar condVar, int32_t timeout);
 
int32_t BSL_SAL_DeleteCondVar(BSL_SAL_CondVar condVar);
 
typedef void *bsl_sal_file_handle; // Pointer to file handle
 
int32_t BSL_SAL_FileOpen(bsl_sal_file_handle *stream, const char *path, const char *mode);
 
void BSL_SAL_FileClose(bsl_sal_file_handle stream);
 
int32_t BSL_SAL_FileRead(bsl_sal_file_handle stream, void *buffer, size_t size, size_t num, size_t *len);
 
int32_t BSL_SAL_FileWrite(bsl_sal_file_handle stream, const void *buffer, size_t size, size_t num);
 
int32_t BSL_SAL_FileLength(const char *path, size_t *len);
 
typedef struct {
    uint16_t year;      
    uint8_t  month;     
    uint8_t  day;       
    uint8_t  hour;      
    uint8_t  minute;    
    uint16_t millSec;   
    uint8_t  second;    
    uint8_t  utcSign;   
    uint8_t  utcHour;   
    uint8_t  utcMinute; 
    uint32_t microSec;  
} BSL_TIME;
 
typedef int64_t BslUnixTime;
 
typedef BslUnixTime (*BslTimeFunc)(void);
 
void BSL_SAL_SysTimeFuncReg(BslTimeFunc func);
 
uint32_t BSL_SAL_DateTimeCompare(const BSL_TIME *dateA, const BSL_TIME *dateB, int64_t *diffSec);
 
uint32_t BSL_SAL_SysTimeGet(BSL_TIME *sysTime);
 
BslUnixTime BSL_SAL_CurrentSysTimeGet(void);
 
uint32_t BSL_SAL_DateToUtcTimeConvert(const BSL_TIME *dateTime, int64_t *utcTime);
 
uint32_t BSL_SAL_UtcTimeToDateConvert(int64_t utcTime, BSL_TIME *sysTime);
 
uint32_t BSL_SAL_DateTimeCompareByUs(const BSL_TIME *dateA, const BSL_TIME *dateB);
 
void BSL_SAL_Sleep(uint32_t time);
 
long BSL_SAL_Tick(void);
 
long BSL_SAL_TicksPerSec(void);
 
typedef void *BSL_SAL_SockAddr;
 
int32_t BSL_SAL_Socket(int32_t af, int32_t type, int32_t protocol);
 
int32_t BSL_SAL_SockClose(int32_t sockId);
 
int32_t BSL_SAL_SetSockopt(int32_t sockId, int32_t level, int32_t name, const void *val, uint32_t len);
 
int32_t BSL_SAL_SockListen(int32_t sockId, int32_t backlog);
 
int32_t BSL_SAL_SockBind(int32_t sockId, BSL_SAL_SockAddr addr, size_t len);
 
int32_t BSL_SAL_SockConnect(int32_t sockId, BSL_SAL_SockAddr addr, size_t len);
 
int32_t BSL_SAL_SockSend(int32_t sockId, const void *msg, size_t len, int32_t flags);
 
int32_t BSL_SAL_SockRecv(int32_t sockfd, void *buff, size_t len, int32_t flags);
 
int32_t BSL_SAL_Select(int32_t nfds, void *readfds, void *writefds, void *exceptfds, void *timeout);
 
int32_t BSL_SAL_Ioctlsocket(int32_t sockId, long cmd, unsigned long *arg);
 
int32_t BSL_SAL_SockGetLastSocketError(void);
 
int32_t BSL_SAL_StrcaseCmp(const char *str1, const char *str2);
 
void *BSL_SAL_Memchr(const char *str, int32_t character, size_t count);
 
int32_t BSL_SAL_Atoi(const char *str);
 
uint32_t BSL_SAL_Strnlen(const char *string, uint32_t count);
 
#ifdef __cplusplus
}
#endif
 
#endif // BSL_SAL_H