static int proctl_monitor_cmd_list(ACL_VSTREAM *client)
{
ACL_ARGV *service_argv;
int i, ret = 0;
service_argv = proctl_serivce_get_all();
if (service_argv == NULL) {
acl_vstream_fprintf(client, "+OK|no service running yet!\r\n");
return (0);
}
for (i = 0; i < service_argv->argc; i++) {
ret = acl_vstream_fprintf(client, "+OK|service=%s running\r\n",
service_argv->argv[i]);
if (ret == ACL_VSTREAM_EOF)
break;
}
if (ret != ACL_VSTREAM_EOF)
acl_vstream_fprintf(client, "+OK|total service is %d\r\n",
service_argv->argc);
proctl_service_free_all(service_argv);
return (0);
}
/* 停止某个服务进程 */
static int proctl_monitor_cmd_stop(ACL_VSTREAM *client,
const char *filepath, const char *args)
{
const char *myname = "proctl_monitor_cmd_stop";
if (filepath == NULL || *filepath == 0) {
acl_vstream_fprintf(client, "-ERR|filepath null\r\n");
acl_msg_error("%s(%d): no filepath", myname, __LINE__);
return (-1);
}
if (strcasecmp(filepath, "all") == 0) {
acl_msg_info("begin to stop file(%s)", filepath);
proctl_monitor_stop_all_service(client);
} else if (!proctl_service_exist(filepath)) {
acl_msg_error("%s(%d): filepath(%s) not running now",
myname, __LINE__, filepath);
acl_vstream_fprintf(client, "-ERR|filepath(%s) not running\r\n",
filepath);
return (-1);
}
acl_msg_info("%s(%d): begin to stop file(%s)", myname, __LINE__, filepath);
proctl_monitor_stop_service(client, filepath, args);
acl_msg_info("%s(%d): stop (%s) end", myname, __LINE__, filepath);
return (0);
}
void acl_proctl_start_one(const char *progname,
const char *progchild, int argc, char *argv[])
{
const char *myname = "acl_proctl_start_one";
char ebuf[256], buf[1024];
ACL_VSTREAM *client;
ACL_VSTRING *child_args = NULL;
int n;
if (argc > 0) {
int i;
child_args = acl_vstring_alloc(256);
for (i = 0; i < argc; i++) {
if (i > 0)
acl_vstring_strcat(child_args, " ");
acl_vstring_strcat(child_args, "\"");
acl_vstring_strcat(child_args, argv[i]);
acl_vstring_strcat(child_args, "\"");
}
}
/* 打开与控制进程之间的连接 */
client = proctl_client_open(progname);
if (child_args) {
/* 向控制进程发送消息，带有控制参数 */
n = acl_vstream_fprintf(client, "%s|-d|START|-f|%s|-a|%s\r\n",
progname, progchild, acl_vstring_str(child_args));
} else {
/* 向控制进程发送消息，不带控制参数 */
n = acl_vstream_fprintf(client, "%s|-d|START|-f|%s\r\n",
progname, progchild);
}
if (child_args != NULL)
acl_vstring_free(child_args);
if (n == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): fprintf to acl_proctl error(%s)",
myname, __LINE__, acl_last_strerror(ebuf, sizeof(ebuf)));
/* 接收所有来自于控制进程的消息响应结果 */
while (1) {
n = acl_vstream_gets_nonl(client, buf, sizeof(buf));
if (n == ACL_VSTREAM_EOF)
break;
acl_msg_info("%s(%d): %s", myname, __LINE__, buf);
}
proctl_client_close(client);
}
static int proctl_monitor_cmd_probe(ACL_VSTREAM *client, const char *filepath)
{
if (filepath == NULL || *filepath == 0) {
acl_vstream_fprintf(client, "-ERR|filepath is null\r\n");
return (-1);
}
if (proctl_service_exist(filepath))
acl_vstream_fprintf(client, "+OK|service: %s is running\r\n", filepath);
else
acl_vstream_fprintf(client, "+OK|service: %s is not running\r\n", filepath);
return (0);
}
static void usage(ACL_VSTREAM *client)
{
acl_vstream_fprintf(client, "usage: progname|-h[help]"
"|-d|{action}[START|STOP|QUIT|LIST|PROBE]|-f|filepath|-a|args\r\n");
acl_msg_info("usage: progname|-h[help]|-d|{action}[START|STOP|QUIT|LIST|PROBE]"
"|-f|filepath|-a|args");
}
static void msg_error(PROBE_SERVER *server, const char *fmt, ...)
{
const char *myname = "msg_error";
va_list ap;
static char buf[4096];
if (server == NULL)
acl_msg_fatal("%s: server null", myname);
if (fmt == NULL)
acl_msg_fatal("%s: fmt null", myname);
va_start(ap, fmt);
acl_vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
server->time_end = time(NULL);
server->time_total_cost = server->time_end - server->time_begin;
if (server->logfp != NULL) {
char fmtstr[128];
acl_logtime_fmt(fmtstr, sizeof(fmtstr));
acl_vstream_fprintf(server->logfp,
"%s, %s: <%s> addr(%s), url(%s), time(%ld), %s\n",
myname, fmtstr, (server->warn_time > 0
&& server->time_total_cost
>= server->warn_time) ? "WARN" : "INFO",
server->addr, server->url, server->time_total_cost, buf);
} else
acl_msg_error("%s <%s> addr(%s), url(%s), time(%ld), %s",
myname, (server->warn_time > 0
&& server->time_total_cost
>= server->warn_time) ? "WARN" : "INFO",
server->addr, server->url, server->time_total_cost, buf);
}
static void end(void)
{
#ifdef ACL_MS_WINDOWS
acl_vstream_fprintf(ACL_VSTREAM_OUT, "enter any key to quit\r\n");
getchar();
#endif
}
static void test_connect(const char *addr)
{
ACL_VSTREAM *stream;
#if 1
const char *request = "GET / HTTP/1.1\nHOST: store.hexun.com\nConnection: keep-alive\n\nGET / HTTP/1.1\nHOST: store.hexun.com\nConnection: close\n\n";
#else
const char *request = "GET / HTTP/1.1\nHOST: store.hexun.com\nConnection: keep-alive\n\n";
#endif
stream = acl_vstream_connect(addr, ACL_BLOCKING, 10, 10, 4096);
if (stream == NULL) {
printf("connect %s error(%s)\n", addr, acl_last_serror());
return;
}
acl_vstream_fprintf(stream, "%s", request);
printf("request:(%s)\n", request);
while (1) {
char buf[4096];
int ret = acl_vstream_read(stream, buf, sizeof(buf) - 1);
if (ret == ACL_VSTREAM_EOF)
break;
buf[ret] = 0;
printf("%s", buf);
}
}
int smtp_quit(SMTP_CLIENT *client)
{
int ret;
ACL_ARGV *tokens;
client->smtp_code = 0;
client->buf[0] = 0;
ret = acl_vstream_fprintf(client->conn, "QUIT\r\n");
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send quit cmd error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets quit's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 221) {
acl_msg_error("%s(%d): quit's reply: %d",
__FUNCTION__, __LINE__, client->smtp_code);
acl_argv_free(tokens);
return -1;
}
acl_argv_free(tokens);
return 0;
}
int smtp_data_end(SMTP_CLIENT *client)
{
int ret;
ACL_ARGV *tokens;
client->smtp_code = 0;
client->buf[0] = 0;
ret = acl_vstream_fprintf(client->conn, "\r\n.\r\n");
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send mail eof error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets mail eof's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 250) {
acl_msg_error("%s(%d): send mail error(%d), line: %s",
__FUNCTION__, __LINE__, client->smtp_code, client->buf);
acl_argv_free(tokens);
return -1;
}
acl_argv_free(tokens);
return 0;
}
int smtp_data(SMTP_CLIENT *client)
{
ACL_ARGV *tokens;
int ret;
client->smtp_code = 0;
client->buf[0] = 0;
ret = acl_vstream_fprintf(client->conn, "DATA\r\n");
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send data error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets data's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 354) {
acl_msg_error("%s(%d): data denied, error(%d), line(%s)",
__FUNCTION__, __LINE__, client->smtp_code, client->buf);
acl_argv_free(tokens);
return -1;
}
acl_argv_free(tokens);
return 0;
}
int smtp_rcpt(SMTP_CLIENT *client, const char *to)
{
int ret;
ACL_ARGV *tokens;
client->smtp_code = 0;
client->buf[0] = 0;
ret = acl_vstream_fprintf(client->conn, "RCPT TO: <%s>\r\n", to);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send rcpt error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets rcpt's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 250) {
acl_msg_error("%s(%d): rcpt's reply error(%d), line(%s)",
__FUNCTION__, __LINE__, client->smtp_code, client->buf);
acl_argv_free(tokens);
return -1;
}
acl_argv_free(tokens);
return 0;
}
/* 连接某个服务进程的监听接口，发送停止消息 */
static void proctl_monitor_stop_service(ACL_VSTREAM *client,
const char *filepath, const char *args)
{
const char *myname = "proctl_monitor_stop_service";
ACL_VSTREAM *stream;
char addr[256], ebuf[256], buf[1024], logfile[MAX_PATH];
int n;
get_lock_file2(filepath, logfile, sizeof(logfile));
if (get_addr_from_file(logfile, addr, sizeof(addr)) < 0) {
acl_vstream_fprintf(client, "-ERR|get addr error from %s\r\n", filepath);
acl_msg_error("%s(%d): get addr for filepath(%s) error",
myname, __LINE__, filepath);
return;
}
stream = acl_vstream_connect(addr, ACL_BLOCKING, 10, 10, 1024);
if (stream == NULL) {
acl_vstream_fprintf(client, "-ERR|connect addr=%s error, file=%s\r\n",
addr, filepath);
acl_msg_error("%s(%d): connect addr(%s) error(%s)",
myname, __LINE__, addr, acl_last_strerror(ebuf, sizeof(ebuf)));
return;
}
if (args && *args)
n = acl_vstream_fprintf(stream, "%s|-d|STOP|-f|%s|-a|%s\r\n",
filepath, filepath, args);
else
n = acl_vstream_fprintf(stream, "%s|-d|STOP|-f|%s\r\n",
filepath, filepath);
buf[0] = 0;
if (n == ACL_VSTREAM_EOF) {
acl_vstream_fprintf(client, "-ERR|write to addr=%s error, file=%s\r\n",
addr, filepath);
acl_msg_error("%s(%d): fprintf to acl_master error(%s)",
myname, __LINE__, acl_last_strerror(ebuf, sizeof(ebuf)));
} else if (acl_vstream_gets_nonl(stream, buf, sizeof(buf)) == ACL_VSTREAM_EOF) {
acl_vstream_fprintf(client, "-ERR|filepath(%s), not get respond\r\n", filepath);
acl_msg_error("%s(%d): not get respond, filepath(%s)",
myname, __LINE__, filepath);
} else if (strncasecmp(buf, "+OK", 3) != 0) {
acl_vstream_fprintf(client, "-ERR|filepath(%s), child respond(%s)\r\n",
filepath, buf);
acl_msg_error("%s(%d): child respond error(%s), filepath(%s)",
myname, __LINE__, buf, filepath);
} else {
acl_vstream_fprintf(client, "+OK|stopped %s\r\n", filepath);
acl_msg_info("%s(%d): stop child(%s) ok", myname, __LINE__, filepath);
}
acl_vstream_close(stream);
}
static void run_thread(void *arg)
{
RUN_CTX *ctx = (RUN_CTX*) arg;
acl_pthread_mutex_lock(&__mutex);
acl_vstream_fprintf(ctx->fp, "hello world, hello world, hello world, hello world, i: %d\n", ctx->i);
acl_pthread_mutex_unlock(&__mutex);
acl_myfree(ctx);
}
int smtp_ehlo(SMTP_CLIENT *client, const char *ehlo)
{
int ret;
char *ptr;
ACL_ARGV *tokens;
client->buf[0] = 0;
client->smtp_code = 0;
ret = acl_vstream_fprintf(client->conn, "EHLO %s\r\n", ehlo);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): set EHLO error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
while (1) {
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): get EHLO's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
} else if (ret < 3) {
acl_msg_warn("%s(%d): EHLO's reply(%s) tool short",
__FUNCTION__, __LINE__, client->buf);
continue;
}
if (strncmp(client->buf, "250", 3) != 0) {
ret = client->buf[3];
client->buf[3] = 0;
client->smtp_code = atoi(client->buf);
client->buf[3] = ret;
acl_msg_error("%s(%d): EHLO's reply(%s) code(%d) error",
__FUNCTION__, __LINE__, client->buf, ret);
return -1;
} else
client->smtp_code = 250;
if (ret == 3)
break;
ptr = client->buf + 4;
tokens = acl_argv_split(ptr, " =");
smtp_ehlo_flag(client, tokens);
acl_argv_free(tokens);
if (client->buf[3] == ' ')
break;
}
return 0;
}
/* 停止所有的服务，并退出整个控制进程 */
static void proctl_monitor_cmd_quit(ACL_VSTREAM *client)
{
const char *myname = "proctl_monitor_cmd_quit";
acl_msg_info("%s(%d): begin to quit ...", myname, __LINE__);
acl_msg_info("%s(%d): begin to stop all ...", myname, __LINE__);
proctl_monitor_stop_all_service(client);
acl_msg_info("%s(%d): stop all end", myname, __LINE__);
acl_msg_info("%s(%d): quit ok", myname, __LINE__);
acl_vstream_fprintf(client, "+OK|stopped all children, and quit now\r\n");
acl_vstream_close(client);
exit(0);
}
int main(int argc, char *argv[])
{
test(argv[1]);
return 0;
ACL_VSTREAM *client;
const char *addr;
char buf[1024];
int ret;
if (argc != 2) {
printf("usage: %s addr\n", argv[0]);
return (0);
}
addr = argv[1];
acl_msg_open("connect.log", argv[0]);
printf("connecting %s ...\n", argv[1]);
//acl_poll_prefered(1);
for (int i = 0; i < 10000; i++)
{
client = acl_vstream_connect(addr, ACL_BLOCKING, 10, 10, 4096);
if (client == NULL) {
printf("connect %s error(%s)\n", addr, acl_last_serror());
return (1);
}
printf("connect %s ok, %s\n", addr, acl_last_serror());
}
printf(">>>>>>connect all ok\r\n");
pause();
sleep(100);
acl_vstream_fprintf(client, "%s", "line1\nline2\nline3\nline4\nline5\nline6\nline7\n");
while (1) {
ret = acl_vstream_gets_nonl(client, buf, sizeof(buf));
if (ret > 0) {
printf("gets from %s: %s\n", addr, buf);
} else if (ret == ACL_VSTREAM_EOF) {
printf("get over\r\n");
break;
}
}
acl_vstream_close(client);
return (0);
}
/* 通知主线程，启动一个服务 */
static int proctl_monitor_cmd_start(ACL_VSTREAM *client,
const char *filepath, const char *args)
{
const char *myname = "proctl_monitor_cmd_start";
ACL_VSTRING *cmdline;
PROCTL_SERVICE *service;
PROCTL_MSG *msg;
if (filepath[0] == 0) {
acl_vstream_fprintf(client, "-ERR|filepath null\r\n");
acl_msg_error("%s(%d): no filepath", myname, __LINE__);
return (-1);
}
if (proctl_service_exist(filepath)) {
acl_msg_error("%s(%d): child(%s) maybe be running!",
myname, __LINE__, filepath);
acl_vstream_fprintf(client, "-ERR|child(%s) maybe be running!\r\n",
filepath);
return (-1);
}
cmdline = acl_vstring_alloc(256);
acl_vstring_strcpy(cmdline, "\"");
acl_vstring_strcat(cmdline, filepath);
acl_vstring_strcat(cmdline, "\"");
if (args && *args) {
acl_vstring_strcat(cmdline, " ");
acl_vstring_strcat(cmdline, args);
}
service = proctl_service_alloc(filepath, cmdline);
msg = proctl_msg_new(PROCTL_MSG_START);
msg->service = service;
proctl_msg_push(msg);
return (0);
}
ACL_VSTREAM *local_listen()
{
const char *myname = "local_listen";
char lock_file[MAX_PATH], ebuf[256];
ACL_VSTREAM *sstream, *fp;
ACL_FILE_HANDLE handle;
get_lock_file(lock_file, sizeof(lock_file));
fp = acl_vstream_fopen(lock_file, O_RDWR | O_CREAT, 0600, 1024);
if (fp == NULL)
acl_msg_fatal("%s(%d): open file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
handle = ACL_VSTREAM_FILE(fp);
if (acl_myflock(handle, 0, ACL_MYFLOCK_OP_EXCLUSIVE | ACL_MYFLOCK_OP_NOWAIT) == -1) {
acl_msg_error("%s(%d): lock file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
return (NULL);
}
sstream = acl_vstream_listen_ex("127.0.0.1:0", 128, ACL_BLOCKING, 1024, 0);
if (sstream == NULL)
acl_msg_fatal("%s(%d): listen error(%s)",
myname, __LINE__, acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_file_ftruncate(fp, 0) < 0)
acl_msg_fatal("%s(%d): truncate file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_fseek(fp, 0, SEEK_SET) < 0)
acl_msg_fatal("%s(%d): fseek file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_fprintf(fp, "%s\r\n", sstream->local_addr) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): fprintf to file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
/* XXX: 只能采用先解排它锁，再加共享锁，微软比较弱!!! */
if (acl_myflock(handle, 0, ACL_MYFLOCK_OP_NONE) == -1)
acl_msg_fatal("%s(%d): unlock file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_myflock(handle, 0, ACL_MYFLOCK_OP_SHARED | ACL_MYFLOCK_OP_NOWAIT) == -1)
acl_msg_fatal("%s(%d): lock file(%s) error(%s)",
myname, __LINE__, lock_file, acl_last_strerror(ebuf, sizeof(ebuf)));
return (sstream);
}
/* 停止所有服务进程 */
static void proctl_monitor_stop_all_service(ACL_VSTREAM *client)
{
ACL_ARGV *service_argv;
int i;
service_argv = proctl_serivce_get_all();
if (service_argv == NULL) {
acl_vstream_fprintf(client, "+OK|no service running yet!\r\n");
return;
}
for (i = 0; i < service_argv->argc; i++) {
proctl_monitor_stop_service(client, service_argv->argv[i], NULL);
}
proctl_service_free_all(service_argv);
}
int main(int argc, char *argv[])
{
ACL_VSTREAM *fp;
char *command, buf[1024];
int ret, i = 0;
if (argc != 2) {
usage(argv[0]);
return (0);
}
command = argv[1];
fp = acl_vstream_popen(O_RDWR,
ACL_VSTREAM_POPEN_COMMAND, command,
ACL_VSTREAM_POPEN_END);
ACL_VSTREAM_SET_RWTIMO(fp, 1);
while (1) {
ret = acl_vstream_gets_nonl(fp, buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF) {
printf("(parent): read over(%s), errno: %d, ACL_ETIMEDOUT: %d\n",
acl_last_serror(), errno, ACL_ETIMEDOUT);
break;
}
printf("(parent): read from child(%s)\n", buf);
ret = acl_vstream_fprintf(fp, "from parent ok\n");
if (ret == ACL_VSTREAM_EOF) {
printf("(parent): write error(%s)\n", acl_last_serror());
break;
}
if (i++ > 10)
break;
}
printf("(parent): over now\n");
if (errno == ACL_ETIMEDOUT)
#if 1
kill(fp->pid, SIGKILL);
#else
kill(fp->pid, SIGTERM);
#endif
acl_vstream_pclose(fp);
return (0);
}
static void echo(ACL_VSTREAM *client)
{
int ret;
char buf[1024];
while (1) {
ret = acl_vstream_gets(client, buf, sizeof(buf));
if (ret == ACL_VSTREAM_EOF) {
break;
}
//ret = acl_vstream_fprintf(client, "hello world\r\nhello world\r\nhello world\r\n");
ret = acl_vstream_fprintf(client, "hello world\r\n");
if (ret == ACL_VSTREAM_EOF)
break;
}
}
static int echo_cmd(ACL_VSTREAM *client, const char *s)
{
char buf[1024];
int ret;
if (acl_vstream_fprintf(client, "%s\r\n", s) == ACL_VSTREAM_EOF) {
printf("send %s error\n", s);
return (-1);
}
ret = acl_vstream_gets_nonl(client, buf, sizeof(buf));
if (ret <= 0) {
printf("get reply for %s error\n", s);
return (-1);
}
printf(">>%s\n", s);
printf("<<%s\n", buf);
return (0);
}
int smtp_rset(SMTP_CLIENT *client)
{
int ret;
char *ptr;
client->buf[0] = 0;
client->smtp_code = 0;
ret = acl_vstream_fprintf(client->conn, "RSET\r\n");
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): write RSET error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): get RSET's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ptr = strchr(client->buf, ' ');
if (ptr == NULL)
ptr = strchr(client->buf, '\t');
if (ptr == NULL) {
acl_msg_error("%s(%d): RSET's reply(%s) invalid",
__FUNCTION__, __LINE__, client->buf);
return -1;
}
ret = *ptr;
*ptr = 0;
client->smtp_code = atoi(client->buf);
*ptr = ret;
if (client->smtp_code != 250) {
acl_msg_error("%s(%d): RSET's reply(%s) code(%d) error",
__FUNCTION__, __LINE__, client->buf, client->smtp_code);
return -1;
}
return 0;
}
int smtp_helo(SMTP_CLIENT *client, const char *helo)
{
int ret;
char *ptr;
client->smtp_code = 0;
client->buf[0] = 0;
/* 发送 helo 信息 */
ret = acl_vstream_fprintf(client->conn, "HELO %s\r\n", helo);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send helo error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
/* 读取响应信息 */
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets helo's error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
ptr = strchr(client->buf, ' ');
if (ptr == NULL)
ptr = strchr(client->buf, '\t');
if (ptr == NULL) {
acl_msg_error("%s(%d): get helo reply error, line(%s)",
__FUNCTION__, __LINE__, client->buf);
return -1;
}
*ptr = 0;
client->smtp_code = atoi(client->buf);
*ptr = ' ';
if (client->smtp_code != 250) {
acl_msg_error("%s(%d): helo's reply code: %d, line(%s)",
__FUNCTION__, __LINE__, client->smtp_code, client->buf);
return -1;
}
return 0;
}
static int vstream_client(void)
{
const char *myname = "vstream_client";
ACL_VSTREAM *client;
char ebuf[256], buf[4096];
int n, dlen = 0;
printf("addr: %s, timeout: %d\n", addr, timeout);
client = acl_vstream_connect(addr, ACL_NON_BLOCKING, timeout, timeout, 1024);
if (client == NULL) {
printf("%s(%d): connect addr %s error(%s)\n",
myname, __LINE__, addr, acl_last_strerror(ebuf, sizeof(ebuf)));
return (-1);
}
printf("%s: connect %s ok\r\n", myname, addr);
acl_non_blocking(ACL_VSTREAM_SOCK(client), ACL_BLOCKING);
n = acl_write_wait(ACL_VSTREAM_SOCK(client), 10);
if (n < 0) {
printf("connect timeout: %s\n", acl_last_serror());
goto END;
}
acl_vstream_fprintf(client, "hello world\n");
while (1) {
n = acl_vstream_read(client, buf, sizeof(buf));
if (n == ACL_VSTREAM_EOF) {
printf("read over: %s\n", acl_last_serror());
break;
}
dlen += n;
buf[n] = 0;
printf("read reply: %s\n", buf);
}
END:
acl_vstream_close(client);
printf("%s: read %d\n", myname, dlen);
return (0);
}
static void msg_info(PROBE_SERVER *server, const char *fmt, ...)
{
const char *myname = "msg_info";
va_list ap;
static char buf[4096];
if (server == NULL)
acl_msg_fatal("%s: server null", myname);
if (fmt == NULL)
acl_msg_fatal("%s: fmt null", myname);
va_start(ap, fmt);
acl_vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
server->time_end = time(NULL);
server->time_total_cost = server->time_end - server->time_begin;
if (server->logfp != NULL) {
char fmtstr[128];
acl_logtime_fmt(fmtstr, sizeof(fmtstr));
acl_vstream_fprintf(server->logfp, "%s: <%s> addr(%s), url(%s),"
" time(%ld), content_length(%lld), reply_status(%d), %s\n",
fmtstr, (server->warn_time > 0 && server->time_total_cost
>= server->warn_time) ? "WARN" : "INFO",
server->addr, server->url, server->time_total_cost,
server->hdr_res->hdr.chunked
? -1 : server->hdr_res->hdr.content_length,
server->hdr_res->reply_status, buf);
} else
acl_msg_info("<%s> addr(%s), url(%s), time(%ld), "
"content_length(%lld), reply_status(%d), %s",
(server->warn_time > 0 && server->time_total_cost
>= server->warn_time) ? "WARN" : "INFO",
server->addr, server->url, server->time_total_cost,
server->hdr_res->hdr.chunked
? -1 : server->hdr_res->hdr.content_length,
server->hdr_res->reply_status, buf);
}
void acl_proctl_list(const char *progname)
{
const char *myname = "acl_proctl_list";
char ebuf[256], buf[1024];
ACL_VSTREAM *client;
int n;
client = proctl_client_open(progname);
n = acl_vstream_fprintf(client, "%s|-d|LIST\r\n", progname);
if (n == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): fprintf to acl_proctl error(%s)",
myname, __LINE__, acl_last_strerror(ebuf, sizeof(ebuf)));
while (1) {
if (acl_vstream_gets_nonl(client, buf, sizeof(buf)) == ACL_VSTREAM_EOF)
break;
acl_debug(ACL_DEBUG_PROCTL, 2) ("%s(%d): buf(%s)",
myname, __LINE__, buf);
printf("%s\r\n", buf);
}
proctl_client_close(client);
}
int smtp_mail(SMTP_CLIENT *client, const char *from)
{
int ret;
ACL_ARGV *tokens;
client->smtp_code = 0;
client->buf[0] = 0;
/* 发送 mail from 信息 */
ret = acl_vstream_fprintf(client->conn, "MAIL FROM: <%s>\r\n", from);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send mail from error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return -1;
}
/* 读取响应信息 */
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets mail from's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
return (-1);
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 250) {
acl_msg_error("%s(%d): mail from error(%d), line(%s)",
__FUNCTION__, __LINE__, client->smtp_code, client->buf);
acl_argv_free(tokens);
return -1;
}
acl_argv_free(tokens);
return 0;
}
int smtp_auth(SMTP_CLIENT *client, const char *user, const char *pass)
{
int ret;
ACL_ARGV *tokens = NULL;
char *user_encoded = NULL, *pass_encoded = NULL;
#undef RETURN
#define RETURN(x) do { \
if (tokens) \
acl_argv_free(tokens); \
if (user_encoded) \
acl_myfree(user_encoded); \
if (pass_encoded) \
acl_myfree(pass_encoded); \
return (x); \
} while (0)
client->smtp_code = 0;
client->buf[0] = 0;
/* 发送认证命令 */
ret = acl_vstream_fprintf(client->conn, "AUTH LOGIN\r\n");
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send AUTH LOGIN to error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): gets AUTH LOGIN's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 334) {
acl_msg_error("%s(%d): AUTH LOGIN failed, line(%s)",
__FUNCTION__, __LINE__, client->buf);
RETURN (-1);
}
/* 发送邮箱帐号 */
user_encoded = (char*) acl_base64_encode(user, (int) strlen(user));
ret = acl_vstream_fprintf(client->conn, "%s\r\n", user_encoded);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send user error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): auth gets error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
acl_argv_free(tokens);
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 334) {
acl_msg_error("%s(%d): AUTH LOGIN failed, line(%s)",
__FUNCTION__, __LINE__, client->buf);
RETURN (-1);
}
/* 发送 password */
pass_encoded = (char*) acl_base64_encode(pass, (int) strlen(pass));
ret = acl_vstream_fprintf(client->conn, "%s\r\n", pass_encoded);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): send pass error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
ret = acl_vstream_gets_nonl(client->conn, client->buf, client->size);
if (ret == ACL_VSTREAM_EOF) {
acl_msg_error("%s(%d): auth gets pass's reply error(%s)",
__FUNCTION__, __LINE__, acl_last_serror());
RETURN (-1);
}
acl_argv_free(tokens);
tokens = acl_argv_split(client->buf, "\t ");
client->smtp_code = atoi(tokens->argv[0]);
if (client->smtp_code != 235) {
acl_msg_error("%s(%d): AUTH LOGIN failed, line(%s)",
__FUNCTION__, __LINE__, client->buf);
RETURN (-1);
}
RETURN (0);
}
