diff --git a/config.h.in b/config.h.in index af0ef7c4..d17335cb 100644 --- a/config.h.in +++ b/config.h.in @@ -67,6 +67,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H +/* Enable IPv6 support in libudns */ +#undef HAVE_IPv6 + /* Define to 1 if you have the `kqueue' function. */ #undef HAVE_KQUEUE diff --git a/configure b/configure index e3cacea4..aecff132 100755 --- a/configure +++ b/configure @@ -15562,6 +15562,10 @@ done +$as_echo "#define HAVE_IPv6 1" >>confdefs.h + + + if test -z "$USE_SYSTEM_SHARED_LIB_TRUE"; then : else diff --git a/src/cache.c b/src/cache.c index 79b605a9..00de6860 100644 --- a/src/cache.c +++ b/src/cache.c @@ -27,8 +27,9 @@ #include #include + #include "cache.h" -#include "mm-wrapper.h" +#include "utils.h" #ifdef __MINGW32__ #include "win32.h" @@ -92,12 +93,12 @@ int cache_delete(struct cache *cache, int keep_data) cache->free_cb(entry->data); } } - SS_SAFEFREE(entry->key); - SS_SAFEFREE(entry); + ss_free(entry->key); + ss_free(entry); } } - SS_SAFEFREE(cache); + ss_free(cache); return 0; } @@ -130,11 +131,11 @@ int cache_remove(struct cache *cache, char *key, size_t key_len) if (cache->free_cb) { cache->free_cb(tmp->data); } else { - SS_SAFEFREE(tmp->data); + ss_free(tmp->data); } } - SS_SAFEFREE(tmp->key); - SS_SAFEFREE(tmp); + ss_free(tmp->key); + ss_free(tmp); } return 0; @@ -230,7 +231,7 @@ int cache_insert(struct cache *cache, char *key, size_t key_len, void *data) return ENOMEM; } - entry->key = SS_SAFEMALLOC(key_len); + entry->key = ss_malloc(key_len); memcpy(entry->key, key, key_len); entry->data = data; HASH_ADD_KEYPTR(hh, cache->entries, entry->key, key_len, entry); @@ -242,11 +243,11 @@ int cache_insert(struct cache *cache, char *key, size_t key_len, void *data) if (cache->free_cb) { cache->free_cb(entry->data); } else { - SS_SAFEFREE(entry->data); + ss_free(entry->data); } } - SS_SAFEFREE(entry->key); - SS_SAFEFREE(entry); + ss_free(entry->key); + ss_free(entry); break; } } diff --git a/src/encrypt.c b/src/encrypt.c index 050015dd..1c8e605c 100644 --- a/src/encrypt.c +++ b/src/encrypt.c @@ -76,7 +76,6 @@ #include "cache.h" #include "encrypt.h" #include "utils.h" -#include "mm-wrapper.h" #define OFFSET_ROL(p, o) ((uint64_t)(*(p + o)) << (8 * o)) @@ -214,17 +213,18 @@ static int safe_memcmp(const void *s1, const void *s2, size_t n) int balloc(buffer_t *ptr, size_t capacity) { memset(ptr, 0, sizeof(buffer_t)); - ptr->array = SS_SAFEMALLOC(capacity); + ptr->array = ss_malloc(capacity); ptr->capacity = capacity; return capacity; } int brealloc(buffer_t *ptr, size_t len, size_t capacity) { - if (ptr == NULL) return -1; + if (ptr == NULL) + return -1; size_t real_capacity = max(len, capacity); if (ptr->capacity < real_capacity) { - ptr->array = SS_SAFEREALLOC(ptr->array, real_capacity); + ptr->array = ss_realloc(ptr->array, real_capacity); ptr->capacity = real_capacity; } return real_capacity; @@ -232,12 +232,13 @@ int brealloc(buffer_t *ptr, size_t len, size_t capacity) void bfree(buffer_t *ptr) { - if (ptr == NULL) return; + if (ptr == NULL) + return; ptr->idx = 0; ptr->len = 0; ptr->capacity = 0; if (ptr->array != NULL) { - SS_SAFEFREE(ptr->array); + ss_free(ptr->array); } } @@ -308,8 +309,8 @@ static void merge(uint8_t *left, int llength, uint8_t *right, } } - SS_SAFEFREE(ltmp); - SS_SAFEFREE(rtmp); + ss_free(ltmp); + ss_free(rtmp); } static void merge_sort(uint8_t array[], int length, @@ -367,8 +368,8 @@ void enc_table_init(const char *pass) uint64_t key = 0; uint8_t *digest; - enc_table = SS_SAFEMALLOC(256); - dec_table = SS_SAFEMALLOC(256); + enc_table = ss_malloc(256); + dec_table = ss_malloc(256); digest = enc_md5((const uint8_t *)pass, strlen(pass), NULL); diff --git a/src/jconf.c b/src/jconf.c index 6eedc279..8f196149 100644 --- a/src/jconf.c +++ b/src/jconf.c @@ -29,7 +29,6 @@ #include "jconf.h" #include "json.h" #include "string.h" -#include "mm-wrapper.h" #include @@ -50,8 +49,8 @@ static char *to_string(const json_value *value) void free_addr(ss_addr_t *addr) { - SS_SAFEFREE(addr->host); - SS_SAFEFREE(addr->port); + ss_free(addr->host); + ss_free(addr->port); } void parse_addr(const char *str, ss_addr_t *addr) @@ -116,7 +115,7 @@ jconf_t *read_jconf(const char *file) FATAL("Too large config file."); } - buf = SS_SAFEMALLOC(pos + 1); + buf = ss_malloc(pos + 1); if (buf == NULL) { FATAL("No enough memory."); } @@ -198,7 +197,7 @@ jconf_t *read_jconf(const char *file) FATAL("Invalid config file"); } - SS_SAFEFREE(buf); + ss_free(buf); json_value_free(obj); return &conf; } diff --git a/src/json.h b/src/json.h index bd3d2561..7b383b30 100644 --- a/src/json.h +++ b/src/json.h @@ -51,7 +51,6 @@ extern "C" { - #endif typedef struct { @@ -61,11 +60,10 @@ typedef struct { /* Custom allocator support (leave null to use malloc/free) */ - void * (*mem_alloc)(size_t, int zero, void * user_data); - void (* mem_free)(void *, void * user_data); - - void * user_data; /* will be passed to mem_alloc and mem_free */ + void * (*mem_alloc)(size_t, int zero, void *user_data); + void (*mem_free)(void *, void *user_data); + void *user_data; /* will be passed to mem_alloc and mem_free */ } json_settings; #define json_enable_comments 0x01 @@ -79,13 +77,12 @@ typedef enum { json_string, json_boolean, json_null - } json_type; extern const struct _json_value json_value_none; typedef struct _json_value { - struct _json_value * parent; + struct _json_value *parent; json_type type; @@ -96,20 +93,18 @@ typedef struct _json_value { struct { unsigned int length; - json_char * ptr; /* null terminated */ - + json_char *ptr; /* null terminated */ } string; struct { unsigned int length; struct { - json_char * name; + json_char *name; unsigned int name_length; - struct _json_value * value; - - } * values; + struct _json_value *value; + } *values; #if defined(__cplusplus) && __cplusplus >= 201103L decltype(values) begin() const @@ -121,12 +116,11 @@ typedef struct _json_value { return values + length; } #endif - } object; struct { unsigned int length; - struct _json_value ** values; + struct _json_value **values; #if defined(__cplusplus) && __cplusplus >= 201103L decltype(values) begin() const @@ -138,18 +132,14 @@ typedef struct _json_value { return values + length; } #endif - } array; - } u; union { - struct _json_value * next_alloc; - void * object_mem; - + struct _json_value *next_alloc; + void *object_mem; } _reserved; - /* Some C++ operator sugar */ #ifdef __cplusplus @@ -166,19 +156,18 @@ public: return json_value_none; } - return *u.array.values [index]; + return *u.array.values[index]; } - inline const struct _json_value &operator [] (const char * index) const { + inline const struct _json_value &operator [] (const char *index) const { if (type != json_object) { return json_value_none; } - for (unsigned int i = 0; i < u.object.length; ++i) { - if (!strcmp(u.object.values [i].name, index)) { - return *u.object.values [i].value; + for (unsigned int i = 0; i < u.object.length; ++i) + if (!strcmp(u.object.values[i].name, index)) { + return *u.object.values[i].value; } - } return json_value_none; } @@ -192,7 +181,6 @@ public: default: return ""; } - ; } inline operator json_int_t() const @@ -207,7 +195,6 @@ public: default: return 0; } - ; } inline operator bool() const @@ -231,36 +218,30 @@ public: default: return 0; } - ; } #endif - } json_value; -json_value * json_parse(const json_char * json, - size_t length); +json_value *json_parse(const json_char *json, + size_t length); #define json_error_max 128 -json_value * json_parse_ex(json_settings * settings, - const json_char * json, - size_t length, - char * error); +json_value *json_parse_ex(json_settings *settings, + const json_char *json, + size_t length, + char *error); void json_value_free(json_value *); - /* Not usually necessary, unless you used a custom mem_alloc and now want to * use a custom mem_free. */ -void json_value_free_ex(json_settings * settings, +void json_value_free_ex(json_settings *settings, json_value *); - #ifdef __cplusplus } /* extern "C" */ #endif #endif - - diff --git a/src/local.c b/src/local.c index 50384312..3e9183c3 100644 --- a/src/local.c +++ b/src/local.c @@ -66,7 +66,6 @@ #include "socks5.h" #include "acl.h" #include "local.h" -#include "mm-wrapper.h" #ifndef EAGAIN #define EAGAIN EWOULDBLOCK @@ -224,7 +223,7 @@ static void server_recv_cb(EV_P_ ev_io *w, int revents) ssize_t r; errno = 0; - r = recv(server->fd, buf->array, BUF_SIZE, 0); + r = recv(server->fd, buf->array, BUF_SIZE, 0); if (r == 0) { // connection closed @@ -775,13 +774,13 @@ static void remote_send_cb(EV_P_ ev_io *w, int revents) static remote_t *new_remote(int fd, int timeout) { remote_t *remote; - remote = SS_SAFEMALLOC(sizeof(remote_t)); + remote = ss_malloc(sizeof(remote_t)); memset(remote, 0, sizeof(remote_t)); - remote->buf = SS_SAFEMALLOC(sizeof(buffer_t)); - remote->recv_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->send_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); + remote->buf = ss_malloc(sizeof(buffer_t)); + remote->recv_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->send_ctx = ss_malloc(sizeof(remote_ctx_t)); remote->recv_ctx->connected = 0; remote->send_ctx->connected = 0; remote->fd = fd; @@ -807,11 +806,11 @@ static void free_remote(remote_t *remote) } if (remote->buf != NULL) { bfree(remote->buf); - SS_SAFEFREE(remote->buf); + ss_free(remote->buf); } - SS_SAFEFREE(remote->recv_ctx); - SS_SAFEFREE(remote->send_ctx); - SS_SAFEFREE(remote); + ss_free(remote->recv_ctx); + ss_free(remote->send_ctx); + ss_free(remote); } static void close_and_free_remote(EV_P_ remote_t *remote) @@ -829,13 +828,13 @@ static void close_and_free_remote(EV_P_ remote_t *remote) static server_t *new_server(int fd, int method) { server_t *server; - server = SS_SAFEMALLOC(sizeof(server_t)); + server = ss_malloc(sizeof(server_t)); memset(server, 0, sizeof(server_t)); - server->recv_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->send_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + server->recv_ctx = ss_malloc(sizeof(server_ctx_t)); + server->send_ctx = ss_malloc(sizeof(server_ctx_t)); + server->buf = ss_malloc(sizeof(buffer_t)); server->recv_ctx->connected = 0; server->send_ctx->connected = 0; server->fd = fd; @@ -843,8 +842,8 @@ static server_t *new_server(int fd, int method) server->send_ctx->server = server; if (method) { - server->e_ctx = SS_SAFEMALLOC(sizeof(struct enc_ctx)); - server->d_ctx = SS_SAFEMALLOC(sizeof(struct enc_ctx)); + server->e_ctx = ss_malloc(sizeof(struct enc_ctx)); + server->d_ctx = ss_malloc(sizeof(struct enc_ctx)); enc_ctx_init(method, server->e_ctx, 1); enc_ctx_init(method, server->d_ctx, 0); } else { @@ -871,19 +870,19 @@ static void free_server(server_t *server) } if (server->e_ctx != NULL) { cipher_context_release(&server->e_ctx->evp); - SS_SAFEFREE(server->e_ctx); + ss_free(server->e_ctx); } if (server->d_ctx != NULL) { cipher_context_release(&server->d_ctx->evp); - SS_SAFEFREE(server->d_ctx); + ss_free(server->d_ctx); } if (server->buf != NULL) { bfree(server->buf); - SS_SAFEFREE(server->buf); + ss_free(server->buf); } - SS_SAFEFREE(server->recv_ctx); - SS_SAFEFREE(server->send_ctx); - SS_SAFEFREE(server); + ss_free(server->recv_ctx); + ss_free(server->send_ctx); + ss_free(server); } static void close_and_free_server(EV_P_ server_t *server) @@ -1189,12 +1188,12 @@ int main(int argc, char **argv) // Setup proxy context listen_ctx_t listen_ctx; listen_ctx.remote_num = remote_num; - listen_ctx.remote_addr = SS_SAFEMALLOC(sizeof(struct sockaddr *) * remote_num); + listen_ctx.remote_addr = ss_malloc(sizeof(struct sockaddr *) * remote_num); for (i = 0; i < remote_num; i++) { char *host = remote_addr[i].host; char *port = remote_addr[i].port == NULL ? remote_port : remote_addr[i].port; - struct sockaddr_storage *storage = SS_SAFEMALLOC(sizeof(struct sockaddr_storage)); + struct sockaddr_storage *storage = ss_malloc(sizeof(struct sockaddr_storage)); memset(storage, 0, sizeof(struct sockaddr_storage)); if (get_sockaddr(host, port, storage, 1) == -1) { FATAL("failed to resolve the provided hostname"); @@ -1257,8 +1256,8 @@ int main(int argc, char **argv) } for (i = 0; i < remote_num; i++) - SS_SAFEFREE(listen_ctx.remote_addr[i]); - SS_SAFEFREE(listen_ctx.remote_addr); + ss_free(listen_ctx.remote_addr[i]); + ss_free(listen_ctx.remote_addr); #ifdef __MINGW32__ winsock_cleanup(); @@ -1324,7 +1323,7 @@ int start_ss_local_server(profile_t profile) LOGI("initialize ciphers... %s", method); int m = enc_init(password, method); - struct sockaddr_storage *storage = SS_SAFEMALLOC(sizeof(struct sockaddr_storage)); + struct sockaddr_storage *storage = ss_malloc(sizeof(struct sockaddr_storage)); memset(storage, 0, sizeof(struct sockaddr_storage)); if (get_sockaddr(remote_host, remote_port_str, storage, 1) == -1) { return -1; @@ -1335,7 +1334,7 @@ int start_ss_local_server(profile_t profile) listen_ctx_t listen_ctx; listen_ctx.remote_num = 1; - listen_ctx.remote_addr = SS_SAFEMALLOC(sizeof(struct sockaddr *)); + listen_ctx.remote_addr = ss_malloc(sizeof(struct sockaddr *)); listen_ctx.remote_addr[0] = (struct sockaddr *)storage; listen_ctx.timeout = timeout; listen_ctx.method = m; @@ -1388,7 +1387,7 @@ int start_ss_local_server(profile_t profile) free_connections(loop); close(listen_ctx.fd); - SS_SAFEFREE(listen_ctx.remote_addr); + ss_free(listen_ctx.remote_addr); #ifdef __MINGW32__ winsock_cleanup(); diff --git a/src/manager.c b/src/manager.c index 4ffa30cc..bbdfe276 100644 --- a/src/manager.c +++ b/src/manager.c @@ -66,7 +66,6 @@ #include "json.h" #include "utils.h" #include "manager.h" -#include "mm-wrapper.h" #ifndef BUF_SIZE #define BUF_SIZE 65535 @@ -324,7 +323,7 @@ static void remove_server(char *prefix, char *port) cork_hash_table_delete(server_table, (void *)port, (void **)&old_port, (void **)&old_server); if (old_server != NULL) { - SS_SAFEFREE(old_server); + ss_free(old_server); } stop_server(prefix, port); @@ -372,7 +371,7 @@ static void manager_recv_cb(EV_P_ ev_io *w, int revents) if (server == NULL || server->port[0] == 0 || server->password[0] == 0) { LOGE("invalid command: %s:%s", buf, get_data(buf, r)); if (server != NULL) { - SS_SAFEFREE(server); + ss_free(server); } goto ERROR_MSG; } @@ -390,13 +389,13 @@ static void manager_recv_cb(EV_P_ ev_io *w, int revents) if (server == NULL || server->port[0] == 0) { LOGE("invalid command: %s:%s", buf, get_data(buf, r)); if (server != NULL) { - SS_SAFEFREE(server); + ss_free(server); } goto ERROR_MSG; } remove_server(working_dir, server->port); - SS_SAFEFREE(server); + ss_free(server); char msg[3] = "ok"; if (sendto(manager->fd, msg, 3, 0, (struct sockaddr *)&claddr, len) != 3) { diff --git a/src/mm-wrapper.h b/src/mm-wrapper.h deleted file mode 100644 index 705a46fe..00000000 --- a/src/mm-wrapper.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * mm-wrapper.h - Define safe memory management wrapper - * - * Copyright (C) 2013 - 2016, Max Lv - * - * This file is part of the shadowsocks-libev. - * shadowsocks-libev is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * shadowsocks-libev is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with shadowsocks-libev; see the file COPYING. If not, see - * . - */ - -#ifndef _MM_WRAPPER_H -#define _MM_WRAPPER_H - -#include - -#define SS_SAFEFREE(ptr) \ - do { \ - free(ptr); \ - ptr = NULL; \ - } while(0) - -static inline void *SS_SAFEMALLOC(size_t size); -static inline void *SS_SAFEREALLOC(void *ptr, size_t new_size); - -static inline void *SS_SAFEMALLOC(size_t size) { - void *tmp = malloc(size); - if (tmp == NULL) - exit(EXIT_FAILURE); - return tmp; -} - -static inline void *SS_SAFEREALLOC(void *ptr, size_t new_size) { - void *new = realloc(ptr, new_size); - if (new == NULL) { - free(ptr); ptr = NULL; - exit(EXIT_FAILURE); - } - return new; -} - -#endif // _MM_WRAPPER_H diff --git a/src/netutils.c b/src/netutils.c index d848484e..e60189cd 100644 --- a/src/netutils.c +++ b/src/netutils.c @@ -135,68 +135,68 @@ ssize_t get_sockaddr(char *host, char *port, struct sockaddr_storage *storage, i return -1; } -int sockaddr_cmp(struct sockaddr_storage* addr1, - struct sockaddr_storage* addr2, socklen_t len) +int sockaddr_cmp(struct sockaddr_storage *addr1, + struct sockaddr_storage *addr2, socklen_t len) { - struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; - struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; - struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; - struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; - if( p1_in->sin_family < p2_in->sin_family) + struct sockaddr_in *p1_in = (struct sockaddr_in *)addr1; + struct sockaddr_in *p2_in = (struct sockaddr_in *)addr2; + struct sockaddr_in6 *p1_in6 = (struct sockaddr_in6 *)addr1; + struct sockaddr_in6 *p2_in6 = (struct sockaddr_in6 *)addr2; + if (p1_in->sin_family < p2_in->sin_family) return -1; - if( p1_in->sin_family > p2_in->sin_family) + if (p1_in->sin_family > p2_in->sin_family) return 1; - if(verbose) { - LOGI("sockaddr_cmp: sin_family equal? %d", p1_in->sin_family == p2_in->sin_family ); + if (verbose) { + LOGI("sockaddr_cmp: sin_family equal? %d", p1_in->sin_family == p2_in->sin_family); } /* compare ip4 */ - if( p1_in->sin_family == AF_INET ) { + if (p1_in->sin_family == AF_INET) { /* just order it, ntohs not required */ - if(p1_in->sin_port < p2_in->sin_port) + if (p1_in->sin_port < p2_in->sin_port) return -1; - if(p1_in->sin_port > p2_in->sin_port) + if (p1_in->sin_port > p2_in->sin_port) return 1; - if(verbose) { + if (verbose) { LOGI("sockaddr_cmp: sin_port equal? %d", p1_in->sin_port == p2_in->sin_port); } return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); } else if (p1_in6->sin6_family == AF_INET6) { /* just order it, ntohs not required */ - if(p1_in6->sin6_port < p2_in6->sin6_port) + if (p1_in6->sin6_port < p2_in6->sin6_port) return -1; - if(p1_in6->sin6_port > p2_in6->sin6_port) + if (p1_in6->sin6_port > p2_in6->sin6_port) return 1; - if(verbose) { + if (verbose) { LOGI("sockaddr_cmp: sin6_port equal? %d", p1_in6->sin6_port == p2_in6->sin6_port); } return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, - INET6_SIZE); + INET6_SIZE); } else { /* eek unknown type, perform this comparison for sanity. */ return memcmp(addr1, addr2, len); } } -int sockaddr_cmp_addr(struct sockaddr_storage* addr1, - struct sockaddr_storage* addr2, socklen_t len) +int sockaddr_cmp_addr(struct sockaddr_storage *addr1, + struct sockaddr_storage *addr2, socklen_t len) { - struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; - struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; - struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; - struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; - if( p1_in->sin_family < p2_in->sin_family) + struct sockaddr_in *p1_in = (struct sockaddr_in *)addr1; + struct sockaddr_in *p2_in = (struct sockaddr_in *)addr2; + struct sockaddr_in6 *p1_in6 = (struct sockaddr_in6 *)addr1; + struct sockaddr_in6 *p2_in6 = (struct sockaddr_in6 *)addr2; + if (p1_in->sin_family < p2_in->sin_family) return -1; - if( p1_in->sin_family > p2_in->sin_family) + if (p1_in->sin_family > p2_in->sin_family) return 1; - if(verbose) { - LOGI("sockaddr_cmp_addr: sin_family equal? %d", p1_in->sin_family == p2_in->sin_family ); + if (verbose) { + LOGI("sockaddr_cmp_addr: sin_family equal? %d", p1_in->sin_family == p2_in->sin_family); } /* compare ip4 */ - if( p1_in->sin_family == AF_INET ) { + if (p1_in->sin_family == AF_INET) { return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); } else if (p1_in6->sin6_family == AF_INET6) { return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, - INET6_SIZE); + INET6_SIZE); } else { /* eek unknown type, perform this comparison for sanity. */ return memcmp(addr1, addr2, len); diff --git a/src/netutils.h b/src/netutils.h index 796f81ae..f607ce26 100644 --- a/src/netutils.h +++ b/src/netutils.h @@ -40,8 +40,8 @@ int set_reuseport(int socket); * @param len: lengths of addr. * @return: 0 if addr1 == addr2. -1 if addr1 is smaller, +1 if larger. */ -int sockaddr_cmp(struct sockaddr_storage* addr1, - struct sockaddr_storage* addr2, socklen_t len); +int sockaddr_cmp(struct sockaddr_storage *addr1, + struct sockaddr_storage *addr2, socklen_t len); /** * Compare two sockaddrs. Compares address, not the port. @@ -50,7 +50,7 @@ int sockaddr_cmp(struct sockaddr_storage* addr1, * @param len: lengths of addr. * @return: 0 if addr1 == addr2. -1 if addr1 is smaller, +1 if larger. */ -int sockaddr_cmp_addr(struct sockaddr_storage* addr1, - struct sockaddr_storage* addr2, socklen_t len); +int sockaddr_cmp_addr(struct sockaddr_storage *addr1, + struct sockaddr_storage *addr2, socklen_t len); #endif diff --git a/src/redir.c b/src/redir.c index 8c601cb0..8ac57045 100644 --- a/src/redir.c +++ b/src/redir.c @@ -49,7 +49,6 @@ #include "utils.h" #include "common.h" #include "redir.h" -#include "mm-wrapper.h" #ifndef EAGAIN #define EAGAIN EWOULDBLOCK @@ -459,13 +458,13 @@ static void remote_send_cb(EV_P_ ev_io *w, int revents) static remote_t *new_remote(int fd, int timeout) { remote_t *remote; - remote = SS_SAFEMALLOC(sizeof(remote_t)); + remote = ss_malloc(sizeof(remote_t)); memset(remote, 0, sizeof(remote_t)); - remote->recv_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->send_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + remote->recv_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->send_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->buf = ss_malloc(sizeof(buffer_t)); remote->fd = fd; remote->recv_ctx->remote = remote; remote->recv_ctx->connected = 0; @@ -490,11 +489,11 @@ static void free_remote(remote_t *remote) } if (remote->buf != NULL) { bfree(remote->buf); - SS_SAFEFREE(remote->buf); + ss_free(remote->buf); } - SS_SAFEFREE(remote->recv_ctx); - SS_SAFEFREE(remote->send_ctx); - SS_SAFEFREE(remote); + ss_free(remote->recv_ctx); + ss_free(remote->send_ctx); + ss_free(remote); } } @@ -512,11 +511,11 @@ static void close_and_free_remote(EV_P_ remote_t *remote) static server_t *new_server(int fd, int method) { server_t *server; - server = SS_SAFEMALLOC(sizeof(server_t)); + server = ss_malloc(sizeof(server_t)); - server->recv_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->send_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + server->recv_ctx = ss_malloc(sizeof(server_ctx_t)); + server->send_ctx = ss_malloc(sizeof(server_ctx_t)); + server->buf = ss_malloc(sizeof(buffer_t)); server->fd = fd; server->recv_ctx->server = server; server->recv_ctx->connected = 0; @@ -524,8 +523,8 @@ static server_t *new_server(int fd, int method) server->send_ctx->connected = 0; if (method) { - server->e_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t)); - server->d_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t)); + server->e_ctx = ss_malloc(sizeof(enc_ctx_t)); + server->d_ctx = ss_malloc(sizeof(enc_ctx_t)); enc_ctx_init(method, server->e_ctx, 1); enc_ctx_init(method, server->d_ctx, 0); } else { @@ -549,19 +548,19 @@ static void free_server(server_t *server) } if (server->e_ctx != NULL) { cipher_context_release(&server->e_ctx->evp); - SS_SAFEFREE(server->e_ctx); + ss_free(server->e_ctx); } if (server->d_ctx != NULL) { cipher_context_release(&server->d_ctx->evp); - SS_SAFEFREE(server->d_ctx); + ss_free(server->d_ctx); } if (server->buf != NULL) { bfree(server->buf); - SS_SAFEFREE(server->buf); + ss_free(server->buf); } - SS_SAFEFREE(server->recv_ctx); - SS_SAFEFREE(server->send_ctx); - SS_SAFEFREE(server); + ss_free(server->recv_ctx); + ss_free(server->send_ctx); + ss_free(server); } } @@ -614,16 +613,16 @@ static void accept_cb(EV_P_ ev_io *w, int revents) setsockopt(remotefd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt)); #endif - //Enable TCP keepalive feature - int keepAlive = 1; - int keepIdle = 40; + // Enable TCP keepalive feature + int keepAlive = 1; + int keepIdle = 40; int keepInterval = 20; - int keepCount = 5; - setsockopt(remotefd, SOL_SOCKET, SO_KEEPALIVE, (void*)&keepAlive, sizeof(keepAlive)); - setsockopt(remotefd, SOL_TCP, TCP_KEEPIDLE, (void*)&keepIdle, sizeof(keepIdle)); - setsockopt(remotefd, SOL_TCP, TCP_KEEPINTVL, (void*)&keepInterval, sizeof(keepInterval)); - setsockopt(remotefd, SOL_TCP, TCP_KEEPCNT, (void*)&keepCount, sizeof(keepCount)); - + int keepCount = 5; + setsockopt(remotefd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepAlive, sizeof(keepAlive)); + setsockopt(remotefd, SOL_TCP, TCP_KEEPIDLE, (void *)&keepIdle, sizeof(keepIdle)); + setsockopt(remotefd, SOL_TCP, TCP_KEEPINTVL, (void *)&keepInterval, sizeof(keepInterval)); + setsockopt(remotefd, SOL_TCP, TCP_KEEPCNT, (void *)&keepCount, sizeof(keepCount)); + // Setup setnonblocking(remotefd); @@ -804,12 +803,12 @@ int main(int argc, char **argv) // Setup proxy context listen_ctx_t listen_ctx; listen_ctx.remote_num = remote_num; - listen_ctx.remote_addr = SS_SAFEMALLOC(sizeof(struct sockaddr *) * remote_num); + listen_ctx.remote_addr = ss_malloc(sizeof(struct sockaddr *) * remote_num); for (int i = 0; i < remote_num; i++) { char *host = remote_addr[i].host; char *port = remote_addr[i].port == NULL ? remote_port : remote_addr[i].port; - struct sockaddr_storage *storage = SS_SAFEMALLOC(sizeof(struct sockaddr_storage)); + struct sockaddr_storage *storage = ss_malloc(sizeof(struct sockaddr_storage)); memset(storage, 0, sizeof(struct sockaddr_storage)); if (get_sockaddr(host, port, storage, 1) == -1) { FATAL("failed to resolve the provided hostname"); diff --git a/src/resolv.c b/src/resolv.c index 9e273c74..cbab9915 100644 --- a/src/resolv.c +++ b/src/resolv.c @@ -46,7 +46,6 @@ #include "resolv.h" #include "utils.h" -#include "mm-wrapper.h" /* * Implement DNS resolution interface using libudns @@ -147,7 +146,7 @@ struct ResolvQuery *resolv_query(const char *hostname, void (*client_cb)(struct /* * Wrap udns's call back in our own */ - struct ResolvQuery *cb_data = SS_SAFEMALLOC(sizeof(struct ResolvQuery)); + struct ResolvQuery *cb_data = ss_malloc(sizeof(struct ResolvQuery)); if (cb_data == NULL) { LOGE("Failed to allocate memory for DNS query callback data."); return NULL; @@ -185,7 +184,7 @@ struct ResolvQuery *resolv_query(const char *hostname, void (*client_cb)(struct if (cb_data->client_free_cb != NULL) { cb_data->client_free_cb(cb_data->client_cb_data); } - SS_SAFEFREE(cb_data); + ss_free(cb_data); } return cb_data; @@ -200,14 +199,14 @@ void resolv_cancel(struct ResolvQuery *query_handle) i++) if (cb_data->queries[i] != NULL) { dns_cancel(ctx, cb_data->queries[i]); - SS_SAFEFREE(cb_data->queries[i]); + ss_free(cb_data->queries[i]); } if (cb_data->client_free_cb != NULL) { cb_data->client_free_cb(cb_data->client_cb_data); } - SS_SAFEFREE(cb_data); + ss_free(cb_data); } /* @@ -234,10 +233,10 @@ static void dns_query_v4_cb(struct dns_ctx *ctx, struct dns_rr_a4 *result, void LOGI("IPv4 resolv: %s", dns_strerror(dns_status(ctx))); } } else if (result->dnsa4_nrr > 0) { - struct sockaddr **new_responses = SS_SAFEREALLOC(cb_data->responses, - (cb_data->response_count + - result->dnsa4_nrr) * - sizeof(struct sockaddr *)); + struct sockaddr **new_responses = ss_realloc(cb_data->responses, + (cb_data->response_count + + result->dnsa4_nrr) * + sizeof(struct sockaddr *)); if (new_responses == NULL) { LOGE("Failed to allocate memory for additional DNS responses"); } else { @@ -262,7 +261,7 @@ static void dns_query_v4_cb(struct dns_ctx *ctx, struct dns_rr_a4 *result, void } } - SS_SAFEFREE(result); + ss_free(result); cb_data->queries[0] = NULL; /* mark A query as being completed */ /* Once all queries have completed, call client callback */ @@ -280,10 +279,10 @@ static void dns_query_v6_cb(struct dns_ctx *ctx, struct dns_rr_a6 *result, void LOGI("IPv6 resolv: %s", dns_strerror(dns_status(ctx))); } } else if (result->dnsa6_nrr > 0) { - struct sockaddr **new_responses = SS_SAFEREALLOC(cb_data->responses, - (cb_data->response_count + - result->dnsa6_nrr) * - sizeof(struct sockaddr *)); + struct sockaddr **new_responses = ss_realloc(cb_data->responses, + (cb_data->response_count + + result->dnsa6_nrr) * + sizeof(struct sockaddr *)); if (new_responses == NULL) { LOGE("Failed to allocate memory for additional DNS responses"); } else { @@ -308,7 +307,7 @@ static void dns_query_v6_cb(struct dns_ctx *ctx, struct dns_rr_a6 *result, void } } - SS_SAFEFREE(result); + ss_free(result); cb_data->queries[1] = NULL; /* mark AAAA query as being completed */ /* Once all queries have completed, call client callback */ @@ -335,13 +334,13 @@ static void process_client_callback(struct ResolvQuery *cb_data) cb_data->client_cb(best_address, cb_data->client_cb_data); for (int i = 0; i < cb_data->response_count; i++) - SS_SAFEFREE(cb_data->responses[i]); + ss_free(cb_data->responses[i]); - SS_SAFEFREE(cb_data->responses); + ss_free(cb_data->responses); if (cb_data->client_free_cb != NULL) { cb_data->client_free_cb(cb_data->client_cb_data); } - SS_SAFEFREE(cb_data); + ss_free(cb_data); } static struct sockaddr *choose_ipv4_first(struct ResolvQuery *cb_data) diff --git a/src/server.c b/src/server.c index 298cd9fe..ddb4d346 100644 --- a/src/server.c +++ b/src/server.c @@ -64,7 +64,6 @@ #include "utils.h" #include "acl.h" #include "server.h" -#include "mm-wrapper.h" #ifndef EAGAIN #define EAGAIN EWOULDBLOCK @@ -275,7 +274,7 @@ int setfastopen(int fd) int opt = 5; #endif errno = 0; - s = setsockopt(fd, IPPROTO_TCP, TCP_FASTOPEN, &opt, sizeof(opt)); + s = setsockopt(fd, IPPROTO_TCP, TCP_FASTOPEN, &opt, sizeof(opt)); if (s == -1) { if (errno == EPROTONOSUPPORT || errno == ENOPROTOOPT) { LOGE("fast open is not supported on this platform"); @@ -1108,10 +1107,10 @@ static remote_t *new_remote(int fd) remote_t *remote; - remote = SS_SAFEMALLOC(sizeof(remote_t)); - remote->recv_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->send_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + remote = ss_malloc(sizeof(remote_t)); + remote->recv_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->send_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->buf = ss_malloc(sizeof(buffer_t)); remote->fd = fd; remote->recv_ctx->remote = remote; remote->recv_ctx->connected = 0; @@ -1134,11 +1133,11 @@ static void free_remote(remote_t *remote) } if (remote->buf != NULL) { bfree(remote->buf); - SS_SAFEFREE(remote->buf); + ss_free(remote->buf); } - SS_SAFEFREE(remote->recv_ctx); - SS_SAFEFREE(remote->send_ctx); - SS_SAFEFREE(remote); + ss_free(remote->recv_ctx); + ss_free(remote->send_ctx); + ss_free(remote); } static void close_and_free_remote(EV_P_ remote_t *remote) @@ -1162,13 +1161,13 @@ static server_t *new_server(int fd, listen_ctx_t *listener) } server_t *server; - server = SS_SAFEMALLOC(sizeof(server_t)); + server = ss_malloc(sizeof(server_t)); memset(server, 0, sizeof(server_t)); - server->recv_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->send_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + server->recv_ctx = ss_malloc(sizeof(server_ctx_t)); + server->send_ctx = ss_malloc(sizeof(server_ctx_t)); + server->buf = ss_malloc(sizeof(buffer_t)); server->fd = fd; server->recv_ctx->server = server; server->recv_ctx->connected = 0; @@ -1180,8 +1179,8 @@ static server_t *new_server(int fd, listen_ctx_t *listener) server->remote = NULL; if (listener->method) { - server->e_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t)); - server->d_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t)); + server->e_ctx = ss_malloc(sizeof(enc_ctx_t)); + server->d_ctx = ss_malloc(sizeof(enc_ctx_t)); enc_ctx_init(listener->method, server->e_ctx, 1); enc_ctx_init(listener->method, server->d_ctx, 0); } else { @@ -1198,7 +1197,7 @@ static server_t *new_server(int fd, listen_ctx_t *listener) server->chunk = (chunk_t *)malloc(sizeof(chunk_t)); memset(server->chunk, 0, sizeof(chunk_t)); - server->chunk->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + server->chunk->buf = ss_malloc(sizeof(buffer_t)); memset(server->chunk->buf, 0, sizeof(buffer_t)); cork_dllist_add(&connections, &server->entries); @@ -1213,29 +1212,29 @@ static void free_server(server_t *server) if (server->chunk != NULL) { if (server->chunk->buf != NULL) { bfree(server->chunk->buf); - SS_SAFEFREE(server->chunk->buf); + ss_free(server->chunk->buf); } - SS_SAFEFREE(server->chunk); + ss_free(server->chunk); } if (server->remote != NULL) { server->remote->server = NULL; } if (server->e_ctx != NULL) { cipher_context_release(&server->e_ctx->evp); - SS_SAFEFREE(server->e_ctx); + ss_free(server->e_ctx); } if (server->d_ctx != NULL) { cipher_context_release(&server->d_ctx->evp); - SS_SAFEFREE(server->d_ctx); + ss_free(server->d_ctx); } if (server->buf != NULL) { bfree(server->buf); - SS_SAFEFREE(server->buf); + ss_free(server->buf); } - SS_SAFEFREE(server->recv_ctx); - SS_SAFEFREE(server->send_ctx); - SS_SAFEFREE(server); + ss_free(server->recv_ctx); + ss_free(server->send_ctx); + ss_free(server); } static void close_and_free_server(EV_P_ server_t *server) diff --git a/src/tunnel.c b/src/tunnel.c index b928dc23..d5b78b71 100644 --- a/src/tunnel.c +++ b/src/tunnel.c @@ -58,7 +58,6 @@ #include "netutils.h" #include "utils.h" #include "tunnel.h" -#include "mm-wrapper.h" #ifndef EAGAIN #define EAGAIN EWOULDBLOCK @@ -507,13 +506,13 @@ static void remote_send_cb(EV_P_ ev_io *w, int revents) static remote_t *new_remote(int fd, int timeout) { remote_t *remote; - remote = SS_SAFEMALLOC(sizeof(remote_t)); + remote = ss_malloc(sizeof(remote_t)); memset(remote, 0, sizeof(remote_t)); - remote->buf = SS_SAFEMALLOC(sizeof(buffer_t)); - remote->recv_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); - remote->send_ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); + remote->buf = ss_malloc(sizeof(buffer_t)); + remote->recv_ctx = ss_malloc(sizeof(remote_ctx_t)); + remote->send_ctx = ss_malloc(sizeof(remote_ctx_t)); remote->fd = fd; remote->recv_ctx->remote = remote; remote->recv_ctx->connected = 0; @@ -538,11 +537,11 @@ static void free_remote(remote_t *remote) } if (remote->buf) { bfree(remote->buf); - SS_SAFEFREE(remote->buf); + ss_free(remote->buf); } - SS_SAFEFREE(remote->recv_ctx); - SS_SAFEFREE(remote->send_ctx); - SS_SAFEFREE(remote); + ss_free(remote->recv_ctx); + ss_free(remote->send_ctx); + ss_free(remote); } } @@ -561,10 +560,10 @@ static server_t *new_server(int fd, int method) { server_t *server; - server = SS_SAFEMALLOC(sizeof(server_t)); - server->buf = SS_SAFEMALLOC(sizeof(buffer_t)); - server->recv_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); - server->send_ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); + server = ss_malloc(sizeof(server_t)); + server->buf = ss_malloc(sizeof(buffer_t)); + server->recv_ctx = ss_malloc(sizeof(server_ctx_t)); + server->send_ctx = ss_malloc(sizeof(server_ctx_t)); server->fd = fd; server->recv_ctx->server = server; server->recv_ctx->connected = 0; @@ -572,8 +571,8 @@ static server_t *new_server(int fd, int method) server->send_ctx->connected = 0; if (method) { - server->e_ctx = SS_SAFEMALLOC(sizeof(struct enc_ctx)); - server->d_ctx = SS_SAFEMALLOC(sizeof(struct enc_ctx)); + server->e_ctx = ss_malloc(sizeof(struct enc_ctx)); + server->d_ctx = ss_malloc(sizeof(struct enc_ctx)); enc_ctx_init(method, server->e_ctx, 1); enc_ctx_init(method, server->d_ctx, 0); } else { @@ -597,19 +596,19 @@ static void free_server(server_t *server) } if (server->e_ctx != NULL) { cipher_context_release(&server->e_ctx->evp); - SS_SAFEFREE(server->e_ctx); + ss_free(server->e_ctx); } if (server->d_ctx != NULL) { cipher_context_release(&server->d_ctx->evp); - SS_SAFEFREE(server->d_ctx); + ss_free(server->d_ctx); } if (server->buf) { bfree(server->buf); - SS_SAFEFREE(server->buf); + ss_free(server->buf); } - SS_SAFEFREE(server->recv_ctx); - SS_SAFEFREE(server->send_ctx); - SS_SAFEFREE(server); + ss_free(server->recv_ctx); + ss_free(server->send_ctx); + ss_free(server); } } @@ -883,12 +882,12 @@ int main(int argc, char **argv) struct listen_ctx listen_ctx; listen_ctx.tunnel_addr = tunnel_addr; listen_ctx.remote_num = remote_num; - listen_ctx.remote_addr = SS_SAFEMALLOC(sizeof(struct sockaddr *) * remote_num); + listen_ctx.remote_addr = ss_malloc(sizeof(struct sockaddr *) * remote_num); for (i = 0; i < remote_num; i++) { char *host = remote_addr[i].host; char *port = remote_addr[i].port == NULL ? remote_port : remote_addr[i].port; - struct sockaddr_storage *storage = SS_SAFEMALLOC(sizeof(struct sockaddr_storage)); + struct sockaddr_storage *storage = ss_malloc(sizeof(struct sockaddr_storage)); memset(storage, 0, sizeof(struct sockaddr_storage)); if (get_sockaddr(host, port, storage, 1) == -1) { FATAL("failed to resolve the provided hostname"); diff --git a/src/udprelay.c b/src/udprelay.c index 60dc6adf..05ab7444 100644 --- a/src/udprelay.c +++ b/src/udprelay.c @@ -60,7 +60,6 @@ #include "netutils.h" #include "cache.h" #include "udprelay.h" -#include "mm-wrapper.h" #ifdef MODULE_REMOTE #define MAX_UDP_CONN_NUM 512 @@ -476,7 +475,7 @@ int create_server_socket(const char *host, const char *port) remote_ctx_t *new_remote(int fd, server_ctx_t *server_ctx) { - remote_ctx_t *ctx = SS_SAFEMALLOC(sizeof(remote_ctx_t)); + remote_ctx_t *ctx = ss_malloc(sizeof(remote_ctx_t)); memset(ctx, 0, sizeof(remote_ctx_t)); ctx->fd = fd; @@ -491,7 +490,7 @@ remote_ctx_t *new_remote(int fd, server_ctx_t *server_ctx) server_ctx_t *new_server_ctx(int fd) { - server_ctx_t *ctx = SS_SAFEMALLOC(sizeof(server_ctx_t)); + server_ctx_t *ctx = ss_malloc(sizeof(server_ctx_t)); memset(ctx, 0, sizeof(server_ctx_t)); ctx->fd = fd; @@ -504,9 +503,9 @@ server_ctx_t *new_server_ctx(int fd) #ifdef MODULE_REMOTE struct query_ctx *new_query_ctx(char *buf, size_t len) { - struct query_ctx *ctx = SS_SAFEMALLOC(sizeof(struct query_ctx)); + struct query_ctx *ctx = ss_malloc(sizeof(struct query_ctx)); memset(ctx, 0, sizeof(struct query_ctx)); - ctx->buf = SS_SAFEMALLOC(sizeof(buffer_t)); + ctx->buf = ss_malloc(sizeof(buffer_t)); balloc(ctx->buf, len); memcpy(ctx->buf->array, buf, len); ctx->buf->len = len; @@ -522,9 +521,9 @@ void close_and_free_query(EV_P_ struct query_ctx *ctx) } if (ctx->buf != NULL) { bfree(ctx->buf); - SS_SAFEFREE(ctx->buf); + ss_free(ctx->buf); } - SS_SAFEFREE(ctx); + ss_free(ctx); } } @@ -536,7 +535,7 @@ void close_and_free_remote(EV_P_ remote_ctx_t *ctx) ev_timer_stop(EV_A_ & ctx->watcher); ev_io_stop(EV_A_ & ctx->io); close(ctx->fd); - SS_SAFEFREE(ctx); + ss_free(ctx); } } @@ -607,7 +606,7 @@ static void query_resolve_cb(struct sockaddr *addr, void *data) if (remote_ctx != NULL) { memcpy(&remote_ctx->dst_addr, addr, sizeof(struct sockaddr_storage)); - + size_t addr_len = get_sockaddr_len(addr); int s = sendto(remote_ctx->fd, query_ctx->buf->array, query_ctx->buf->len, 0, addr, addr_len); @@ -656,7 +655,7 @@ static void remote_recv_cb(EV_P_ ev_io *w, int revents) socklen_t src_addr_len = sizeof(src_addr); memset(&src_addr, 0, src_addr_len); - buffer_t *buf = SS_SAFEMALLOC(sizeof(buffer_t)); + buffer_t *buf = ss_malloc(sizeof(buffer_t)); balloc(buf, BUF_SIZE); // recv @@ -796,7 +795,7 @@ static void remote_recv_cb(EV_P_ ev_io *w, int revents) CLEAN_UP: bfree(buf); - SS_SAFEFREE(buf); + ss_free(buf); } static void server_recv_cb(EV_P_ ev_io *w, int revents) @@ -805,7 +804,7 @@ static void server_recv_cb(EV_P_ ev_io *w, int revents) struct sockaddr_storage src_addr; memset(&src_addr, 0, sizeof(struct sockaddr_storage)); - buffer_t *buf = SS_SAFEMALLOC(sizeof(buffer_t)); + buffer_t *buf = ss_malloc(sizeof(buffer_t)); balloc(buf, BUF_SIZE); socklen_t src_addr_len = sizeof(struct sockaddr_storage); @@ -843,7 +842,7 @@ static void server_recv_cb(EV_P_ ev_io *w, int revents) #else ssize_t r; r = recvfrom(server_ctx->fd, buf->array, BUF_SIZE, - 0, (struct sockaddr *)&src_addr, &src_addr_len); + 0, (struct sockaddr *)&src_addr, &src_addr_len); if (r == -1) { // error on recv @@ -1154,7 +1153,7 @@ static void server_recv_cb(EV_P_ ev_io *w, int revents) need_query = 1; } } else { - memcpy(&dst_addr,&remote_ctx->dst_addr,sizeof(struct sockaddr_storage)); + memcpy(&dst_addr, &remote_ctx->dst_addr, sizeof(struct sockaddr_storage)); } } else { if (dst_addr.ss_family == AF_INET || dst_addr.ss_family == AF_INET6) { @@ -1238,7 +1237,7 @@ static void server_recv_cb(EV_P_ ev_io *w, int revents) CLEAN_UP: bfree(buf); - SS_SAFEFREE(buf); + ss_free(buf); } void free_cb(void *element) @@ -1310,7 +1309,7 @@ void free_udprelay() ev_io_stop(loop, &server_ctx->io); close(server_ctx->fd); cache_delete(server_ctx->conn_cache, 0); - SS_SAFEFREE(server_ctx); + ss_free(server_ctx); server_ctx_list[server_num] = NULL; } } diff --git a/src/utils.c b/src/utils.c index 2c07bcda..5777153a 100644 --- a/src/utils.c +++ b/src/utils.c @@ -103,7 +103,7 @@ int run_as(const char *user) * which returns its result in a statically allocated buffer and * cannot be considered thread safe. */ errno = 0; - err = getpwnam_r(user, &pwdbuf, buf, buflen, &pwd); + err = getpwnam_r(user, &pwdbuf, buf, buflen, &pwd); if (err == 0 && pwd) { /* setgid first, because we may not be allowed to do it anymore after setuid */ diff --git a/src/utils.h b/src/utils.h index 8eeb138d..a5653d02 100644 --- a/src/utils.h +++ b/src/utils.h @@ -23,6 +23,7 @@ #ifndef _UTILS_H #define _UTILS_H +#include #include #include @@ -202,4 +203,29 @@ char *ss_strndup(const char *s, size_t n); int set_nofile(int nofile); #endif +inline void ss_free(void *ptr) +{ + free(ptr); + ptr = NULL; +} + +inline void *ss_malloc(size_t size) +{ + void *tmp = malloc(size); + if (tmp == NULL) + exit(EXIT_FAILURE); + return tmp; +} + +inline void *ss_realloc(void *ptr, size_t new_size) +{ + void *new = realloc(ptr, new_size); + if (new == NULL) { + free(ptr); + ptr = NULL; + exit(EXIT_FAILURE); + } + return new; +} + #endif // _UTILS_H