/**
* 送信
*
* @param[in] sockfd ソケット
* @param[in] sbuf 送信バッファ
* @param[in] length バイト数
* @retval EX_NG エラー
*/
static int
send_client(int sockfd, uchar *sbuf, size_t length)
{
struct client_data *cdata = NULL; /* 送信データ構造体 */
ssize_t slen = 0; /* 送信データバイト数 */
int retval = 0; /* 戻り値 */
dbglog("start");
/* データ設定 */
slen = set_client_data(&cdata, sbuf, length);
if (slen < 0) {
cut_notify("set_server_data=%zd(%d)", slen, errno);
return EX_NG;
}
/* 送信 */
retval = send_data(sockfd, cdata, (size_t *)&slen);
if (retval < 0) {
cut_notify("send_data: slen=%zd(%d)", slen, errno);
memfree((void **)&cdata, NULL);
return EX_NG;
}
memfree((void **)&cdata, NULL);
return EX_OK;
}
static int active_send(int fd, char *data)
{
LOG(vfs_sig_log, LOG_DEBUG, "send %d cmdid %s\n", fd, data);
set_client_data(fd, data, strlen(data));
modify_fd_event(fd, EPOLLOUT);
return 0;
}
void do_send_task(int fd, t_task_base *base, t_pfs_sig_head *h)
{
struct conn *curcon = &acon[fd];
curcon->send_len = 0;
char obuf[2048] = {0x0};
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
peer->hbtime = time(NULL);
uint8_t tmp_status = FILE_SYNC_DST_2_SRC;
if (base->fsize == 0 || base->retry)
{
if (get_localfile_stat(base) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "filename[%s] get_localfile_stat ERROR %m!\n", base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_OPENFILE;
}
}
if (tmp_status == FILE_SYNC_DST_2_SRC)
{
t_pfs_tasklist *task = NULL;
if (pfs_get_task(&task, TASK_Q_HOME))
{
LOG(pfs_data_log, LOG_ERROR, "filename[%s] do_newtask ERROR!\n", base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_MALLOC;
}
else
{
memset(&(task->task), 0, sizeof(task->task));
t_task_sub *sub = &(task->task.sub);
memset(sub, 0, sizeof(t_task_sub));
ip2str(sub->peerip, peer->ip);
sub->processlen = base->fsize;
sub->starttime = time(NULL);
sub->oper_type = OPER_GET_RSP;
sub->need_sync = TASK_SRC_NOSYNC;
memcpy(&(task->task.base), base, sizeof(t_task_base));
int lfd = -1;
if (open_localfile_4_read(base, &lfd) != LOCALFILE_OK)
{
LOG(pfs_data_log, LOG_ERROR, "fd[%d] err open [%s] %m close it\n", fd, base->filename);
tmp_status = FILE_SYNC_DST_2_SRC_E_OPENFILE;
task->task.base.overstatus = OVER_E_OPEN_SRCFILE;
pfs_set_task(task, TASK_Q_FIN);
}
else
{
task->task.base.overstatus = OVER_UNKNOWN;
pfs_set_task(task, TASK_Q_SEND);
peer->sendtask = task;
set_client_fd(fd, lfd, 0, sub->processlen);
peer->sock_stat = SENDFILEING;
}
}
}
int n = create_sig_msg(CMD_GET_FILE_RSP, tmp_status, (t_pfs_sig_body *)base, obuf, sizeof(t_task_base));
set_client_data(fd, obuf, n);
peer->headlen = n;
}
void create_push_rsp_err(char *errmsg, int fd)
{
struct conn *curcon = &acon[fd];
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
peer->close = 1;
char obuf[2048] = {0x0};
int n = create_sig_msg(CMD_PUT_FILE_RSP, 0x0, (t_pfs_sig_body *)errmsg, obuf, strlen(errmsg));
set_client_data(fd, obuf, n);
modify_fd_event(fd, EPOLLOUT);
}
/*发起连接与心跳*/
int active_send(log_peer *peer, sig_head *h, sig_body *b)
{
char buf[2048] = {0x0};
size_t n = 0;
peer->hbtime = time(NULL);
n = create_sig_msg(h->cmdid, h->status, b, buf, h->bodylen);
set_client_data(peer->fd, buf, n);
modify_fd_event(peer->fd, EPOLLOUT);
LOG(sig_log, LOG_DEBUG, "active send %d cmdid %x\n", peer->fd, h->cmdid);
return 0;
}
void create_push_rsp(t_pfs_tasklist *task, int fd)
{
struct conn *curcon = &acon[fd];
pfs_cs_peer *peer = (pfs_cs_peer *) curcon->user;
peer->close = 1;
char obuf[2048] = {0x0};
t_task_base *base = &(task->task.base);
char retbuf[256] = {0x0};
snprintf(retbuf, sizeof(retbuf), "OK|%s|%s", base->retfile, self_domain->domain);
int n = create_sig_msg(CMD_PUT_FILE_RSP, 0x0, (t_pfs_sig_body *)retbuf, obuf, sizeof(retbuf));
set_client_data(fd, obuf, n);
modify_fd_event(fd, EPOLLOUT);
}
/**
* ソケット送信
*
* @param[in] sock ソケット
* @return ステータス
*/
static st_client
send_sock(int sock)
{
int retval = 0; /* 戻り値 */
size_t length = 0; /* 長さ */
ssize_t slen = 0; /* 送信するバイト数 */
expr = _readline(stdin);
if (!expr)
return EX_ALLOC_ERR;
if (*expr == '\0') { /* 文字列長ゼロ */
memfree((void **)&expr, NULL);
return EX_EMPTY;
}
if (!strcmp((char *)expr, "quit") ||
!strcmp((char *)expr, "exit"))
return EX_QUIT;
length = strlen((char *)expr) + 1;
dbgdump(expr, length, "stdin: expr=%zu", length);
if (g_tflag)
start_timer(&start_time);
/* データ設定 */
slen = set_client_data(&sdata, expr, length);
if (slen < 0) /* メモリ確保できない */
return EX_ALLOC_ERR;
dbglog("slen=%zd", slen);
if (g_gflag)
outdump(sdata, slen, "send: sdata=%p, length=%zd", sdata, slen);
stddump(sdata, slen, "send: sdata=%p, length=%zd", sdata, slen);
/* データ送信 */
retval = send_data(sock, sdata, (size_t *)&slen);
if (retval < 0) /* エラー */
return EX_SEND_ERR;
memfree((void **)&expr, (void **)&sdata, NULL);
return EX_SUCCESS;
}
/**
* スレッド処理
*
* @return なし
*/
static void *
client_thread(void *arg)
{
/* スレッドデータ */
thread_data *dt = (thread_data *)arg;
int retval = 0; /* 戻り値 */
size_t length = 0; /* 長さ */
ssize_t slen = 0; /* 送信するバイト数 */
struct header hd; /* ヘッダ */
/* コネクト */
dt->sock = connect_sock();
if (dt->sock < 0) {
outstd("Connect error");
pthread_exit((void *)EX_CONNECT_ERR);
}
pthread_cleanup_push(thread_cleanup, &dt);
length = strlen((char *)dt->expr) + 1;
/* データ設定 */
slen = set_client_data(&dt->sdata, dt->expr, length);
if (slen < 0) /* メモリ確保できない */
pthread_exit((void *)EX_ALLOC_ERR);
pthread_cleanup_push(thread_memfree, &dt->sdata);
/* データ送信 */
retval = send_data(dt->sock, dt->sdata, (size_t *)&slen);
/* ヘッダ受信 */
length = sizeof(struct header);
(void)memset(&hd, 0, length);
retval = recv_data(dt->sock, &hd, &length);
if (retval < 0) /* エラー */
pthread_exit((void *)EX_RECV_ERR);
dbglog("recv_data: hd=%p, length=%zu", &hd, length);
length = (size_t)ntohl((uint32_t)hd.length); /* データ長を保持 */
/* データ受信 */
dt->answer = (uchar *)recv_data_new(dt->sock, &length);
if (!dt->answer) /* メモリ確保できない */
pthread_exit((void *)EX_ALLOC_ERR);
pthread_cleanup_push(thread_memfree, &dt->answer);
if (!length) /* 受信エラー */
pthread_exit((void *)EX_RECV_ERR);
dbglog("answer=%p, length=%zu", dt->answer, length);
stdlog("%s", dt->answer);
retval = strcmp((char *)dt->expected, (char *)dt->answer);
stdlog("strcmp=%d", retval);
assert(0 == retval);
retval = shutdown(dt->sock, SHUT_RDWR);
if (retval < 0) {
outstd("shutdown: sock=%d", dt->sock);
pthread_exit((void *)EXIT_FAILURE);
}
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
pthread_exit((void *)EX_SUCCESS);
return (void *)EX_SUCCESS;
}
