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;
}
int main(int unused_argc, char **argv)
{
ACL_HTABLE *table = acl_htable_create(1);
acl_msg_verbose = 1;
acl_htable_enter(table, "foo-name", mystrdup("foo-value"));
acl_htable_enter(table, "bar-name", mystrdup("bar-value"));
attr_print64(ACL_VSTREAM_OUT, ATTR_FLAG_NONE,
ATTR_TYPE_INT, ATTR_NAME_INT, 4711,
ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
ATTR_TYPE_HASH, table,
ATTR_TYPE_END);
attr_print64(ACL_VSTREAM_OUT, ATTR_FLAG_NONE,
ATTR_TYPE_INT, ATTR_NAME_INT, 4711,
ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
ATTR_TYPE_END);
if (acl_vstream_fflush(ACL_VSTREAM_OUT) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s: write error", __FUNCTION__);
acl_htable_free(table, myfree);
return (0);
}
int http_hdr_req_cookies_parse(HTTP_HDR_REQ *hh)
{
/* data format: "name1=value1; name2=value2; name3=value3" */
const char *myname = "http_hdr_req_cookies_parse";
const HTTP_HDR_ENTRY *entry;
ACL_ARGV *argv;
const char *ptr;
ACL_ITER iter;
if (hh == NULL)
acl_msg_fatal("%s, %s(%d): input invalid",
__FILE__, myname, __LINE__);
if ((hh->flag & HTTP_HDR_REQ_FLAG_PARSE_COOKIE) == 0)
return 0;
entry = http_hdr_entry((HTTP_HDR *) hh, "Cookie");
if (entry == NULL)
return 0;
if (hh->cookies_table == NULL)
hh->cookies_table = acl_htable_create(__http_hdr_max_cookies,
ACL_HTABLE_FLAG_KEY_REUSE);
if (hh->cookies_table == NULL)
acl_msg_fatal("%s, %s(%d): htable create error(%s)",
__FILE__, myname, __LINE__, acl_last_serror());
/* 分隔数据段 */
argv = acl_argv_split(entry->value, ";");
acl_foreach(iter, argv) {
ptr = (const char*) iter.data;
__add_cookie_item(hh->cookies_table, ptr);
}
int http_hdr_req_cookies_parse(HTTP_HDR_REQ *hh)
{
/* data format: "name1=value1; name2=value2; name3=value3" */
const char *myname = "http_hdr_req_cookies_parse";
const HTTP_HDR_ENTRY *entry;
ACL_ARGV *argv;
const char *ptr;
ACL_ITER iter;
if (hh == NULL)
acl_msg_fatal("%s, %s(%d): input invalid",
__FILE__, myname, __LINE__);
if ((hh->flag & HTTP_HDR_REQ_FLAG_PARSE_COOKIE) == 0)
return 0;
entry = http_hdr_entry((HTTP_HDR *) hh, "Cookie");
if (entry == NULL)
return 0;
/* bugfix: 在创建哈希表时此处不应设置 ACL_HTABLE_FLAG_KEY_REUSE 标志位，
* 如果设置了此标志，则在 __add_cookie_item 中调用 acl_htable_enter 时，
* 会将 name 值的内存交给 htable，但随后在宏 RETURN 时却调用了释放数组
* 的函数 acl_argv_free(argv)，将 name 所属的数组内存一起给释放了
* ---zsx, 2014.5.13
*/
if (hh->cookies_table == NULL)
#if 0
hh->cookies_table = acl_htable_create(__http_hdr_max_cookies,
ACL_HTABLE_FLAG_KEY_REUSE);
#else
hh->cookies_table = acl_htable_create(__http_hdr_max_cookies, 0);
#endif
if (hh->cookies_table == NULL)
acl_msg_fatal("%s, %s(%d): htable create error(%s)",
__FILE__, myname, __LINE__, acl_last_serror());
/* 分隔数据段 */
argv = acl_argv_split(entry->value, ";");
acl_foreach(iter, argv) {
ptr = (const char*) iter.data;
if (ptr && *ptr)
__add_cookie_item(hh->cookies_table, ptr);
}
void service_set_dns(SERVICE *service, ACL_AIO *aio,
const char *dns_list, int dns_lookup_timeout,
int dns_cache_limit, const char *hosts_list)
{
const char *myname = "service_set_dns";
ACL_ARGV *argv;
ACL_ITER iter;
/* 创建DNS域名查询对象：外挂式查询或非阻塞式查询 */
if (!dns_list || !strcmp(dns_list, "")) {
int nthreads = 100, idle = 60;
/* 创建外挂式DNS查询对象 */
service->dns_server = dns_server_create(aio, 300);
service->dns_table = acl_htable_create(100, 0);
/* 创建半驻留线程池对象 */
service->wq = acl_workq_create(nthreads, idle, NULL, NULL);
return;
}
/* 采用直接发送DNS协议方式进行查询的对象 */
argv = acl_argv_split(dns_list, ",; \t");
service->dns_handle = acl_dns_create(aio, dns_lookup_timeout);
if (dns_cache_limit > 0)
acl_dns_open_cache(service->dns_handle, dns_cache_limit);
/* 添加DNS服务器地址 */
acl_foreach(iter, argv) {
char *addr = (char*) iter.data;
char *ptr1 = strchr(addr, ':'), *ptr2;
int port, netmask = 24;
if (ptr1) {
*ptr1++ = 0;
ptr2 = strchr(ptr1, ':');
if (ptr2) {
*ptr2++ = 0;
netmask = atoi(ptr2);
if (netmask <= 0 || netmask >= 32)
netmask = 24;
}
port = atoi(ptr1);
if (port <= 0 || port >= 65535)
port = 53;
} else
port = 53;
acl_msg_info("%s(%d): add dns addr (%s:%d)",
myname, __LINE__, addr, port);
acl_dns_add_dns(service->dns_handle, addr, port, netmask);
}
int main(int argc, char *argv[])
{
ACL_HTABLE *htable;
char key[128], *value;
int i, n = 50, ch, flag = 0;
while ((ch = getopt(argc, argv, "hn:m")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return (0);
case 'n':
n = atoi(optarg);
break;
case 'm':
flag |= ACL_HTABLE_FLAG_MSLOOK;
break;
default:
break;
}
}
htable = acl_htable_create(1, flag);
for (i = 0; i < n; i++) {
value = (char*) acl_mymalloc(256);
snprintf(value, 256, "value:%d", i);
snprintf(key, sizeof(key), "key:%d", i);
acl_htable_enter(htable, key, value);
}
acl_htable_stat(htable);
printf("------------------------------------------------------------\n");
for (i = n - 1; i >= 0; i--) {
snprintf(key, sizeof(key), "key:%d", i);
(void) acl_htable_find(htable, key);
}
acl_htable_stat(htable);
acl_htable_free(htable, free_fn);
return (0);
}
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);
}
SERVICE *service_create(const char *local_ip, short local_port,
const char *dns_ip, short dns_port)
{
const char *myname = "service_create";
SERVICE *service;
ACL_VSTREAM *sstream;
char addr[64];
// 创建提供 TCP 方式查询时的监听流
snprintf(addr, sizeof(addr), "%s:%d", local_ip, local_port);
sstream = acl_vstream_listen_ex(addr, 128, ACL_NON_BLOCKING, 1024, 10);
if (sstream == NULL) {
acl_msg_error("%s(%d): can't listen on addr(%s)",
myname, __LINE__, addr);
return (NULL);
}
service = (SERVICE*) acl_mycalloc(1, sizeof(SERVICE));
ACL_SAFE_STRNCPY(service->listen_addr,
addr, sizeof(service->listen_addr));
ACL_SAFE_STRNCPY(service->dns_ip, dns_ip, sizeof(service->dns_ip));
service->dns_port = dns_port;
snprintf(service->dns_addr, sizeof(service->dns_addr),
"%s:%d", dns_ip, dns_port);
service->conn_timeout = 10;
service->rw_timeout = 10;
service->table = acl_htable_create(100, 0);
service->aio = acl_aio_create(ACL_EVENT_SELECT);
service->sstream = acl_aio_open(service->aio, sstream);
acl_aio_ctl(service->sstream, ACL_AIO_CTL_ACCEPT_FN, accept_callback,
ACL_AIO_CTL_CTX, service, ACL_AIO_CTL_END);
acl_aio_accept(service->sstream);
service_udp_init(service, local_ip, local_port, dns_ip, dns_port);
return (service);
}
void file_cache_init(void)
{
__cache_table = acl_htable_create(100, 0);
}
int test_htable_create(AUT_LINE *test_line, void *arg acl_unused)
{
const char *ptr;
ACL_ARGV *argv;
char *pname, *pvalue;
int i;
ACL_HASH_FN hash_fn;
AUT_SET_STR(test_line, "hash_fn", ptr);
hash_fn = __get_hash_fn(ptr);
AUT_SET_STR(test_line, "table", ptr);
printf("table=[%s]\n", ptr);
__table = acl_htable_create(1, 0);
acl_htable_ctl(__table,
ACL_HTABLE_CTL_RWLOCK, FALSE,
ACL_HTABLE_CTL_HASH_FN, hash_fn,
ACL_HTABLE_CTL_END);
argv = acl_argv_split(ptr, "; ");
for (i = 0; i < acl_argv_size(argv); i++) {
pname = acl_argv_index(argv, i);
pvalue = strchr(pname, ':');
if (pvalue == NULL) {
printf("invalid for [%s]\n", pname);
continue;
}
*pvalue++ = 0;
