c->udppkt = (ms_udppkt_t *) malloc(MAX_UDP_PACKET * sizeof(ms_udppkt_t));
if ((c->rudpbuf == NULL) || (c->udppkt == NULL)) {
- if (c->rudpbuf != NULL)
+ if (c->rudpbuf)
free(c->rudpbuf);
- if (c->udppkt != NULL)
+ if (c->udppkt)
free(c->udppkt);
fprintf(stderr, "malloc()\n");
return -1;
*/
static int ms_conn_init(ms_conn_t *c, const int init_state, const int read_buffer_size,
const bool is_udp) {
- assert(c != NULL);
+ assert(c);
c->rbuf = c->wbuf = 0;
c->iov = 0;
|| (c->tcpsfd == NULL)
|| ((ms_setting.mult_key_num > 1) && (c->mlget_task.mlget_item == NULL)))
{
- if (c->rbuf != NULL)
+ if (c->rbuf)
free(c->rbuf);
- if (c->wbuf != NULL)
+ if (c->wbuf)
free(c->wbuf);
- if (c->iov != NULL)
+ if (c->iov)
free(c->iov);
- if (c->msglist != NULL)
+ if (c->msglist)
free(c->msglist);
- if (c->mlget_task.mlget_item != NULL)
+ if (c->mlget_task.mlget_item)
free(c->mlget_task.mlget_item);
- if (c->tcpsfd != NULL)
+ if (c->tcpsfd)
free(c->tcpsfd);
fprintf(stderr, "malloc()\n");
return -1;
}
/* initialize udp */
- if (ms_conn_udp_init(c, is_udp) != 0) {
+ if (ms_conn_udp_init(c, is_udp)) {
return -1;
}
int ret_sfd;
uint32_t srv_idx = 0;
- assert(c != NULL);
- assert(c->tcpsfd != NULL);
+ assert(c);
+ assert(c->tcpsfd);
for (i = 0; i < c->total_sfds; i++) {
ret_sfd = 0;
if (ms_network_connect(c, ms_setting.servers[srv_idx].srv_host_name,
ms_setting.servers[srv_idx].srv_port, ms_setting.udp, &ret_sfd)
- != 0)
+)
{
break;
}
ret_sfd = 0;
if (ms_network_connect(c, ms_setting.servers[srv_idx].srv_host_name,
ms_setting.servers[srv_idx].srv_port, true, &ret_sfd)
- != 0)
+)
{
c->udpsfd = 0;
} else {
}
}
- if (c->udpsfd != 0) {
+ if (c->udpsfd) {
close(c->udpsfd);
}
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
int ms_setup_conn(ms_conn_t *c) {
- if (ms_item_win_init(c) != 0) {
+ if (ms_item_win_init(c)) {
return -1;
}
- if (ms_conn_init(c, conn_write, DATA_BUFFER_SIZE, ms_setting.udp) != 0) {
+ if (ms_conn_init(c, conn_write, DATA_BUFFER_SIZE, ms_setting.udp)) {
return -1;
}
- if (ms_conn_sock_init(c) != 0) {
+ if (ms_conn_sock_init(c)) {
return -1;
}
- if (ms_conn_event_init(c) != 0) {
+ if (ms_conn_event_init(c)) {
return -1;
}
*/
void ms_conn_free(ms_conn_t *c) {
ms_thread_t *ms_thread = pthread_getspecific(ms_thread_key);
- if (c != NULL) {
- if (c->hdrbuf != NULL)
+ if (c) {
+ if (c->hdrbuf)
free(c->hdrbuf);
- if (c->msglist != NULL)
+ if (c->msglist)
free(c->msglist);
- if (c->rbuf != NULL)
+ if (c->rbuf)
free(c->rbuf);
- if (c->wbuf != NULL)
+ if (c->wbuf)
free(c->wbuf);
- if (c->iov != NULL)
+ if (c->iov)
free(c->iov);
- if (c->mlget_task.mlget_item != NULL)
+ if (c->mlget_task.mlget_item)
free(c->mlget_task.mlget_item);
- if (c->rudpbuf != NULL)
+ if (c->rudpbuf)
free(c->rudpbuf);
- if (c->udppkt != NULL)
+ if (c->udppkt)
free(c->udppkt);
- if (c->item_win != NULL)
+ if (c->item_win)
free(c->item_win);
- if (c->tcpsfd != NULL)
+ if (c->tcpsfd)
free(c->tcpsfd);
if (--ms_thread->nactive_conn == 0) {
*/
static void ms_conn_close(ms_conn_t *c) {
ms_thread_t *ms_thread = pthread_getspecific(ms_thread_key);
- assert(c != NULL);
+ assert(c);
/* delete the event, the socket and the connection */
event_del(&c->event);
}
if (ms_thread->nactive_conn == 0) {
- pthread_exit(NULL);
+ event_base_loopbreak(ms_thread->base);
}
} /* ms_conn_close */
unsigned int old_size;
/* Start with the default size. */
- if (getsockopt(sfd, SOL_SOCKET, SO_SNDBUF, &old_size, &intsize) != 0) {
+ if (getsockopt(sfd, SOL_SOCKET, SO_SNDBUF, &old_size, &intsize)) {
fprintf(stderr, "getsockopt(SO_SNDBUF)\n");
return;
}
snprintf(port_buf, NI_MAXSERV, "%d", srv_port);
error = getaddrinfo(srv_host_name, port_buf, &hints, &ai);
- if (error != 0) {
+ if (error) {
if (error != EAI_SYSTEM)
fprintf(stderr, "getaddrinfo(): %s.\n", gai_strerror(error));
else
return -1;
}
- if (ret_sfd != NULL) {
+ if (ret_sfd) {
*ret_sfd = sfd;
}
uint32_t i = 0;
for (i = 0; i < c->total_sfds; i++) {
- if (c->tcpsfd[i] != 0) {
+ if (c->tcpsfd[i]) {
break;
}
}
uint32_t srv_conn_cnt = 0;
struct timeval cur_time;
- assert(c != NULL);
+ assert(c);
if ((c->total_sfds == 1) || (c->total_sfds == c->alive_sfds)) {
return EXIT_SUCCESS;
* Usage example:
*
* while(ms_tokenize_command(command, ncommand, tokens, max_tokens) > 0) {
- * for(int ix = 0; tokens[ix].length != 0; ix++) {
+ * for(int ix = 0; tokens[ix].length; ix++) {
* ...
* }
* ncommand = tokens[ix].value - command;
char *s, *e;
int ntokens = 0;
- assert(command != NULL && tokens != NULL && max_tokens > 1);
+ assert(command && tokens && max_tokens > 1);
for (s = e = command; ntokens < max_tokens - 1; ++e) {
if (*e == ' ') {
int64_t value_len;
char *buffer = command;
- assert(c != NULL);
+ assert(c);
/**
* for command get, we store the returned value into local buffer
ms_tokenize_command(command, tokens, MAX_TOKENS);
errno = 0;
value_len = strtol(tokens[VALUELEN_TOKEN].value, NULL, 10);
- if (errno != 0) {
+ if (errno) {
printf("<%d ERROR %s\n", c->sfd, strerror(errno));
}
memcpy(&c->currcmd.key_prefix, tokens[KEY_TOKEN].value, sizeof(c->currcmd.key_prefix));
* @param timeout, whether it's timeout
*/
void ms_reset_conn(ms_conn_t *c, bool timeout) {
- assert(c != NULL);
+ assert(c);
if (c->udp) {
if ((c->packets > 0) && (c->packets < MAX_UDP_PACKET)) {
return EXIT_SUCCESS;
} else {
#ifdef NEED_ALIGN
- if (((long) (c->rcurr)) % 8 != 0) {
+ if (((long) (c->rcurr)) % 8) {
/* must realign input buffer */
memmove(c->rbuf, c->rcurr, c->rbytes);
c->rcurr = c->rbuf;
} else {
char *el, *cont;
- assert(c != NULL);
+ assert(c);
assert(c->rcurr <= (c->rbuf + c->rsize));
if (c->rbytes == 0)
unsigned char *header = NULL;
/* no enough data */
- assert(c != NULL);
- assert(buf != NULL);
+ assert(c);
+ assert(buf);
assert(c->rudpbytes >= UDP_HEADER_SIZE);
/* calculate received packets count */
for (int i = c->ordcurr; i < c->recvpkt; i++) {
/* there is some data to copy */
- if ((c->udppkt[i].data != NULL) && (c->udppkt[i].copybytes < c->udppkt[i].rbytes)) {
+ if ((c->udppkt[i].data) && (c->udppkt[i].copybytes < c->udppkt[i].rbytes)) {
header = c->udppkt[i].header;
len = c->udppkt[i].rbytes - c->udppkt[i].copybytes;
if (len > rbytes - wbytes) {
int res;
int64_t avail;
- assert(c != NULL);
+ assert(c);
if ((c->rcurr != c->rbuf)
&& (!c->readval || (c->rvbytes > c->rsize - (c->rcurr - c->rbuf))
|| (c->readval && (c->rcurr - c->rbuf > c->rbytes))))
{
- if (c->rbytes != 0) /* otherwise there's nothing to copy */
+ if (c->rbytes) /* otherwise there's nothing to copy */
memmove(c->rbuf, c->rcurr, (size_t) c->rbytes);
c->rcurr = c->rbuf;
}
}
}
} else {
- if ((c->curr_task.item->value_size != vlen) || (memcmp(orignval, value, (size_t) vlen) != 0))
+ if ((c->curr_task.item->value_size != vlen) || (memcmp(orignval, value, (size_t) vlen)))
{
atomic_add_size(&ms_stats.vef_failed, 1);
c->curr_task.finish_verify = true;
- if (mlget_item != NULL) {
+ if (mlget_item) {
mlget_item->finish_verify = true;
}
}
* @param c, pointer of the concurrency
*/
static void ms_ascii_complete_nread(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
assert(c->rbytes >= c->rvbytes);
assert(c->protocol == ascii_prot);
if (c->rvbytes > 2) {
* @param c, pointer of the concurrency
*/
static void ms_bin_complete_nread(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
assert(c->rbytes >= c->rvbytes);
assert(c->protocol == binary_prot);
* @param c, pointer of the concurrency
*/
static void ms_complete_nread(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
assert(c->rbytes >= c->rvbytes);
assert(c->protocol == ascii_prot || c->protocol == binary_prot);
static int ms_add_msghdr(ms_conn_t *c) {
struct msghdr *msg;
- assert(c != NULL);
+ assert(c);
if (c->msgsize == c->msgused) {
msg = realloc(c->msglist, (size_t) c->msgsize * 2 * sizeof(struct msghdr));
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
static int ms_ensure_iov_space(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
if (c->iovused >= c->iovsize) {
int i, iovnum;
int leftover;
bool limit_to_mtu;
- assert(c != NULL);
+ assert(c);
do {
m = &c->msglist[c->msgused - 1];
}
#endif
- if (ms_ensure_iov_space(c) != 0)
+ if (ms_ensure_iov_space(c))
return -1;
/* If the fragment is too big to fit in the datagram, split it up */
int i;
unsigned char *hdr;
- assert(c != NULL);
+ assert(c);
c->request_id = ms_get_udp_request_id();
* TRANSMIT_HARD_ERROR Can't write (c->state is set to conn_closing)
*/
static int ms_transmit(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
if ((c->msgcurr < c->msgused) && (c->msglist[c->msgcurr].msg_iovlen == 0)) {
/* Finished writing the current msg; advance to the next. */
* @param c, pointer of the concurrency
*/
static void ms_conn_shrink(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
if (c->udp)
return;
* @param state, connection state
*/
static void ms_conn_set_state(ms_conn_t *c, int state) {
- assert(c != NULL);
+ assert(c);
if (state != c->state) {
if (state == conn_read) {
* @return bool, if success, return true, else return false
*/
static bool ms_update_event(ms_conn_t *c, const int new_flags) {
- assert(c != NULL);
+ assert(c);
struct event_base *base = c->event.ev_base;
if ((c->ev_flags == new_flags) && (ms_setting.rep_write_srv == 0)
static void ms_drive_machine(ms_conn_t *c) {
bool stop = false;
- assert(c != NULL);
+ assert(c);
while (!stop) {
switch (c->state) {
break;
}
} else {
- if (ms_try_read_line(c) != 0) {
+ if (ms_try_read_line(c)) {
break;
}
}
- if (ms_try_read_network(c) != 0) {
+ if (ms_try_read_network(c)) {
break;
}
break;
}
- if (!c->ctnwrite && (ms_exec_task(c) != 0)) {
+ if (!c->ctnwrite && (ms_exec_task(c))) {
ms_conn_set_state(c, conn_closing);
break;
}
if (ms_setting.reconnect
&& (!ms_global.time_out || ((ms_setting.run_time == 0) && (c->remain_exec_num > 0))))
{
- if (ms_reconn(c) != 0) {
+ if (ms_reconn(c)) {
ms_conn_close(c);
stop = true;
break;
void ms_event_handler(const int fd, const short which, void *arg) {
ms_conn_t *c = (ms_conn_t *) arg;
- assert(c != NULL);
+ assert(c);
c->which = which;
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
static int ms_update_conn_sock_event(ms_conn_t *c) {
- assert(c != NULL);
+ assert(c);
switch (c->currcmd.cmd) {
case CMD_SET:
}
c->sfd = c->tcpsfd[c->cur_idx];
- assert(c->sfd != 0);
+ assert(c->sfd);
c->change_sfd = true;
}
value_offset = item->value_offset;
}
- if ((ms_add_iov(c, "set ", 4) != 0)
- || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE) != 0)
+ if ((ms_add_iov(c, "set ", 4))
+ || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE))
|| (ms_add_iov(c, &ms_setting.char_block[item->key_suffix_offset],
item->key_size - (int) KEY_PREFIX_SIZE)
- != 0)
- || (ms_add_iov(c, buffer, write_len) != 0)
- || (ms_add_iov(c, &ms_setting.char_block[value_offset], item->value_size) != 0)
- || (ms_add_iov(c, "\r\n", 2) != 0) || (c->udp && (ms_build_udp_headers(c) != 0)))
+)
+ || (ms_add_iov(c, buffer, write_len))
+ || (ms_add_iov(c, &ms_setting.char_block[value_offset], item->value_size))
+ || (ms_add_iov(c, "\r\n", 2)) || (c->udp && (ms_build_udp_headers(c))))
{
return -1;
}
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
int ms_mcd_set(ms_conn_t *c, ms_task_item_t *item) {
- assert(c != NULL);
+ assert(c);
c->currcmd.cmd = CMD_SET;
c->currcmd.isfinish = false;
c->currcmd.retstat = MCD_FAILURE;
- if (ms_update_conn_sock_event(c) != 0) {
+ if (ms_update_conn_sock_event(c)) {
return -1;
}
c->msgcurr = 0;
c->msgused = 0;
c->iovused = 0;
- if (ms_add_msghdr(c) != 0) {
+ if (ms_add_msghdr(c)) {
fprintf(stderr, "Out of memory preparing request.");
return -1;
}
/* binary protocol */
if (c->protocol == binary_prot) {
- if (ms_build_bin_write_buf_set(c, item) != 0) {
+ if (ms_build_bin_write_buf_set(c, item)) {
return -1;
}
} else {
- if (ms_build_ascii_write_buf_set(c, item) != 0) {
+ if (ms_build_ascii_write_buf_set(c, item)) {
return -1;
}
}
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
static int ms_build_ascii_write_buf_get(ms_conn_t *c, ms_task_item_t *item) {
- if ((ms_add_iov(c, "get ", 4) != 0)
- || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE) != 0)
+ if ((ms_add_iov(c, "get ", 4))
+ || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE))
|| (ms_add_iov(c, &ms_setting.char_block[item->key_suffix_offset],
item->key_size - (int) KEY_PREFIX_SIZE)
- != 0)
- || (ms_add_iov(c, "\r\n", 2) != 0) || (c->udp && (ms_build_udp_headers(c) != 0)))
+)
+ || (ms_add_iov(c, "\r\n", 2)) || (c->udp && (ms_build_udp_headers(c))))
{
return -1;
}
* @return int, if success, return EXIT_SUCCESS, else return -1
*/
int ms_mcd_get(ms_conn_t *c, ms_task_item_t *item) {
- assert(c != NULL);
+ assert(c);
c->currcmd.cmd = CMD_GET;
c->currcmd.isfinish = false;
c->currcmd.retstat = MCD_FAILURE;
- if (ms_update_conn_sock_event(c) != 0) {
+ if (ms_update_conn_sock_event(c)) {
return -1;
}
c->msgcurr = 0;
c->msgused = 0;
c->iovused = 0;
- if (ms_add_msghdr(c) != 0) {
+ if (ms_add_msghdr(c)) {
fprintf(stderr, "Out of memory preparing request.");
return -1;
}
/* binary protocol */
if (c->protocol == binary_prot) {
- if (ms_build_bin_write_buf_get(c, item) != 0) {
+ if (ms_build_bin_write_buf_get(c, item)) {
return -1;
}
} else {
- if (ms_build_ascii_write_buf_get(c, item) != 0) {
+ if (ms_build_ascii_write_buf_get(c, item)) {
return -1;
}
}
static int ms_build_ascii_write_buf_mlget(ms_conn_t *c) {
ms_task_item_t *item;
- if (ms_add_iov(c, "get", 3) != 0) {
+ if (ms_add_iov(c, "get", 3)) {
return -1;
}
for (int i = 0; i < c->mlget_task.mlget_num; i++) {
item = c->mlget_task.mlget_item[i].item;
- assert(item != NULL);
- if ((ms_add_iov(c, " ", 1) != 0)
- || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE) != 0)
+ assert(item);
+ if ((ms_add_iov(c, " ", 1))
+ || (ms_add_iov(c, (char *) &item->key_prefix, (int) KEY_PREFIX_SIZE))
|| (ms_add_iov(c, &ms_setting.char_block[item->key_suffix_offset],
item->key_size - (int) KEY_PREFIX_SIZE)
- != 0))
+))
{
return -1;
}
}
- if ((ms_add_iov(c, "\r\n", 2) != 0) || (c->udp && (ms_build_udp_headers(c) != 0))) {
+ if ((ms_add_iov(c, "\r\n", 2)) || (c->udp && (ms_build_udp_headers(c)))) {
return -1;
}
int ms_mcd_mlget(ms_conn_t *c) {
ms_task_item_t *item;
- assert(c != NULL);
+ assert(c);
assert(c->mlget_task.mlget_num >= 1);
c->currcmd.cmd = CMD_GET;
c->currcmd.isfinish = false;
c->currcmd.retstat = MCD_FAILURE;
- if (ms_update_conn_sock_event(c) != 0) {
+ if (ms_update_conn_sock_event(c)) {
return -1;
}
c->msgcurr = 0;
c->msgused = 0;
c->iovused = 0;
- if (ms_add_msghdr(c) != 0) {
+ if (ms_add_msghdr(c)) {
fprintf(stderr, "Out of memory preparing request.");
return -1;
}
/* binary protocol */
if (c->protocol == binary_prot) {
- if (ms_build_bin_write_buf_mlget(c) != 0) {
+ if (ms_build_bin_write_buf_mlget(c)) {
return -1;
}
} else {
- if (ms_build_ascii_write_buf_mlget(c) != 0) {
+ if (ms_build_ascii_write_buf_mlget(c)) {
return -1;
}
}
static int ms_bin_process_response(ms_conn_t *c) {
const char *errstr = NULL;
- assert(c != NULL);
+ assert(c);
uint32_t bodylen = c->binary_header.response.bodylen;
uint8_t opcode = c->binary_header.response.opcode;
break;
} /* switch */
- if (errstr != NULL) {
+ if (errstr) {
fprintf(stderr, "%s\n", errstr);
}
}
uint32_t body_len) {
protocol_binary_request_header *header;
- assert(c != NULL);
+ assert(c);
header = (protocol_binary_request_header *) c->wcurr;
for (int i = 0; i < c->mlget_task.mlget_num; i++) {
item = c->mlget_task.mlget_item[i].item;
- assert(item != NULL);
+ assert(item);
ms_add_bin_header(c, PROTOCOL_BINARY_CMD_GET, 0, (uint16_t) item->key_size,
(uint32_t) item->key_size);