int acl_unix_trigger(ACL_EVENT *event, const char *service,
const char *buf, int len, int timeout)
{
const char *myname = "acl_unix_trigger";
struct ACL_UNIX_TRIGGER *up;
ACL_SOCKET fd;
if (acl_msg_verbose > 0)
acl_msg_info("%s: service %s", myname, service);
/*
* Connect...
*/
if ((fd = acl_unix_connect(service, ACL_BLOCKING, timeout)) < 0) {
if (acl_msg_verbose)
acl_msg_warn("%s: connect to %s: %s",
myname, service, strerror(errno));
return -1;
}
acl_close_on_exec(fd, ACL_CLOSE_ON_EXEC);
/*
* Stash away context.
*/
up = (struct ACL_UNIX_TRIGGER *) acl_mymalloc(sizeof(*up));
up->service = acl_mystrdup(service);
up->stream = acl_vstream_fdopen(fd, O_RDWR, 4096,
timeout, ACL_VSTREAM_TYPE_LISTEN_UNIX);
/*
* Write the request...
*/
if (acl_vstream_writen(up->stream, buf, len) < 0
|| acl_vstream_writen(up->stream, "", 1) < 0)
{
if (acl_msg_verbose)
acl_msg_warn("%s: write to %s: %s",
myname, service, strerror(errno));
}
/*
* Wakeup when the peer disconnects, or when we lose patience.
*/
#ifdef __USE_TIMER
if (timeout > 0)
acl_event_request_timer(event, acl_unix_trigger_timer,
(void *) up, (timeout + 100) * 1000000);
acl_event_enable_read(event, up->stream, 0,
acl_unix_trigger_event, (void *) up);
#else
if (timeout > 0)
acl_event_enable_read(event, up->stream, timeout + 100,
acl_unix_trigger_event, (void *) up);
else
acl_event_enable_read(event, up->stream, 0,
acl_unix_trigger_event, (void *) up);
#endif
return 0;
}
int smtp_send_stream(SMTP_CLIENT *client, ACL_VSTREAM *in)
{
int n = 0, ret;
while (1) {
ret = acl_vstream_read(in, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF)
break;
if (acl_vstream_writen(client->conn, client->buf, ret)
== ACL_VSTREAM_EOF)
{
acl_msg_error("%s(%d): write data error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
n += ret;
}
if (n == 0) {
acl_msg_error("%s(%d): in stream is empty",
__FUNCTION__, __LINE__);
return -1;
}
return 0;
}
static int http_demo(ACL_VSTREAM *cstream, const char* res, size_t len)
{
char buf[8192];
int ret;
cstream->rw_timeout = __rw_timeout;
while (1) {
ret = acl_vstream_gets_nonl(cstream, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF) {
printf("gets error: %s\r\n", acl_last_serror());
return -1;
}
buf[ret] = 0;
if (strcasecmp(buf, "stop") == 0) {
__stop = 1;
printf("----stop now----\r\n");
break;
}
if (ret == 0)
break;
}
if (acl_vstream_writen(cstream, res, len) == ACL_VSTREAM_EOF) {
printf("write error\r\n");
return -1;
}
return 0;
}
static int gid_store_sync(GID_STORE *store)
{
char buf[1024];
/* 需要先将文件内容清空 */
#if 0
if (acl_file_ftruncate(store->fh.fp, 0) < 0) {
acl_msg_error("%s(%d), %s: ftruncate %s error(%s)",
__FILE__, __LINE__, __FUNCTION__,
ACL_VSTREAM_PATH(store->fh.fp), acl_last_serror());
return (-1);
}
#endif
if (acl_vstream_fseek(store->fh.fp, SEEK_SET, 0) < 0) {
acl_msg_error("%s(%d), %s: fseek %s error(%s)",
__FILE__, __LINE__, __FUNCTION__,
ACL_VSTREAM_PATH(store->fh.fp), acl_last_serror());
}
snprintf(buf, sizeof(buf), "%s:%s %d %lld %lld %lld\r\n",
store->tag, store->sid, store->step, store->cur_gid,
store->min_gid, store->max_gid);
/* 初始化文件内容: tag:sid step cur_gid min_gid max_gid\r\n */
if (acl_vstream_writen(store->fh.fp,
buf, strlen(buf)) == ACL_VSTREAM_EOF)
{
acl_msg_error("%s(%d), %s: write to %s error(%s)",
__FILE__, __LINE__, __FUNCTION__,
ACL_VSTREAM_PATH(store->fh.fp), acl_last_serror());
return (-1);
}
return (0);
}
static int request(ACL_VSTREAM *client, int cmd_num, int out)
{
const char cmd1[] = "CMD^new_gid|TAG^default:hello\r\n";
const char cmd2[] = "CMD^test_gid\r\n";
const char *cmd;
char buf[256];
int ret;
if (cmd_num == 1)
cmd = cmd1;
else
cmd = cmd2;
ret = acl_vstream_writen(client, cmd, strlen(cmd));
if (ret == ACL_VSTREAM_EOF) {
printf("write cmd to server error\n");
return (-1);
}
ret = acl_vstream_gets(client, buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF) {
printf("gets error\n");
return (-1);
}
if (out)
printf(">>gets: %s\n", buf);
return (0);
}
int smtp_send(SMTP_CLIENT *client, const char* src, size_t len)
{
if (acl_vstream_writen(client->conn, src, len) == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): write data error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
return 0;
}
static void echo_client(ACL_FIBER *fiber, void *ctx)
{
ACL_VSTREAM *cstream = (ACL_VSTREAM *) ctx;
char buf[8192];
int ret, count = 0;
int ntimeout = 0;
FIBER_TIMER *ft = (FIBER_TIMER *) acl_mymalloc(sizeof(FIBER_TIMER));
ft->fiber = fiber;
ft->timer = acl_fiber_create_timer(__rw_timeout * 1000,
320000, io_timer, ft);
ft->conn = cstream;
#define SOCK ACL_VSTREAM_SOCK
while (1) {
printf("begin read\n");
ret = acl_vstream_gets(cstream, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF) {
printf("fiber-%d, gets error: %s, %d, %d, fd: %d, "
"count: %d\r\n", acl_fiber_id(fiber),
acl_last_serror(), errno, acl_fiber_errno(fiber),
SOCK(cstream), count);
if (errno != ETIMEDOUT)
break;
if (++ntimeout > 2)
{
printf("too many timeout: %d\r\n", ntimeout);
break;
}
printf("ntimeout: %d\r\n", ntimeout);
ft->timer = acl_fiber_create_timer(__rw_timeout * 1000,
320000, io_timer, ft);
}
acl_fiber_reset_timer(ft->timer, __rw_timeout * 1000);
buf[ret] = 0;
//printf("gets line: %s", buf);
if (acl_vstream_writen(cstream, buf, ret) == ACL_VSTREAM_EOF) {
printf("write error, fd: %d\r\n", SOCK(cstream));
break;
}
count++;
}
acl_myfree(ft);
acl_vstream_close(cstream);
}
int http_util_put_req_data(HTTP_UTIL *http_util, const char *data, size_t dlen)
{
const char *myname = "http_util_put_req_data";
if (data == NULL || dlen == 0) {
acl_msg_info("%s(%d): data %s, dlen %d invalid",
myname, __LINE__, data ? "not null" : "null", (int) dlen);
return (-1);
}
if (acl_vstream_writen(http_util->stream, data, dlen) == ACL_VSTREAM_EOF)
return (-1);
return ((int) dlen);
}
void event_dog_notify(EVENT_DOG *evdog)
{
const char *myname = "event_dog_notify";
char buf[2];
buf[0] = '0';
buf[1] = 0;
if (acl_vstream_writen(evdog->server, buf, 1) == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): notify error, reset", myname, __LINE__);
event_dog_reopen(evdog);
}
}
int CGb2Utf8::TransformFile(const char *pFrom, const char *pTo)
{
char *sBuf = NULL;
size_t iLen;
#undef RETURN
#define RETURN(_x_) do \
{ \
if (sBuf) \
acl_myfree(sBuf); \
return(_x_); \
} while(0);
sBuf = acl_vstream_loadfile(pFrom);
if (sBuf == NULL)
RETURN (-1);
if (*sBuf == 0)
RETURN (-1);
iLen = strlen(sBuf);
acl::charset_conv conv;
acl::string buf;
if (conv.convert(m_fromCharset.GetString(), m_toCharset.GetString(),
sBuf, iLen, &buf) == false)
{
logger_error("conver from %s to %s error: %s, file: %s",
m_fromCharset.GetString(), m_toCharset.GetString(),
conv.serror(), pFrom);
RETURN (-1);
}
ACL_VSTREAM *fp;
fp = acl_vstream_fopen(pFrom, O_RDWR | O_TRUNC | O_BINARY /* | O_APPEND */,
0600, 1024);
if (fp == NULL)
{
logger_error("open %s error %s", pFrom, acl::last_serror());
RETURN (-1);
}
int ret = acl_vstream_writen(fp, buf.c_str(), buf.length());
acl_vstream_close(fp);
if (ret == ACL_VSTREAM_EOF)
logger_error("write to %s error %s", pFrom, acl::last_serror());
else
logger("transer from %s to %s ok, file: %s",
m_fromCharset.GetString(), m_toCharset.GetString(), pFrom);
RETURN (ret == ACL_VSTREAM_EOF ? -1 : 0);
}
static void reply_client2(ACL_VSTREAM *client)
{
char buf[1024];
int ret;
while (1) {
ret = acl_vstream_gets(client, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF)
break;
buf[ret] = 0;
acl_vstream_printf("get one line:%s", buf);
if (acl_vstream_writen(client, buf, ret) == ACL_VSTREAM_EOF)
break;
}
}
bool CDelBOM::DeleteBOM(CString& filePath)
{
char* sBuf;
sBuf = acl_vstream_loadfile(filePath);
if (sBuf == NULL)
return false;
size_t len = strlen(sBuf);
if (len < 3)
{
acl_myfree(sBuf);
return false;
}
// 先判断文件内容前缀是否是BOM格式
if (sBuf[0] != (char) 0xEF || sBuf[1] != (char) 0xBB || sBuf[2] != (char) 0xBF)
{
acl_myfree(sBuf);
return false;
}
// 将内容指针偏移 3 个字节，即去掉BOM格式
len -= 3;
char* ptr = sBuf + 3;
ACL_VSTREAM* fp = acl_vstream_fopen(filePath,
O_WRONLY | O_APPEND | O_TRUNC, 0600, 4096);
if (fp == NULL)
{
acl_myfree(sBuf);
return false;
}
else if (len == 0)
{
acl_vstream_fclose(fp);
acl_myfree(sBuf);
return true;
}
else if (acl_vstream_writen(fp, ptr, len) == ACL_VSTREAM_EOF)
{
acl_msg_error("write to file: %s error: %s",
filePath.GetString(), acl_last_serror());
}
acl_vstream_fclose(fp);
acl_myfree(sBuf);
return true;
}
int protocol(SPOOL *spool, ACL_VSTREAM *cstream)
{
char buf[4096];
int n, ret;
spool = spool;
n = acl_vstream_gets(cstream, buf, sizeof(buf));
if (n == ACL_VSTREAM_EOF)
return (-1);
ret = acl_vstream_writen(cstream, buf, n);
if (ret != n)
return (-1);
return (0);
}
static void io_blk_free(ZDB_IO_BLK *blk)
{
const char *myname = "io_blk_free";
int ret;
if ((blk->flag & BLK_F_DIRTY)) {
ZDB_IO *io = blk->io;
avl_remove(&io->blk_tree, blk);
#ifdef PWRITE
ret = PWRITE(IO_HANDLE(io), blk->dat, blk->dlen, blk->off);
if (ret != (int) blk->dlen) {
acl_msg_error("%s(%d): pwrite to %s error(%s),"
" ret(%d) != len(%d), off: " ACL_FMT_I64D,
myname, __LINE__, PATH(IO_STREAM(io)),
acl_last_serror(), ret,
(int) blk->dlen, blk->off);
}
#else
if (acl_vstream_fseek(IO_STREAM(io), blk->off, SEEK_SET) < 0) {
acl_msg_error("%s(%d): fseek %s error(%s), off: " ACL_FMT_I64D,
myname, __LINE__, IO_PATH(io),
acl_last_serror(), blk->off);
} else if ((ret = acl_vstream_writen(IO_STREAM(io), blk->dat, blk->dlen))
== ACL_VSTREAM_EOF)
{
acl_msg_error("%s(%d): readn from %s, ret(%d) != size(%d),"
" off(" ACL_FMT_I64D "), error(%s)", myname, __LINE__,
IO_PATH(io), ret, (int) blk->dlen,
blk->off, acl_last_serror());
}
#endif
}
if (blk->io->dat_slice)
acl_slice_free2(blk->io->dat_slice, blk->dat);
else
acl_myfree(blk->dat);
if (blk->io->blk_slice)
acl_slice_free2(blk->io->blk_slice, blk);
else
acl_myfree(blk);
__n--;
}
int http_util_get_res_body(HTTP_UTIL *http_util, char *buf, size_t size)
{
const char *myname = "http_util_get_res_body";
int ret;
if (buf == NULL || size == 0) {
acl_msg_error("%s(%d): buf(%s), size(%d) invalid",
myname, __LINE__, buf ? "not null" : "null", (int) size);
return (-1);
}
if ((http_util->flag & (HTTP_UTIL_FLAG_HAS_RES_BODY
| HTTP_UTIL_FLAG_NO_RES_BODY)) == 0)
{
if (!http_util_has_res_body(http_util))
return (http_util->res_body_dlen);
}
ret = (int) http_res_body_get_sync(http_util->http_res,
http_util->stream, buf, (int) size);
if (ret <= 0)
return (ret);
http_util->res_body_dlen += ret;
if (http_util->dump_stream == NULL)
return (ret);
if (acl_vstream_writen(http_util->dump_stream, buf, ret) == ACL_VSTREAM_EOF)
{
/* 如果有一次不能转储数据至文件或流则关闭该功能不再进行转储 */
acl_msg_error("%s(%d): dump to stream(%s) error(%s)",
myname, __LINE__, ACL_VSTREAM_PATH(http_util->dump_stream),
acl_last_serror());
if ((http_util->flag & HTTP_UTIL_FLAG_SET_DUMP_FILE)) {
if (http_util->dump_stream)
acl_vstream_close(http_util->dump_stream);
http_util->flag &= ~HTTP_UTIL_FLAG_SET_DUMP_FILE;
} else
http_util->flag &= ~HTTP_UTIL_FLAG_SET_DUMP_STREAM;
http_util->dump_stream = NULL;
}
return (ret);
}
static void run_client(const char *addr, const char *filename)
{
char *request = acl_vstream_loadfile(filename);
ACL_VSTREAM *client;
int ret;
char buf[1024];
if (request == NULL) {
printf("load file(%s) error(%s)\n", filename, acl_last_serror());
return;
}
client = acl_vstream_connect(addr, ACL_BLOCKING,
0, 0, 4096);
if (client == NULL) {
printf("connect addr(%s) error(%s)\n", addr, acl_last_serror());
acl_myfree(request);
return;
}
acl_tcp_set_sndbuf(ACL_VSTREAM_SOCK(client), 10);
if (acl_vstream_writen(client, request, strlen(request)) == ACL_VSTREAM_EOF) {
printf("write to addr(%s) error(%s)\n", addr, acl_last_serror());
acl_vstream_close(client);
acl_myfree(request);
return;
}
memset(buf, 0, sizeof(buf));
while (1) {
ret = acl_vstream_read(client, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF)
break;
buf[ret] = 0;
usleep(100000);
printf(">>>%s\n", buf);
}
printf(">>>last data(%s)\n", buf);
acl_vstream_close(client);
acl_myfree(request);
}
int acl_mbox_send(ACL_MBOX *mbox, void *msg)
{
int ret;
acl_pthread_mutex_lock(mbox->lock);
acl_ypipe_write(mbox->ypipe, msg);
ret = acl_ypipe_flush(mbox->ypipe);
acl_pthread_mutex_unlock(mbox->lock);
if (ret == 0)
return 0;
mbox->nsend++;
if (acl_vstream_writen(mbox->out, __key, sizeof(__key) - 1)
== ACL_VSTREAM_EOF)
{
return -1;
} else
return 0;
}
static void event_dog_open(EVENT_DOG *evdog)
{
const char *myname = "event_dog_open";
const char *addr = "127.0.0.1:0";
char ebuf[256];
evdog->sstream = acl_vstream_listen(addr, 32);
if (evdog->sstream == NULL)
acl_msg_fatal("%s(%d): listen on addr(%s) error(%s)",
myname, __LINE__, addr,
acl_last_strerror(ebuf, sizeof(ebuf)));
evdog->server = acl_vstream_connect(evdog->sstream->local_addr,
ACL_BLOCKING, 0, 0, 1024);
if (evdog->server == NULL)
acl_msg_fatal("%s(%d): connect to addr(%s) error(%s)",
myname, __LINE__, addr,
acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_writen(evdog->server, ebuf, 1) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): pre write error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
evdog->client = acl_vstream_accept(evdog->sstream, ebuf, sizeof(ebuf));
if (evdog->client == NULL)
acl_msg_fatal("%s(%d): accept error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_readn(evdog->client, ebuf, 1) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): pre read error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
acl_vstream_close(evdog->sstream);
evdog->sstream = NULL;
acl_event_enable_read(evdog->eventp, evdog->client, 0, read_fn, evdog);
}
static void echo_client(ACL_VSTREAM *cstream)
{
char buf[8192];
int ret;
while (1) {
ret = acl_vstream_gets(cstream, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF) {
printf("gets error\r\n");
break;
}
buf[ret] = 0;
printf("gets line: %s", buf);
if (acl_vstream_writen(cstream, buf, ret) == ACL_VSTREAM_EOF) {
printf("write error\r\n");
break;
}
}
acl_vstream_close(cstream);
}
static void notify_thread(void *arg)
{
const char *myname = "notify_thread";
WARN_INFO *info = (WARN_INFO*) arg;
ACL_VSTREAM *client;
ACL_VSTRING *buf;
int ret;
buf = acl_vstring_alloc(256);
acl_vstring_sprintf(buf, "PROC=%s|PID=%d|RCPT=%s|info=%s\r\n",
info->path, info->pid, info->notify_recipients, info->desc);
client = acl_vstream_connect(info->notify_addr,
ACL_BLOCKING, 60, 60, 1024);
if (client == NULL) {
acl_msg_error("%s(%d): connect %s error, info(%s)", myname,
__LINE__, info->notify_addr, acl_vstring_str(buf));
acl_vstring_free(buf);
warn_info_free(info);
return;
}
/* 禁止将该句柄传递给子进程 */
acl_close_on_exec(ACL_VSTREAM_SOCK(client), ACL_CLOSE_ON_EXEC);
ret = acl_vstream_writen(client, acl_vstring_str(buf),
ACL_VSTRING_LEN(buf));
if (ret == ACL_VSTREAM_EOF)
acl_msg_error("%s(%d): write to notify server error, info(%s)",
myname, __LINE__, acl_vstring_str(buf));
else
acl_msg_info("%s(%d): notify ok!", myname, __LINE__);
acl_vstream_close(client);
acl_vstring_free(buf);
warn_info_free(info);
}
int http_util_req_open(HTTP_UTIL *http_util)
{
const char *myname = "http_util_req_open";
int ret;
/* 连接远程 http 服务器 */
http_util->stream = acl_vstream_connect(http_util->server_addr,
ACL_BLOCKING /* 采用阻塞方式 */,
http_util->conn_timeout /* 连接超时时间 */,
http_util->rw_timeout /* 网络 IO 操作超时时间 */,
4096 /* stream 流缓冲区大小为 4096 字节 */);
if (http_util->stream == NULL) {
acl_msg_error("%s(%d): connect %s error(%s)",
myname, __LINE__, http_util->server_addr,
acl_last_serror());
return (-1);
}
/* 构建 HTTP 请求头数据 */
http_hdr_build_request(http_util->hdr_req, http_util->req_buf);
/* 向 HTTP 服务器发送请求 */
ret = acl_vstream_writen(http_util->stream,
acl_vstring_str(http_util->req_buf),
ACL_VSTRING_LEN(http_util->req_buf));
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send request to server(%s) error(%s)",
myname, __LINE__, http_util->server_addr,
acl_last_serror());
return (-1);
}
return (0);
}
static int sms_send(ACL_VSTREAM *client, const char *phone, const char *proc,
int pid, const char *info, const char *ip)
{
ACL_VSTRING *buf = acl_vstring_alloc(256);
ACL_XML *xml = acl_xml_alloc();
char res[1024];
int ret;
acl_vstring_sprintf(buf, "<send_sms phone=\"%s\" message=\"proc:%s, pid:%d, ip:%s, info:%s\" />",
phone, proc, pid, ip, info);
if (acl_vstream_writen(client, acl_vstring_str(buf), ACL_VSTRING_LEN(buf))
== ACL_VSTREAM_EOF)
{
acl_msg_error("write to sms server error, msg: %s",
acl_vstring_str(buf));
acl_vstring_free(buf);
return (-1);
}
acl_msg_info(">>send: %s", acl_vstring_str(buf));
acl_vstring_free(buf);
while (1) {
ret = acl_vstream_read(client, res, sizeof(res) - 1);
if (ret == ACL_VSTREAM_EOF)
return (-1);
res[ret] = 0;
acl_xml_parse(xml, res);
if (acl_xml_is_complete(xml, "send_sms")) {
acl_msg_info("send ok!(%s)", res);
break;
}
}
return (0);
}
static void __service(ACL_VSTREAM *stream, char *service, char **argv)
{
char myname[] = "__service";
int n, ret;
VSTREAM_PROXY_OBJ *vpobj, *peer;
/*
* Sanity check. This service takes no command-line arguments.
*/
if (argv[0])
acl_msg_fatal("%s(%d)->%s: unexpected command-line argument: %s",
__FILE__, __LINE__, myname, argv[0]);
if (stream == NULL)
acl_msg_fatal("%s(%d)->%s: stream null",
__FILE__, __LINE__, myname);
vpobj = (VSTREAM_PROXY_OBJ *) stream->context;
if (vpobj == NULL)
acl_msg_fatal("%s(%d)->%s: stream's context null",
__FILE__, __LINE__, myname);
if (acl_msg_verbose > 3)
acl_msg_info("%s(%d)->%s: service name = %s, rw_timeout = %d",
__FILE__, __LINE__, myname, service, stream->rw_timeout);
acl_watchdog_pat();
peer = vpobj->peer;
if (peer == NULL || peer->stream == NULL || peer->peer != vpobj) {
acl_multi_server_disconnect(stream);
return;
}
acl_multi_server_cancel_rw_timer(peer->stream);
n = acl_vstream_read(stream, __data_buf, var_proxy_bufsize);
if (n == ACL_VSTREAM_EOF) {
acl_multi_server_disconnect(stream);
if (acl_msg_verbose > 3)
acl_msg_info("%s(%d)->%s: read over",
__FILE__, __LINE__, myname);
return;
}
if (vpobj->flag == VSTREAM_PROXY_FRONT_FLAG && __request_stream) {
ret = acl_vstream_writen(__request_stream, __data_buf, n);
if (ret != n) {
acl_msg_error("%s(%d)->%s: writen to %s, serr = %s",
__FILE__, __LINE__, myname,
var_proxy_request_file, strerror(errno));
acl_vstream_close(__request_stream);
__request_stream = NULL;
}
} else if (vpobj->flag == VSTREAM_PROXY_BACKEND_FLAG && __respond_stream) {
ret = acl_vstream_writen(__respond_stream, __data_buf, n);
if (ret != n) {
acl_msg_error("%s(%d)->%s: writen to %s, serr = %s",
__FILE__, __LINE__, myname,
var_proxy_request_file, strerror(errno));
acl_vstream_close(__respond_stream);
__respond_stream = NULL;
}
}
ret = acl_vstream_writen(peer->stream, __data_buf, n);
if (ret != n) {
acl_multi_server_disconnect(peer->stream);
if (acl_msg_verbose > 3)
acl_msg_info("%s(%d)->%s: write error = %s",
__FILE__, __LINE__, myname,
strerror(errno));
return;
}
acl_multi_server_request_rw_timer(stream);
acl_multi_server_request_rw_timer(peer->stream);
}
static void thread_run(void *arg)
{
CONN *conn = (CONN*) arg;
ACL_VSTREAM *client = conn->stream;
const char *reply_200 = "HTTP/1.1 200 OK\r\n"
"Server: nginx/0.6.32\r\n"
"Date: Tue, 29 Dec 2009 02:18:25 GMT\r\n"
"Content-Type: text/html\r\n"
"Content-Length: 43\r\n"
"Last-Modified: Mon, 16 Nov 2009 02:18:14 GMT\r\n"
"Connection: keep-alive\r\n"
"Accept-Ranges: bytes\r\n\r\n"
"<html>\n"
"<body>\n"
"hello world!\n"
"</body>\n"
"</html>\n";
int ret, keep_alive;
char buf[4096];
while (0) {
ret = read(ACL_VSTREAM_SOCK(client), buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF)
break;
ret = acl_vstream_writen(client, reply_200, strlen(reply_200));
if (ret == ACL_VSTREAM_EOF)
break;
}
while (0) {
ret = acl_vstream_read(client, buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF)
break;
ret = acl_vstream_writen(client, reply_200, strlen(reply_200));
if (ret == ACL_VSTREAM_EOF)
break;
}
while (0) {
/*
HTTP_REQ *req;
*/
HTTP_HDR_REQ *hdr_req = http_hdr_req_new();
ret = http_hdr_req_get_sync(hdr_req, client, 300);
if (ret < 0) {
http_hdr_req_free(hdr_req);
break;
}
if (http_hdr_req_parse(hdr_req) < 0) {
http_hdr_req_free(hdr_req);
printf("parse error\n");
break;
}
/*
keep_alive = hdr_req->hdr.keep_alive;
if (hdr_req->hdr.content_length > 0) {
req = http_req_new(hdr_req);
ret = (int) http_req_body_get_sync(req, client, buf, sizeof(buf));
if (ret < 0) {
http_req_free(req);
break;
}
http_req_free(req);
} else {
http_hdr_req_free(hdr_req);
}
*/
http_hdr_req_free(hdr_req);
ret = acl_vstream_writen(client, reply_200, strlen(reply_200));
if (ret == ACL_VSTREAM_EOF) {
break;
}
/*
if (!keep_alive)
break;
*/
}
while (1) {
HTTP_REQ *req;
HTTP_HDR_REQ *hdr_req = http_hdr_req_new();
ret = http_hdr_req_get_sync(hdr_req, client, 0);
if (ret < 0) {
http_hdr_req_free(hdr_req);
break;
}
if (http_hdr_req_parse(hdr_req) < 0) {
http_hdr_req_free(hdr_req);
printf("parse error\n");
break;
}
keep_alive = hdr_req->hdr.keep_alive;
if (hdr_req->hdr.content_length > 0) {
req = http_req_new(hdr_req);
ret = (int) http_req_body_get_sync(req, client, buf, sizeof(buf));
if (ret < 0) {
http_req_free(req);
break;
}
http_req_free(req);
} else {
http_hdr_req_free(hdr_req);
}
ret = acl_vstream_writen(client, reply_200, strlen(reply_200));
if (ret == ACL_VSTREAM_EOF) {
break;
}
if (!keep_alive)
break;
}
acl_vstream_close(client);
acl_myfree(conn);
printf("thread(%ld) exit\n", (long) acl_pthread_self());
}
static void get_url(const char *method, const char *url,
const char *proxy, const char *dump)
{
/* 创建 HTTP 请求头 */
HTTP_HDR_REQ *hdr_req = http_hdr_req_create(url, method, "HTTP/1.1");
ACL_VSTREAM *stream;
ACL_VSTRING *buf = acl_vstring_alloc(256);
HTTP_HDR_RES *hdr_res;
HTTP_RES *res;
ACL_FILE *fp = NULL;
const char *ptr;
int ret;
/* 输出 HTTP 请求头内容 */
http_hdr_print(&hdr_req->hdr, "---request hdr---");
/* 如果设定代理服务器，则连接代理服务器地址，
* 否则使用 HTTP 请求头里指定的地址
*/
if (*proxy)
acl_vstring_strcpy(buf, proxy);
else
acl_vstring_strcpy(buf, http_hdr_req_host(hdr_req));
/* 获得远程 HTTP 服务器的连接地址 */
ptr = acl_vstring_memchr(buf, ':');
if (ptr == NULL)
acl_vstring_strcat(buf, ":80");
else {
int port;
ptr++;
port = atoi(ptr);
if (port <= 0 || port >= 65535) {
printf("http server's addr(%s) invalid\n", acl_vstring_str(buf));
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
}
/* 连接远程 http 服务器 */
stream = acl_vstream_connect(acl_vstring_str(buf) /* 服务器地址 */,
ACL_BLOCKING /* 采用阻塞方式 */,
10 /* 连接超时时间为 10 秒 */,
10 /* 网络 IO 操作超时时间为 10 秒 */,
4096 /* stream 流缓冲区大小为 4096 字节 */);
if (stream == NULL) {
printf("connect addr(%s) error(%s)\n",
acl_vstring_str(buf), acl_last_serror());
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
/* 构建 HTTP 请求头数据 */
http_hdr_build_request(hdr_req, buf);
/* 向 HTTP 服务器发送请求 */
ret = acl_vstream_writen(stream, acl_vstring_str(buf), ACL_VSTRING_LEN(buf));
if (ret == ACL_VSTREAM_EOF) {
printf("write to server error(%s)\n", acl_last_serror());
acl_vstream_close(stream);
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
/* 创建一个 HTTP 响应头对象 */
hdr_res = http_hdr_res_new();
/* 读取 HTTP 服务器响应头*/
ret = http_hdr_res_get_sync(hdr_res, stream, 10 /* IO 超时时间为 10 秒 */);
if (ret < 0) {
printf("get http reply header error(%s)\n", acl_last_serror());
http_hdr_res_free(hdr_res);
acl_vstream_close(stream);
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
if (http_hdr_res_parse(hdr_res) < 0) {
printf("parse http reply header error\n");
http_hdr_print(&hdr_res->hdr, "--- reply http header ---");
http_hdr_res_free(hdr_res);
acl_vstream_close(stream);
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
/* 如果需要转储至磁盘则需要先打开文件 */
if (dump != NULL) {
fp = acl_fopen(dump, "w+");
if (fp == NULL)
printf("open file(%s) error(%s)\n",
dump, acl_last_serror());
}
/* 如果 HTTP 响应没有数据体则仅输出 HTTP 响应头即可 */
if (hdr_res->hdr.content_length == 0
|| (hdr_res->hdr.content_length == -1
&& !hdr_res->hdr.chunked
&& hdr_res->reply_status > 300
&& hdr_res->reply_status < 400))
{
if (fp)
http_hdr_fprint(ACL_FSTREAM(fp), &hdr_res->hdr,
"--- reply http header ---");
else
http_hdr_fprint(ACL_VSTREAM_OUT, &hdr_res->hdr,
"--- reply http header ---");
http_hdr_res_free(hdr_res);
acl_vstream_close(stream);
acl_vstring_free(buf);
http_hdr_req_free(hdr_req);
return;
}
/* 输出 HTTP 响应头 */
http_hdr_print(&hdr_res->hdr, "--- reply http header ---");
/* 创建 HTTP 响应体对象 */
res = http_res_new(hdr_res);
/* 如果有数据体则开始读取 HTTP 响应数据体部分 */
while (1) {
http_off_t n;
char buf2[4096];
n = http_res_body_get_sync(res, stream, buf2, sizeof(buf2) - 1);
if (n <= 0)
break;
if (fp) {
if (acl_fwrite(buf2, (size_t) n, 1, fp) == (size_t) EOF) {
printf("write to dump file(%s) error(%s)\n",
dump, acl_last_serror());
break;
}
} else {
buf2[n] = 0;
printf("%s", buf2);
}
}
if (fp)
acl_fclose(fp);
http_res_free(res); /* 释放 HTTP 响应对象, hdr_res 会在此函数内部自动被释放 */
acl_vstream_close(stream); /* 关闭网络流 */
acl_vstring_free(buf); /* 释放内存区 */
http_hdr_req_free(hdr_req); /* 释放 HTTP 请求头对象 */
}
acl_int64 gid_cmdline_next(ACL_VSTREAM *client, const char *tag, int *errnum)
{
char buf[1204];
ACL_ARGV *tokens;
ACL_ITER iter;
const char *status = NULL, *gid = NULL, *tag_ptr = NULL, *msg = NULL, *err = NULL;
if (tag && *tag)
snprintf(buf, sizeof(buf), "CMD^%s|TAG^%s\r\n", GID_CMD_NEXT, tag);
else
snprintf(buf, sizeof(buf), "CMD^%s\r\n", GID_CMD_NEXT);
if (acl_vstream_writen(client, buf, strlen(buf)) == ACL_VSTREAM_EOF) {
if (errnum)
*errnum = GID_ERR_IO;
return (-1);
} else if (acl_vstream_gets_nonl(client, buf, sizeof(buf)) == ACL_VSTREAM_EOF)
{
if (errnum)
*errnum = GID_ERR_IO;
return (-1);
}
tokens = acl_argv_split(buf, "|");
acl_foreach(iter, tokens) {
const char *ptr = (const char*) iter.data;
if (strncasecmp(ptr, "STATUS^", sizeof("STATUS^") - 1) == 0) {
status = ptr + sizeof("STATUS^") - 1;
} else if (strncasecmp(ptr, "GID^", sizeof("GID^") - 1) == 0) {
gid = ptr + sizeof("GID^") - 1;
} else if (strncasecmp(ptr, "TAG^", sizeof("TAG^") - 1) == 0) {
tag_ptr = ptr + sizeof("TAG^") - 1;
} else if (strncasecmp(ptr, "MSG^", sizeof("MSG^") - 1) == 0) {
msg = ptr + sizeof("MSG^") - 1;
} else if (strncasecmp(ptr, "ERR^", sizeof("ERR^") - 1) == 0) {
err = ptr + sizeof("ERR^");
}
}
if (status == NULL) {
if (errnum)
*errnum = GID_ERR_PROTO;
acl_argv_free(tokens);
return (-1);
} else if (strcasecmp(status, "OK") != 0) {
if (errnum) {
if (err)
*errnum = atoi(err);
else
*errnum = GID_ERR_SERVER;
}
acl_argv_free(tokens);
return (-1);
} else if (gid == NULL) {
if (errnum)
*errnum = GID_ERR_PROTO;
acl_argv_free(tokens);
return (-1);
} else {
acl_int64 ngid = atoll(gid);
acl_argv_free(tokens);
return (ngid);
}
}
static void run_one(TLS_APPL_STATE *client_tls_ctx)
{
ACL_VSTREAM *client;
TLS_SESS_STATE *client_sess_ctx;
TLS_CLIENT_START_PROPS tls_props;
char buf[4096];
int i, ret;
time_t last, now;
int tls_level = 2;
char *tls_nexthop = "test.com.cn";
char *host = "test.com.cn";
char *namaddrport = "test.com.cn";
char *serverid = "service:addr:port:helo";
char *tls_protocols = SSL_TXT_TLSV1;
char *tls_grade = "low"; /* high, medium, low, export, null */
char *tls_exclusions = "";
ACL_ARGV *tls_matchargv = 0;
client = acl_vstream_connect(serv_addr, ACL_BLOCKING, 20, 30, 8192);
if (client == NULL) {
printf("connect %s error(%s)\n", serv_addr, acl_last_serror());
return;
}
acl_tcp_set_nodelay(ACL_VSTREAM_SOCK(client));
#if 0
client_sess_ctx = TLS_CLIENT_START(&tls_props,
ctx = client_tls_ctx,
stream = client,
log_level = var_client_tls_loglevel,
timeout = var_client_starttls_tmout,
tls_level = tls_level,
nexthop = tls_nexthop,
host = host,
namaddr = namaddrport,
serverid = serverid,
protocols = tls_protocols,
cipher_grade = tls_grade,
cipher_exclusions = tls_exclusions,
matchargv = tls_matchargv,
fpt_dgst = var_client_tls_fpt_dgst);
#else
tls_props.ctx = client_tls_ctx;
tls_props.stream = client;
tls_props.log_level = var_client_tls_loglevel;
tls_props.timeout = var_client_starttls_tmout;
tls_props.tls_level = tls_level;
tls_props.nexthop = tls_nexthop;
tls_props.host = host;
tls_props.namaddr = namaddrport;
tls_props.serverid = serverid;
tls_props.protocols = tls_protocols;
tls_props.cipher_grade = tls_grade;
tls_props.cipher_exclusions = tls_exclusions;
tls_props.matchargv = tls_matchargv;
tls_props.fpt_dgst = var_client_tls_fpt_dgst;
client_sess_ctx = tls_client_start(&tls_props);
#endif
if (client_sess_ctx == NULL) {
printf("TLS_CLIENT_START error\n");
acl_vstream_close(client);
return;
}
if (tls_level >= TLS_LEV_VERIFY) {
if (!TLS_CERT_IS_TRUSTED(client_sess_ctx)) {
printf("Server certificate not trusted\n");
}
}
if (tls_level > TLS_LEV_ENCRYPT) {
if (!TLS_CERT_IS_MATCHED(client_sess_ctx)) {
printf("Server certificate not verified\n");
}
}
time(&last);
i = 0;
while (1) {
ret = acl_vstream_fprintf(client, "hello world\n");
if (ret == ACL_VSTREAM_EOF)
goto END;
ret = acl_vstream_gets(client, buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF)
goto END;
break;
i++;
if (i % 50000 == 0) {
time(&now);
printf("client: i=%d, time=%ld\n", i, now - last);
last = now;
}
}
if (0)
{
if (acl_vstream_writen(client, request, strlen(request)) == ACL_VSTREAM_EOF)
printf("write request error\n");
else {
while (1) {
if (acl_vstream_gets_nonl(client, buf, sizeof(buf)) == ACL_VSTREAM_EOF)
break;
/*
printf("%s\n", buf);
*/
}
/*
printf("gets respond over now\n");
*/
}
}
END:
tls_client_stop(client_tls_ctx, client, var_client_starttls_tmout, 0, client_sess_ctx);
acl_vstream_close(client);
}
void *CHttpClient::DoRequestThread(void* arg)
{
CHttpClient *phClient = (CHttpClient*) arg;
HTTP_HDR_REQ *hdr_req = NULL;
HTTP_HDR_RES *hdr_res = NULL;
HTTP_RES *http_res = NULL;
ACL_VSTRING *buf = acl_vstring_alloc(256);
ACL_VSTREAM *server = NULL;
const char *pHost = NULL;
ACL_VSTREAM *fp = NULL;
int ret;
UINT nForward = 0;
time_t begin = 0;
struct timeval begin_tv, end_tv;
double time_cost = 0;
#undef RETURN
#define RETURN(_x_) do \
{ \
if (hdr_req) \
http_hdr_req_free(hdr_req); \
if (buf) \
acl_vstring_free(buf); \
if (hdr_res) \
http_hdr_res_free(hdr_res); \
if (http_res) { \
http_res->hdr_res = NULL; \
http_res_free(http_res); \
} \
if (server) \
acl_vstream_close(server); \
if (fp) \
acl_vstream_close(fp); \
gettimeofday(&end_tv, NULL); \
time_cost = stamp_sub(&end_tv, &begin_tv); \
if (time_cost >= 0) \
phClient->ReportTime(time_cost); \
phClient->ReportComplete(); \
return (_x_); \
} while(0)
const char *pUrl = phClient->m_sReqUrl.GetString();
hdr_req = http_hdr_req_create(pUrl, phClient->m_bPostMethod ? "POST" : "GET",
phClient->m_bHttp11 ? "HTTP/1.1" : "HTTP/1.0");
ASSERT(hdr_req);
if (phClient->m_bZip)
http_hdr_put_str(&hdr_req->hdr, "Accept-Encoding", "gzip, deflate");
if (phClient->m_bKeepAlive)
http_hdr_entry_replace(&hdr_req->hdr, "Connection", "Keep-Alive", 1);
if (phClient->m_bPostMethod)
http_hdr_put_int(&hdr_req->hdr, "Content-Length",
(int) phClient->m_sHttpBody.GetLength());
if (!phClient->m_sAccept.IsEmpty())
http_hdr_put_str(&hdr_req->hdr, "Accept", phClient->m_sAccept.GetString());
if (!phClient->m_sCtype.IsEmpty())
http_hdr_put_str(&hdr_req->hdr, "Content-Type", phClient->m_sCtype.GetString());
if (phClient->m_sHttpHdrAppend.GetLength() > 0) {
ACL_ARGV *argv;
HTTP_HDR_ENTRY *entry;
int i;
argv = acl_argv_split(phClient->m_sHttpHdrAppend.GetString(), "\r\n");
for (i = 0; i < argv->argc; i++) {
entry = http_hdr_entry_new(argv->argv[i]);
if (entry == NULL)
continue;
http_hdr_append_entry(&hdr_req->hdr, entry);
}
acl_argv_free(argv);
}
FORWARD:
http_hdr_build_request(hdr_req, buf);
pHost = http_hdr_req_host(hdr_req);
ASSERT(pHost);
phClient->ReportReqHdr(acl_vstring_str(buf), (int) ACL_VSTRING_LEN(buf));
CString serverAddr;
if (phClient->m_bUseAddr)
serverAddr.Format("%s", phClient->m_sServerAddr);
if (serverAddr.GetLength() == 0)
serverAddr.Format("%s", pHost);
if (strchr(serverAddr.GetString(), ':') == NULL)
serverAddr.AppendFormat(":80");
time(&begin);
gettimeofday(&begin_tv, NULL);
server = acl_vstream_connect(serverAddr.GetString(),
ACL_BLOCKING, 10, 10, 4096);
if (server == NULL) {
CString msg;
msg.Format("Connect server(%s) error", serverAddr.GetString());
phClient->ReportErrConnect(msg.GetString());
RETURN (NULL);
}
if (phClient->m_bLocalSave && fp == NULL) {
fp = acl_vstream_fopen(phClient->m_sLocalFile.GetString(),
O_WRONLY | O_CREAT | O_TRUNC, 0600, 4096);
if (fp == NULL) {
acl_msg_error("%s(%d): can't create file(%s)",
__FILE__, __LINE__, phClient->m_sLocalFile.GetString());
RETURN (NULL);
}
}
ret = acl_vstream_writen(server, acl_vstring_str(buf), ACL_VSTRING_LEN(buf));
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): write error", __FILE__, __LINE__);
RETURN (NULL);
}
if (phClient->m_bPostMethod && !phClient->m_sHttpBody.IsEmpty())
{
if (acl_vstream_writen(server, phClient->m_sHttpBody.GetString(),
phClient->m_sHttpBody.GetLength()) == ACL_VSTREAM_EOF)
{
acl_msg_error("%s(%d): write body error", __FILE__, __LINE__);
RETURN (NULL);
}
}
hdr_res = http_hdr_res_new();
if (http_hdr_res_get_sync(hdr_res, server, 10) < 0) {
acl_msg_error("%s(%d): get res hdr error", __FILE__, __FILE__, __LINE__);
RETURN (NULL);
}
if (http_hdr_res_parse(hdr_res) < 0) {
acl_msg_error("%s(%d): parse hdr_res error", __FILE__, __LINE__);
RETURN (NULL);
}
http_hdr_build(&hdr_res->hdr, buf);
phClient->ReportResHdr(acl_vstring_str(buf), (int) ACL_VSTRING_LEN(buf));
phClient->ReportResContentLength((int) hdr_res->hdr.content_length);
if (hdr_res->reply_status > 300 && hdr_res->reply_status < 400) {
const char* pLocation;
HTTP_HDR_REQ *hdr_req_tmp;
if (!phClient->m_bForwardAuto)
RETURN (NULL);
if (nForward++ >= phClient->m_nMaxTry) {
acl_msg_error("%s(%d): too many redirect, nForward(%d)",
__FILE__, __LINE__, nForward);
RETURN (NULL);
}
pLocation = http_hdr_entry_value(&hdr_res->hdr, "Location");
if (pLocation == NULL || *pLocation == 0) {
acl_msg_error("%s(%d): 302 reply with no Location", __FILE__, __LINE__);
RETURN (NULL);
}
hdr_req_tmp = http_hdr_req_rewrite(hdr_req, pLocation);
if (hdr_req_tmp == NULL)
RETURN (NULL);
http_hdr_req_free(hdr_req);
http_hdr_res_free(hdr_res);
hdr_req = hdr_req_tmp;
goto FORWARD;
}
http_res = http_res_new(hdr_res);
while (1) {
char tmp_buf[4096];
ret = (int) http_res_body_get_sync2(http_res, server,
tmp_buf, sizeof(tmp_buf) - 1);
if (ret <= 0)
break;
phClient->ReportResBody(tmp_buf, ret);
phClient->ReportResDownLength((int)(time(NULL) - begin), ret);
if (fp != NULL && acl_vstream_writen(fp, tmp_buf, ret) == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): write to file error", __FILE__, __LINE__);
break;
}
}
RETURN (NULL);
}
static int parse_xml_file(const char *filepath)
{
int n;
acl_int64 len;
char buf[10240];
ACL_VSTREAM *in = acl_vstream_fopen(filepath, O_RDONLY, 0600, 8192);
const char* outfile = "./out.xml";
ACL_VSTREAM *out = acl_vstream_fopen(outfile, O_RDWR | O_CREAT | O_TRUNC, 0600, 8192);
ACL_XML2 *xml;
const char *mmap_file = "./local.map";
const char* ptr;
if (in == NULL) {
printf("open %s error %s\r\n", filepath, acl_last_serror());
return -1;
}
if (out == NULL)
{
printf("open %s error %s\r\n", outfile, acl_last_serror());
acl_vstream_close(in);
return -1;
}
len = acl_vstream_fsize(in);
if (len <= 0) {
printf("fsize %s error %s\r\n", filepath, acl_last_serror());
acl_vstream_close(in);
acl_vstream_close(out);
return -1;
}
acl_vstream_printf(">>>file(%s)'s size: %lld\r\n", filepath, len);
len *= 4;
xml = acl_xml2_mmap_file(mmap_file, len, 10, 1, NULL);
len = 0;
while (1) {
n = acl_vstream_read(in, buf, sizeof(buf) - 1);
if (n == ACL_VSTREAM_EOF)
break;
buf[n] = 0;
acl_xml2_update(xml, buf);
len += n;
}
acl_vstream_close(in);
acl_vstream_printf(">>read size: %lld\r\n", len);
ptr = acl_xml2_build(xml);
if (ptr == NULL)
printf("acl_xml2_build error\r\n");
len = xml->ptr - ptr;
acl_vstream_printf(">>>build xml's size:%lld\r\n", len);
acl_vstream_printf(">>> ptr: {%s}\r\n", ptr);
if (acl_vstream_writen(out, ptr, len) == ACL_VSTREAM_EOF) {
printf("write error %s, len: %ld\r\n",
acl_last_serror(), (long) len);
return -1;
}
acl_vstream_close(out);
acl_xml2_free(xml);
return 0;
}
int main(int argc, char *argv[])
{
ACL_VSTREAM *client;
char addr[64], *buf = NULL, line[128];
int n, i, len = 4096, count = 10, inter = 1000;
snprintf(addr, sizeof(addr), "127.0.0.1:8888");
while ((n = getopt(argc, argv, "hs:l:n:i:")) > 0) {
switch (n) {
case 'h':
usage(argv[0]);
return 0;
case 's':
snprintf(addr, sizeof(addr), "%s", optarg);
break;
case 'l':
len = atoi(optarg);
break;
case 'n':
count = atoi(optarg);
break;
case 'i':
inter = atoi(optarg);
break;
default:
break;
}
}
if (len <= 0) {
printf("invalid len: %d <= 0\r\n", len);
return 1;
}
/* 连接服务器 */
client = acl_vstream_connect(addr, ACL_BLOCKING, 10, 10, 4096);
if (client == NULL) {
printf("connect %s error %s\r\n", addr, acl_last_serror());
return 1;
}
printf("connect %s ok ...\r\n", addr);
buf = (char*) acl_mymalloc(len);
snprintf(buf, len, "%d\r\n", len);
/* 发送一行数据通知服务端每次数据体的长度 */
if (acl_vstream_writen(client, buf, strlen(buf)) == ACL_VSTREAM_EOF)
if (n == ACL_VSTREAM_EOF)
goto END;
memset(buf, 'X', len);
for (i = 0; i < count; i++) {
n = acl_vstream_writen(client, buf, len);
if (n == ACL_VSTREAM_EOF) {
printf("write error %s\r\n", acl_last_serror());
break;
}
if (i % inter == 0) {
snprintf(line, sizeof(line), "curr: %d, total: %d", i, count);
ACL_METER_TIME(line);
}
}
END:
if (buf)
acl_myfree(buf);
acl_vstream_close(client);
return 0;
}
