EC_BOOL csrv_clean(CSRV *csrv)
{
if(CMPI_ERROR_SOCKFD != CSRV_SOCKFD(csrv))
{
csocket_close(CSRV_SOCKFD(csrv));
CSRV_SOCKFD(csrv) = CMPI_ERROR_SOCKFD;
}
if(CMPI_ERROR_SOCKFD != CSRV_UNIX_SOCKFD(csrv))
{
csocket_close(CSRV_UNIX_SOCKFD(csrv));
CSRV_UNIX_SOCKFD(csrv) = CMPI_ERROR_SOCKFD;
}
CSRV_IPADDR(csrv) = CMPI_ERROR_IPADDR;
CSRV_PORT(csrv) = CMPI_ERROR_SRVPORT;
CSRV_MD_ID(csrv) = ERR_MODULE_ID;
CSRV_INIT_CSOCKET_CNODE(csrv) = NULL_PTR;
CSRV_ADD_CSOCKET_CNODE(csrv) = NULL_PTR;
CSRV_DEL_CSOCKET_CNODE(csrv) = NULL_PTR;
CSRV_RD_EVENT_HANDLER(csrv) = NULL_PTR;
CSRV_WR_EVENT_HANDLER(csrv) = NULL_PTR;
CSRV_TIMEOUT_HANDLER(csrv) = NULL_PTR;
CSRV_COMPLETE_HANDLER(csrv) = NULL_PTR;
CSRV_CLOSE_HANDLER(csrv) = NULL_PTR;
if(NULL_PTR != CSRV_CSSL_NODE(csrv))
{
cssl_node_free(CSRV_CSSL_NODE(csrv));
CSRV_CSSL_NODE(csrv) = NULL_PTR;
}
return (EC_TRUE);
}
EC_BOOL cextclnt_clean(CEXTCLNT *cextclnt)
{
if(CMPI_ERROR_SOCKFD != CEXTCLNT_SOCKFD(cextclnt))
{
csocket_close(CEXTCLNT_SOCKFD(cextclnt));
CEXTCLNT_SOCKFD(cextclnt) = CMPI_ERROR_SOCKFD;
}
CEXTCLNT_IPADDR(cextclnt) = CMPI_ERROR_IPADDR;
return (EC_TRUE);
}
EC_BOOL cextsrv_clean(CEXTSRV *cextsrv)
{
if(CMPI_ERROR_SOCKFD != CEXTSRV_SOCKFD(cextsrv))
{
csocket_close(CEXTSRV_SOCKFD(cextsrv));
CEXTSRV_SOCKFD(cextsrv) = CMPI_ERROR_SOCKFD;
}
CEXTSRV_IPADDR(cextsrv) = CMPI_ERROR_IPADDR;
CEXTSRV_PORT(cextsrv) = CMPI_ERROR_SRVPORT;
CEXTSRV_CMUTEX_CLEAN(cextsrv, LOC_CEXTSRV_0005);
return (EC_TRUE);
}
CEXTSRV * cextsrv_start(const UINT32 srv_ipaddr, const UINT32 srv_port)
{
CEXTSRV *cextsrv;
int srv_sockfd;
if(EC_FALSE == csocket_srv_start(srv_ipaddr, srv_port, CSOCKET_IS_BLOCK_MODE, &srv_sockfd))
{
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDERR, "error:cextsrv_start: failed to listen on port %ld\n", srv_port);
return (NULL_PTR);
}
cextsrv = cextsrv_new(srv_ipaddr, srv_port, srv_sockfd);
if(NULL_PTR == cextsrv)
{
dbg_log(SEC_0069_CEXTSRV, 0)(LOGSTDOUT, "error:cextsrv_start: new cextsrv failed, close srv sockfd %d\n", srv_sockfd);
csocket_close(srv_sockfd);
return (NULL_PTR);
}
dbg_log(SEC_0069_CEXTSRV, 5)(LOGSTDOUT, "cextsrv_start: start srv sockfd %d on port %s:%ld\n", srv_sockfd, c_word_to_ipv4(srv_ipaddr), srv_port);
return (cextsrv);
}
CSOCKET_CNODE *cconnp_reserve(CCONNP *cconnp)
{
CSOCKET_CNODE *csocket_cnode;
int sockfd;
if(EC_TRUE == cqueue_is_empty(CCONNP_IDLE_CONN_QUEUE(cconnp)))
{
CQUEUE_DATA *cqueue_data;
/*if no idle, new one*/
if(csocket_connect(CCONNP_SRV_IPADDR(cconnp), CCONNP_SRV_PORT(cconnp), CSOCKET_IS_NONBLOCK_MODE, &sockfd))
{
dbg_log(SEC_0154_CCONNP, 0)(LOGSTDOUT, "error:cconnp_reserve: connect server %s:%ld failed\n",
CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
return (NULL_PTR);
}
csocket_cnode = csocket_cnode_new(CCONNP_SRV_TCID(cconnp), sockfd, CSOCKET_TYPE_TCP, CCONNP_SRV_IPADDR(cconnp), CCONNP_SRV_PORT(cconnp));
if(NULL_PTR == csocket_cnode)
{
dbg_log(SEC_0154_CCONNP, 0)(LOGSTDOUT, "error:cconnp_reserve: new csocket_cnode for socket %d to server %s:%ld failed\n",
sockfd, CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
csocket_close(sockfd);
return (NULL_PTR);
}
cqueue_data = cqueue_push(CCONNP_IDLE_CONN_QUEUE(cconnp), (void *)csocket_cnode);
if(NULL_PTR == cqueue_data)
{
dbg_log(SEC_0154_CCONNP, 0)(LOGSTDOUT, "error:cconnp_reserve: push socket %d to server %s:%ld failed\n",
sockfd, CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
csocket_cnode_free(csocket_cnode);
return (NULL_PTR);
}
CSOCKET_CNODE_WORK_NODE(csocket_cnode) = (void *)cqueue_data;
CSOCKET_CNODE_WORK_OWNER(csocket_cnode) = (void *)cconnp;
CSOCKET_CNODE_WORK_RELEASE(csocket_cnode) = (CSOCKET_CNODE_WORK_REL)cconnp_erase;;
CSOCKET_CNODE_WORK_STATUS(csocket_cnode) = CSOCKET_CNODE_WORK_STATUS_IDLE;
dbg_log(SEC_0154_CCONNP, 9)(LOGSTDOUT, "[DEBUG] cconnp_reserve: create and push sockfd %d to server %s:%ld done\n",
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
}
/*reserve one idle*/
csocket_cnode = cqueue_pop(CCONNP_IDLE_CONN_QUEUE(cconnp));
if(NULL_PTR == csocket_cnode)
{
dbg_log(SEC_0154_CCONNP, 0)(LOGSTDOUT, "error:cconnp_reserve: server %s:%ld has no idle conn\n",
CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
return (NULL_PTR);
}
if(EC_TRUE == CSOCKET_CNODE_WORK_PUSHED(csocket_cnode))
{
/*when csocket_cnode was released and pushed to connp, RD event was set. here need to clear it*/
cepoll_del_event(task_brd_default_get_cepoll(), CSOCKET_CNODE_SOCKFD(csocket_cnode), CEPOLL_RD_EVENT);
CSOCKET_CNODE_WORK_PUSHED(csocket_cnode) = EC_FALSE;
}
CSOCKET_CNODE_WORK_NODE(csocket_cnode) = NULL_PTR;
CSOCKET_CNODE_WORK_OWNER(csocket_cnode) = (void *)cconnp;
CSOCKET_CNODE_WORK_RELEASE(csocket_cnode) = (CSOCKET_CNODE_WORK_REL)cconnp_release;
CSOCKET_CNODE_WORK_STATUS(csocket_cnode) = CSOCKET_CNODE_WORK_STATUS_NONE;
dbg_log(SEC_0154_CCONNP, 9)(LOGSTDOUT, "[DEBUG] cconnp_reserve: pop sockfd %d from server %s:%ld done\n",
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CCONNP_SRV_IPADDR_STR(cconnp), CCONNP_SRV_PORT(cconnp));
return (csocket_cnode);
}
int main(int argc, char ** argv)
{
int bytes = 0;
CSOCKET* sock=NULL;
CLOG_INFO* log=NULL;
CSTRING* buf = NULL;
// open the logfile
log = clog_open("./test_csocket.log", CTRACE, NULL, 0);
if(3>argc) {
clog(log, CFATAL, "USAGE: %s host user password", argv[0]);
clog_close(log);
return 1;
}
// create the new socket
sock = csocket_new(log);
// initialize the socket
csocket_init(log, sock, argv[1], 110);
// connect
csocket_connect(log, sock);
// read/write
buf = cstring_new(1024);
bytes=csocket_read(log, sock, buf->string, 1024);
fprintf(stdout, "%s", buf->string);
buf->length=0;
memset(buf->string, 0, buf->memsize);
cstring_strcat_imp(buf, "USER ", 5);
cstring_strcat_imp(buf, argv[2], strlen(argv[2]));
cstring_strcat_imp(buf, "\r\n", 2);
csocket_write(log, sock, buf->string, buf->length);
buf->length=0;
memset(buf->string, 0, buf->memsize);
bytes=csocket_read(log, sock, buf->string, 1024);
fprintf(stdout, "%s", buf->string);
buf->length=0;
memset(buf->string, 0, buf->memsize);
cstring_strcat_imp(buf, "PASS ", 5);
cstring_strcat_imp(buf, argv[3], strlen(argv[3]));
cstring_strcat_imp(buf, "\r\n", 2);
csocket_write(log, sock, buf->string, buf->length);
buf->length=0;
memset(buf->string, 0, buf->memsize);
bytes=csocket_read(log, sock, buf->string, 1024);
fprintf(stdout, "%s", buf->string);
buf->length=0;
memset(buf->string, 0, buf->memsize);
cstring_strcat_imp(buf, "STAT\r\n", 6);
csocket_write(log, sock, buf->string, buf->length);
buf->length=0;
memset(buf->string, 0, buf->memsize);
bytes=csocket_read(log, sock, buf->string, 1024);
fprintf(stdout, "%s", buf->string);
buf->length=0;
memset(buf->string, 0, buf->memsize);
cstring_strcat_imp(buf, "QUIT\r\n", 6);
csocket_write(log, sock, buf->string, buf->length);
buf->length=0;
memset(buf->string, 0, buf->memsize);
bytes=csocket_read(log, sock, buf->string, 1024);
fprintf(stdout, "%s", buf->string);
cstring_free(&buf);
// close the connection
csocket_close(log, sock);
// free the socket
csocket_free(log, sock);
// close the log
clog_close(log);
return 0;
}
EC_BOOL csrv_unix_accept_once(CSRV *csrv, EC_BOOL *continue_flag)
{
UINT32 client_ipaddr;
EC_BOOL ret;
int client_conn_sockfd;
ret = csocket_unix_accept(CSRV_UNIX_SOCKFD(csrv), &(client_conn_sockfd), CSOCKET_IS_NONBLOCK_MODE);
if(EC_TRUE == ret)
{
CSOCKET_CNODE *csocket_cnode;
client_ipaddr = c_ipv4_to_word((const char *)"127.0.0.1");
dbg_log(SEC_0112_CSRV, 1)(LOGSTDOUT, "csrv_unix_accept_once: handle new sockfd %d\n", client_conn_sockfd);
csocket_cnode = csocket_cnode_unix_new(CMPI_ERROR_TCID, client_conn_sockfd, CSOCKET_TYPE_TCP, client_ipaddr, CMPI_ERROR_SRVPORT);/*here do not know the remote client srv port*/
if(NULL_PTR == csocket_cnode)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_unix_accept_once:failed to alloc csocket cnode for sockfd %d, hence close it\n", client_conn_sockfd);
csocket_close(client_conn_sockfd);
return (EC_FALSE);
}
if(NULL_PTR != CSRV_ADD_CSOCKET_CNODE(csrv))
{
CSRV_ADD_CSOCKET_CNODE(csrv)(CSRV_MD_ID(csrv), csocket_cnode);
}
#if (SWITCH_OFF == TASK_BRD_CEPOLL_SWITCH)
if(1)
{
TASK_BRD *task_brd;
CROUTINE_NODE *croutine_node;
task_brd = task_brd_default_get();
croutine_node = croutine_pool_load(TASK_REQ_CTHREAD_POOL(task_brd), (UINT32)csrv_handle, 2, csrv, csocket_cnode);
if(NULL_PTR == croutine_node)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_unix_accept_once: cthread load failed\n");
csocket_cnode_close(csocket_cnode);
return (EC_FALSE);
}
CROUTINE_NODE_COND_RELEASE(croutine_node, LOC_CSRV_0004);
}
#endif/*(SWITCH_OFF == TASK_BRD_CEPOLL_SWITCH)*/
#if (SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)
/*note: CSOCKET_CNODE_PKT_HDR will be used for specific purpose*/
BSET(CSOCKET_CNODE_PKT_HDR(csocket_cnode), 0, CSOCKET_CNODE_PKT_HDR_SIZE);
CSOCKET_CNODE_MODI(csocket_cnode) = CSRV_MD_ID(csrv);
cepoll_set_event(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)CSRV_RD_EVENT_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_complete(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
(CEPOLL_EVENT_HANDLER)CSRV_COMPLETE_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_shutdown(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
(CEPOLL_EVENT_HANDLER)CSRV_CLOSE_HANDLER(csrv),
(void *)csocket_cnode);
cepoll_set_timeout(task_brd_default_get_cepoll(),
CSOCKET_CNODE_SOCKFD(csocket_cnode),
CSRV_TIMEOUT_NSEC(csrv),
(CEPOLL_EVENT_HANDLER)CSRV_TIMEOUT_HANDLER(csrv),
(void *)csocket_cnode);
#endif/*(SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)*/
}
(*continue_flag) = ret;
return (EC_TRUE);
}
CSRV * csrv_start(const UINT32 srv_ipaddr, const UINT32 srv_port, const UINT32 md_id,
const uint32_t timeout_nsec,
CSRV_INIT_CSOCKET_CNODE init_csocket_cnode,
CSRV_ADD_CSOCKET_CNODE add_csocket_cnode,
CSRV_DEL_CSOCKET_CNODE del_csocket_cnode,
CSRV_RD_HANDLER_FUNC rd_handler,
CSRV_WR_HANDLER_FUNC wr_handler,
CSRV_TIMEOUT_HANDLER_FUNC timeout_handler,
CSRV_COMPLETE_HANDLER_FUNC complete_handler,
CSRV_CLOSE_HANDLER_FUNC close_handler
)
{
CSRV *csrv;
int srv_sockfd;
int srv_unix_sockfd;
if(ERR_MODULE_ID == md_id)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_start: md id is invalid\n");
return (NULL_PTR);
}
if(EC_FALSE == csocket_listen(srv_ipaddr, srv_port, &srv_sockfd))
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDERR, "error:csrv_start: failed to listen on %s:%ld\n",
c_word_to_ipv4(srv_ipaddr), srv_port);
return (NULL_PTR);
}
srv_unix_sockfd = CMPI_ERROR_SOCKFD;
#if 0
if(EC_FALSE == csocket_unix_listen(srv_ipaddr, srv_port, &srv_unix_sockfd))
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDERR, "error:csrv_start: failed to listen on unix@%s:%ld\n",
c_word_to_ipv4(srv_ipaddr), srv_port);
}
#endif
csrv = csrv_new();
if(NULL_PTR == csrv)
{
dbg_log(SEC_0112_CSRV, 0)(LOGSTDOUT, "error:csrv_start: new csrv failed, close srv sockfd %d\n", srv_sockfd);
csocket_close(srv_sockfd);
return (NULL_PTR);
}
CSRV_IPADDR(csrv) = srv_ipaddr;
CSRV_PORT(csrv) = srv_port;
CSRV_SOCKFD(csrv) = srv_sockfd;
CSRV_UNIX_SOCKFD(csrv) = srv_unix_sockfd;
CSRV_MD_ID(csrv) = md_id;
CSRV_TIMEOUT_NSEC(csrv) = timeout_nsec;
CSRV_INIT_CSOCKET_CNODE(csrv) = NULL_PTR;
CSRV_ADD_CSOCKET_CNODE(csrv) = add_csocket_cnode;
CSRV_DEL_CSOCKET_CNODE(csrv) = del_csocket_cnode;
CSRV_RD_EVENT_HANDLER(csrv) = rd_handler;
CSRV_WR_EVENT_HANDLER(csrv) = wr_handler;
CSRV_TIMEOUT_HANDLER(csrv) = timeout_handler;
CSRV_COMPLETE_HANDLER(csrv) = complete_handler;
CSRV_CLOSE_HANDLER(csrv) = close_handler;
CSRV_CSSL_NODE(csrv) = NULL_PTR;
#if (SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)
cepoll_set_event(task_brd_default_get_cepoll(),
CSRV_SOCKFD(csrv),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)csrv_accept,
(void *)csrv);
#if 0
if(CMPI_ERROR_SOCKFD != CSRV_UNIX_SOCKFD(csrv))
{
cepoll_set_event(task_brd_default_get_cepoll(),
CSRV_UNIX_SOCKFD(csrv),
CEPOLL_RD_EVENT,
(CEPOLL_EVENT_HANDLER)csrv_unix_accept,
(void *)csrv);
}
#endif
#endif/*(SWITCH_ON == TASK_BRD_CEPOLL_SWITCH)*/
dbg_log(SEC_0112_CSRV, 5)(LOGSTDOUT, "csrv_start: start srv sockfd %d on port %s:%ld\n",
srv_sockfd, c_word_to_ipv4(srv_ipaddr), srv_port);
return (csrv);
}