HTTP_HDR_REQ *http_hdr_req_clone(const HTTP_HDR_REQ* hdr_req)
{
HTTP_HDR_REQ *hh;
hh = http_hdr_req_new();
http_hdr_clone(&hdr_req->hdr, &hh->hdr);
hh->port = hdr_req->port;
ACL_SAFE_STRNCPY(hh->method, hdr_req->method, sizeof(hh->method));
ACL_SAFE_STRNCPY(hh->host, hdr_req->host, sizeof(hh->host));
acl_vstring_strcpy(hh->url_part, acl_vstring_str(hdr_req->url_part));
acl_vstring_strcpy(hh->url_path, acl_vstring_str(hdr_req->url_path));
acl_vstring_strcpy(hh->url_params, acl_vstring_str(hdr_req->url_params));
acl_vstring_strcpy(hh->file_path, acl_vstring_str(hdr_req->file_path));
if (hdr_req->params_table) {
hh->params_table = acl_htable_create(__http_hdr_max_request, 0);
acl_htable_walk(hdr_req->params_table, clone_table_entry,
(void*) hh->params_table);
}
if (hdr_req->cookies_table) {
hh->cookies_table = acl_htable_create(__http_hdr_max_cookies, 0);
acl_htable_walk(hdr_req->cookies_table, clone_table_entry,
(void*) hh->cookies_table);
}
return hh;
}
static void dbconn_init(const char *addr, const char *name, const char *usr,
const char *pass, int dbpool_max, int dbping, int dbtimeout)
{
const char *myname = "dbconn_init";
ACL_DB_INFO db_info;
memset(&db_info, 0, sizeof(ACL_DB_INFO));
ACL_SAFE_STRNCPY(db_info.db_addr, addr, sizeof(db_info.db_addr));
ACL_SAFE_STRNCPY(db_info.db_name, name, sizeof(db_info.db_name));
ACL_SAFE_STRNCPY(db_info.db_user, usr, sizeof(db_info.db_user));
ACL_SAFE_STRNCPY(db_info.db_pass, pass, sizeof(db_info.db_pass));
db_info.db_max = dbpool_max;
db_info.ping_inter = dbping;
db_info.timeout_inter = dbtimeout;
db_info.auto_commit = 1;
//db_info.db_before_connect = db_before_connect;
//db_info.db_after_connect = db_after_connect;
__db_pool = acl_dbpool_create("mysql", &db_info);
if (__db_pool == NULL)
acl_msg_fatal("%s(%d): init db pool error", myname, __LINE__);
}
static int xml_new_gid(ACL_VSTREAM *client, int keep_alive, ACL_XML_NODE *node)
{
acl_int64 gid;
char buf[256], tag[64];
const char *ptr;
int errnum = 0;
#define STR acl_vstring_str
ACL_SAFE_STRNCPY(tag, "default:", sizeof(tag));
ptr = acl_xml_getElementAttrVal(node, "tag");
if (ptr && *ptr) {
ACL_SAFE_STRNCPY(tag, ptr, sizeof(tag));
}
gid = gid_next(var_cfg_gid_path, tag, var_cfg_gid_step, &errnum);
if (gid >= 0)
snprintf(buf, sizeof(buf),
"<respond status='ok' gid='%lld' tag='%s' />\r\n", gid, tag);
else
snprintf(buf, sizeof(buf),
"<respond status='error' gid='%lld' tag='%s'"
" err='%d' msg='%s' />\r\n",
gid, tag, errnum, gid_serror(errnum));
return (http_server_send_respond(client, 200, keep_alive,
buf, (int) strlen(buf)));
}
bool server_socket::open(const char* addr)
{
#ifndef ACL_WINDOWS
if (strchr(addr, '/') != NULL)
{
fd_ = acl_unix_listen(addr, backlog_, block_
? ACL_BLOCKING : ACL_NON_BLOCKING);
unix_sock_ = true;
ACL_SAFE_STRNCPY(addr_, addr, sizeof(addr_));
}
else
#endif
fd_ = acl_inet_listen(addr, backlog_, block_
? ACL_BLOCKING : ACL_NON_BLOCKING);
if (fd_ == ACL_SOCKET_INVALID)
{
logger_error("listen %s error %s", addr, last_serror());
unix_sock_ = false;
ACL_SAFE_STRNCPY(addr_, addr, sizeof(addr_));
return false;
}
if (unix_sock_)
return true;
// 之所以再用 getsockname 重新获得一些监听地址，主要是为了应对当输入的 addr
// 为 ip:0 的情形，即当给定的地址中的端口为 0 时要求操作系统自动分配一个端口号
if (acl_getsockname(fd_, addr_, sizeof(addr_)) < 0)
{
logger_error("getsockname error: %s", acl_last_serror());
ACL_SAFE_STRNCPY(addr_, addr, sizeof(addr_));
}
return true;
}
int main(int argc, char *argv[])
{
int ch;
char url[256], dump[256];
acl_init(); /* ³õʼ»¯ acl ¿â */
url[0] = 0;
dump[0] = 0;
while ((ch = getopt(argc, argv, "hr:t:f:X:")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return (0);
case 'r':
ACL_SAFE_STRNCPY(url, optarg, sizeof(url));
break;
case 'f':
ACL_SAFE_STRNCPY(dump, optarg, sizeof(dump));
break;
default:
break;
}
}
if (url[0] == 0) {
usage(argv[0]);
return (0);
}
get_url(url, dump);
return (0);
}
bool queue_file::move_file(const char* queueName, const char* extName)
{
acl::string buf(256);
bool once_again = false;
while (true)
{
buf.clear();
buf << m_home << PATH_SEP << queueName << PATH_SEP << m_queueSub
<< PATH_SEP << m_partName << "." << extName;
#ifdef WIN32
// 在win32下必须先关闭文件句柄
this->close();
#endif
if (rename(m_filePath.c_str(), buf.c_str()) == 0)
break;
// 如果返回错误原因是目标路径不存在，则尝试创建目录结构
if (once_again || acl_last_error() != ENOENT)
{
logger_error("move from %s to %s error(%s), errno: %d, %d",
m_filePath.c_str(), buf.c_str(), acl_last_serror(),
acl_last_error(), ENOENT);
return (false);
}
// 设置重试标志位
once_again = true;
buf.clear();
buf << m_home << PATH_SEP << queueName
<< PATH_SEP << m_queueSub;
// 创建队列目录
if (acl_make_dirs(buf.c_str(), 0700) == -1)
{
logger_error("mkdir: %s error(%s)",
buf.c_str(), acl_last_serror());
return false;
}
}
#ifdef WIN32
// win32 下需要重新再打开
return (open(m_home, queueName, m_queueSub, m_partName, extName));
#else
if (m_queueName != queueName)
ACL_SAFE_STRNCPY(m_queueName, queueName, sizeof(m_queueName));
if (m_extName != extName)
ACL_SAFE_STRNCPY(m_extName, extName, sizeof(m_extName));
m_filePath.clear();
m_filePath << m_home << PATH_SEP << m_queueName << PATH_SEP
<< m_queueSub << PATH_SEP << m_partName << "." << m_extName;
#endif
return (true);
}
bool http_utils::get_addr(const char* url, char* domain, size_t size,
unsigned short* pport)
{
#define HTTP_PREFIX "http://"
#define HTTPS_PREFIX "https://"
const char* ptr;
unsigned short default_port;
if (strncasecmp(url, HTTP_PREFIX, sizeof(HTTP_PREFIX) - 1) == 0)
{
ptr = url + sizeof(HTTP_PREFIX) - 1;
default_port = 80;
}
else if (strncasecmp(url, HTTPS_PREFIX, sizeof(HTTPS_PREFIX) - 1) == 0)
{
ptr = url + sizeof(HTTPS_PREFIX) - 1;
default_port = 443;
}
else
{
logger_error("invalid url: %s", url);
return false;
}
if (*ptr == 0)
{
logger_error("invalid url: %s", url);
return false;
}
char buf[256];
ACL_SAFE_STRNCPY(buf, ptr, sizeof(buf));
char* slash = strchr(buf, '/');
if (slash)
*slash = 0;
unsigned short port;
char* col = strchr(buf, ':');
if (col == NULL)
port = default_port;
else
{
*col++ = 0;
port = (unsigned short) atoi(col);
if (port == 0 || port == 65535)
port = default_port;
}
if (pport)
*pport = port;
ACL_SAFE_STRNCPY(domain, buf, size);
return true;
}
int main(int argc, char *argv[])
{
int ch;
char url[256], dump[256], proxy[256], method[32];
/*
const char *url1 = "http://127.0.0.1:80/";
HTTP_UTIL *req = http_util_req_new(url1, "POST");
printf(">>>host: %s\n", http_hdr_req_host(req->hdr_req));
acl_assert(req);
return (0);
*/
acl_init(); /* 初始化 acl 库 */
ACL_SAFE_STRNCPY(method, "GET", sizeof(method));
url[0] = 0;
dump[0] = 0;
proxy[0] = 0;
while ((ch = getopt(argc, argv, "hr:t:f:X:")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return (0);
case 'r':
ACL_SAFE_STRNCPY(url, optarg, sizeof(url));
break;
case 't':
ACL_SAFE_STRNCPY(method, optarg, sizeof(method));
break;
case 'f':
ACL_SAFE_STRNCPY(dump, optarg, sizeof(dump));
break;
case 'X':
ACL_SAFE_STRNCPY(proxy, optarg, sizeof(proxy));
break;
default:
break;
}
}
if (url[0] == 0) {
usage(argv[0]);
return (0);
}
get_url(method, url, proxy, dump);
return (0);
}
void acl_netdb_add_addr(ACL_DNS_DB *dns_db, const char *ip, int hport)
{
const char *myname = "acl_netdb_add_addr";
ACL_HOSTNAME *phost;
char buf[256];
if (dns_db == NULL || dns_db->h_db == NULL || ip == NULL) {
acl_msg_error("%s(%d): input invalid", myname, __LINE__);
return;
}
phost = acl_mycalloc(1, sizeof(ACL_HOSTNAME));
if (phost == NULL) {
acl_msg_error("%s(%d): calloc error(%s)",
myname, __LINE__, acl_last_strerror(buf, sizeof(buf)));
return;
}
memset(&phost->saddr, 0, sizeof(phost->saddr));
ACL_SAFE_STRNCPY(phost->ip, ip, sizeof(phost->ip));
phost->saddr.sin_addr.s_addr = (unsigned long) inet_addr(ip);
phost->hport = hport;
if (acl_array_append(dns_db->h_db, phost) < 0) {
acl_msg_error("%s(%d): array append error(%s)",
myname, __LINE__, acl_last_strerror(buf, sizeof(buf)));
return;
}
dns_db->size++;
}
connect_pool& connect_manager::set(const char* addr, int count)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
lock_.unlock();
return **it;
}
}
connect_pool* pool = create_pool(key, count, pools_.size() - 1);
pools_.push_back(pool);
lock_.unlock();
logger("Add one service, addr: %s, count: %d", addr, count);
return *pool;
}
void queue_file::set_extName(const char* extName)
{
ACL_SAFE_STRNCPY(m_extName, extName, sizeof(m_extName));
m_filePath.clear();
m_filePath << m_home << PATH_SEP << m_queueName << PATH_SEP
<< m_queueSub << PATH_SEP << m_partName << "." << m_extName;
}
int main(int argc, char *argv[])
{
char ch, addr[32];
int n = 1, keep_alive = 0, cmd_num = 0;
addr[0] = 0;
while ((ch = getopt(argc, argv, "hks:n:i:")) > 0) {
switch (ch) {
case 's':
ACL_SAFE_STRNCPY(addr, optarg, sizeof(addr));
break;
case 'n':
n = atoi(optarg);
break;
case 'k':
keep_alive = 1;
break;
case 'i':
cmd_num = atoi(optarg);
break;
case 'h':
default:
usage(argv[0]);
return (0);
}
}
if (addr[0] == 0 || n <= 0) {
usage(argv[0]);
return (0);
}
run(addr, n, keep_alive, cmd_num);
return (0);
}
ACL_DNS_DB *acl_netdb_clone(const ACL_DNS_DB *db)
{
ACL_DNS_DB *dbp;
ACL_HOSTNAME *phost, *h_host;
int i, n;
if (db == NULL || db->h_db == NULL)
return NULL;
n = acl_array_size(db->h_db);
if (n <= 0) {
acl_msg_error("%s, %s(%d): h_db's size(%d) <= 0",
__FILE__, __FUNCTION__, __LINE__, n);
return NULL;
}
dbp = acl_netdb_new(db->name);
for (i = 0; i < n; i++) {
phost = (ACL_HOSTNAME *) acl_array_index(db->h_db, i);
acl_assert(phost);
h_host = acl_mycalloc(1, sizeof(ACL_HOSTNAME));
memcpy(&h_host->saddr, &phost->saddr, sizeof(h_host->saddr));
ACL_SAFE_STRNCPY(h_host->ip, phost->ip, sizeof(h_host->ip));
h_host->hport = phost->hport;
(void) acl_array_append(dbp->h_db, h_host);
dbp->size++;
}
return dbp;
}
/*
* rfc1035BuildPTRQuery()
*
* Builds a message buffer with a QUESTION to lookup PTR records
* for an address. Caller must allocate 'buf' which should
* probably be at least 512 octets. The 'szp' initially
* specifies the size of the buffer, on return it contains
* the size of the message (i.e. how much to write).
* Returns the size of the query
*/
ssize_t rfc1035BuildPTRQuery(const struct in_addr addr, char *buf,
size_t sz, unsigned short qid, rfc1035_query * query)
{
const char *myname = "rfc1035BuildPTRQuery";
rfc1035_message h;
size_t offset = 0;
static char rev[32];
unsigned int i;
memset(&h, '\0', sizeof(h));
i = (unsigned int) ntohl(addr.s_addr);
snprintf(rev, 32, "%u.%u.%u.%u.in-addr.arpa.",
i & 255, (i >> 8) & 255, (i >> 16) & 255, (i >> 24) & 255);
h.id = qid;
h.qr = 0;
h.rd = 1;
h.opcode = 0; /* QUERY */
h.qdcount = (unsigned int) 1;
offset += rfc1035HeaderPack(buf + offset, sz - offset, &h);
offset += rfc1035QuestionPack(buf + offset, sz - offset, rev,
RFC1035_TYPE_PTR, RFC1035_CLASS_IN);
if (query) {
query->qtype = RFC1035_TYPE_PTR;
query->qclass = RFC1035_CLASS_IN;
ACL_SAFE_STRNCPY(query->name, rev, sizeof(query->name));
}
if (offset > sz)
acl_msg_fatal("%s: offset(%d) > sz(%d)", myname, offset, sz);
return (ssize_t) offset;
}
/*
* rfc1035BuildAQuery()
*
* Builds a message buffer with a QUESTION to lookup A records
* for a hostname. Caller must allocate 'buf' which should
* probably be at least 512 octets. The 'szp' initially
* specifies the size of the buffer, on return it contains
* the size of the message (i.e. how much to write).
* Returns the size of the query
*/
ssize_t rfc1035BuildAQuery(const char *hostname, char *buf, size_t sz,
unsigned short qid, rfc1035_query * query)
{
const char *myname = "rfc1035BuildAQuery";
rfc1035_message h;
size_t offset = 0;
memset(&h, '\0', sizeof(h));
h.id = qid;
h.qr = 0;
h.rd = 1;
h.opcode = 0; /* QUERY */
h.qdcount = (unsigned int) 1;
offset += rfc1035HeaderPack(buf + offset, sz - offset, &h);
offset += rfc1035QuestionPack(buf + offset, sz - offset, hostname,
RFC1035_TYPE_A, RFC1035_CLASS_IN);
if (query) {
query->qtype = RFC1035_TYPE_A;
query->qclass = RFC1035_CLASS_IN;
ACL_SAFE_STRNCPY(query->name, hostname, sizeof(query->name));
}
if (offset > sz)
acl_msg_fatal("%s: offset(%d) > sz(%d)", myname, offset, sz);
return (ssize_t) offset;
}
connect_pool* connect_manager::get(const char* addr,
bool exclusive /* = true */, bool restore /* = false */)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
if (exclusive)
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
if (restore && (*it)->aliving() == false)
(*it)->set_alive(true);
if (exclusive)
lock_.unlock();
return *it;
}
}
if (exclusive)
lock_.unlock();
logger_error("no connect pool for addr %s", addr);
return NULL;
}
bool fstream::open(const char* path, unsigned int oflags, int mode)
{
if (path == NULL)
return (false);
ACL_FILE_HANDLE fh;
fh = acl_file_open(path, oflags, mode);
if (fh == ACL_FILE_INVALID)
return (false);
m_pStream->fread_fn = acl_file_read;
m_pStream->fwrite_fn = acl_file_write;
m_pStream->fwritev_fn = acl_file_writev;
m_pStream->fclose_fn = acl_file_close;
m_pStream->fd.h_file = fh;
m_pStream->type = ACL_VSTREAM_TYPE_FILE;
m_pStream->oflags = oflags;
ACL_SAFE_STRNCPY(m_pStream->remote_addr, path,
sizeof(m_pStream->remote_addr));
m_bOpened = true;
m_bEof = false;
return (true);
}
int main(int argc, char *argv[])
{
char addr[128] = "127.0.0.1:8283";
int ch;
acl_init();
test();
while ((ch = getopt(argc, argv, "hs:")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return (0);
case 's':
ACL_SAFE_STRNCPY(addr, optarg, sizeof(addr));
break;
default:
break;
}
}
test_connect(addr);
return (0);
}
connect_pool& connect_manager::set(const char* addr, size_t count,
int conn_timeout /* = 30 */, int rw_timeout /* = 30 */)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
lock_.unlock();
return **it;
}
}
connect_pool* pool = create_pool(key, count, pools_.size() - 1);
pool->set_retry_inter(retry_inter_);
pool->set_timeout(conn_timeout, rw_timeout);
if (idle_ttl_ >= 0)
pool->set_idle_ttl(idle_ttl_);
if (check_inter_ > 0)
pool->set_check_inter(check_inter_);
pools_.push_back(pool);
lock_.unlock();
logger("Add one service, addr: %s, count: %d", addr, (int) count);
return *pool;
}
void domain_info::add_ip(const char* ip, int ttl)
{
IP_INFO* info = (IP_INFO*) acl_mycalloc(1, sizeof(IP_INFO));
ACL_SAFE_STRNCPY(info->ip, ip, sizeof(info->ip));
info->ttl = ttl;
ip_list_.push_back(info);
}
void acl_netdb_add_addr(ACL_DNS_DB *db, const char *ip, int hport)
{
ACL_HOSTNAME *phost;
ACL_SOCKADDR saddr;
if (db == NULL || db->h_db == NULL || ip == NULL) {
acl_msg_error("%s(%d): input invalid", __FUNCTION__, __LINE__);
return;
}
memset(&saddr, 0, sizeof(saddr));
if (ip2addr(ip, 0, &saddr) == 0) {
acl_msg_error("%s(%d): invalid ip=%s",
__FUNCTION__, __LINE__, ip);
return;
}
phost = acl_mycalloc(1, sizeof(ACL_HOSTNAME));
memcpy(&phost->saddr, &saddr, sizeof(phost->saddr));
ACL_SAFE_STRNCPY(phost->ip, ip, sizeof(phost->ip));
phost->hport = hport;
(void) acl_array_append(db->h_db, phost);
db->size++;
}
bool queue_file::open(const char* home, const char* queueName,
const char* queueSub, const char* partName, const char* extName)
{
if (m_fp)
logger_fatal("old file(%s) exist", m_filePath.c_str());
m_filePath.clear();
m_filePath << home << PATH_SEP << queueName << PATH_SEP << queueSub
<< PATH_SEP << partName << "." << extName;
m_fp = NEW fstream;
if (m_fp->open(m_filePath.c_str(), O_RDWR, 0600) == false)
{
logger_error("open %s error(%s)", m_filePath.c_str(),
acl_last_serror());
delete m_fp;
m_fp = NULL;
return (false);
}
if (m_home != home)
ACL_SAFE_STRNCPY(m_home, home, sizeof(m_home));
if (m_queueName != queueName)
ACL_SAFE_STRNCPY(m_queueName, queueName, sizeof(m_queueName));
if (m_queueSub != queueSub)
ACL_SAFE_STRNCPY(m_queueSub, queueSub, sizeof(m_queueSub));
if (m_partName != partName)
ACL_SAFE_STRNCPY(m_partName, partName, sizeof(m_partName));
if (m_extName != extName)
ACL_SAFE_STRNCPY(m_extName, extName, sizeof(m_extName));
// 打开队列文件对象锁
if (m_locker.open(m_fp->file_handle()) == false)
{
logger_error("open lock for %s error(%s)",
m_filePath.c_str(), acl_last_serror());
m_bLockerOpened = false;
}
else
{
m_bLockerOpened = true;
}
// XXX, 需要分析该全路径, 以提取需要的字段
return (true);
}
/*----------------------------------------------------------------------------*/
ACL_DB_POOL *acl_dbpool_create(const char *db_type, const ACL_DB_INFO *db_info)
{
char myname[] = "acl_dbpool_create";
ACL_DB_POOL *db_pool = NULL;
ACL_DB_INFO *info;
if (db_type == NULL)
db_type = "mysql";
if (strcasecmp(db_type, "null") == 0)
db_pool = acl_dbpool_null_create(db_info);
#ifdef HAS_MYSQL
else if (strcasecmp(db_type, "mysql") == 0)
db_pool = acl_dbpool_mysql_create(db_info);
#endif
else {
acl_msg_fatal("%s, %s(%d): %s not supported yet",
__FILE__, myname, __LINE__, db_type);
}
if (db_pool == NULL) {
acl_msg_error("%s, %s(%d): dbpool_%s_create error",
__FILE__, myname, __LINE__, db_type);
return (NULL);
}
info = &db_pool->db_info;
#if 0
ACL_SAFE_STRNCPY(info->db_addr, db_info->db_addr, sizeof(info->db_addr));
ACL_SAFE_STRNCPY(info->db_name, db_info->db_name, sizeof(info->db_name));
ACL_SAFE_STRNCPY(info->db_user, db_info->db_user, sizeof(info->db_user));
ACL_SAFE_STRNCPY(info->db_pass, db_info->db_pass, sizeof(info->db_pass));
info->db_max = db_info->db_max;
info->ping_inter = db_info->ping_inter;
info->timeout_inter = db_info->timeout_inter;
#endif
memcpy(info, db_info, sizeof(ACL_DB_INFO));
db_pool->db_max = info->db_max;
db_pool->db_ready = 0;
db_pool->db_inuse = 0;
return (db_pool);
}
void redis_command::set_client_addr(redis_client& conn)
{
socket_stream* stream = conn.get_stream();
if (stream == NULL)
addr_[0] = 0;
else
ACL_SAFE_STRNCPY(addr_, stream->get_peer(true), sizeof(addr_));
}
int main(int argc, char *argv[])
{
char ch;
char dns_ip[64], domain[128];
int dns_port = 53, ret;
ACL_VSTRING *sbuf;
dns_ip[0] = 0;
domain[0] = 0;
while ((ch = getopt(argc, argv, "h:p:d:")) > 0) {
switch (ch) {
case 'h':
ACL_SAFE_STRNCPY(dns_ip, optarg, sizeof(dns_ip));
break;
case 'p':
dns_port = atoi(optarg);
break;
case 'd':
ACL_SAFE_STRNCPY(domain, optarg, sizeof(domain));
break;
default:
usage(argv[0]);
return (0);
}
}
if (dns_ip[0] == 0 || domain[0] == 0) {
usage(argv[0]);
return (0);
}
sbuf = acl_vstring_alloc(128);
ret = dns_lookup(domain, dns_ip, dns_port, sbuf);
if (ret < 0) {
printf("dns lookup(%s) error(%s)\r\n", domain, acl_vstring_str(sbuf));
acl_vstring_free(sbuf);
return (0);
}
printf("domain: %s\r\n%s", domain, acl_vstring_str(sbuf));
acl_vstring_free(sbuf);
return (0);
}
ACL_DNS_DB *acl_netdb_clone(const ACL_DNS_DB *h_dns_db)
{
const char *myname = "acl_netdb_clone";
char buf[256];
ACL_DNS_DB *dns_db;
ACL_HOSTNAME *phost, *h_host;
int i, n;
if (h_dns_db == NULL || h_dns_db->h_db == NULL)
return (NULL);
n = acl_array_size(h_dns_db->h_db);
if (n <= 0) {
acl_msg_error("%s, %s(%d): h_db's size(%d) <= 0",
__FILE__, myname, __LINE__, n);
return (NULL);
}
dns_db = acl_netdb_new(h_dns_db->name);
if (dns_db == NULL) {
acl_msg_error("%s, %s(%d): acl_netdb_new error(%s)",
__FILE__, myname, __LINE__,
acl_last_strerror(buf, sizeof(buf)));
return (NULL);
}
for (i = 0; i < n; i++) {
phost = (ACL_HOSTNAME *) acl_array_index(h_dns_db->h_db, i);
acl_assert(phost);
h_host = acl_mycalloc(1, sizeof(ACL_HOSTNAME));
if (h_host == NULL) {
acl_msg_error("%s, %s(%d): calloc error(%s)",
__FILE__, myname, __LINE__,
acl_last_strerror(buf, sizeof(buf)));
acl_netdb_free(dns_db);
return (NULL);
}
h_host->saddr.sin_addr.s_addr = phost->saddr.sin_addr.s_addr;
ACL_SAFE_STRNCPY(h_host->ip, phost->ip, sizeof(h_host->ip));
h_host->hport = phost->hport;
if (acl_array_append(dns_db->h_db, h_host) < 0) {
acl_msg_error("%s, %s(%d): array append error(%s)",
__FILE__, myname, __LINE__,
acl_last_strerror(buf, sizeof(buf)));
acl_netdb_free(dns_db);
return (NULL);
}
dns_db->size++;
}
return (dns_db);
}
void acl_xml3_tag_add(const char *tag)
{
if (tag_tree) {
char buf[256];
ACL_SAFE_STRNCPY(buf, tag, sizeof(buf));
acl_lowercase(buf);
acl_token_tree_add(tag_tree, buf, ACL_TOKEN_F_STOP, NULL);
}
}
void acl_scan_dir_rm2(ACL_SCAN_DIR *scan)
{
const char *myname = "acl_scan_dir_rm2";
const char *name;
char path[256];
struct acl_stat sbuf;
for (;;) {
if ((name = acl_scan_dir_next(scan)) == NULL) {
if (scan->current != NULL)
snprintf(path, sizeof(path), "%s", ACL_SCAN_DIR_PATH(scan));
else
path[0] = 0;
/* ±ØÐëÍ˳ö¸Ã¿ÕĿ¼ºó²Å¿ÉÒÔɾ³ý¸ÃĿ¼ */
if (acl_scan_dir_pop(scan) == 0) {
/* ɾ³ý×²ã¿ÕĿ¼ */
if (path[0] != 0 && SANE_RMDIR(path) == 0)
scan->ndirs++;
break;
}
/* ɾ³ý¿ÕĿ¼ */
if (path[0] != 0 && SANE_RMDIR(path) == 0)
scan->ndirs++;
continue;
}
snprintf(path, sizeof(path), "%s/%s", ACL_SCAN_DIR_PATH(scan), name);
if (acl_stat(path, &sbuf) < 0) {
char tbuf[256];
acl_msg_error("%s(%d), %s: stat file(%s) error(%s)",
__FILE__, __LINE__, myname,
path, acl_last_strerror(tbuf, sizeof(tbuf)));
break;
}
if (S_ISDIR(sbuf.st_mode)) {
scan->file_name[0] = 0;
if (scan->recursive && acl_scan_dir_push(scan, name) < 0)
break;
if (scan->scan_fn && scan->scan_fn(scan, scan->scan_ctx) < 0)
break;
continue;
} else
ACL_SAFE_STRNCPY(scan->file_name, name, sizeof(scan->file_name));
if (scan->scan_fn && scan->scan_fn(scan, scan->scan_ctx) < 0)
break;
scan->nfiles++;
scan->nsize += sbuf.st_size;
SANE_UNLINK(path);
}
}
ACL_MDB *acl_mdb_create(const char *dbname, const char *dbtype)
{
const char *myname = "acl_mdb_create";
ACL_MDB *mdb;
if (dbname == NULL || *dbname == 0) {
acl_msg_error("%s(%d): dbname invalid", myname, __LINE__);
return (NULL);
}
if (dbtype == NULL || *dbtype == 0) {
acl_msg_error("%s(%d): dbtype invalid", myname, __LINE__);
return (NULL);
}
mdb = acl_mycalloc(1, sizeof(ACL_MDB));
ACL_SAFE_STRNCPY(mdb->name, dbname, sizeof(mdb->name));
ACL_SAFE_STRNCPY(mdb->type, dbtype, sizeof(mdb->type));
mdb->tbls = acl_htable_create(10, 0);
return (mdb);
}
FILE_CACHE *file_cache_new(const char *file_path, time_t last_modified)
{
FILE_CACHE *cache;
cache = (FILE_CACHE*) acl_mymalloc(sizeof(FILE_CACHE));
cache->size = 0;
http_mkrfc1123(cache->tm_mtime, sizeof(cache->tm_mtime), last_modified);
ACL_SAFE_STRNCPY(cache->path, file_path, sizeof(cache->path));
cache->fifo = acl_fifo_new();
(void) acl_htable_enter(__cache_table, file_path, (char*) cache);
return (cache);
}
