started some code for hcl client
This commit is contained in:
parent
5aa3a72eea
commit
89f3fc2d08
256
lib/hcl-c.c
256
lib/hcl-c.c
@ -27,6 +27,25 @@
|
||||
#include "hcl-c.h"
|
||||
#include "hcl-prv.h"
|
||||
|
||||
enum hcl_reply_type_t
|
||||
{
|
||||
HCL_REPLY_TYPE_OK = 0,
|
||||
HCL_REPLY_TYPE_ERROR = 1
|
||||
};
|
||||
typedef enum hcl_reply_type_t hcl_reply_type_t;
|
||||
|
||||
enum hcl_client_proto_state_t
|
||||
{
|
||||
HCL_CLIENT_PROTO_STATE_START,
|
||||
HCL_CLIENT_PROTO_STATE_IN_REPLY_NAME,
|
||||
HCL_CLIENT_PROTO_STATE_IN_REPLY_VALUE,
|
||||
HCL_CLIENT_PROTO_STATE_IN_HEADER_NAME,
|
||||
HCL_CLIENT_PROTO_STATE_IN_HEADER_VALUE,
|
||||
HCL_CLIENT_PROTO_STATE_IN_DATA,
|
||||
HCL_CLIENT_PROTO_STATE_IN_BINARY_DATA,
|
||||
HCL_CLIENT_PROTO_STATE_IN_CHUNK,
|
||||
};
|
||||
typedef enum hcl_client_proto_state_t hcl_client_proto_state_t;
|
||||
|
||||
struct hcl_client_proto_t
|
||||
{
|
||||
@ -38,25 +57,45 @@ struct hcl_client_proto_t
|
||||
hcl_oow_t len;
|
||||
hcl_oow_t capa;
|
||||
} req;
|
||||
|
||||
|
||||
hcl_client_proto_state_t state;
|
||||
struct
|
||||
{
|
||||
/*
|
||||
hcl_ooch_t* ptr;
|
||||
hcl_oow_t len;
|
||||
hcl_oow_t capa;
|
||||
*/
|
||||
struct
|
||||
{
|
||||
hcl_ooch_t* ptr;
|
||||
hcl_oow_t len;
|
||||
hcl_oow_t capa;
|
||||
} tok;
|
||||
|
||||
hcl_reply_type_t type;
|
||||
} rep;
|
||||
};
|
||||
typedef struct hcl_client_proto_t hcl_client_proto_t;
|
||||
|
||||
struct hcl_client_t
|
||||
{
|
||||
hcl_mmgr_t* mmgr;
|
||||
hcl_cmgr_t* cmgr;
|
||||
/*hcl_t* dummy_hcl;*/
|
||||
|
||||
hcl_errnum_t errnum;
|
||||
struct
|
||||
{
|
||||
hcl_ooch_t buf[HCL_ERRMSG_CAPA];
|
||||
hcl_oow_t len;
|
||||
} errmsg;
|
||||
};
|
||||
|
||||
/* ========================================================================= */
|
||||
|
||||
|
||||
#if 0
|
||||
static void proto_start_request (hcl_client_proto_t* proto)
|
||||
{
|
||||
proto->req.len = 0;
|
||||
@ -74,24 +113,162 @@ static int proto_end_request (hcl_client_proto_t* proto)
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
static void proto_start_response (hcl_client_proto_t* proto)
|
||||
{
|
||||
proto->state = HCL_CLIENT_PROTO_STATE_START;
|
||||
//proto->rep.len = 0;
|
||||
}
|
||||
|
||||
static void proto_feed_reply_data (hcl_client_proto_t* proto, const hcl_bch_t* ptr, hcl_oow_t len)
|
||||
{
|
||||
const hcl_bch_t* end = ptr + len;
|
||||
while (ptr < end)
|
||||
{
|
||||
hcl_bch_t b = *ptr++;
|
||||
|
||||
switch (b)
|
||||
static HCL_INLINE int is_spacechar (hcl_bch_t c)
|
||||
{
|
||||
/* TODO: handle other space unicode characters */
|
||||
switch (c)
|
||||
{
|
||||
case ' ':
|
||||
case '\f': /* formfeed */
|
||||
case '\r': /* carriage return */
|
||||
case '\t': /* horizon tab */
|
||||
case '\v': /* vertical tab */
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_alphachar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_digitchar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
|
||||
static void clear_reply_token (hcl_client_proto_t* proto)
|
||||
{
|
||||
proto->rep.tok.len = 0;
|
||||
}
|
||||
|
||||
static int add_to_reply_token (hcl_client_proto_t* proto, hcl_ooch_t ch)
|
||||
{
|
||||
if (proto->rep.tok.len >= proto->rep.tok.capa)
|
||||
{
|
||||
hcl_ooch_t* tmp;
|
||||
hcl_oow_t newcapa;
|
||||
|
||||
newcapa = HCL_ALIGN_POW2(proto->rep.tok.len + 1, 128);
|
||||
tmp = hcl_client_reallocmem(proto->client, proto->rep.tok.ptr, newcapa * HCL_SIZEOF(*tmp));
|
||||
if (!tmp) return -1;
|
||||
|
||||
proto->rep.tok.capa = newcapa;
|
||||
proto->rep.tok.ptr = tmp;
|
||||
}
|
||||
|
||||
proto->rep.tok.ptr[proto->rep.tok.len++] = ch;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int proto_feed_reply_data (hcl_client_proto_t* proto, const hcl_bch_t* data, hcl_oow_t len)
|
||||
{
|
||||
const hcl_bch_t* ptr;
|
||||
const hcl_bch_t* end;
|
||||
|
||||
ptr = data;
|
||||
end = ptr + len;
|
||||
|
||||
if (proto->state == HCL_CLIENT_PROTO_STATE_IN_BINARY_DATA)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
while (ptr < end)
|
||||
{
|
||||
case '\0':
|
||||
hcl_ooch_t c;
|
||||
|
||||
#if defined(HCL_OOCH_IS_UCH)
|
||||
hcl_oow_t bcslen, ucslen;
|
||||
int n;
|
||||
|
||||
bcslen = end - ptr;
|
||||
ucslen = 1;
|
||||
|
||||
n = hcl_conv_bcsn_to_ucsn_with_cmgr(ptr, &bcslen, &c, &ucslen, proto->client->cmgr, 0);
|
||||
if (n <= -1)
|
||||
{
|
||||
if (n == -3)
|
||||
{
|
||||
/* incomplete sequence */
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
#else
|
||||
c = *ptr++;
|
||||
#endif
|
||||
|
||||
switch (proto->state)
|
||||
{
|
||||
case HCL_CLIENT_PROTO_STATE_START:
|
||||
if (c == '.')
|
||||
{
|
||||
proto->state = HCL_CLIENT_PROTO_STATE_IN_REPLY_NAME;
|
||||
clear_reply_token (proto);
|
||||
if (add_to_reply_token(proto, c) <= -1) goto oops;
|
||||
break;
|
||||
}
|
||||
else if (!is_spacechar(c))
|
||||
{
|
||||
/* TODO: set error code? or log error messages? */
|
||||
goto oops;
|
||||
}
|
||||
break;
|
||||
|
||||
case HCL_CLIENT_PROTO_STATE_IN_REPLY_NAME:
|
||||
if (is_alphachar(c) || (proto->rep.tok.len > 2 && c == '-'))
|
||||
{
|
||||
if (add_to_reply_token(proto, c) <= -1) goto oops;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (hcl_compoocharsbcstr(proto->rep.tok.ptr, proto->rep.tok.len, ".OK") == 0)
|
||||
{
|
||||
proto->rep.type = HCL_REPLY_TYPE_OK;
|
||||
}
|
||||
else if (hcl_compoocharsbcstr(proto->rep.tok.ptr, proto->rep.tok.len, ".ERROR") == 0)
|
||||
{
|
||||
proto->rep.type = HCL_REPLY_TYPE_ERROR;
|
||||
}
|
||||
|
||||
clear_reply_token (proto);
|
||||
if (add_to_reply_token(proto, c) <= -1) goto oops;
|
||||
}
|
||||
break;
|
||||
/*case HCL_CLIENT_PROTO_STATE_IN_START_LINE:*/
|
||||
|
||||
case HCL_CLIENT_PROTO_STATE_IN_HEADER_NAME:
|
||||
|
||||
break;
|
||||
|
||||
case HCL_CLIENT_PROTO_STATE_IN_HEADER_VALUE:
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
|
||||
oops:
|
||||
/* TODO: compute the number of processes bytes so far and return it via a parameter??? */
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
@ -217,6 +394,64 @@ void hcl_client_close (hcl_client_t* client)
|
||||
HCL_MMGR_FREE (client->mmgr, client);
|
||||
}
|
||||
|
||||
|
||||
hcl_errnum_t hcl_client_geterrnum (hcl_client_t* client)
|
||||
{
|
||||
return client->errnum;
|
||||
}
|
||||
|
||||
const hcl_ooch_t* hcl_client_geterrstr (hcl_client_t* client)
|
||||
{
|
||||
return hcl_errnum_to_errstr(client->errnum);
|
||||
}
|
||||
|
||||
const hcl_ooch_t* hcl_client_geterrmsg (hcl_client_t* client)
|
||||
{
|
||||
if (client->errmsg.len <= 0) return hcl_errnum_to_errstr(client->errnum);
|
||||
return client->errmsg.buf;
|
||||
}
|
||||
|
||||
void hcl_client_seterrnum (hcl_client_t* client, hcl_errnum_t errnum)
|
||||
{
|
||||
/*if (client->shuterr) return; */
|
||||
client->errnum = errnum;
|
||||
client->errmsg.len = 0;
|
||||
}
|
||||
|
||||
void* hcl_client_allocmem (hcl_client_t* client, hcl_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
|
||||
ptr = HCL_MMGR_ALLOC(client->mmgr, size);
|
||||
if (!ptr) hcl_client_seterrnum (client, HCL_ESYSMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hcl_client_callocmem (hcl_client_t* client, hcl_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
|
||||
ptr = HCL_MMGR_ALLOC(client->mmgr, size);
|
||||
if (!ptr) hcl_client_seterrnum (client, HCL_ESYSMEM);
|
||||
else HCL_MEMSET (ptr, 0, size);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hcl_client_reallocmem (hcl_client_t* client, void* ptr, hcl_oow_t size)
|
||||
{
|
||||
ptr = HCL_MMGR_REALLOC(client->mmgr, ptr, size);
|
||||
if (!ptr) hcl_client_seterrnum (client, HCL_ESYSMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void hcl_client_freemem (hcl_client_t* client, void* ptr)
|
||||
{
|
||||
HCL_MMGR_FREE (client->mmgr, ptr);
|
||||
}
|
||||
|
||||
|
||||
/* ========================================================================= */
|
||||
|
||||
int hcl_client_start (hcl_client_t* client, const hcl_bch_t* addrs)
|
||||
{
|
||||
|
||||
@ -228,3 +463,6 @@ int hcl_client_start (hcl_client_t* client, const hcl_bch_t* addrs)
|
||||
int hcl_client_sendreq (hcl_client_t* client, const hcl_bch_t* addrs)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
86
lib/hcl-c.h
86
lib/hcl-c.h
@ -49,6 +49,92 @@ HCL_EXPORT void hcl_client_close (
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT hcl_errnum_t hcl_client_geterrnum (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT const hcl_ooch_t* hcl_client_geterrstr (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT const hcl_ooch_t* hcl_client_geterrmsg (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT void hcl_client_seterrnum (
|
||||
hcl_client_t* client,
|
||||
hcl_errnum_t errnum
|
||||
);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
HCL_EXPORT void* hcl_client_allocmem (
|
||||
hcl_client_t* client,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_client_callocmem (
|
||||
hcl_client_t* client,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_client_reallocmem (
|
||||
hcl_client_t* client,
|
||||
void* ptr,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT void hcl_client_freemem (
|
||||
hcl_client_t* client,
|
||||
void* ptr
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT hcl_errnum_t hcl_client_geterrnum (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT const hcl_ooch_t* hcl_client_geterrstr (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT const hcl_ooch_t* hcl_client_geterrmsg (
|
||||
hcl_client_t* client
|
||||
);
|
||||
|
||||
HCL_EXPORT void hcl_client_seterrnum (
|
||||
hcl_client_t* client,
|
||||
hcl_errnum_t errnum
|
||||
);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
HCL_EXPORT void* hcl_client_allocmem (
|
||||
hcl_client_t* client,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_client_callocmem (
|
||||
hcl_client_t* client,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_client_reallocmem (
|
||||
hcl_client_t* client,
|
||||
void* ptr,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT void hcl_client_freemem (
|
||||
hcl_client_t* client,
|
||||
void* ptr
|
||||
);
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
111
lib/hcl-s.c
111
lib/hcl-s.c
@ -1046,7 +1046,7 @@ hcl_server_proto_t* hcl_server_proto_open (hcl_oow_t xtnsize, hcl_server_worker_
|
||||
vmprim.vm_gettime = vm_gettime;
|
||||
vmprim.vm_sleep = vm_sleep;
|
||||
|
||||
proto = (hcl_server_proto_t*)HCL_MMGR_ALLOC(worker->server->mmgr, HCL_SIZEOF(*proto));
|
||||
proto = (hcl_server_proto_t*)hcl_server_allocmem(worker->server, HCL_SIZEOF(*proto));
|
||||
if (!proto) return HCL_NULL;
|
||||
|
||||
HCL_MEMSET (proto, 0, HCL_SIZEOF(*proto));
|
||||
@ -1087,16 +1087,16 @@ oops:
|
||||
if (proto)
|
||||
{
|
||||
if (proto->hcl) hcl_close (proto->hcl);
|
||||
HCL_MMGR_FREE (proto->worker->server->mmgr, proto);
|
||||
hcl_server_freemem (proto->worker->server, proto);
|
||||
}
|
||||
return HCL_NULL;
|
||||
}
|
||||
|
||||
void hcl_server_proto_close (hcl_server_proto_t* proto)
|
||||
{
|
||||
if (proto->tok.ptr) HCL_MMGR_FREE (proto->worker->server->mmgr, proto->tok.ptr);
|
||||
if (proto->tok.ptr) hcl_server_freemem (proto->worker->server, proto->tok.ptr);
|
||||
hcl_close (proto->hcl);
|
||||
HCL_MMGR_FREE (proto->worker->server->mmgr, proto);
|
||||
hcl_server_freemem (proto->worker->server, proto);
|
||||
}
|
||||
|
||||
static int write_reply_chunk (hcl_server_proto_t* proto)
|
||||
@ -1293,6 +1293,18 @@ static HCL_INLINE int is_spacechar (hcl_ooci_t c)
|
||||
}
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_alphachar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_digitchar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
|
||||
static HCL_INLINE int read_char (hcl_server_proto_t* proto)
|
||||
{
|
||||
proto->lxc = hcl_readchar(proto->hcl);
|
||||
@ -1329,7 +1341,7 @@ static HCL_INLINE int add_token_char (hcl_server_proto_t* proto, hcl_ooch_t c)
|
||||
hcl_oow_t capa;
|
||||
|
||||
capa = HCL_ALIGN_POW2(proto->tok.len + 1, HCL_SERVER_TOKEN_NAME_ALIGN);
|
||||
tmp = (hcl_ooch_t*)HCL_MMGR_REALLOC(proto->worker->server->mmgr, proto->tok.ptr, capa * HCL_SIZEOF(*tmp));
|
||||
tmp = (hcl_ooch_t*)hcl_server_reallocmem(proto->worker->server, proto->tok.ptr, capa * HCL_SIZEOF(*tmp));
|
||||
if (!tmp)
|
||||
{
|
||||
HCL_LOG0 (proto->hcl, SERVER_LOGMASK_ERROR, "Out of memory in allocating a token buffer\n");
|
||||
@ -1344,18 +1356,6 @@ static HCL_INLINE int add_token_char (hcl_server_proto_t* proto, hcl_ooch_t c)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_alphachar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_digitchar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: support full unicode */
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
|
||||
static void classify_current_ident_token (hcl_server_proto_t* proto)
|
||||
{
|
||||
static struct cmd_t
|
||||
@ -1832,10 +1832,10 @@ int hcl_server_proto_handle_request (hcl_server_proto_t* proto)
|
||||
|
||||
hcl_server_t* hcl_server_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize, hcl_server_prim_t* prim, hcl_errnum_t* errnum)
|
||||
{
|
||||
hcl_server_t* server;
|
||||
hcl_t* hcl;
|
||||
hcl_server_t* server = HCL_NULL;
|
||||
hcl_t* hcl = HCL_NULL;
|
||||
hcl_vmprim_t vmprim;
|
||||
hcl_tmr_t* tmr;
|
||||
hcl_tmr_t* tmr = HCL_NULL;
|
||||
dummy_hcl_xtn_t* xtn;
|
||||
int pfd[2], fcv;
|
||||
unsigned int trait;
|
||||
@ -1857,26 +1857,19 @@ hcl_server_t* hcl_server_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize, hcl_server_p
|
||||
vmprim.vm_sleep = vm_sleep;
|
||||
|
||||
hcl = hcl_open(mmgr, HCL_SIZEOF(*xtn), 2048, &vmprim, errnum);
|
||||
if (!hcl)
|
||||
{
|
||||
HCL_MMGR_FREE (mmgr, server);
|
||||
return HCL_NULL;
|
||||
}
|
||||
if (!hcl) goto oops;
|
||||
|
||||
tmr = hcl_tmr_open(hcl, 0, 1024); /* TOOD: make the timer's default size configurable */
|
||||
if (!tmr)
|
||||
{
|
||||
hcl_close (hcl);
|
||||
HCL_MMGR_FREE (mmgr, server);
|
||||
return HCL_NULL;
|
||||
if (errnum) *errnum = HCL_ESYSMEM;
|
||||
goto oops;
|
||||
}
|
||||
|
||||
if (pipe(pfd) <= -1)
|
||||
{
|
||||
hcl_tmr_close (tmr);
|
||||
hcl_close (hcl);
|
||||
HCL_MMGR_FREE (mmgr, server);
|
||||
return HCL_NULL;
|
||||
if (errnum) *errnum = hcl_syserr_to_errnum(errno);
|
||||
goto oops;
|
||||
}
|
||||
|
||||
#if defined(O_CLOEXEC)
|
||||
@ -1932,13 +1925,20 @@ hcl_server_t* hcl_server_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize, hcl_server_p
|
||||
hcl_setoption (server->dummy_hcl, HCL_TRAIT, &trait);
|
||||
|
||||
return server;
|
||||
|
||||
oops:
|
||||
/* NOTE: pipe should be closed if jump to here is made after pipe() above */
|
||||
if (tmr) hcl_tmr_close (tmr);
|
||||
if (hcl) hcl_close (hcl);
|
||||
if (server) HCL_MMGR_FREE (mmgr, server);
|
||||
return HCL_NULL;
|
||||
}
|
||||
|
||||
void hcl_server_close (hcl_server_t* server)
|
||||
{
|
||||
if (server->wid_map.ptr)
|
||||
{
|
||||
HCL_MMGR_FREE (server->mmgr, server->wid_map.ptr);
|
||||
hcl_server_freemem(server, server->wid_map.ptr);
|
||||
server->wid_map.capa = 0;
|
||||
server->wid_map.free_first = HCL_SERVER_WID_INVALID;
|
||||
server->wid_map.free_last = HCL_SERVER_WID_INVALID;
|
||||
@ -1976,12 +1976,8 @@ static HCL_INLINE int prepare_to_acquire_wid (hcl_server_t* server)
|
||||
new_capa = HCL_SERVER_WID_MAX;
|
||||
}
|
||||
|
||||
tmp = (hcl_server_wid_map_data_t*)HCL_MMGR_REALLOC(server->mmgr, server->wid_map.ptr, HCL_SIZEOF(*tmp) * new_capa);
|
||||
if (!tmp)
|
||||
{
|
||||
hcl_server_seterrnum (server, HCL_ESYSERR);
|
||||
return -1;
|
||||
}
|
||||
tmp = (hcl_server_wid_map_data_t*)hcl_server_reallocmem(server, server->wid_map.ptr, HCL_SIZEOF(*tmp) * new_capa);
|
||||
if (!tmp) return -1;
|
||||
|
||||
server->wid_map.free_first = server->wid_map.capa;
|
||||
for (i = server->wid_map.capa, j = server->wid_map.capa + 1; j < new_capa; i++, j++)
|
||||
@ -2039,7 +2035,7 @@ static hcl_server_worker_t* alloc_worker (hcl_server_t* server, int cli_sck, con
|
||||
{
|
||||
hcl_server_worker_t* worker;
|
||||
|
||||
worker = (hcl_server_worker_t*)HCL_MMGR_ALLOC(server->mmgr, HCL_SIZEOF(*worker));
|
||||
worker = (hcl_server_worker_t*)hcl_server_allocmem(server, HCL_SIZEOF(*worker));
|
||||
if (!worker) return HCL_NULL;
|
||||
|
||||
HCL_MEMSET (worker, 0, HCL_SIZEOF(*worker));
|
||||
@ -2053,7 +2049,7 @@ static hcl_server_worker_t* alloc_worker (hcl_server_t* server, int cli_sck, con
|
||||
|
||||
if (server->wid_map.free_first == HCL_SERVER_WID_INVALID && prepare_to_acquire_wid(server) <= -1)
|
||||
{
|
||||
HCL_MMGR_FREE (server->mmgr, worker);
|
||||
hcl_server_freemem (server, worker);
|
||||
return HCL_NULL;
|
||||
}
|
||||
|
||||
@ -2092,7 +2088,7 @@ static void free_worker (hcl_server_worker_t* worker)
|
||||
}
|
||||
|
||||
release_wid (worker->server, worker);
|
||||
HCL_MMGR_FREE (worker->server->mmgr, worker);
|
||||
hcl_server_freemem (worker->server, worker);
|
||||
}
|
||||
|
||||
static void add_worker_to_server (hcl_server_t* server, hcl_server_worker_state_t wstate, hcl_server_worker_t* worker)
|
||||
@ -2604,3 +2600,34 @@ void hcl_server_seterrufmt (hcl_server_t* server, hcl_errnum_t errnum, const hcl
|
||||
hcl_copyoochars (server->errmsg.buf, server->dummy_hcl->errmsg.buf, HCL_COUNTOF(server->errmsg.buf));
|
||||
server->errmsg.len = server->dummy_hcl->errmsg.len;
|
||||
}
|
||||
|
||||
void* hcl_server_allocmem (hcl_server_t* server, hcl_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
|
||||
ptr = HCL_MMGR_ALLOC(server->mmgr, size);
|
||||
if (!ptr) hcl_server_seterrnum (server, HCL_ESYSMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hcl_server_callocmem (hcl_server_t* server, hcl_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
|
||||
ptr = HCL_MMGR_ALLOC(server->mmgr, size);
|
||||
if (!ptr) hcl_server_seterrnum (server, HCL_ESYSMEM);
|
||||
else HCL_MEMSET (ptr, 0, size);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hcl_server_reallocmem (hcl_server_t* server, void* ptr, hcl_oow_t size)
|
||||
{
|
||||
ptr = HCL_MMGR_REALLOC(server->mmgr, ptr, size);
|
||||
if (!ptr) hcl_server_seterrnum (server, HCL_ESYSMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void hcl_server_freemem (hcl_server_t* server, void* ptr)
|
||||
{
|
||||
HCL_MMGR_FREE (server->mmgr, ptr);
|
||||
}
|
||||
|
||||
23
lib/hcl-s.h
23
lib/hcl-s.h
@ -176,6 +176,29 @@ HCL_EXPORT void hcl_server_logufmt (
|
||||
...
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT void* hcl_server_allocmem (
|
||||
hcl_server_t* server,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_server_callocmem (
|
||||
hcl_server_t* server,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
HCL_EXPORT void* hcl_server_reallocmem (
|
||||
hcl_server_t* server,
|
||||
void* ptr,
|
||||
hcl_oow_t size
|
||||
);
|
||||
|
||||
|
||||
HCL_EXPORT void hcl_server_freemem (
|
||||
hcl_server_t* server,
|
||||
void* ptr
|
||||
);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -240,6 +240,7 @@ static hcl_oop_t string_to_num (hcl_t* hcl, hcl_oocs_t* str, int radixed)
|
||||
if (negsign) base = -base;
|
||||
return hcl_strtoint(hcl, ptr, end - ptr, base);
|
||||
}
|
||||
|
||||
static HCL_INLINE int is_spacechar (hcl_ooci_t c)
|
||||
{
|
||||
/* TODO: handle other space unicode characters */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user