void connect_manager::set_service_list(const char* addr_list, int count,
int conn_timeout, int rw_timeout)
{
if (addr_list == NULL || *addr_list == 0)
{
logger("addr_list null");
return;
}
// 创建连接池服务集群
char* buf = acl_mystrdup(addr_list);
char* addrs = acl_mystr_trim(buf);
ACL_ARGV* tokens = acl_argv_split(addrs, ";,");
ACL_ITER iter;
acl::string addr;
acl_foreach(iter, tokens)
{
const char* ptr = (const char*) iter.data;
int max = check_addr(ptr, addr, count);
if (max < 0)
{
logger_error("invalid server addr: %s", addr.c_str());
continue;
}
(void) set(addr.c_str(), max, conn_timeout, rw_timeout);
logger("add one service: %s, max connect: %d",
addr.c_str(), max);
}
acl_argv_free(tokens);
acl_myfree(buf);
}
http_service_request::http_service_request(const char* domain,
unsigned short port)
{
acl_assert(domain && *domain);
domain_ = acl_mystrdup(domain);
port_ = port;
}
TLS_SCACHE *tls_scache_open(const char *dbname, const char *cache_label,
int verbose, int timeout)
{
const char *myname = "tls_scache_open";
TLS_SCACHE *cp;
DICT *dict;
/*
* Logging.
*/
if (verbose)
acl_msg_info("open %s TLS cache %s", cache_label, dbname);
/*
* Open the dictionary with O_TRUNC, so that we never have to worry about
* opening a damaged file after some process terminated abnormally.
*/
#ifdef SINGLE_UPDATER
#define DICT_FLAGS (DICT_FLAG_DUP_REPLACE)
#elif defined(ACL_UNIX)
#define DICT_FLAGS \
(DICT_FLAG_DUP_REPLACE | DICT_FLAG_LOCK | DICT_FLAG_SYNC_UPDATE)
#elif defined(ACL_MS_WINDOWS)
#define DICT_FLAGS \
(DICT_FLAG_DUP_REPLACE | DICT_FLAG_SYNC_UPDATE)
#endif
dict = dict_open(dbname, O_RDWR | O_CREAT | O_TRUNC, DICT_FLAGS);
/*
* Sanity checks.
*/
if (dict->lock_fd < 0)
acl_msg_fatal("%s: dictionary %s is not a regular file", myname, dbname);
#ifdef SINGLE_UPDATER
if (acl_myflock(dict->lock_fd, INTERNAL_LOCK,
MYFLOCK_OP_EXCLUSIVE | MYFLOCK_OP_NOWAIT) < 0)
acl_msg_fatal("%s: cannot lock dictionary %s for exclusive use: %s",
myname, dbname, acl_last_serror());
#endif
if (dict->update == 0)
acl_msg_fatal("%s: dictionary %s does not support update operations", myname, dbname);
if (dict->delete_it == 0)
acl_msg_fatal("%s: dictionary %s does not support delete operations", myname, dbname);
if (dict->sequence == 0)
acl_msg_fatal("%s: dictionary %s does not support sequence operations", myname, dbname);
/*
* Create the TLS_SCACHE object.
*/
cp = (TLS_SCACHE *) acl_mymalloc(sizeof(*cp));
cp->flags = 0;
cp->db = dict;
cp->cache_label = acl_mystrdup(cache_label);
cp->verbose = verbose;
cp->timeout = timeout;
cp->saved_cursor = 0;
return (cp);
}
mime_head& mime_head::add_rcpt(const char* addr)
{
if (m_rcpts == NULL)
m_rcpts = NEW std::list<char*>;
m_rcpts->push_back(acl_mystrdup(addr));
return (*this);
}
int acl_scan_dir_push(ACL_SCAN_DIR *scan, const char *path)
{
const char *myname = "acl_scan_dir_push";
ACL_SCAN_INFO *info;
info = (ACL_SCAN_INFO *) acl_mymalloc(sizeof(*info));
if (scan->current) {
info->path =
acl_concatenate(ACL_SCAN_DIR_PATH(scan), "/", path, (char *) 0);
} else {
info->path = acl_mystrdup(path);
}
if ((info->dir_name = opendir(info->path)) == 0) {
char tbuf[256];
acl_msg_error("%s(%d), %s: open directory(%s) error(%s)",
__FILE__, __LINE__, myname,
info->path, acl_last_strerror(tbuf, sizeof(tbuf)));
return (-1);
}
if (acl_msg_verbose > 1)
acl_msg_info("%s: open %s", myname, info->path);
info->parent = scan->current;
scan->current = info;
return (0);
}
TLS_PRNG_SRC *tls_prng_egd_open(const char *name, int timeout)
{
const char *myname = "tls_prng_egd_open";
TLS_PRNG_SRC *egd;
ACL_SOCKET fd;
if (acl_msg_verbose)
acl_msg_info("%s: connect to EGD server %s", myname, name);
#ifdef ACL_UNIX
fd = acl_unix_connect(name, ACL_BLOCKING, timeout);
#elif defined(ACL_MS_WINDOWS)
fd = acl_inet_connect(name, ACL_BLOCKING, timeout);
#endif
if (fd < 0) {
if (acl_msg_verbose)
acl_msg_info("%s: cannot connect to EGD server %s: %s",
myname, name, acl_last_serror());
return (0);
} else {
egd = (TLS_PRNG_SRC *) acl_mymalloc(sizeof(*egd));
egd->fd.sock = fd;
egd->name = acl_mystrdup(name);
egd->timeout = timeout;
if (acl_msg_verbose)
acl_msg_info("%s: connected to EGD server %s", myname, name);
return (egd);
}
}
static ACL_CFG_LINE *_backup_junk_line(const char *ptr)
{
char myname[] = "_backup_junk_line";
ACL_CFG_LINE *cfg_line;
char tbuf[256];
if (ptr == NULL)
return (NULL);
cfg_line = (ACL_CFG_LINE *) acl_mycalloc(1, sizeof(ACL_CFG_LINE));
if (cfg_line == NULL) {
printf("%s: calloc ACL_CFG_LINE, errmsg=%s",
myname, acl_last_strerror(tbuf, sizeof(tbuf)));
return (NULL);
}
cfg_line->ncount = 0;
cfg_line->value = NULL;
cfg_line->pdata = acl_mystrdup(ptr);
if (cfg_line->pdata == NULL) {
printf("%s: strdup pdata, errmsg=%s",
myname, acl_last_strerror(tbuf, sizeof(tbuf)));
return (NULL);
}
return (cfg_line);
}
void redis_client_cluster::set_slot(int slot, const char* addr)
{
if (slot < 0 || slot >= max_slot_ || addr == NULL || *addr == 0)
return;
// 遍历缓存的所有地址，若该地址不存在则直接添加，然后使之与 slot 进行关联
// 该段代码需要加锁保护
lock();
std::vector<char*>::const_iterator cit = addrs_.begin();
for (; cit != addrs_.end(); ++cit)
{
if (strcmp((*cit), addr) == 0)
break;
}
// 将 slot 与地址进行关联映射
if (cit != addrs_.end())
slot_addrs_[slot] = *cit;
else
{
// 只所以采用动态分配方式，是因为在往数组中添加对象时，无论
// 数组如何做动态调整，该添加的动态内存地址都是固定的，所以
// slot_addrs_ 的下标地址也是相对不变的
char* buf = acl_mystrdup(addr);
addrs_.push_back(buf);
slot_addrs_[slot] = buf;
}
unlock();
}
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;
}
/**
* 创建索引
*/
static ACL_MDT_IDX *mdt_idx_create(ACL_MDT *mdt, size_t init_capacity,
const char *name, unsigned int flag)
{
ACL_MDT_IDX_BHASH *idx;
unsigned int flag2 = 0;
if (init_capacity < 128)
init_capacity = 128;
idx = (ACL_MDT_IDX_BHASH*) acl_mycalloc(1, sizeof(ACL_MDT_IDX_BHASH));
if ((mdt->tbl_flag & ACL_MDT_FLAG_SLICE1))
flag2 |= ACL_BINHASH_FLAG_SLICE1;
else if ((mdt->tbl_flag & ACL_MDT_FLAG_SLICE2))
flag2 |= ACL_BINHASH_FLAG_SLICE2;
else if ((mdt->tbl_flag & ACL_MDT_FLAG_SLICE3))
flag2 |= ACL_BINHASH_FLAG_SLICE3;
if ((mdt->tbl_flag & ACL_MDT_FLAG_SLICE_RTGC_OFF))
flag2 |= ACL_BINHASH_FLAG_SLICE_RTGC_OFF;
if ((flag & ACL_MDT_FLAG_KMR))
flag2 |= ACL_BINHASH_FLAG_KEY_REUSE;
idx->table = acl_binhash_create(init_capacity, flag2);
idx->idx.name = acl_mystrdup(name);
idx->idx.flag = flag;
return ((ACL_MDT_IDX*) idx);
}
OSSClient::OSSClient(const char* end_point, const char* key_id,
const char* key_secret)
{
acl_assert(end_point && *end_point);
acl_assert(key_id_ && *key_id_);
acl_assert(key_secret && *key_secret);
end_point_ = acl_mystrdup(end_point);
key_id_ = acl_mystrdup(key_id);
key_secret_ = acl_mystrdup(key_secret);
bucket_oper_ = NULL;
object_oper_ = NULL;
multipart_oper_ = NULL;
cors_oper_ = NULL;
}
const char *tls_dns_name(const GENERAL_NAME *gn, const TLS_SESS_STATE *TLScontext)
{
const char *myname = "tls_dns_name";
char *cp;
const char *dnsname;
int len;
/*
* Peername checks are security sensitive, carefully scrutinize the
* input!
*/
if (gn->type != GEN_DNS)
acl_msg_panic("%s: Non DNS input argument", myname);
/*
* We expect the OpenSSL library to construct GEN_DNS extesion objects as
* ASN1_IA5STRING values. Check we got the right union member.
*/
if (ASN1_STRING_type(gn->d.ia5) != V_ASN1_IA5STRING) {
acl_msg_warn("%s: %s: invalid ASN1 value type in subjectAltName",
myname, TLScontext->namaddr);
return (0);
}
/*
* Safe to treat as an ASCII string possibly holding a DNS name
*/
dnsname = (char *) ASN1_STRING_data(gn->d.ia5);
len = ASN1_STRING_length(gn->d.ia5);
TRIM0(dnsname, len);
/*
* Per Dr. Steven Henson of the OpenSSL development team, ASN1_IA5STRING
* values can have internal ASCII NUL values in this context because
* their length is taken from the decoded ASN1 buffer, a trailing NUL is
* always appended to make sure that the string is terminated, but the
* ASN.1 length may differ from strlen().
*/
if (len != (int) strlen(dnsname)) {
acl_msg_warn("%s: %s: internal NUL in subjectAltName",
myname, TLScontext->namaddr);
return 0;
}
/*
* XXX: Should we be more strict and call valid_hostname()? So long as
* the name is safe to handle, if it is not a valid hostname, it will not
* compare equal to the expected peername, so being more strict than
* "printable" is likely excessive...
*/
if (*dnsname && !allprint(dnsname)) {
cp = acl_mystrdup(dnsname);
acl_msg_warn("%s: %s: non-printable characters in subjectAltName: %.100s",
myname, TLScontext->namaddr, printable(cp, '?'));
acl_myfree(cp);
return 0;
}
return (dnsname);
}
char *tls_peer_CN(X509 *peercert, const TLS_SESS_STATE *TLScontext)
{
char *cn;
cn = tls_text_name(X509_get_subject_name(peercert), NID_commonName,
"subject CN", TLScontext, DO_GRIPE);
return (cn ? cn : acl_mystrdup(""));
}
redis_client::redis_client(const char* addr, int conn_timeout /* = 60 */,
int rw_timeout /* = 30 */, bool retry /* = true */)
: conn_timeout_(conn_timeout)
, rw_timeout_(rw_timeout)
, retry_(retry)
{
addr_ = acl_mystrdup(addr);
}
db_handle& db_handle::set_id(const char* id)
{
if (id == NULL || *id == 0)
return *this;
if (id_)
acl_myfree(id_);
id_ = acl_mystrdup(id);
return *this;
}
tcp_client::tcp_client(const char* addr, int conn_timeout, int rw_timeout)
: conn_timeout_(conn_timeout)
, rw_timeout_(rw_timeout)
{
addr_ = acl_mystrdup(addr);
conn_ = new socket_stream;
sender_ = new tcp_sender(*conn_);
reader_ = NULL;
}
void redis_client::set_password(const char* pass)
{
if (pass_)
acl_myfree(pass_);
if (pass && *pass)
pass_ = acl_mystrdup(pass);
else
pass_ = NULL;
}
const std::list<rfc822_addr*>& rfc822::parse_addrs(const char* in,
const char* to_charset /* = "utf-8" */)
{
reset();
if (to_charset == NULL)
to_charset = "gb18030";
if (in == NULL || *in == 0)
{
logger_error("input invalid");
return (addrs_);
}
TOK822 *tree = tok822_parse(in);
if (tree == NULL)
{
logger_error("tok822_parse(%s) error", in);
return (addrs_);
}
const ACL_VSTRING* comment_prev = NULL;
string buf;
for (TOK822 *tp = tree; tp; tp = tp->next)
{
if (tp->type == TOK822_ATOM
|| tp->type == TOK822_COMMENT
|| tp->type == TOK822_QSTRING
|| tp->vstr != NULL)
{
comment_prev = tp->vstr;
}
if (tp->type != TOK822_ADDR || tp->head == NULL)
continue;
ACL_VSTRING* addrp = acl_vstring_alloc(32);
(void) tok822_internalize(addrp, tp->head, TOK822_STR_DEFL);
rfc822_addr* addr = (rfc822_addr*)
acl_mymalloc(sizeof(rfc822_addr));
addr->addr = acl_vstring_export(addrp);
if (comment_prev)
{
buf.clear();
rfc2047::decode(STR(comment_prev),
(int) LEN(comment_prev), &buf, to_charset);
addr->comment = acl_mystrdup(buf.c_str());
comment_prev = NULL;
}
else
addr->comment = NULL;
addrs_.push_back(addr);
}
tok822_free_tree(tree);
return (addrs_);
}
void db_mysql::sane_mysql_init(const char* dbaddr, const char* dbname,
const char* dbuser, const char* dbpass,
unsigned long dbflags, bool auto_commit,
int conn_timeout, int rw_timeout,
const char* charset)
{
if (dbaddr == NULL || *dbaddr == 0)
logger_fatal("dbaddr null");
if (dbname == NULL || *dbname == 0)
logger_fatal("dbname null");
// 地址格式：[dbname@]dbaddr
const char* ptr = strchr(dbaddr, '@');
if (ptr)
ptr++;
else
ptr = dbaddr;
acl_assert(*ptr);
dbaddr_ = acl_mystrdup(ptr);
dbname_ = acl_mystrdup(dbname);
if (dbuser && *dbuser)
dbuser_ = acl_mystrdup(dbuser);
else
dbuser_ = NULL;
if (dbpass && *dbpass)
dbpass_ = acl_mystrdup(dbpass);
else
dbpass_ = NULL;
if (charset && *charset)
charset_ = charset;
dbflags_ = dbflags;
auto_commit_ = auto_commit;
conn_timeout_ = conn_timeout;
rw_timeout_ = rw_timeout;
#ifdef HAS_MYSQL_DLL
acl_pthread_once(&__mysql_once, __mysql_dll_load);
#endif
conn_ = NULL;
}
redis_client::redis_client(const char* addr, int conn_timeout /* = 60 */,
int rw_timeout /* = 30 */, bool retry /* = true */)
: retry_(retry)
, slice_req_(false)
, slice_res_(false)
{
addr_ = acl_mystrdup(addr);
pass_ = NULL;
set_timeout(conn_timeout, rw_timeout);
}
int acl_inet_trigger(ACL_EVENT *eventp, const char *service,
const char *buf, int len, int timeout)
{
const char *myname = "acl_inet_trigger";
struct ACL_INET_TRIGGER *ip;
int fd;
if (acl_msg_verbose > 1)
acl_msg_info("%s: service %s", myname, service);
/*
* Connect...
*/
if ((fd = acl_inet_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.
*/
ip = (struct ACL_INET_TRIGGER *) acl_mymalloc(sizeof(*ip));
ip->fd = fd;
ip->service = acl_mystrdup(service);
ip->stream = acl_vstream_fdopen(fd, O_RDWR, 4096,
timeout, ACL_VSTREAM_TYPE_LISTEN_INET);
ip->eventp = eventp;
/*
* Write the request...
*/
if (acl_write_buf(fd, buf, len, timeout) < 0
|| acl_write_buf(fd, "", 1, timeout) < 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.
*/
if (timeout > 0)
acl_event_enable_read(ip->eventp, ip->stream, timeout + 100,
acl_inet_trigger_event, (void *) ip);
else
acl_event_enable_read(ip->eventp, ip->stream, 0,
acl_inet_trigger_event, (void *) ip);
return (0);
}
void db_pgsql::sane_pgsql_init(const char* dbaddr, const char* dbname,
const char* dbuser, const char* dbpass, int conn_timeout,
int rw_timeout, const char* charset)
{
affect_count_ = 0;
if (dbaddr == NULL || *dbaddr == 0)
logger_fatal("dbaddr null");
if (dbname == NULL || *dbname == 0)
logger_fatal("dbname null");
// 地址格式：[dbname@]dbaddr
const char* ptr = strchr(dbaddr, '@');
if (ptr)
ptr++;
else
ptr = dbaddr;
acl_assert(*ptr);
dbaddr_ = acl_mystrdup(ptr);
dbname_ = acl_mystrdup(dbname);
if (dbuser && *dbuser)
dbuser_ = acl_mystrdup(dbuser);
else
dbuser_ = NULL;
if (dbpass && *dbpass)
dbpass_ = acl_mystrdup(dbpass);
else
dbpass_ = NULL;
if (charset && *charset)
charset_ = charset;
conn_timeout_ = conn_timeout;
rw_timeout_ = rw_timeout;
#ifdef HAS_PGSQL_DLL
acl_pthread_once(&__pgsql_once, __pgsql_dll_load);
#endif
conn_ = NULL;
}
static void mail_from(MIME_NODE *node, const HEADER_OPTS *header_info)
{
//MIME_STATE *state = node->state;
TOK822 *tree;
TOK822 **addr_list;
TOK822 **tpp;
ACL_VSTRING *temp;
const char *cp;
temp = acl_vstring_alloc(10);
cp = STR(node->buffer) + strlen(header_info->name) + 1;
tree = tok822_parse(cp);
addr_list = tok822_grep(tree, TOK822_ADDR);
for (tpp = addr_list; *tpp; tpp++) {
tok822_internalize(temp, tpp[0]->head, TOK822_STR_DEFL);
if (header_info->type == HDR_SENDER) {
if (node->header_sender)
acl_myfree(node->header_sender);
node->header_sender = acl_mystrdup(STR(temp));
break;
} else if (header_info->type == HDR_FROM) {
if (node->header_from)
acl_myfree(node->header_from);
node->header_from = acl_mystrdup(STR(temp));
break;
} else if (header_info->type == HDR_REPLY_TO) {
if (node->header_replyto)
acl_myfree(node->header_replyto);
node->header_replyto = acl_mystrdup(STR(temp));
break;
} else if (header_info->type == HDR_RETURN_PATH) {
if (node->header_returnpath)
acl_myfree(node->header_returnpath);
node->header_returnpath = acl_mystrdup(STR(temp));
}
}
acl_myfree(addr_list);
tok822_free_tree(tree);
acl_vstring_free(temp);
}
void acl_proctl_deamon_init(const char *progname)
{
acl_pthread_attr_t attr;
acl_pthread_t tid;
var_progname = acl_mystrdup(progname);
proctl_start_init(var_progname);
acl_pthread_attr_init(&attr);
(void) acl_pthread_attr_setdetachstate(&attr, 1);
acl_pthread_create(&tid, &attr, proctl_monitor_thread, NULL);
}
void acl_proctl_child(const char *progname, void (*onexit_fn)(void *), void *arg)
{
acl_pthread_attr_t attr;
acl_pthread_t tid;
proctl_child_atexit(onexit_fn, arg);
var_progname = acl_mystrdup(progname);
acl_pthread_attr_init(&attr);
(void) acl_pthread_attr_setdetachstate(&attr, 1);
acl_pthread_create(&tid, &attr, proctl_child_thread, NULL);
}
static ACL_FIFO *mail_addr_add(ACL_FIFO *addr_list, const char *addr)
{
MAIL_ADDR *mail_addr;
if (addr_list == NULL)
addr_list = acl_fifo_new();
mail_addr = (MAIL_ADDR*) acl_mycalloc(1, sizeof(MAIL_ADDR));
mail_addr->addr = acl_mystrdup(addr);
acl_fifo_push(addr_list, mail_addr);
return (addr_list);
}
mem_cache::mem_cache(const char* key_pre /* = NULL */,
const char* addr /* = "127.0.0.1:11211" */, bool retry /* = true */,
int conn_timeout /* = 180 */, int rw_timeout /* = 300 */,
bool encode_key /* = true */)
: m_coder(false, false)
, m_conn_timeout(conn_timeout)
, m_rw_timeout(rw_timeout)
, m_encode_key(encode_key)
, m_opened(false)
, m_retry(retry)
, m_conn(NULL)
{
if (key_pre && *key_pre)
{
bool beCoding = false;
m_key_pre = NEW acl::string(strlen(key_pre));
while (*key_pre)
{
if (SPECIAL_CHAR(*key_pre) || !ACL_ISPRINT(*key_pre))
{
m_coder.encode_update(key_pre, 1, m_key_pre);
beCoding = true;
}
else if (beCoding)
{
m_coder.encode_finish(m_key_pre);
m_coder.reset();
beCoding = false;
*m_key_pre << (char) *key_pre;
}
else
*m_key_pre << (char) *key_pre;
key_pre++;
}
if (beCoding)
m_coder.encode_finish(m_key_pre);
}
else
m_key_pre = NULL;
acl_assert(addr && *addr);
m_addr = acl_mystrdup(addr);
char* ptr = strchr(m_addr, ':');
if (ptr == NULL)
logger_fatal("addr(%s) invalid", addr);
*ptr++ = 0;
if (*ptr == 0)
logger_fatal("addr(%s) invalid", addr);
m_ip = m_addr;
m_port = atoi(ptr);
if (m_port <= 0)
logger_fatal("addr(%s) invalid", addr);
}
static void clone_table_entry(ACL_HTABLE_INFO *info, void *arg)
{
const char *myname = "clone_table_entry";
ACL_HTABLE *table = (ACL_HTABLE*) arg;
char *value;
value = acl_mystrdup(info->value);
if (acl_htable_enter(table, info->key.key, value) == NULL)
acl_msg_fatal("%s, %s(%d): acl_htable_enter error=%s",
__FILE__, myname, __LINE__, acl_last_serror());
}
PROCTL_SERVICE *proctl_service_alloc(const char *filepath, ACL_VSTRING *cmdline)
{
PROCTL_SERVICE *service;
service = (PROCTL_SERVICE*) acl_mycalloc(1, sizeof(PROCTL_SERVICE));
acl_assert(service);
service->filepath = acl_mystrdup(filepath);
service->cmdline = cmdline;
service->hProcess = INVALID_HANDLE_VALUE;
return (service);
}
AUT_LINE *aut_add_outer_cmd(const ACL_CFG_LINE *cfg_line)
{
const char *myname = "aut_add_outer_cmd";
AUT_LINE *test_line;
if (cfg_line->ncount < 3)
aut_log_fatal("%s: cmd_name=%s, ncount=%d, input error, "
"please check configure file",
myname, cfg_line->value[0], cfg_line->ncount);
test_line = (AUT_LINE *) acl_mycalloc(1, sizeof(*test_line));
if (test_line == NULL) {
char tbuf[256];
aut_log_fatal("%s: can't malloc AUT_LINE, err_msg=%s",
myname, acl_last_strerror(tbuf, sizeof(tbuf)));
}
snprintf(test_line->cmd_name, sizeof(test_line->cmd_name),
"%s", cfg_line->value[0]);
test_line->line_number = cfg_line->line_number;
test_line->result = atoi(cfg_line->value[1]);
test_line->argc = atoi(cfg_line->value[2]);
if (cfg_line->ncount >= 4) {
test_line->args_str = acl_mystrdup(cfg_line->value[3]);
if (test_line->args_str == NULL) {
char tbuf[256];
aut_log_fatal("%s: cmd_name=%s, strdup for "
"args_str, err_msg=%s",
myname,
cfg_line->value[0],
acl_last_strerror(tbuf, sizeof(tbuf)));
}
test_line->argv = aut_parse_args_list(cfg_line->value[3]);
if (test_line->argv == NULL)
aut_log_fatal("%s: cmd_name=%s, aut_parse_args_list error",
myname, cfg_line->value[0]);
} else {
test_line->args_str = NULL;
test_line->argv = NULL;
}
if (acl_array_append(var_aut_line_array, (void *) test_line) < 0) {
char tbuf[256];
aut_log_fatal("%s: cmd_name=%s, acl_array_append error, err_msg=%s",
myname, acl_last_strerror(tbuf, sizeof(tbuf)));
}
test_line->valid_line_idx = var_aut_valid_line_idx++;
return (test_line);
}
