Example #1
0
const char *acl_getcwd()
{
	const char *myname = "acl_getcwd";
	char *buf_ptr = get_tls_buf();
	char *ptr;

	ptr = getcwd(buf_ptr, BUF_SIZE);
	if (ptr == NULL) {
		acl_msg_error("%s(%d): getcwd error(%s)",
			myname, __LINE__, acl_last_serror());
	}
	return (ptr);
}
Example #2
0
const char *acl_netdb_index_ip(const ACL_DNS_DB *db, int n)
{
	ACL_HOSTNAME *h_hostname;

	if (db == NULL || n < 0) {
		acl_msg_error("%s, %s(%d): input error",
			__FILE__, __FUNCTION__, __LINE__);
		return NULL;
	}
	if (db->size == 0) {
		acl_msg_error("%s, %s(%d): dns db size is 0",
			__FILE__, __FUNCTION__, __LINE__);
		return NULL;
	}
	if (n >= db->size) {
		acl_msg_error("%s, %s(%d): index(%d) > size(%d)",
			__FILE__, __FUNCTION__, __LINE__, n, db->size);
		return NULL;
	}
	h_hostname = (ACL_HOSTNAME *) acl_array_index(db->h_db, n);
	return h_hostname->ip;
}
Example #3
0
const char *acl_process_path()
{
	const char *myname = "acl_process_path";
	const char *ptr;

	ptr = getexecname();
	if (ptr == NULL) {
		acl_msg_error("%s(%d): readlink error(%s)",
				myname, __LINE__, acl_last_serror());
		return (NULL);
	}
	return (ptr);
}
Example #4
0
static int epoll_event_add(EVENT *ev, int fd, int mask)
{
	EVENT_EPOLL *ep = (EVENT_EPOLL *) ev;
	struct epoll_event ee;
	int  op;

	if ((ev->events[fd].mask & mask) == mask)
		return 0;

	/* If the fd was already monitored for some event, we need a MOD
	 * operation. Otherwise we need an ADD operation. */
	op = ev->events[fd].mask == EVENT_NONE
		? EPOLL_CTL_ADD : EPOLL_CTL_MOD;

	ee.events   = 0;
	ee.data.u64 = 0;
	ee.data.ptr = NULL;
	ee.data.fd  = fd;

#if 1
	mask |= ev->events[fd].mask; /* Merge old events */
#endif

	if (mask & EVENT_READABLE)
		ee.events |= EPOLLIN;
	if (mask & EVENT_WRITABLE)
		ee.events |= EPOLLOUT;

#if 0
#ifdef	EPOLLRDHUP
	ee.events |= EPOLLERR | EPOLLRDHUP | EPOLLHUP;
#else
	ee.events |= EPOLLERR | EPOLLHUP;
#endif
#endif

	if (__sys_epoll_ctl == NULL)
		hook_epoll();

	if (__sys_epoll_ctl(ep->epfd, op, fd, &ee) == -1) {
		fiber_save_errno();
#if 0
		acl_msg_error("%s, %s(%d): epoll_ctl error %s, epfd=%d, fd=%d",
			__FILE__, __FUNCTION__, __LINE__, acl_last_serror(),
			ep->epfd, fd);
#endif
		return -1;
	}

	return 0;
}
Example #5
0
const char *acl_process_path()
{
	const char *myname = "acl_process_path";
	char *buf_ptr = get_tls_buf();
	int   ret;

	ret = readlink("/proc/curproc/file", buf_ptr, BUF_SIZE);
	if (ret < 0) {
		acl_msg_error("%s(%d): readlink error(%s)",
			myname, __LINE__, acl_last_serror());
		return (NULL);
	}
	return (buf_ptr);
}
Example #6
0
void acl_clean_env(char **preserve_list)
{
#ifdef ACL_UNIX
	extern char **environ;
	char  **env = environ;
#elif defined(ACL_WINDOWS)
	extern char **_environ;
	char  **env = _environ;
#endif
	ACL_ARGV   *save_list;
	char   *value;
	char  **cpp;
	char   *eq;

	/*
	 * Preserve or specify selected environment variables.
	 */
#define STRING_AND_LENGTH(x, y) (x), (ssize_t) (y)

	save_list = acl_argv_alloc(10);
	for (cpp = preserve_list; *cpp; cpp++)
		if ((eq = strchr(*cpp, '=')) != 0)
			acl_argv_addn(save_list, STRING_AND_LENGTH(*cpp, eq - *cpp),
				STRING_AND_LENGTH(eq + 1, strlen(eq + 1)), (char *) 0);
		else if ((value = acl_safe_getenv(*cpp)) != 0)
			acl_argv_add(save_list, *cpp, value, (char *) 0);

	/*
	 * Truncate the process environment, if available. On some systems
	 * (Ultrix!), environ can be a null pointer.
	 */
	if (env)
		env[0] = 0;

	/*
	 * Restore preserved environment variables.
	 */
	for (cpp = save_list->argv; *cpp; cpp += 2)
#ifdef ACL_UNIX
		if (setenv(cpp[0], cpp[1], 1))
#elif defined(ACL_WINDOWS)
		if (!SetEnvironmentVariable(cpp[0], cpp[1]))
#endif
			acl_msg_error("setenv(%s, %s): %s", cpp[0], cpp[1], acl_last_serror());

	/*
	 * Cleanup.
	 */
	acl_argv_free(save_list);
}
Example #7
0
const char *acl_netdb_index_ip(const ACL_DNS_DB *h_dns_db, int n)
{
	const char *myname = "acl_netdb_index_ip";
	ACL_HOSTNAME *h_hostname;

	if (h_dns_db == NULL || n < 0) {
		acl_msg_error("%s, %s(%d): input error",
				__FILE__, myname, __LINE__);
		return (NULL);
	}
	if (h_dns_db->size == 0) {
		acl_msg_error("%s, %s(%d): dns db size is 0",
				__FILE__, myname, __LINE__);
		return (NULL);
	}
	if (n >= h_dns_db->size) {
		acl_msg_error("%s, %s(%d): index(%d) > size(%d)",
				__FILE__, myname, __LINE__, n, h_dns_db->size);
		return (NULL);
	}
	h_hostname = (ACL_HOSTNAME *) acl_array_index(h_dns_db->h_db, n);
	return (h_hostname->ip);
}
Example #8
0
static DWORD WINAPI RunThreadWrap(LPVOID data)
#endif
{
	acl_pthread_t *thread = (acl_pthread_t *) data;
	void *return_arg;
	ACL_FIFO *tls_value_list_ptr = tls_value_list_get();
	unsigned long *tid = 0;

	/* 只是为了避免与主线程的 h_thread->handle = handle 产生冲突 */
	if (__thread_inited)
		acl_pthread_mutex_lock(&__thread_lock);
	if (__thread_inited)
		acl_pthread_mutex_unlock(&__thread_lock);

	thread->id = acl_pthread_self();

	return_arg = (void*) thread->start_routine(thread->routine_arg);

	/* 释放由 acl_pthread_setspecific 添加的线程局部变量 */
	while (1) {
		TLS_VALUE *tls_value = private_fifo_pop(tls_value_list_ptr);

		if (tls_value == NULL)
			break;

		if (tls_value->tls_key == NULL
			|| tls_value->tls_key->destructor == NULL
			|| tls_value->tls_key->key < 0
			|| tls_value->tls_key->key >= ACL_PTHREAD_KEYS_MAX)
		{
			acl_default_free(__FILE__, __LINE__, tls_value);
			continue;
		}
		tls_value->tls_key->destructor(tls_value->value);
		acl_default_free(__FILE__, __LINE__, tls_value);
	}

	private_fifo_free(tls_value_list_ptr, NULL);

	/* 如果线程创建时为分离方式则需要关闭线程句柄 */
	if (thread->detached) {
		if (!CloseHandle(thread->handle)) {
			acl_msg_error("close handle error(%s)", 
				acl_last_serror());
		}
	}

	acl_default_free(__FILE__, __LINE__, thread);
	return (DWORD) return_arg;
}
Example #9
0
int smtp_send_file(SMTP_CLIENT *client, const char* filepath)
{
	int   ret;
	ACL_VSTREAM *in = acl_vstream_fopen(filepath, O_RDONLY, 0600, 4096);

	if (in == NULL) {
		acl_msg_error("%s(%d): open %s error(%s)", __FUNCTION__,
			__LINE__, filepath, acl_last_serror());
		return -1;
	}
	ret = smtp_send_stream(client, in);
	acl_vstream_close(in);
	return ret;
}
Example #10
0
void acl_netdb_refer_oper(ACL_DNS_DB *db, int idx, int value)
{
	ACL_HOSTNAME *h_hostname;

	if (db == NULL || idx < 0) {
		acl_msg_error("%s, %s(%d): input error",
			__FILE__, __FUNCTION__, __LINE__);
		return;
	}

	if (db->size == 0) {
		acl_msg_error("%s, %s(%d): dns db size is 0",
			__FILE__, __FUNCTION__, __LINE__);
		return;
	}
	if (idx >= db->size) {
		acl_msg_error("%s, %s(%d): index(%d) > size(%d)",
			__FILE__, __FUNCTION__, __LINE__, idx, db->size);
		return;
	}
	h_hostname = (ACL_HOSTNAME *) acl_array_index(db->h_db, idx);
	h_hostname->nrefer += value;
}
Example #11
0
int acl_btree_destroy(ACL_BTREE *tree)
{
	const char *myname = "acl_btree_destroy";

	btree_validate(tree);
	if (tree->root != NULL) {
		acl_msg_error("%s(%d): Tree not empty", myname, __LINE__);
		return (-1);
	}

	acl_slice_destroy(tree->slice);
	acl_myfree(tree);
	return (0);
}
Example #12
0
inline ssize_t fiber_recvfrom(int sockfd, void *buf, size_t len, int flags,
	struct sockaddr *src_addr, socklen_t *addrlen)
{
	ssize_t ret;
	EVENT  *ev;
	ACL_FIBER *me;

	if (sockfd < 0) {
		acl_msg_error("%s: invalid sockfd: %d", __FUNCTION__, sockfd);
		return -1;
	}

	if (!acl_var_hook_sys_api) {
		if (__sys_recvfrom == NULL)
			hook_io();

		return __sys_recvfrom(sockfd, buf, len,
				flags, src_addr, addrlen);
	}

	ev = fiber_io_event();
	if (ev && event_readable(ev, sockfd)) {
		event_clear_readable(ev, sockfd);

		ret = __sys_recvfrom(sockfd, buf, len,
				flags, src_addr, addrlen);
		if (ret < 0)
			fiber_save_errno();
		return ret;
	}

	fiber_wait_read(sockfd);
	if (ev)
		event_clear_readable(ev, sockfd);

	ret = __sys_recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
	if (ret >= 0)
		return ret;

	fiber_save_errno();

	me = acl_fiber_running();
	if (acl_fiber_killed(me)) {
		acl_msg_info("%s(%d), %s: fiber-%u is existing",
			__FILE__, __LINE__, __FUNCTION__, acl_fiber_id(me));
		return -1;
	}

	return ret;
}
Example #13
0
const char *acl_process_path()
{
	const char *myname = "acl_process_path";
	char *buf_ptr = get_tls_buf();
	int   ret;

	ret = GetModuleFileName(NULL, buf_ptr, BUF_SIZE);
	if (ret == 0) {
		acl_msg_error("%s(%d): readlink error(%s)",
			myname, __LINE__, acl_last_serror());
		return (NULL);
	}
	return (buf_ptr);
}
Example #14
0
int acl_get_tcp_nodelay(ACL_SOCKET fd)
{
	const char *myname = "acl_get_tcp_nodelay";
	int  on = 0;
	socklen_t len = (socklen_t) sizeof(on);

	if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*) &on, &len) < 0) {
		acl_msg_error("%s(%d): getsockopt error: %s, fd: %d",
			myname, __LINE__, acl_last_serror(), fd);
		return -1;
	}

	return on;
}
Example #15
0
int get_addr_from_file(const char *filepath, char *buf, size_t size)
{
	const char *myname = "get_addr_from_file";
	ACL_VSTREAM *fp;
	char  ebuf[256];
	int   n;

	fp = acl_vstream_fopen(filepath, O_RDONLY, 0600, 1024);
	if (fp == NULL) {
		acl_msg_error("%s(%d): fopen file(%s) error(%s)",
			myname, __LINE__, filepath, acl_last_strerror(ebuf, sizeof(ebuf)));
		return (-1);
	}

	n = acl_vstream_gets_nonl(fp, buf, size);
	acl_vstream_close(fp);

	if (n == ACL_VSTREAM_EOF)
		acl_msg_error("%s(%d): gets from file(%s) error(%s)",
			myname, __LINE__, filepath, acl_last_strerror(ebuf, sizeof(ebuf)));

	return (0);
}
Example #16
0
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);
}
Example #17
0
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;
}
Example #18
0
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);
}
Example #19
0
static int chunked_sep_gets(HTTP_CHAT_CTX *ctx)
{
	const char *myname = "chunked_sep_gets2";
	char  buf[HTTP_BSIZE];
	int   n;

	n = acl_vstream_gets(ctx->stream, buf, sizeof(buf));
	if (n == ACL_VSTREAM_EOF) {
		acl_msg_error("%s(%d): gets sep line error", myname, __LINE__);
		return -1;
	}

	ctx->body_len += n;
	return 0;
}
Example #20
0
int acl_get_tcp_solinger(ACL_SOCKET fd)
{
	const char *myname = "acl_get_tcp_solinger";
	struct linger  l;
	socklen_t len = (socklen_t) sizeof(l);

	memset(&l, 0, sizeof(l));
	if (getsockopt(fd, SOL_SOCKET, SO_LINGER, (char*) &l, &len) < 0) {
		acl_msg_error("%s(%d): getsockopt error: %s, fd: %d",
			myname, __LINE__, acl_last_serror(), fd);
		return -1;
	}

	return l.l_linger == 0 ? -1 : l.l_linger;
}
Example #21
0
void acl_tcp_so_linger(ACL_SOCKET fd, int onoff, int timeout)
{
	const char *myname = "acl_tcp_so_linger";
	struct linger  l;

	l.l_onoff = onoff ? 1 : 0;
	l.l_linger = timeout >= 0 ? timeout : 0;
	if (setsockopt(fd, SOL_SOCKET, SO_LINGER,
		(char *) &l, sizeof(l)) < 0)
	{
		acl_msg_error("%s(%d): setsockopt(SO_LINGER) error(%s),"
			" onoff(%d), timeout(%d)", myname, __LINE__,
			acl_last_serror(), onoff, timeout);
	}
}
Example #22
0
int acl_pthread_mutex_init(acl_pthread_mutex_t *mutex,
	const acl_pthread_mutexattr_t *mattr)
{
	const char *myname = "acl_pthread_mutex_init";

	if (mutex == NULL) {
		acl_msg_error("%s, %s(%d): input invalid",
			__FILE__, myname, __LINE__);
		return -1;
	}

	mutex->dynamic = 0;

	/* Create the mutex, with initial value signaled */
	mutex->id = CreateMutex((SECURITY_ATTRIBUTES *) mattr, FALSE, NULL);
	if (!mutex->id) {
		acl_msg_error("%s, %s(%d): CreateMutex error(%s)",
			__FILE__, myname, __LINE__, acl_last_serror());
		acl_myfree(mutex);
		return -1;
	}

	return 0;
}
Example #23
0
int http_util_set_dump_file(HTTP_UTIL *http_util, const char *filename)
{
	const char *myname = "http_util_set_dump_file";

	if (filename == NULL || *filename == 0) {
		acl_msg_error("%s(%d): filename invalid", myname, __LINE__);
		return (-1);
	}
	if ((http_util->flag & HTTP_UTIL_FLAG_SET_DUMP_STREAM)) {
		acl_msg_error("%s(%d): You've called http_util_set_dump_stream before!",
			myname, __LINE__);
		return (-1);
	}

	http_util->dump_stream = acl_vstream_fopen(filename,
			O_CREAT | O_TRUNC | O_WRONLY, 0600, 4096);
	if (http_util->dump_stream == NULL) {
		acl_msg_error("%s(%d): open dump file(%s) error(%s)",
			myname, __LINE__, filename, acl_last_serror());
		return (-1);
	}
	http_util->flag |= HTTP_UTIL_FLAG_SET_DUMP_FILE;
	return (0);
}
Example #24
0
int acl_pthread_mutex_init(acl_pthread_mutex_t *mutex, const acl_pthread_mutexattr_t *mattr)
{
	char  myname[] = "acl_pthread_mutex_init";
	char  buf[256];

	if (mutex == NULL) {
		acl_msg_error("%s, %s(%d): input invalid",
				__FILE__, myname, __LINE__);
		return (-1);
	}

	mutex->dynamic = 0;

	/* Create the mutex, with initial value signaled */
	mutex->id = CreateMutex((SECURITY_ATTRIBUTES *) mattr, FALSE, NULL);
	if (!mutex->id) {
		acl_msg_error("%s, %s(%d): CreateMutex error(%s)",
				__FILE__, myname, __LINE__,
				acl_last_strerror(buf, sizeof(buf)));
		acl_myfree(mutex);
		return (-1);
	}
	return (0);
}
Example #25
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);
}
Example #26
0
/* Create a semaphore */
ACL_SEM *acl_sem_create2(const char *pathname, unsigned int initial_value)
{
	const char *myname = "acl_sem_create2";
	ACL_SEM *sem;

	/* Allocate sem memory */
	sem = (ACL_SEM *) acl_mymalloc(sizeof(*sem));
	if (sem == NULL) {
		acl_msg_error("%s, %s(%d): malloc error(%s)",
			__FILE__, myname, __LINE__, acl_last_serror());
		return NULL;
	}
	/* Create the semaphore, with max value 32K */
	sem->id = CreateSemaphore(NULL, initial_value, 32 * 1024, pathname);
	sem->count = initial_value;
	if (!sem->id) {
		acl_msg_error("%s, %s(%d): Couldn't create semaphore(%s)",
			__FILE__, myname, __LINE__, acl_last_serror());
		acl_myfree(sem);
		return NULL;
	}

	return sem;
}
Example #27
0
int acl_pipe(ACL_FILE_HANDLE fds[2])
{
	const char *myname = "acl_pipe";
	DWORD dwPipeMode;
	DWORD dwOpenMode;
	char name[250];
	SECURITY_ATTRIBUTES sa;
	static unsigned long id = 0;

	InterlockedIncrement(&id);

	sa.nLength = sizeof(sa);
	sa.bInheritHandle = TRUE;
	sa.lpSecurityDescriptor = NULL;

	/* Create the read/write end of the pipe */

	dwOpenMode = PIPE_ACCESS_DUPLEX;
	dwPipeMode = PIPE_WAIT; /* PIPE_NOWAIT; */
	snprintf(name, sizeof(name), "\\\\.\\pipe\\acl-pipe-%u-%lu-%lu",
		_getpid(), (unsigned long) acl_pthread_self(), id);
	fds[0] = CreateNamedPipe(name,
				dwOpenMode,
				dwPipeMode,
				1,            /* nMaxInstances */
				65536,        /* nOutBufferSize */
				65536,        /* nInBufferSize */
				1,            /* nDefaultTimeOut */
				&sa);

	/* Create the read/write end of the pipe */
	dwOpenMode = FILE_ATTRIBUTE_NORMAL;
	fds[1] = CreateFile(name,
				GENERIC_WRITE | GENERIC_READ,   /* access mode */
				0,               /* share mode */
				NULL,            /* Security attributes */
				OPEN_EXISTING,   /* dwCreationDisposition */
				dwOpenMode,      /* Pipe attributes */
				NULL);           /* handle to template file */

	if (fds[1] == ACL_FILE_INVALID) {
		acl_msg_error("%s(%d): CreateFile(%s) error(%s)",
			myname, __LINE__, name, acl_last_serror());
		acl_file_close(fds[0]);
		return (-1);
	}
	return (0);
}
Example #28
0
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;
}
Example #29
0
static int io_close_fn(ACL_ASTREAM *astream, void *context)
{
	const char *myname = "io_close_fn";

	CLIENT_ENTRY *entry = (CLIENT_ENTRY *) context;
	ACL_VSTREAM *stream;

	stream = acl_aio_vstream(astream);
	if (stream)
		acl_debug(22, 2) ("%s: error to stream", myname);
	else
		acl_msg_error("not connected");

	forward_complete(entry);
	return (-1);
}
Example #30
0
void http_util_set_dump_stream(HTTP_UTIL *http_util, ACL_VSTREAM *stream)
{
	const char *myname = "http_util_set_dump_stream";

	if (stream == NULL)
		return;

	if ((http_util->flag & HTTP_UTIL_FLAG_SET_DUMP_FILE)) {
		acl_msg_error("%s(%d): You've called http_util_set_dump_file before!",
			myname, __LINE__);
		return;
	}

	http_util->dump_stream = stream;
	http_util->flag |= HTTP_UTIL_FLAG_SET_DUMP_STREAM;
}