Alawn/shadowsocks-libev
1
0
Fork 0
mirror of https://github.com/shadowsocks/shadowsocks-libev.git synced 2026-10-26 18:53:41 +00:00
Code Releases Activity

Refine memory management (#579)

Browse Source 
- Added one macro to avoid dangling pointers
- Added two functions to perform NULL pointer check
  since the allocation is not guaranteed by C library, although it
  is a rare case, just for sanity
- Add NULL pointer check to brealloc() and bfree() and for sanity as well

Signed-off-by: Syrone Wong <wong.syrone@gmail.com>
This commit is contained in:
Syrone Wong
2016-04-15 09:16:38 -07:00
committed by Max Lv
parent 446e570b7d
commit ebe79bbbd8
12 changed files with 209 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/server.c
+24 -25
View File
@@ -64,6 +64,7 @@
#include "utils.h"
#include "acl.h"
#include "server.h"
#include "mm-wrapper.h"
#ifndef EAGAIN
#define EAGAIN EWOULDBLOCK
@@ -1107,10 +1108,10 @@ static remote_t *new_remote(int fd)
remote_t *remote;
remote = malloc(sizeof(remote_t));
remote->recv_ctx = malloc(sizeof(remote_ctx_t));
remote->send_ctx = malloc(sizeof(remote_ctx_t));
remote->buf = malloc(sizeof(buffer_t));
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->fd = fd;
remote->recv_ctx->remote = remote;
remote->recv_ctx->connected = 0;
@@ -1133,11 +1134,11 @@ static void free_remote(remote_t *remote)
}
if (remote->buf != NULL) {
bfree(remote->buf);
free(remote->buf);
SS_SAFEFREE(remote->buf);
}
free(remote->recv_ctx);
free(remote->send_ctx);
free(remote);
SS_SAFEFREE(remote->recv_ctx);
SS_SAFEFREE(remote->send_ctx);
SS_SAFEFREE(remote);
}
static void close_and_free_remote(EV_P_ remote_t *remote)
@@ -1161,13 +1162,13 @@ static server_t *new_server(int fd, listen_ctx_t *listener)
}
server_t *server;
server = malloc(sizeof(server_t));
server = SS_SAFEMALLOC(sizeof(server_t));
memset(server, 0, sizeof(server_t));
server->recv_ctx = malloc(sizeof(server_ctx_t));
server->send_ctx = malloc(sizeof(server_ctx_t));
server->buf = malloc(sizeof(buffer_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->fd = fd;
server->recv_ctx->server = server;
server->recv_ctx->connected = 0;
@@ -1179,8 +1180,8 @@ static server_t *new_server(int fd, listen_ctx_t *listener)
server->remote = NULL;
if (listener->method) {
server->e_ctx = malloc(sizeof(enc_ctx_t));
server->d_ctx = malloc(sizeof(enc_ctx_t));
server->e_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t));
server->d_ctx = SS_SAFEMALLOC(sizeof(enc_ctx_t));
enc_ctx_init(listener->method, server->e_ctx, 1);
enc_ctx_init(listener->method, server->d_ctx, 0);
} else {
@@ -1197,7 +1198,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 = malloc(sizeof(buffer_t));
server->chunk->buf = SS_SAFEMALLOC(sizeof(buffer_t));
memset(server->chunk->buf, 0, sizeof(buffer_t));
cork_dllist_add(&connections, &server->entries);
@@ -1212,31 +1213,29 @@ static void free_server(server_t *server)
if (server->chunk != NULL) {
if (server->chunk->buf != NULL) {
bfree(server->chunk->buf);
free(server->chunk->buf);
server->chunk->buf = NULL;
SS_SAFEFREE(server->chunk->buf);
}
free(server->chunk);
server->chunk = NULL;
SS_SAFEFREE(server->chunk);
}
if (server->remote != NULL) {
server->remote->server = NULL;
}
if (server->e_ctx != NULL) {
cipher_context_release(&server->e_ctx->evp);
free(server->e_ctx);
SS_SAFEFREE(server->e_ctx);
}
if (server->d_ctx != NULL) {
cipher_context_release(&server->d_ctx->evp);
free(server->d_ctx);
SS_SAFEFREE(server->d_ctx);
}
if (server->buf != NULL) {
bfree(server->buf);
free(server->buf);
SS_SAFEFREE(server->buf);
}
free(server->recv_ctx);
free(server->send_ctx);
free(server);
SS_SAFEFREE(server->recv_ctx);
SS_SAFEFREE(server->send_ctx);
SS_SAFEFREE(server);
}
static void close_and_free_server(EV_P_ server_t *server)