richard
/
shadowsocks-libev
mirror of https://github.com/shadowsocks/shadowsocks-libev.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Refine helper functions

pull/587/head
Max Lv 8 years ago
parent
ebe79bbbd8
commit
114128668c
18 changed files with 259 additions and 303 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      config.h.in
  2. 4
      configure
  3. 23
      src/cache.c
  4. 21
      src/encrypt.c
  5. 9
      src/jconf.c
  6. 65
      src/json.h
  7. 57
      src/local.c
  8. 9
      src/manager.c
  9. 52
      src/mm-wrapper.h
  10. 60
      src/netutils.c
  11. 8
      src/netutils.h
  12. 63
      src/redir.c
  13. 35
      src/resolv.c
  14. 49
      src/server.c
  15. 45
      src/tunnel.c
  16. 31
      src/udprelay.c
  17. 2
      src/utils.c
  18. 26
      src/utils.h

3
config.h.in
View File

@ -67,6 +67,9 @@
/* Define to 1 if you have the <inttypes.h> 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

4
configure
View File

@ -15562,6 +15562,10 @@ done
$as_echo "#define HAVE_IPv6 1" >>confdefs.h
if test -z "$USE_SYSTEM_SHARED_LIB_TRUE"; then :
else

23
src/cache.c
View File

@ -27,8 +27,9 @@
#include <errno.h>
#include <stdlib.h>
#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;
}
}

21
src/encrypt.c
View File

@ -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);

9
src/jconf.c
View File

@ -29,7 +29,6 @@
#include "jconf.h"
#include "json.h"
#include "string.h"
#include "mm-wrapper.h"
#include <libcork/core.h>
@ -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;
}

65
src/json.h
View File

@ -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

57
src/local.c
View File

@ -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();

9
src/manager.c
View File

@ -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) {

52
src/mm-wrapper.h
View File

@ -1,52 +0,0 @@
/*
* mm-wrapper.h - Define safe memory management wrapper
*
* Copyright (C) 2013 - 2016, Max Lv <max.c.lv@gmail.com>
*
* 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
* <http://www.gnu.org/licenses/>.
*/
#ifndef _MM_WRAPPER_H
#define _MM_WRAPPER_H
#include <stdlib.h>
#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

60
src/netutils.c
View File

@ -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);

8
src/netutils.h
View File

@ -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

63
src/redir.c
View File

@ -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");

35
src/resolv.c
View File

@ -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)

49
src/server.c
View File

@ -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)

45
src/tunnel.c
View File

@ -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");

31
src/udprelay.c
View File

@ -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;
}
}

2
src/utils.c
View File

@ -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 */

26
src/utils.h
View File

@ -23,6 +23,7 @@
#ifndef _UTILS_H
#define _UTILS_H
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
@ -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
Write Preview
Loading…
Cancel
Save