use prefix hv

base/array.h

@@ -79,7 +79,7 @@ static inline void atype##_cleanup(atype* p) {\
 \
 static inline void atype##_resize(atype* p, int maxsize) {\
     if (maxsize == 0) maxsize = ARRAY_INIT_SIZE;\
-    p->ptr = (type*)safe_realloc(p->ptr, sizeof(type) * maxsize, sizeof(type) * p->maxsize);\
+    p->ptr = (type*)hv_realloc(p->ptr, sizeof(type) * maxsize, sizeof(type) * p->maxsize);\
     p->maxsize = maxsize;\
 }\
 \

base/hbase.c

@@ -21,7 +21,7 @@ long hv_free_cnt() {
     return s_free_cnt;
 }
 
-void* safe_malloc(size_t size) {
+void* hv_malloc(size_t size) {
     hatomic_inc(&s_alloc_cnt);
     void* ptr = malloc(size);
     if (!ptr) {
@@ -31,7 +31,7 @@ void* safe_malloc(size_t size) {
     return ptr;
 }
 
-void* safe_realloc(void* oldptr, size_t newsize, size_t oldsize) {
+void* hv_realloc(void* oldptr, size_t newsize, size_t oldsize) {
     hatomic_inc(&s_alloc_cnt);
     hatomic_inc(&s_free_cnt);
     void* ptr = realloc(oldptr, newsize);
@@ -45,7 +45,7 @@ void* safe_realloc(void* oldptr, size_t newsize, size_t oldsize) {
     return ptr;
 }
 
-void* safe_calloc(size_t nmemb, size_t size) {
+void* hv_calloc(size_t nmemb, size_t size) {
     hatomic_inc(&s_alloc_cnt);
     void* ptr =  calloc(nmemb, size);
     if (!ptr) {
@@ -55,7 +55,7 @@ void* safe_calloc(size_t nmemb, size_t size) {
     return ptr;
 }
 
-void* safe_zalloc(size_t size) {
+void* hv_zalloc(size_t size) {
     hatomic_inc(&s_alloc_cnt);
     void* ptr = malloc(size);
     if (!ptr) {
@@ -66,7 +66,7 @@ void* safe_zalloc(size_t size) {
     return ptr;
 }
 
-void safe_free(void* ptr) {
+void hv_free(void* ptr) {
     if (ptr) {
         free(ptr);
         ptr = NULL;
@@ -74,7 +74,7 @@ void safe_free(void* ptr) {
     }
 }
 
-char* strupper(char* str) {
+char* hv_strupper(char* str) {
     char* p = str;
     while (*p != '\0') {
         if (*p >= 'a' && *p <= 'z') {
@@ -85,7 +85,7 @@ char* strupper(char* str) {
     return str;
 }
 
-char* strlower(char* str) {
+char* hv_strlower(char* str) {
     char* p = str;
     while (*p != '\0') {
         if (*p >= 'A' && *p <= 'Z') {
@@ -96,7 +96,7 @@ char* strlower(char* str) {
     return str;
 }
 
-char* strreverse(char* str) {
+char* hv_strreverse(char* str) {
     if (str == NULL) return NULL;
     char* b = str;
     char* e = str;
@@ -114,7 +114,7 @@ char* strreverse(char* str) {
 }
 
 // n = sizeof(dest_buf)
-char* safe_strncpy(char* dest, const char* src, size_t n) {
+char* hv_strncpy(char* dest, const char* src, size_t n) {
     assert(dest != NULL && src != NULL);
     char* ret = dest;
     while (*src != '\0' && --n > 0) {
@@ -125,7 +125,7 @@ char* safe_strncpy(char* dest, const char* src, size_t n) {
 }
 
 // n = sizeof(dest_buf)
-char* safe_strncat(char* dest, const char* src, size_t n) {
+char* hv_strncat(char* dest, const char* src, size_t n) {
     assert(dest != NULL && src != NULL);
     char* ret = dest;
     while (*dest) {++dest;--n;}
@@ -136,7 +136,7 @@ char* safe_strncat(char* dest, const char* src, size_t n) {
     return ret;
 }
 
-bool strstartswith(const char* str, const char* start) {
+bool hv_strstartswith(const char* str, const char* start) {
     assert(str != NULL && start != NULL);
     while (*str && *start && *str == *start) {
         ++str;
@@ -145,7 +145,7 @@ bool strstartswith(const char* str, const char* start) {
     return *start == '\0';
 }
 
-bool strendswith(const char* str, const char* end) {
+bool hv_strendswith(const char* str, const char* end) {
     assert(str != NULL && end != NULL);
     int len1 = 0;
     int len2 = 0;
@@ -162,12 +162,12 @@ bool strendswith(const char* str, const char* end) {
     return true;
 }
 
-bool strcontains(const char* str, const char* sub) {
+bool hv_strcontains(const char* str, const char* sub) {
     assert(str != NULL && sub != NULL);
     return strstr(str, sub) != NULL;
 }
 
-char* strrchr_dir(const char* filepath) {
+char* hv_strrchr_dir(const char* filepath) {
     char* p = (char*)filepath;
     while (*p) ++p;
     while (--p >= filepath) {
@@ -182,12 +182,12 @@ char* strrchr_dir(const char* filepath) {
 }
 
 const char* hv_basename(const char* filepath) {
-    const char* pos = strrchr_dir(filepath);
+    const char* pos = hv_strrchr_dir(filepath);
     return pos ? pos+1 : filepath;
 }
 
 const char* hv_suffixname(const char* filename) {
-    const char* pos = strrchr_dot(filename);
+    const char* pos = hv_strrchr_dot(filename);
     return pos ? pos+1 : "";
 }
 
@@ -196,7 +196,7 @@ int hv_mkdir_p(const char* dir) {
         return EEXIST;
     }
     char tmp[MAX_PATH] = {0};
-    safe_strncpy(tmp, dir, sizeof(tmp));
+    hv_strncpy(tmp, dir, sizeof(tmp));
     char* p = tmp;
     char delim = '/';
     while (*p) {
@@ -226,7 +226,7 @@ int hv_rmdir_p(const char* dir) {
         return EPERM;
     }
     char tmp[MAX_PATH] = {0};
-    safe_strncpy(tmp, dir, sizeof(tmp));
+    hv_strncpy(tmp, dir, sizeof(tmp));
     char* p = tmp;
     while (*p) ++p;
     while (--p >= tmp) {
@@ -283,20 +283,6 @@ size_t hv_filesize(const char* filepath) {
     return st.st_size;
 }
 
-bool getboolean(const char* str) {
-    if (str == NULL) return false;
-    int len = strlen(str);
-    if (len == 0) return false;
-    switch (len) {
-    case 1: return *str == '1' || *str == 'y' || *str == 'Y';
-    case 2: return stricmp(str, "on") == 0;
-    case 3: return stricmp(str, "yes") == 0;
-    case 4: return stricmp(str, "true") == 0;
-    case 6: return stricmp(str, "enable") == 0;
-    default: return false;
-    }
-}
-
 char* get_executable_path(char* buf, int size) {
 #ifdef OS_WIN
     GetModuleFileName(NULL, buf, size);
@@ -313,7 +299,7 @@ char* get_executable_path(char* buf, int size) {
 char* get_executable_dir(char* buf, int size) {
     char filepath[MAX_PATH] = {0};
     get_executable_path(filepath, sizeof(filepath));
-    char* pos = strrchr_dir(filepath);
+    char* pos = hv_strrchr_dir(filepath);
     if (pos) {
         *pos = '\0';
         strncpy(buf, filepath, size);
@@ -324,7 +310,7 @@ char* get_executable_dir(char* buf, int size) {
 char* get_executable_file(char* buf, int size) {
     char filepath[MAX_PATH] = {0};
     get_executable_path(filepath, sizeof(filepath));
-    char* pos = strrchr_dir(filepath);
+    char* pos = hv_strrchr_dir(filepath);
     if (pos) {
         strncpy(buf, pos+1, size);
     }
@@ -361,3 +347,17 @@ void hv_random_string(char *buf, int len) {
     }
     buf[i] = '\0';
 }
+
+bool hv_getboolean(const char* str) {
+    if (str == NULL) return false;
+    int len = strlen(str);
+    if (len == 0) return false;
+    switch (len) {
+    case 1: return *str == '1' || *str == 'y' || *str == 'Y';
+    case 2: return stricmp(str, "on") == 0;
+    case 3: return stricmp(str, "yes") == 0;
+    case 4: return stricmp(str, "true") == 0;
+    case 6: return stricmp(str, "enable") == 0;
+    default: return false;
+    }
+}

base/hbase.h

@@ -7,16 +7,16 @@
 
 BEGIN_EXTERN_C
 
-//--------------------safe alloc/free---------------------------
-HV_EXPORT void* safe_malloc(size_t size);
-HV_EXPORT void* safe_realloc(void* oldptr, size_t newsize, size_t oldsize);
-HV_EXPORT void* safe_calloc(size_t nmemb, size_t size);
-HV_EXPORT void* safe_zalloc(size_t size);
-HV_EXPORT void  safe_free(void* ptr);
+//--------------------alloc/free---------------------------
+HV_EXPORT void* hv_malloc(size_t size);
+HV_EXPORT void* hv_realloc(void* oldptr, size_t newsize, size_t oldsize);
+HV_EXPORT void* hv_calloc(size_t nmemb, size_t size);
+HV_EXPORT void* hv_zalloc(size_t size);
+HV_EXPORT void  hv_free(void* ptr);
 
 #define HV_ALLOC(ptr, size)\
     do {\
-        *(void**)&(ptr) = safe_zalloc(size);\
+        *(void**)&(ptr) = hv_zalloc(size);\
         printd("alloc(%p, size=%llu)\tat [%s:%d:%s]\n", ptr, (unsigned long long)size, __FILE__, __LINE__, __FUNCTION__);\
     } while(0)
 
@@ -25,7 +25,7 @@ HV_EXPORT void  safe_free(void* ptr);
 #define HV_FREE(ptr)\
     do {\
         if (ptr) {\
-            safe_free(ptr);\
+            hv_free(ptr);\
             printd("free( %p )\tat [%s:%d:%s]\n", ptr, __FILE__, __LINE__, __FUNCTION__);\
             ptr = NULL;\
         }\
@@ -55,33 +55,33 @@ HV_INLINE void hv_memcheck() {
 }
 #define HV_MEMCHECK    atexit(hv_memcheck);
 
-//--------------------safe string-------------------------------
-HV_EXPORT char* strupper(char* str);
-HV_EXPORT char* strlower(char* str);
-HV_EXPORT char* strreverse(char* str);
+//--------------------string-------------------------------
+HV_EXPORT char* hv_strupper(char* str);
+HV_EXPORT char* hv_strlower(char* str);
+HV_EXPORT char* hv_strreverse(char* str);
 
-HV_EXPORT bool strstartswith(const char* str, const char* start);
-HV_EXPORT bool strendswith(const char* str, const char* end);
-HV_EXPORT bool strcontains(const char* str, const char* sub);
+HV_EXPORT bool hv_strstartswith(const char* str, const char* start);
+HV_EXPORT bool hv_strendswith(const char* str, const char* end);
+HV_EXPORT bool hv_strcontains(const char* str, const char* sub);
 
 // strncpy n = sizeof(dest_buf)-1
-// safe_strncpy n = sizeof(dest_buf)
-HV_EXPORT char* safe_strncpy(char* dest, const char* src, size_t n);
+// hv_strncpy n = sizeof(dest_buf)
+HV_EXPORT char* hv_strncpy(char* dest, const char* src, size_t n);
 
 // strncat n = sizeof(dest_buf)-1-strlen(dest)
-// safe_strncpy n = sizeof(dest_buf)
-HV_EXPORT char* safe_strncat(char* dest, const char* src, size_t n);
+// hv_strncpy n = sizeof(dest_buf)
+HV_EXPORT char* hv_strncat(char* dest, const char* src, size_t n);
 
 #if !HAVE_STRLCPY
-#define strlcpy safe_strncpy
+#define strlcpy hv_strncpy
 #endif
 
 #if !HAVE_STRLCAT
-#define strlcat safe_strncat
+#define strlcat hv_strncat
 #endif
 
-#define strrchr_dot(str) strrchr(str, '.')
-HV_EXPORT char* strrchr_dir(const char* filepath);
+#define hv_strrchr_dot(str) strrchr(str, '.')
+HV_EXPORT char* hv_strrchr_dir(const char* filepath);
 
 // basename
 HV_EXPORT const char* hv_basename(const char* filepath);
@@ -97,17 +97,17 @@ HV_EXPORT bool hv_isfile(const char* path);
 HV_EXPORT bool hv_islink(const char* path);
 HV_EXPORT size_t hv_filesize(const char* filepath);
 
-// 1 y on yes true enable
-HV_EXPORT bool getboolean(const char* str);
-
 HV_EXPORT char* get_executable_path(char* buf, int size);
 HV_EXPORT char* get_executable_dir(char* buf, int size);
 HV_EXPORT char* get_executable_file(char* buf, int size);
 HV_EXPORT char* get_run_dir(char* buf, int size);
 
 // random
-HV_EXPORT int   hv_rand(int min, int max);
-HV_EXPORT void  hv_random_string(char *buf, int len);
+HV_EXPORT int  hv_rand(int min, int max);
+HV_EXPORT void hv_random_string(char *buf, int len);
+
+// 1 y on yes true enable
+HV_EXPORT bool hv_getboolean(const char* str);
 
 END_EXTERN_C
 

base/hbuf.h

@@ -95,7 +95,7 @@ public:
             HV_ALLOC(base, cap);
         }
         else {
-            base = (char*)safe_realloc(base, cap, len);
+            base = (char*)hv_realloc(base, cap, len);
         }
         len = cap;
         cleanup_ = true;
@@ -128,7 +128,7 @@ public:
     void push_front(void* ptr, size_t len) {
         if (len > this->len - _size) {
             size_t newsize = MAX(this->len, len)*2;
-            base = (char*)safe_realloc(base, newsize, this->len);
+            base = (char*)hv_realloc(base, newsize, this->len);
             this->len = newsize;
         }
 
@@ -146,7 +146,7 @@ public:
     void push_back(void* ptr, size_t len) {
         if (len > this->len - _size) {
             size_t newsize = MAX(this->len, len)*2;
-            base = (char*)safe_realloc(base, newsize, this->len);
+            base = (char*)hv_realloc(base, newsize, this->len);
             this->len = newsize;
         }
         else if (len > this->len - _offset - _size) {

base/queue.h

@@ -72,7 +72,7 @@ static inline void qtype##_cleanup(qtype* p) {\
 \
 static inline void qtype##_resize(qtype* p, int maxsize) {\
     if (maxsize == 0) maxsize = QUEUE_INIT_SIZE;\
-    p->ptr = (type*)safe_realloc(p->ptr, sizeof(type) * maxsize, sizeof(type) * p->maxsize);\
+    p->ptr = (type*)hv_realloc(p->ptr, sizeof(type) * maxsize, sizeof(type) * p->maxsize);\
     p->maxsize = maxsize;\
 }\
 \

cpputil/iniparser.cpp

@@ -330,7 +330,7 @@ void IniParser::SetValue(const std::string& key, const std::string& value, const
 template<>
 HV_EXPORT bool IniParser::Get(const std::string& key, const std::string& section, bool defvalue) {
     std::string str = GetValue(key, section);
-    return str.empty() ? defvalue : getboolean(str.c_str());
+    return str.empty() ? defvalue : hv_getboolean(str.c_str());
 }
 
 template<>

docs/API.md

@@ -94,22 +94,20 @@
 - varint_decode
 
 ### hbase.h
-- safe_malloc
-- safe_calloc
-- safe_realloc
-- safe_zalloc
-- safe_strncpy
-- safe_strncat
-- strlower
-- strupper
-- strreverse
-- strstartswith
-- strendswith
-- strcontains
-- strlcpy
-- strlcat
-- strrchr_dot
-- strrchr_dir
+- hv_malloc
+- hv_calloc
+- hv_realloc
+- hv_zalloc
+- hv_strncpy
+- hv_strncat
+- hv_strlower
+- hv_strupper
+- hv_strreverse
+- hv_strstartswith
+- hv_strendswith
+- hv_strcontains
+- hv_strrchr_dot
+- hv_strrchr_dir
 - hv_basename
 - hv_suffixname
 - hv_mkdir_p
@@ -119,13 +117,13 @@
 - hv_isfile
 - hv_islink
 - hv_filesize
-- getboolean
 - get_executable_path
 - get_executable_dir
 - get_executable_file
 - get_run_dir
 - hv_rand
 - hv_random_string
+- hv_getboolean
 
 ### hversion.h
 - hv_version

event/evport.c

@@ -20,7 +20,7 @@ typedef struct evport_ctx_s {
 static void evport_ctx_resize(evport_ctx_t* evport_ctx, int size) {
     int bytes = sizeof(port_event_t) * size;
     int oldbytes = sizeof(port_event_t) * evport_ctx->capacity;
-    evport_ctx->events = (port_event_t*)safe_realloc(evport_ctx->events, bytes, oldbytes);
+    evport_ctx->events = (port_event_t*)hv_realloc(evport_ctx->events, bytes, oldbytes);
     evport_ctx->capacity = size;
 }
 

event/hevent.c

@@ -695,7 +695,7 @@ void hio_alloc_readbuf(hio_t* io, int len) {
         return;
     }
     if (hio_is_alloced_readbuf(io)) {
-        io->readbuf.base = (char*)safe_realloc(io->readbuf.base, len, io->readbuf.len);
+        io->readbuf.base = (char*)hv_realloc(io->readbuf.base, len, io->readbuf.len);
     } else {
         HV_ALLOC(io->readbuf.base, len);
     }

event/kqueue.c

@@ -26,8 +26,8 @@ typedef struct kqueue_ctx_s {
 static void kqueue_ctx_resize(kqueue_ctx_t* kqueue_ctx, int size) {
     int bytes = sizeof(struct kevent) * size;
     int oldbytes = sizeof(struct kevent) * kqueue_ctx->capacity;
-    kqueue_ctx->changes = (struct kevent*)safe_realloc(kqueue_ctx->changes, bytes, oldbytes);
-    kqueue_ctx->events = (struct kevent*)safe_realloc(kqueue_ctx->events, bytes, oldbytes);
+    kqueue_ctx->changes = (struct kevent*)hv_realloc(kqueue_ctx->changes, bytes, oldbytes);
+    kqueue_ctx->events = (struct kevent*)hv_realloc(kqueue_ctx->events, bytes, oldbytes);
     kqueue_ctx->capacity = size;
 }
 

examples/hmain_test.cpp

@@ -101,7 +101,7 @@ int parse_confile(const char* confile) {
     // log_fsync
     str = g_conf_ctx.parser->GetValue("log_fsync");
     if (!str.empty()) {
-        logger_enable_fsync(hlog, getboolean(str.c_str()));
+        logger_enable_fsync(hlog, hv_getboolean(str.c_str()));
     }
     // first log here
     hlogi("%s version: %s", g_main_ctx.program_name, hv_compile_version());

examples/httpd/httpd.cpp

@@ -79,7 +79,7 @@ int parse_confile(const char* confile) {
     // log_fsync
     str = ini.GetValue("log_fsync");
     if (!str.empty()) {
-        logger_enable_fsync(hlog, getboolean(str.c_str()));
+        logger_enable_fsync(hlog, hv_getboolean(str.c_str()));
     }
     hlogi("%s version: %s", g_main_ctx.program_name, hv_compile_version());
     hlog_fsync();

http/Http2Parser.cpp

@@ -214,7 +214,7 @@ int Http2Parser::SubmitRequest(HttpRequest* req) {
     for (auto& header : req->headers) {
         name = header.first.c_str();
         value = header.second.c_str();
-        strlower((char*)name);
+        hv_strlower((char*)name);
         if (strcmp(name, "connection") == 0) {
             // HTTP2 default keep-alive
             continue;
@@ -262,7 +262,7 @@ int Http2Parser::SubmitResponse(HttpResponse* res) {
     for (auto& header : res->headers) {
         name = header.first.c_str();
         value = header.second.c_str();
-        strlower((char*)name);
+        hv_strlower((char*)name);
         if (strcmp(name, "connection") == 0) {
             // HTTP2 default keep-alive
             continue;

http/HttpMessage.cpp

@@ -239,7 +239,7 @@ HV_EXPORT bool HttpMessage::Get(const char* key, bool defvalue) {
         }
         else if (value.is_string()) {
             std::string str = value;
-            return getboolean(str.c_str());
+            return hv_getboolean(str.c_str());
         }
         else if (value.is_null()) {
             return false;
@@ -253,7 +253,7 @@ HV_EXPORT bool HttpMessage::Get(const char* key, bool defvalue) {
     }
     else {
         std::string str = GetString(key);
-        return str.empty() ? defvalue : getboolean(str.c_str());
+        return str.empty() ? defvalue : hv_getboolean(str.c_str());
     }
 }
 

http/server/HttpHandler.cpp

@@ -137,7 +137,7 @@ int HttpHandler::defaultStaticHandler() {
     }
     bool is_dir = filepath.c_str()[filepath.size()-1] == '/';
     bool is_index_of = false;
-    if (service->index_of.size() != 0 && strstartswith(req_path, service->index_of.c_str())) {
+    if (service->index_of.size() != 0 && hv_strstartswith(req_path, service->index_of.c_str())) {
         is_index_of = true;
     }
     if (!is_dir || is_index_of) {

http/server/HttpService.cpp

@@ -1,6 +1,6 @@
 #include "HttpService.h"
 
-#include "hbase.h" // import strendswith
+#include "hbase.h" // import hv_strendswith
 
 namespace hv {
 
@@ -77,7 +77,7 @@ int HttpService::GetApi(HttpRequest* req, http_handler** handler) {
         while (*kp && *vp) {
             if (kp[0] == '*') {
                 // wildcard *
-                match = strendswith(vp, kp+1);
+                match = hv_strendswith(vp, kp+1);
                 break;
             } else if (*kp != *vp) {
                 match = false;

mqtt/mqtt_client.c

@@ -381,7 +381,7 @@ void mqtt_client_stop(mqtt_client_t* cli) {
 
 void mqtt_client_set_id(mqtt_client_t* cli, const char* id) {
     if (!cli || !id) return;
-    safe_strncpy(cli->client_id, id, sizeof(cli->client_id));
+    hv_strncpy(cli->client_id, id, sizeof(cli->client_id));
 }
 
 void mqtt_client_set_will(mqtt_client_t* cli, mqtt_message_t* will) {
@@ -395,10 +395,10 @@ void mqtt_client_set_will(mqtt_client_t* cli, mqtt_message_t* will) {
 void mqtt_client_set_auth(mqtt_client_t* cli, const char* username, const char* password) {
     if (!cli) return;
     if (username) {
-        safe_strncpy(cli->username, username, sizeof(cli->username));
+        hv_strncpy(cli->username, username, sizeof(cli->username));
     }
     if (password) {
-        safe_strncpy(cli->password, password, sizeof(cli->password));
+        hv_strncpy(cli->password, password, sizeof(cli->password));
     }
 }
 
@@ -454,7 +454,7 @@ int mqtt_client_reconnect(mqtt_client_t* cli) {
 
 int mqtt_client_connect(mqtt_client_t* cli, const char* host, int port, int ssl) {
     if (!cli) return -1;
-    safe_strncpy(cli->host, host, sizeof(cli->host));
+    hv_strncpy(cli->host, host, sizeof(cli->host));
     cli->port = port;
     cli->ssl = ssl;
     hio_t* io = hio_create_socket(cli->loop, host, port, HIO_TYPE_TCP, HIO_CLIENT_SIDE);