#include "acl_define.h"
#include <time.h>
#include <sys/types.h>
#include "acl_array.h"
#include "acl_htable.h"
#include "acl_vstring.h"

acl_vstream.h 的引用(Include)关系图:

此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

类
struct	ACL_VSTREAM_CLOSE_HANDLE

struct	ACL_VSTREAM

宏定义
#define	ACL_VSTREAM_EOF (-1) /* no more space or data */

#define	ACL_VSTREAM_BUFSIZE 4096

#define	ACL_VSTREAM_TYPE_SOCK (1 << 0)

#define	ACL_VSTREAM_TYPE_FILE (1 << 1)

#define	ACL_VSTREAM_TYPE_LISTEN (1 << 2)

#define	ACL_VSTREAM_TYPE_LISTEN_INET (1 << 3)

#define	ACL_VSTREAM_TYPE_LISTEN_UNIX (1 << 4)

#define	ACL_VSTREAM_TYPE_LISTEN_IOCP (1 << 5)

#define	ACL_VSTREAM_TYPE_INET4 (1 << 6)

#define	ACL_VSTREAM_TYPE_INET6 (1 << 7)

#define	ACL_VSTREAM_TYPE_UNIX (1 << 8)

#define	ACL_VSTREAM_FLAG_READ (1 << 0)

#define	ACL_VSTREAM_FLAG_WRITE (1 << 1)

#define	ACL_VSTREAM_FLAG_RW (1 << 2)

#define	ACL_VSTREAM_FLAG_CACHE_SEEK (1 << 3)

#define	ACL_VSTREAM_FLAG_DEFER_FREE (1 << 4)

#define	ACL_VSTREAM_FLAG_ERR (1 << 10)

#define	ACL_VSTREAM_FLAG_EOF (1 << 11)

#define	ACL_VSTREAM_FLAG_TIMEOUT (1 << 12)

#define	ACL_VSTREAM_FLAG_RDSHORT (1 << 13)

#define	ACL_VSTREAM_FLAG_BAD

#define	ACL_VSTREAM_FLAG_CLIENT (1 << 14)

#define	ACL_VSTREAM_FLAG_CONNECT (1 << 15)

#define	ACL_VSTREAM_FLAG_SOCKPAIR (1 << 16)

#define	ACL_VSTREAM_FLAG_TAGYES (1 << 17) /* 若读到要求的标志位则置位 */

#define	ACL_VSTREAM_FLAG_CONNECTING (1 << 18) /* 正在连接过程中 */

#define	ACL_VSTREAM_FLAG_PREREAD (1 << 19) /* 对于 acl_vstream_can_read 调用过程是否允许预读 */

#define	ACL_VSTREAM_FLAG_MS (1 << 20)

#define	ACL_VSTREAM_FLAG_US (1 << 21)

#define	ACL_VSTREAM_FLAG_NS (1 << 22)

#define	ACL_VSTREAM_SET_MS(x) ((x)->flag \|= ACL_VSTREAM_FLAG_MS)

#define	ACL_VSTREAM_SET_US(x) ((x)->flag \|= ACL_VSTREAM_FLAG_US)

#define	ACL_VSTREAM_SET_NS(x) ((x)->flag \|= ACL_VSTREAM_FLAG_NS)

#define	ACL_VSTREAM_CLR_MS(x) ((x)->flag &= ~ACL_VSTREAM_FLAG_MS)

#define	ACL_VSTREAM_CLR_US(x) ((x)->flag &= ~ACL_VSTREAM_FLAG_US)

#define	ACL_VSTREAM_CLR_NS(x) ((x)->flag &= ~ACL_VSTREAM_FLAG_NS)

#define	ACL_VSTREAM_IS_MS(x) (((x)->flag & ACL_VSTREAM_FLAG_MS) != 0)

#define	ACL_VSTREAM_IS_US(x) (((x)->flag & ACL_VSTREAM_FLAG_US) != 0)

#define	ACL_VSTREAM_IS_NS(x) (((x)->flag & ACL_VSTREAM_FLAG_NS) != 0)

#define	ACL_VSTREAM_IN (&acl_vstream_fstd[0])

#define	ACL_VSTREAM_OUT (&acl_vstream_fstd[1])

#define	ACL_VSTREAM_ERR (&acl_vstream_fstd[2])

#define	ACL_VSTREAM_CTL_END 0

#define	ACL_VSTREAM_CTL_READ_FN 1

#define	ACL_VSTREAM_CTL_WRITE_FN 2

#define	ACL_VSTREAM_CTL_PATH 3

#define	ACL_VSTREAM_CTL_FD 4

#define	ACL_VSTREAM_CTL_TIMEOUT 5

#define	ACL_VSTREAM_CTL_CONTEXT 6

#define	ACL_VSTREAM_CTL_CTX ACL_VSTREAM_CTL_CONTEXT

#define	ACL_VSTREAM_CTL_CACHE_SEEK 7

#define	acl_vstream_get_char acl_vstream_getc

#define	acl_vstream_readline acl_vstream_gets

#define	acl_vstream_fgets acl_vstream_gets

#define	acl_vstream_buffed_fwrite acl_vstream_buffed_writen

#define	acl_vstream_fwrite acl_vstream_writen

#define	acl_vstream_fclose acl_vstream_close

#define	ACL_VSTREAM_GETC(stream_ptr)

#define	ACL_VSTREAM_PUTC(ch, stream_ptr)

#define	ACL_VSTREAM_SOCK(stream_ptr) ((stream_ptr)->fd.sock)

#define	ACL_VSTREAM_FILE(stream_ptr) ((stream_ptr)->fd.h_file)

#define	ACL_VSTREAM_PATH(stream_ptr) ((stream_ptr)->path)

#define	ACL_VSTREAM_PEER(stream_ptr) ((stream_ptr)->addr_peer)

#define	ACL_VSTREAM_LOCAL(stream_ptr) ((stream_ptr)->addr_local)

#define	ACL_VSTREAM_SET_SOCK(stream_ptr, _fd)

#define	ACL_VSTREAM_SET_FILE(stream_ptr, _fh)

#define	ACL_VSTREAM_BFRD_CNT(stream_ptr) ((stream_ptr) == NULL ? -1 : (stream_ptr)->read_cnt)

#define	ACL_VSTREAM_SET_RWTIMO(stream_ptr, _rw_timeo)

#define	ACL_VSTREAM_SET_EOF(stream_ptr)

#define	ACL_IF_VSTREAM_ERR(stream_ptr) ((stream_ptr)->flag & ACL_VSTREAM_FLAG_BAD)

#define	ACL_VSTREAM_ERRNO(stream_ptr) ((stream_ptr)->errnum)

#define	acl_vstream_ftimeout(stream_ptr) ((stream_ptr)->flag & ACL_VSTREAM_FLAG_TIMEOUT)

类型定义
typedef struct ACL_VSTREAM	ACL_VSTREAM

typedef int(*	ACL_VSTREAM_RD_FN) (ACL_SOCKET fd, void buf, size_t size, int timeout, ACL_VSTREAM fp, void *context)

typedef int(*	ACL_VSTREAM_WR_FN) (ACL_SOCKET fd, const void buf, size_t size, int timeout, ACL_VSTREAM fp, void *context)

typedef int(*	ACL_VSTREAM_WV_FN) (ACL_SOCKET fd, const struct iovec vec, int count, int timeout, ACL_VSTREAM fp, void *context)

typedef int(*	ACL_FSTREAM_RD_FN) (ACL_FILE_HANDLE fh, void buf, size_t size, int timeout, ACL_VSTREAM fp, void *context)

typedef int(*	ACL_FSTREAM_WR_FN) (ACL_FILE_HANDLE fh, const void buf, size_t size, int timeout, ACL_VSTREAM fp, void *context)

typedef int(*	ACL_FSTREAM_WV_FN) (ACL_FILE_HANDLE fh, const struct iovec vec, int count, int timeout, ACL_VSTREAM fp, void *context)

typedef struct ACL_VSTREAM_CLOSE_HANDLE	ACL_VSTREAM_CLOSE_HANDLE

函数
ACL_API void	acl_vstream_init (void)

ACL_API int	acl_vstream_peekfd (ACL_VSTREAM *fp)

ACL_API ACL_VSTREAM *	acl_vstream_clone (const ACL_VSTREAM *stream_src)

ACL_API int	acl_vstream_set_fdtype (ACL_VSTREAM *fp, int type)

ACL_API ACL_VSTREAM *	acl_vstream_fhopen (ACL_FILE_HANDLE fh, unsigned int oflags)

ACL_API ACL_VSTREAM *	acl_vstream_fdopen (ACL_SOCKET fd, unsigned int oflags, size_t buflen, int rw_timeo, int fdtype)

ACL_API ACL_VSTREAM *	acl_vstream_fopen (const char *path, unsigned int oflags, int mode, size_t buflen)

ACL_API char *	acl_vstream_loadfile (const char *path)

ACL_API char *	acl_vstream_loadfile2 (const char path, ssize_t size)

ACL_API void	acl_vstream_ctl (ACL_VSTREAM *fp, int name,...)

ACL_API acl_off_t	acl_vstream_fseek (ACL_VSTREAM *fp, acl_off_t offset, int whence)

ACL_API acl_off_t	acl_vstream_fseek2 (ACL_VSTREAM *fp, acl_off_t offset, int whence)

ACL_API acl_off_t	acl_vstream_ftell (ACL_VSTREAM *fp)

ACL_API int	acl_file_ftruncate (ACL_VSTREAM *fp, acl_off_t length)

ACL_API int	acl_file_truncate (const char *path, acl_off_t length)

ACL_API int	acl_vstream_fstat (ACL_VSTREAM fp, struct acl_stat buf)

ACL_API acl_int64	acl_vstream_fsize (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_getc (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_nonb_readn (ACL_VSTREAM fp, char buf, int size)

ACL_API int	acl_vstream_probe_status (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_ungetc (ACL_VSTREAM *fp, int ch)

ACL_API int	acl_vstream_unread (ACL_VSTREAM fp, const void ptr, size_t length)

ACL_API int	acl_vstream_gets (ACL_VSTREAM fp, void vptr, size_t maxlen)

ACL_API int	acl_vstream_gets_nonl (ACL_VSTREAM fp, void vptr, size_t maxlen)

ACL_API int	acl_vstream_readtags (ACL_VSTREAM fp, void vptr, size_t maxlen, const char *tag, size_t taglen)

ACL_API int	acl_vstream_readn (ACL_VSTREAM fp, void vptr, size_t maxlen)

ACL_API int	acl_vstream_bfcp_some (ACL_VSTREAM fp, void vptr, size_t maxlen)

ACL_API int	acl_vstream_read (ACL_VSTREAM fp, void vptr, size_t maxlen)

ACL_API int	acl_vstream_gets_peek (ACL_VSTREAM fp, ACL_VSTRING buf, int *ready)

ACL_API int	acl_vstream_gets_nonl_peek (ACL_VSTREAM fp, ACL_VSTRING buf, int *ready)

ACL_API int	acl_vstream_readn_peek (ACL_VSTREAM fp, ACL_VSTRING buf, int cnt, int *ready)

ACL_API int	acl_vstream_read_peek (ACL_VSTREAM fp, ACL_VSTRING buf)

ACL_API int	acl_vstream_read_peek3 (ACL_VSTREAM fp, void buf, size_t size)

ACL_API int	acl_vstream_can_read (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_fsync (ACL_VSTREAM *fp)

ACL_API void	acl_vstream_buffed_space (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_fflush (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_buffed_writen (ACL_VSTREAM fp, const void vptr, size_t dlen)

ACL_API int	acl_vstream_buffed_vfprintf (ACL_VSTREAM fp, const char fmt, va_list ap)

ACL_API int	ACL_PRINTF (2, 3) acl_vstream_buffed_fprintf(ACL_VSTREAM *fp

ACL_API int const char ACL_API int	acl_vstream_buffed_printf (const char *,...)

ACL_API int	acl_vstream_buffed_fputs (const char s, ACL_VSTREAM fp)

ACL_API int	acl_vstream_buffed_puts (const char *s)

ACL_API int	acl_vstream_write (ACL_VSTREAM fp, const void vptr, int dlen)

ACL_API int	acl_vstream_writev (ACL_VSTREAM fp, const struct iovec vector, int count)

ACL_API int	acl_vstream_writevn (ACL_VSTREAM fp, const struct iovec vector, int count)

ACL_API int	acl_vstream_vfprintf (ACL_VSTREAM fp, const char fmt, va_list ap)

ACL_API int const char ACL_API int	acl_vstream_printf (const char *,...)

ACL_API int	acl_vstream_fputs (const char s, ACL_VSTREAM fp)

ACL_API int	acl_vstream_puts (const char *s)

ACL_API int	acl_vstream_writen (ACL_VSTREAM fp, const void vptr, size_t dlen)

ACL_API void	acl_vstream_free (ACL_VSTREAM *fp)

ACL_API int	acl_vstream_close (ACL_VSTREAM *fp)

ACL_API void	acl_vstream_call_close_handles (ACL_VSTREAM *fp)

ACL_API void	acl_vstream_add_close_handle (ACL_VSTREAM fp, void(close_fn)(ACL_VSTREAM , void ), void *context)

ACL_API void	acl_vstream_delete_close_handle (ACL_VSTREAM fp, void(close_fn)(ACL_VSTREAM , void ), void *context)

ACL_API void	acl_vstream_clean_close_handle (ACL_VSTREAM *fp)

ACL_API void	acl_vstream_reset (ACL_VSTREAM *fp)

ACL_API const char *	acl_vstream_strerror (ACL_VSTREAM *fp)

ACL_API void	acl_vstream_set_path (ACL_VSTREAM fp, const char path)

ACL_API void	acl_vstream_set_peer (ACL_VSTREAM fp, const char addr)

ACL_API int	acl_vstream_set_peer_addr (ACL_VSTREAM fp, const struct sockaddr sa)

ACL_API void	acl_vstream_set_local (ACL_VSTREAM fp, const char addr)

ACL_API int	acl_vstream_set_local_addr (ACL_VSTREAM fp, const struct sockaddr sa)

ACL_API int	acl_vstream_add_object (ACL_VSTREAM fp, const char key, void *obj)

ACL_API int	acl_vstream_del_object (ACL_VSTREAM fp, const char key)

ACL_API void *	acl_vstream_get_object (ACL_VSTREAM fp, const char key)

ACL_API void	acl_socket_read_hook (ACL_VSTREAM_RD_FN read_fn)

ACL_API void	acl_socket_write_hook (ACL_VSTREAM_WR_FN write_fn)

ACL_API void	acl_socket_writev_hook (ACL_VSTREAM_WV_FN writev_fn)

ACL_API void	acl_socket_close_hook (int(*close_fn)(ACL_SOCKET))

变量
ACL_API ACL_VSTREAM	acl_vstream_fstd []

ACL_API int const char *	fmt

宏定义说明

◆ ACL_IF_VSTREAM_ERR

#define ACL_IF_VSTREAM_ERR ( stream_ptr ) ((stream_ptr)->flag & ACL_VSTREAM_FLAG_BAD)

判断数据流是否出了错

参数

stream_ptr ACL_VSTREAM 类型的指针

返回: 0表示正常, 非0表示出错

在文件 acl_vstream.h 第 951 行定义.

◆ ACL_VSTREAM_BFRD_CNT

#define ACL_VSTREAM_BFRD_CNT ( stream_ptr ) ((stream_ptr) == NULL ? -1 : (stream_ptr)->read_cnt)

流中在读缓冲区中的数据量大小

参数

stream_ptr {ACL_VSTREAM*) 类型的指针

返回: -1: 表示出错, >= 0 此值即为流读缓冲区中的数据量大小

在文件 acl_vstream.h 第 924 行定义.

◆ acl_vstream_buffed_fwrite

#define acl_vstream_buffed_fwrite acl_vstream_buffed_writen

在文件 acl_vstream.h 第 612 行定义.

◆ ACL_VSTREAM_BUFSIZE

#define ACL_VSTREAM_BUFSIZE 4096

在文件 acl_vstream.h 第 40 行定义.

◆ ACL_VSTREAM_CLR_MS

#define ACL_VSTREAM_CLR_MS ( x ) ((x)->flag &= ~ACL_VSTREAM_FLAG_MS)

在文件 acl_vstream.h 第 139 行定义.

◆ ACL_VSTREAM_CLR_NS

#define ACL_VSTREAM_CLR_NS ( x ) ((x)->flag &= ~ACL_VSTREAM_FLAG_NS)

在文件 acl_vstream.h 第 143 行定义.

◆ ACL_VSTREAM_CLR_US

#define ACL_VSTREAM_CLR_US ( x ) ((x)->flag &= ~ACL_VSTREAM_FLAG_US)

在文件 acl_vstream.h 第 141 行定义.

◆ ACL_VSTREAM_CTL_CACHE_SEEK

#define ACL_VSTREAM_CTL_CACHE_SEEK 7

在文件 acl_vstream.h 第 317 行定义.

◆ ACL_VSTREAM_CTL_CONTEXT

#define ACL_VSTREAM_CTL_CONTEXT 6

在文件 acl_vstream.h 第 315 行定义.

◆ ACL_VSTREAM_CTL_CTX

#define ACL_VSTREAM_CTL_CTX ACL_VSTREAM_CTL_CONTEXT

在文件 acl_vstream.h 第 316 行定义.

◆ ACL_VSTREAM_CTL_END

#define ACL_VSTREAM_CTL_END 0

在文件 acl_vstream.h 第 309 行定义.

◆ ACL_VSTREAM_CTL_FD

#define ACL_VSTREAM_CTL_FD 4

在文件 acl_vstream.h 第 313 行定义.

◆ ACL_VSTREAM_CTL_PATH

#define ACL_VSTREAM_CTL_PATH 3

在文件 acl_vstream.h 第 312 行定义.

◆ ACL_VSTREAM_CTL_READ_FN

#define ACL_VSTREAM_CTL_READ_FN 1

在文件 acl_vstream.h 第 310 行定义.

◆ ACL_VSTREAM_CTL_TIMEOUT

#define ACL_VSTREAM_CTL_TIMEOUT 5

在文件 acl_vstream.h 第 314 行定义.

◆ ACL_VSTREAM_CTL_WRITE_FN

#define ACL_VSTREAM_CTL_WRITE_FN 2

在文件 acl_vstream.h 第 311 行定义.

◆ ACL_VSTREAM_EOF

#define ACL_VSTREAM_EOF (-1) /* no more space or data */

在文件 acl_vstream.h 第 25 行定义.

◆ ACL_VSTREAM_ERR

#define ACL_VSTREAM_ERR (&acl_vstream_fstd[2])

标准错误输出

在文件 acl_vstream.h 第 208 行定义.

◆ ACL_VSTREAM_ERRNO

#define ACL_VSTREAM_ERRNO ( stream_ptr ) ((stream_ptr)->errnum)

从数据流中取出与该流读写有关的系统错误号

参数

stream_ptr {ACL_VSTREAM*) 类型的指针

返回: err {int} 整形错误号，调用者可以用 strerror(err) 的方式查看具体含义

在文件 acl_vstream.h 第 963 行定义.

◆ acl_vstream_fclose

#define acl_vstream_fclose acl_vstream_close

在文件 acl_vstream.h 第 750 行定义.

◆ acl_vstream_fgets

#define acl_vstream_fgets acl_vstream_gets

在文件 acl_vstream.h 第 441 行定义.

◆ ACL_VSTREAM_FILE

#define ACL_VSTREAM_FILE ( stream_ptr ) ((stream_ptr)->fd.h_file)

由流获得文件句柄

参数

stream_ptr {ACL_VSTREAM*}

在文件 acl_vstream.h 第 833 行定义.

◆ ACL_VSTREAM_FLAG_BAD

#define ACL_VSTREAM_FLAG_BAD

值:

(ACL_VSTREAM_FLAG_ERR \
                               | ACL_VSTREAM_FLAG_EOF \
                               | ACL_VSTREAM_FLAG_TIMEOUT)

在文件 acl_vstream.h 第 115 行定义.

◆ ACL_VSTREAM_FLAG_CACHE_SEEK

#define ACL_VSTREAM_FLAG_CACHE_SEEK (1 << 3)

在文件 acl_vstream.h 第 108 行定义.

◆ ACL_VSTREAM_FLAG_CLIENT

#define ACL_VSTREAM_FLAG_CLIENT (1 << 14)

在文件 acl_vstream.h 第 118 行定义.

◆ ACL_VSTREAM_FLAG_CONNECT

#define ACL_VSTREAM_FLAG_CONNECT (1 << 15)

在文件 acl_vstream.h 第 119 行定义.

◆ ACL_VSTREAM_FLAG_CONNECTING

#define ACL_VSTREAM_FLAG_CONNECTING (1 << 18) /* 正在连接过程中 */

在文件 acl_vstream.h 第 124 行定义.

◆ ACL_VSTREAM_FLAG_DEFER_FREE

#define ACL_VSTREAM_FLAG_DEFER_FREE (1 << 4)

延迟关闭

在文件 acl_vstream.h 第 109 行定义.

◆ ACL_VSTREAM_FLAG_EOF

#define ACL_VSTREAM_FLAG_EOF (1 << 11)

结束

在文件 acl_vstream.h 第 112 行定义.

◆ ACL_VSTREAM_FLAG_ERR

#define ACL_VSTREAM_FLAG_ERR (1 << 10)

其它错误

在文件 acl_vstream.h 第 111 行定义.

◆ ACL_VSTREAM_FLAG_MS

#define ACL_VSTREAM_FLAG_MS (1 << 20)

毫秒超时级别

在文件 acl_vstream.h 第 127 行定义.

◆ ACL_VSTREAM_FLAG_NS

#define ACL_VSTREAM_FLAG_NS (1 << 22)

纳秒超时级别

在文件 acl_vstream.h 第 129 行定义.

◆ ACL_VSTREAM_FLAG_PREREAD

#define ACL_VSTREAM_FLAG_PREREAD (1 << 19) /* 对于 acl_vstream_can_read 调用过程是否允许预读 */

在文件 acl_vstream.h 第 125 行定义.

◆ ACL_VSTREAM_FLAG_RDSHORT

#define ACL_VSTREAM_FLAG_RDSHORT (1 << 13)

读的不够

在文件 acl_vstream.h 第 114 行定义.

◆ ACL_VSTREAM_FLAG_READ

#define ACL_VSTREAM_FLAG_READ (1 << 0)

在文件 acl_vstream.h 第 105 行定义.

◆ ACL_VSTREAM_FLAG_RW

#define ACL_VSTREAM_FLAG_RW (1 << 2)

在文件 acl_vstream.h 第 107 行定义.

◆ ACL_VSTREAM_FLAG_SOCKPAIR

#define ACL_VSTREAM_FLAG_SOCKPAIR (1 << 16)

在文件 acl_vstream.h 第 120 行定义.

◆ ACL_VSTREAM_FLAG_TAGYES

#define ACL_VSTREAM_FLAG_TAGYES (1 << 17) /* 若读到要求的标志位则置位 */

在文件 acl_vstream.h 第 122 行定义.

◆ ACL_VSTREAM_FLAG_TIMEOUT

#define ACL_VSTREAM_FLAG_TIMEOUT (1 << 12)

超时

在文件 acl_vstream.h 第 113 行定义.

◆ ACL_VSTREAM_FLAG_US

#define ACL_VSTREAM_FLAG_US (1 << 21)

微秒超时级别

在文件 acl_vstream.h 第 128 行定义.

◆ ACL_VSTREAM_FLAG_WRITE

#define ACL_VSTREAM_FLAG_WRITE (1 << 1)

在文件 acl_vstream.h 第 106 行定义.

◆ acl_vstream_ftimeout

#define acl_vstream_ftimeout ( stream_ptr ) ((stream_ptr)->flag & ACL_VSTREAM_FLAG_TIMEOUT)

判断一个流是否超时

参数

stream_ptr {ACL_VSTREAM*) 类型的指针

返回: {int} 0: 否; != 0: 是

在文件 acl_vstream.h 第 970 行定义.

◆ acl_vstream_fwrite

#define acl_vstream_fwrite acl_vstream_writen

在文件 acl_vstream.h 第 737 行定义.

◆ acl_vstream_get_char

#define acl_vstream_get_char acl_vstream_getc

在文件 acl_vstream.h 第 386 行定义.

◆ ACL_VSTREAM_GETC

#define ACL_VSTREAM_GETC ( stream_ptr )

值:

(                        \
    (stream_ptr)->read_cnt > 0 ?                              \
        (stream_ptr)->read_cnt--,                             \
        (stream_ptr)->offset++,                               \
        *(stream_ptr)->read_ptr++:                            \
        (stream_ptr)->sys_getc((stream_ptr)))

从流中读取一个字节的宏实现，效率要比 acl_vstream_getc()/1 高

参数

stream_ptr {ACL_VSTREAM*} 数据流指针

返回: {int} ACL_VSTREAM_EOF(出错) 或所读到的某个字节的ASCII, 若为 ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭该数据流

在文件 acl_vstream.h 第 801 行定义.

◆ ACL_VSTREAM_IN

#define ACL_VSTREAM_IN (&acl_vstream_fstd[0])

标准输入

在文件 acl_vstream.h 第 206 行定义.

◆ ACL_VSTREAM_IS_MS

#define ACL_VSTREAM_IS_MS ( x ) (((x)->flag & ACL_VSTREAM_FLAG_MS) != 0)

在文件 acl_vstream.h 第 146 行定义.

◆ ACL_VSTREAM_IS_NS

#define ACL_VSTREAM_IS_NS ( x ) (((x)->flag & ACL_VSTREAM_FLAG_NS) != 0)

在文件 acl_vstream.h 第 150 行定义.

◆ ACL_VSTREAM_IS_US

#define ACL_VSTREAM_IS_US ( x ) (((x)->flag & ACL_VSTREAM_FLAG_US) != 0)

在文件 acl_vstream.h 第 148 行定义.

◆ ACL_VSTREAM_LOCAL

#define ACL_VSTREAM_LOCAL ( stream_ptr ) ((stream_ptr)->addr_local)

当 ACL_VSTREAM 为网络流时，用此宏取得本地的地址

在文件 acl_vstream.h 第 871 行定义.

◆ ACL_VSTREAM_OUT

#define ACL_VSTREAM_OUT (&acl_vstream_fstd[1])

标准输出

在文件 acl_vstream.h 第 207 行定义.

◆ ACL_VSTREAM_PATH

#define ACL_VSTREAM_PATH ( stream_ptr ) ((stream_ptr)->path)

获得文件流句柄的文件路径名

参数

stream_ptr {ACL_VSTREAM*}

在文件 acl_vstream.h 第 839 行定义.

◆ ACL_VSTREAM_PEER

#define ACL_VSTREAM_PEER ( stream_ptr ) ((stream_ptr)->addr_peer)

当 ACL_VSTREAM 为网络流时，用此宏取得对方的地址

在文件 acl_vstream.h 第 851 行定义.

◆ ACL_VSTREAM_PUTC

#define ACL_VSTREAM_PUTC	(	ch,
		stream_ptr
	)

值:

(                                   \
  (stream_ptr)->wbuf_size == 0 ?                                             \
    (acl_vstream_buffed_space((stream_ptr)),                                 \
        ((stream_ptr)->wbuf[(size_t) (stream_ptr)->wbuf_dlen++] = (ch)))     \
    : ((stream_ptr)->wbuf_dlen == stream_ptr->wbuf_size ?                    \
        (acl_vstream_fflush((stream_ptr)) == ACL_VSTREAM_EOF ?               \
          ACL_VSTREAM_EOF                                                    \
          : ((stream_ptr)->wbuf[(size_t) (stream_ptr)->wbuf_dlen++] = (ch))) \
        : ((stream_ptr)->wbuf[(size_t) (stream_ptr)->wbuf_dlen++] = (ch))))

向流中写一个字节的宏实现

参数

stream_ptr {ACL_VSTREAM*} 数据流指针

返回: {int} ACL_VSTREAM_EOF(出错) 或所写入字节的 ASCII

在文件 acl_vstream.h 第 813 行定义.

◆ acl_vstream_readline

#define acl_vstream_readline acl_vstream_gets

在文件 acl_vstream.h 第 440 行定义.

◆ ACL_VSTREAM_SET_EOF

#define ACL_VSTREAM_SET_EOF ( stream_ptr )

值:

do {                  \
        ACL_VSTREAM *__stream_ptr = stream_ptr;               \
        __stream_ptr->flag |= ACL_VSTREAM_FLAG_EOF;           \
} while (0)

将流置为结束状态

参数

stream_ptr {ACL_VSTREAM*) 类型的指针

在文件 acl_vstream.h 第 941 行定义.

◆ ACL_VSTREAM_SET_FILE

#define ACL_VSTREAM_SET_FILE	(	stream_ptr,
		_fh
	)

值:

do {            \
        ACL_VSTREAM *__stream_ptr = stream_ptr;               \
        __stream_ptr->fd.h_file = _fh;                        \
} while (0)

设置流中的文件句柄

参数

stream_ptr	{ACL_VSTREAM*}
_fh	{ACL_FILE_HANDLE}

在文件 acl_vstream.h 第 912 行定义.

◆ ACL_VSTREAM_SET_MS

#define ACL_VSTREAM_SET_MS ( x ) ((x)->flag |= ACL_VSTREAM_FLAG_MS)

在文件 acl_vstream.h 第 132 行定义.

◆ ACL_VSTREAM_SET_NS

#define ACL_VSTREAM_SET_NS ( x ) ((x)->flag |= ACL_VSTREAM_FLAG_NS)

在文件 acl_vstream.h 第 136 行定义.

◆ ACL_VSTREAM_SET_RWTIMO

#define ACL_VSTREAM_SET_RWTIMO	(	stream_ptr,
		_rw_timeo
	)

值:

do {    \
        ACL_VSTREAM *__stream_ptr  = stream_ptr;              \
        __stream_ptr->rw_timeout = _rw_timeo;                 \
} while (0)

设定流的读写超时值

参数

stream_ptr	{ACL_VSTREAM*) 类型的指针
_rw_timeo	{int} 超时值大小(以秒为单位)

在文件 acl_vstream.h 第 932 行定义.

◆ ACL_VSTREAM_SET_SOCK

#define ACL_VSTREAM_SET_SOCK	(	stream_ptr,
		_fd
	)

值:

do {            \
        ACL_VSTREAM *__stream_ptr = stream_ptr;               \
        __stream_ptr->fd.sock   = _fd;                        \
} while (0)

设定流的读/写套接字

参数

stream_ptr	{ACL_VSTREAM*}
_fd	{ACL_SOCKET} 套接字

在文件 acl_vstream.h 第 902 行定义.

◆ ACL_VSTREAM_SET_US

#define ACL_VSTREAM_SET_US ( x ) ((x)->flag |= ACL_VSTREAM_FLAG_US)

在文件 acl_vstream.h 第 134 行定义.

◆ ACL_VSTREAM_SOCK

#define ACL_VSTREAM_SOCK ( stream_ptr ) ((stream_ptr)->fd.sock)

由流获得套接字

参数

stream_ptr {ACL_VSTREAM*}

在文件 acl_vstream.h 第 827 行定义.

◆ ACL_VSTREAM_TYPE_FILE

#define ACL_VSTREAM_TYPE_FILE (1 << 1)

在文件 acl_vstream.h 第 75 行定义.

◆ ACL_VSTREAM_TYPE_INET4

#define ACL_VSTREAM_TYPE_INET4 (1 << 6)

在文件 acl_vstream.h 第 80 行定义.

◆ ACL_VSTREAM_TYPE_INET6

#define ACL_VSTREAM_TYPE_INET6 (1 << 7)

在文件 acl_vstream.h 第 81 行定义.

◆ ACL_VSTREAM_TYPE_LISTEN

#define ACL_VSTREAM_TYPE_LISTEN (1 << 2)

在文件 acl_vstream.h 第 76 行定义.

◆ ACL_VSTREAM_TYPE_LISTEN_INET

#define ACL_VSTREAM_TYPE_LISTEN_INET (1 << 3)

在文件 acl_vstream.h 第 77 行定义.

◆ ACL_VSTREAM_TYPE_LISTEN_IOCP

#define ACL_VSTREAM_TYPE_LISTEN_IOCP (1 << 5)

在文件 acl_vstream.h 第 79 行定义.

◆ ACL_VSTREAM_TYPE_LISTEN_UNIX

#define ACL_VSTREAM_TYPE_LISTEN_UNIX (1 << 4)

在文件 acl_vstream.h 第 78 行定义.

◆ ACL_VSTREAM_TYPE_SOCK

#define ACL_VSTREAM_TYPE_SOCK (1 << 0)

在文件 acl_vstream.h 第 74 行定义.

◆ ACL_VSTREAM_TYPE_UNIX

#define ACL_VSTREAM_TYPE_UNIX (1 << 8)

在文件 acl_vstream.h 第 82 行定义.

类型定义说明

◆ ACL_FSTREAM_RD_FN

typedef int(* ACL_FSTREAM_RD_FN) (ACL_FILE_HANDLE fh, void *buf, size_t size, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 50 行定义.

◆ ACL_FSTREAM_WR_FN

typedef int(* ACL_FSTREAM_WR_FN) (ACL_FILE_HANDLE fh, const void *buf, size_t size, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 52 行定义.

◆ ACL_FSTREAM_WV_FN

typedef int(* ACL_FSTREAM_WV_FN) (ACL_FILE_HANDLE fh, const struct iovec *vec, int count, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 54 行定义.

◆ ACL_VSTREAM

typedef struct ACL_VSTREAM ACL_VSTREAM

在文件 acl_vstream.h 第 42 行定义.

◆ ACL_VSTREAM_CLOSE_HANDLE

typedef struct ACL_VSTREAM_CLOSE_HANDLE ACL_VSTREAM_CLOSE_HANDLE

◆ ACL_VSTREAM_RD_FN

typedef int(* ACL_VSTREAM_RD_FN) (ACL_SOCKET fd, void *buf, size_t size, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 44 行定义.

◆ ACL_VSTREAM_WR_FN

typedef int(* ACL_VSTREAM_WR_FN) (ACL_SOCKET fd, const void *buf, size_t size, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 46 行定义.

◆ ACL_VSTREAM_WV_FN

typedef int(* ACL_VSTREAM_WV_FN) (ACL_SOCKET fd, const struct iovec *vec, int count, int timeout, ACL_VSTREAM *fp, void *context)

在文件 acl_vstream.h 第 48 行定义.

函数说明

◆ acl_file_ftruncate()

ACL_API int acl_file_ftruncate	(	ACL_VSTREAM *	fp,
		acl_off_t	length
	)

将源文件进程截断

参数

fp	{ACL_VSTREAM*} 数据流指针
length	{acl_off_t} 数据长度(>=0)

返回: {int} 0: ok, -1: error

◆ acl_file_truncate()

ACL_API int acl_file_truncate	(	const char *	path,
		acl_off_t	length
	)

将源文件进程截断

参数

path	{const char*} 文件名(可以是全路径或相对路径)
length	{acl_off_t} 数据长度(>=0)

返回: {int} 0: ok, -1: error

◆ ACL_PRINTF()

ACL_API int ACL_PRINTF	(	2	,
		3
	)

缓冲带格式的流输出, 类似于 fprintf()

参数

fp	{ACL_VSTREAM*} 数据流
fmt	{const char*} 数据格式
...	变参序列

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 dlen 个字节的数据

带格式的流输出, 类似于 fprintf()

参数

fp	{ACL_VSTREAM*} 数据流
fmt	{const char*} 数据格式
...	变参序列

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 dlen 个字节的数据

◆ acl_socket_close_hook()

ACL_API void acl_socket_close_hook ( int(*)(ACL_SOCKET) close_fn )

◆ acl_socket_read_hook()

ACL_API void acl_socket_read_hook ( ACL_VSTREAM_RD_FN read_fn )

◆ acl_socket_write_hook()

ACL_API void acl_socket_write_hook ( ACL_VSTREAM_WR_FN write_fn )

◆ acl_socket_writev_hook()

ACL_API void acl_socket_writev_hook ( ACL_VSTREAM_WV_FN writev_fn )

◆ acl_vstream_add_close_handle()

ACL_API void acl_vstream_add_close_handle	(	ACL_VSTREAM *	fp,
		void()(ACL_VSTREAM , void *)	close_fn,
		void *	context
	)

注册一个关闭函数

参数

fp	{ACL_VSTREAM*} 数据流
close_fn	{void ()(ACL_VSTREAM, void*)} 关闭函数指针
context	{void*} close_fn 所需要的参数

◆ acl_vstream_add_object()

ACL_API int acl_vstream_add_object	(	ACL_VSTREAM *	fp,
		const char *	key,
		void *	obj
	)

◆ acl_vstream_bfcp_some()

ACL_API int acl_vstream_bfcp_some	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen
	)

将缓冲区内的数据拷贝到 vptr 中

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{void*} 用户的数据缓冲区指针地址
maxlen	{size_t} vptr 数据缓冲区的空间大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示出错, 应该关闭本地数据流, ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据

◆ acl_vstream_buffed_fputs()

ACL_API int acl_vstream_buffed_fputs	(	const char *	s,
		ACL_VSTREAM *	fp
	)

向流缓冲区中写入一行数据

参数

s	{const char*} 源字符串
fp	{ACL_VSTREAM*} 数据流

返回: {int} 0 成功; ACL_VSTREAM_EOF 失败

◆ acl_vstream_buffed_printf()

ACL_API int const char ACL_API int acl_vstream_buffed_printf	(	const char *	,
			...
	)

向标准输出打印信息

参数

... 变参序列

返回: {int}, ACL_VSTREAM_EOF: 表示写出错, > 0: 表示成功写了 dlen 个字节的数据

◆ acl_vstream_buffed_puts()

ACL_API int acl_vstream_buffed_puts ( const char * s )

向标准输出流缓冲区中写入一行数据

参数

s	{const char*} 源字符串

返回: {int} 0 成功; ACL_VSTREAM_EOF 失败

◆ acl_vstream_buffed_space()

ACL_API void acl_vstream_buffed_space ( ACL_VSTREAM * fp )

对于带缓冲方式的写，该函数保证缓冲区空间非空

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_buffed_vfprintf()

ACL_API int acl_vstream_buffed_vfprintf	(	ACL_VSTREAM *	fp,
		const char *	fmt,
		va_list	ap
	)

缓冲带格式的流输出, 类似于 vfprintf()

参数

fp	{ACL_VSTREAM*} 数据流
fmt	{const char*} 数据格式
ap	{va_list}

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 dlen 个字节的数据

◆ acl_vstream_buffed_writen()

ACL_API int acl_vstream_buffed_writen	(	ACL_VSTREAM *	fp,
		const void *	vptr,
		size_t	dlen
	)

带缓冲式写

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{const void*} 数据指针起始位置
dlen	{size_t} 要写入的数据量

返回: {int} 写入的数据量或出错 ACL_VSTREAM_EOF

◆ acl_vstream_call_close_handles()

ACL_API void acl_vstream_call_close_handles ( ACL_VSTREAM * fp )

调用数据流中的所有关闭回调函数同时清除这些回调函数

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_can_read()

ACL_API int acl_vstream_can_read ( ACL_VSTREAM * fp )

检查 ACL_VSTREAM 流是否可读或出错

参数

fp	{ACL_VSTREAM*} 数据流

返回: {int} 0: 表示无数据可读; ACL_VSTREAM_EOF 表示出错; > 0 表示有数据可读

◆ acl_vstream_clean_close_handle()

ACL_API void acl_vstream_clean_close_handle ( ACL_VSTREAM * fp )

清除一个数据流中所有的关闭句柄

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_clone()

ACL_API ACL_VSTREAM* acl_vstream_clone ( const ACL_VSTREAM * stream_src )

克隆一个ACL_VSTREAM流，除ioctl_read_ctx, ioctl_write_ctx, fdp 外所有数据都拷贝，如果是动态内存数据，则新的流将在内部动态分配内存且将源数据进行拷贝

参数

stream_src {ACL_VSTREAM*} 源流指针

返回: {ACL_VSTREAM*} 目的流指针

◆ acl_vstream_close()

ACL_API int acl_vstream_close ( ACL_VSTREAM * fp )

释放一个数据流的内存空间并关闭其所携带的 socket 描述符

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_ctl()

ACL_API void acl_vstream_ctl	(	ACL_VSTREAM *	fp,
		int	name,
			...
	)

设置流的各个参数

参数

fp	{ACL_VSTREAM*} 流指针
name	{int} 所设置的参数类型中的第一个参数类型名, defined as ACL_VSTREAM_CTL_

◆ acl_vstream_del_object()

ACL_API int acl_vstream_del_object	(	ACL_VSTREAM *	fp,
		const char *	key
	)

◆ acl_vstream_delete_close_handle()

ACL_API void acl_vstream_delete_close_handle	(	ACL_VSTREAM *	fp,
		void()(ACL_VSTREAM , void *)	close_fn,
		void *	context
	)

删除一个关闭句柄.

参数

fp	{ACL_VSTREAM*} 数据流
close_fn	{void ()(ACL_VSTREAM, void*)} 关闭函数指针
context	{void*} close_fn 所需要的参数

◆ acl_vstream_fdopen()

ACL_API ACL_VSTREAM* acl_vstream_fdopen	(	ACL_SOCKET	fd,
		unsigned int	oflags,
		size_t	buflen,
		int	rw_timeo,
		int	fdtype
	)

分配一个数据流

参数

fd	{ACL_SOCKET} 描述符(可以为网络描述字也可以为文件描述字)
oflags	{unsigned int} 标志位, We're assuming that O_RDONLY: 0x0000, O_WRONLY: 0x0001, O_RDWR: 0x0002, O_APPEND: 0x0008, O_CREAT: 0x0100, O_TRUNC: 0x0200, O_EXCL: 0x0400; just for win32, O_TEXT: 0x4000, O_BINARY: 0x8000, O_RAW: O_BINARY, O_SEQUENTIAL: 0x0020, O_RANDOM: 0x0010.
buflen	{size_t} 内置缓冲区的大小
rw_timeo	{int} 读写超时时间(以秒为单位)
fdtype	{int} ACL_VSTREAM_TYPE_FILE, ACL_VSTREAM_TYPE_SOCK, ACL_VSTREAM_TYPE_LISTEN \| ACL_VSTREAM_TYPE_LISTEN_INET \| ACL_VSTREAM_TYPE_LISTEN_UNIX

返回: ret {ACL_VSTREAM*}, ret == NULL: 出错, ret != NULL: OK

◆ acl_vstream_fflush()

ACL_API int acl_vstream_fflush ( ACL_VSTREAM * fp )

刷新写缓冲区里的数据

参数

fp	socket 数据流

返回: 刷新写缓冲区里的数据量或出错 ACL_VSTREAM_EOF

◆ acl_vstream_fhopen()

ACL_API ACL_VSTREAM* acl_vstream_fhopen	(	ACL_FILE_HANDLE	fh,
		unsigned int	oflags
	)

分配一文件句柄所对应的数据流

参数

fh	{ACL_FILE_HANDLE} 文件句柄
oflags	{unsigned int} 标志位, We're assuming that O_RDONLY: 0x0000, O_WRONLY: 0x0001, O_RDWR: 0x0002, O_APPEND: 0x0008, O_CREAT: 0x0100, O_TRUNC: 0x0200, O_EXCL: 0x0400; just for win32, O_TEXT: 0x4000, O_BINARY: 0x8000, O_RAW: O_BINARY, O_SEQUENTIAL: 0x0020, O_RANDOM: 0x0010. 同时设置

返回: {ACL_VSTREAM*} 数据流句柄

◆ acl_vstream_fopen()

ACL_API ACL_VSTREAM* acl_vstream_fopen	(	const char *	path,
		unsigned int	oflags,
		int	mode,
		size_t	buflen
	)

打开一个文件的数据流

参数

path	{const char*} 文件名
oflags	{unsigned int} 标志位, We're assuming that O_RDONLY: 0x0000, O_WRONLY: 0x0001, O_RDWR: 0x0002, O_APPEND: 0x0008, O_CREAT: 0x0100, O_TRUNC: 0x0200, O_EXCL: 0x0400; just for win32, O_TEXT: 0x4000, O_BINARY: 0x8000, O_RAW: O_BINARY, O_SEQUENTIAL: 0x0020, O_RANDOM: 0x0010.
mode	{int} 打开文件句柄时的模式(如: 0600)
buflen	{size_t} 内置缓冲区的大小

返回: ret {ACL_VSTREAM*}, ret== NULL: 出错, ret != NULL: OK

◆ acl_vstream_fputs()

ACL_API int acl_vstream_fputs	(	const char *	s,
		ACL_VSTREAM *	fp
	)

向流中写入一行数据

参数

s	{const char*} 源字符串
fp	{ACL_VSTREAM*} 数据流

返回: {int} 0 成功; ACL_VSTREAM_EOF 失败

◆ acl_vstream_free()

ACL_API void acl_vstream_free ( ACL_VSTREAM * fp )

释放一个数据流的内存空间, 但并不关闭 socket 描述符

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_fseek()

ACL_API acl_off_t acl_vstream_fseek	(	ACL_VSTREAM *	fp,
		acl_off_t	offset,
		int	whence
	)

定位文件指针

参数

fp	{ACL_VSTREAM*} 数据流指针
offset	{acl_off_t} 偏移量
whence	{int} 偏移方向, SEEK_SET, SEEK_CUR, SEEK_END

返回: ret {acl_off_t}, ret >= 0: 正确, ret < 0: 出错注： acl_vstream_fseek() 效率更高些, 其充分利用了缓冲区的功能, 且比 acl_vstream_fseek2() 少调用一次 lseek() 系统调用.

◆ acl_vstream_fseek2()

ACL_API acl_off_t acl_vstream_fseek2	(	ACL_VSTREAM *	fp,
		acl_off_t	offset,
		int	whence
	)

定位文件指针

参数

fp	{ACL_VSTREAM*} 数据流指针
offset	{acl_off_t} 偏移量
whence	{int} 移动方向：SEEK_SET（从文件起始位置后移动）, SEEK_CUR（从当前文件指针位置向后移动）, SEEK_END（从文件尾向前移动）

返回: ret {acl_off_t}, ret >= 0: 正确, ret < 0: 出错 @DEPRECATED 该函数的效率较低

◆ acl_vstream_fsize()

ACL_API acl_int64 acl_vstream_fsize ( ACL_VSTREAM * fp )

查看一个文件的大小

参数

fp	{ACL_VSTREAM *} 文件流句柄

返回: {int} >= 0: ok; -1: error

◆ acl_vstream_fstat()

ACL_API int acl_vstream_fstat	(	ACL_VSTREAM *	fp,
		struct acl_stat *	buf
	)

查看一个文件流句柄的属性

参数

fp	{ACL_VSTREAM *} 文件流句柄
buf	{acl_stat *} 存储结果的结构地址

返回: {int} 0: ok; -1: error

◆ acl_vstream_fsync()

ACL_API int acl_vstream_fsync ( ACL_VSTREAM * fp )

将文件流中的系统缓冲区及流缓冲区中的数据都直接同步至硬盘

参数

fp	{ACL_VSTREAM*} 文件流指针

返回: {int} 0: ok; ACL_VSTREAM_EOF: error

◆ acl_vstream_ftell()

ACL_API acl_off_t acl_vstream_ftell ( ACL_VSTREAM * fp )

返回当前文件指针所在位置

参数

fp	{ACL_VSTREAM*} 数据流指针

返回: {acl_off_t} 当前文件指针所在位置, -1 表示出错

◆ acl_vstream_get_object()

ACL_API void* acl_vstream_get_object	(	ACL_VSTREAM *	fp,
		const char *	key
	)

◆ acl_vstream_getc()

ACL_API int acl_vstream_getc ( ACL_VSTREAM * fp )

从流中读取一个字节

参数

fp	{ACL_VSTREAM*} 数据流指针

返回: {int} ACL_VSTREAM_EOF(出错) 或所读到的某个字节的ASCII 或为 ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭该数据流

◆ acl_vstream_gets()

ACL_API int acl_vstream_gets	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen
	)

从数据流中读取一行数据, 直到读到 "\n" 或读结束为止, 正常情况下包括 "\n"

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{void*} 用户所给的内存缓冲区指针
maxlen	{size_t} vptr 缓冲区的大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭本地数据流; n > 0: 读到了 n 个字节的数据, 如果该 n 个数据的最后一个非 0 字符为 "\n" 表明读到了一个完整的行, 否则表明读到了 n 个数据但对方未发送 "\n" 就关闭了连接; 还可以通过检查 (fp->flag & ACL_VSTREAM_FLAG_TAGYES) 不等于 0 来判断是否读到了 "\n", 如果非 0 则表示读到了 "\n".

◆ acl_vstream_gets_nonl()

ACL_API int acl_vstream_gets_nonl	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen
	)

从数据流中读取一行数据, 直到读到 "\n" 或读结束为止, 返回的结果中不包括 "\n"

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{void*} 用户所给的内存缓冲区指针
maxlen	{size_t} vptr 缓冲区的大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭本地数据流, n == 0: 读到了一行数据, 但该行数据仅有 "\r\n", n > 0: 读到了 n 个字节的数据.

◆ acl_vstream_gets_nonl_peek()

ACL_API int acl_vstream_gets_nonl_peek	(	ACL_VSTREAM *	fp,
		ACL_VSTRING *	buf,
		int *	ready
	)

一次性从 ACL_VSTREAM 流或系统缓存区中读取一行数据, 如果未读到回车换行符, 也将数据拷贝至用户的内存缓冲区, 如果读到回车换行符便将回车换行符自动去掉, 并将回车换行符前的数据拷贝至用户内存区.

参数

fp	{ACL_VSTREAM*} 数据流
buf	{ACL_VSTRING*} 数据缓冲区，当 buf->maxlen > 0 时，则限制每行数据的长度，即当 buf 中的数据长度达到 maxlen 时，即使没有读到完整一行数据，该函数也会返回，且会将 ready 置 1，调用者需调用 fp->flag 标志位中是否包含 ACL_VSTREAM_FLAG_TAGYES 来判断是否读到一行数据
ready	{int*} 是否按要求读到所需数据的标志位指针, 不能为空

返回: ret {int}, ret == ACL_VSTREAM_EOF 时，如果 acl_last_error() 系统错误号为 ACL_EWOULDBLOCK 或 ACL_EAGAIN，则表示在非阻塞套接字上未读到数据，否则，表示出错，应该关闭该流对象； ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据, 如果仅读到了一个空行, 则 ret == 0.

◆ acl_vstream_gets_peek()

ACL_API int acl_vstream_gets_peek	(	ACL_VSTREAM *	fp,
		ACL_VSTRING *	buf,
		int *	ready
	)

一次性从 ACL_VSTREAM 流或系统缓存区中读取一行数据, 包括回车换行符 (调用者自行解决WINDOWS与UNIX对于回车换行的兼容性问题), 如果未读到回车换行符, 也将数据拷贝至用户的内存缓冲区.

参数

fp	{ACL_VSTREAM*} 数据流
buf	{ACL_VSTRING*} 数据缓冲区，当 buf->maxlen > 0 时，则限制每行数据的长度，即当 buf 中的数据长度达到 maxlen 时，即使没有读到完整一行数据，该函数也会返回，且会将 ready 置 1，调用者需调用 fp->flag 标志位中是否包含 ACL_VSTREAM_FLAG_TAGYES 来判断是否读到一行数据
ready	{int*} 是否按要求读到所需数据的标志位指针, 不能为空

返回: ret {int}, ret == ACL_VSTREAM_EOF 时，如果 acl_last_error() 系统错误号为 ACL_EWOULDBLOCK 或 ACL_EAGAIN，则表示在非阻塞套接字上未读到数据，否则，表示出错，应该关闭该流对象； ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据

◆ acl_vstream_init()

ACL_API void acl_vstream_init ( void )

初始化ACL_VSTREAM流的函数库对于_WIN32来说，如果想要用标准输入输出，则需要调用此函数进行初始化

◆ acl_vstream_loadfile()

ACL_API char* acl_vstream_loadfile ( const char * path )

读取整个文件内容于内存中

参数

path	{const char*} 文件名, 如: /opt/acl/conf/service/test.cf

返回: {char*} 存有文件全部内容的缓冲区, 用完后用户需要调用 acl_myfree 释放该内存区

◆ acl_vstream_loadfile2()

ACL_API char* acl_vstream_loadfile2	(	const char *	path,
		ssize_t *	size
	)

读取整个文件内容于内存中

参数

path	{const char*} 文件名, 如: /opt/acl/conf/service/test.cf
size	{ssize_t*} 如果非空，则该值存储返回的缓冲区大小，如果读取内容出错，则该值会被置 -1

返回: {char*} 存有文件全部内容的缓冲区, 用完后用户需要调用 acl_myfree 释放该内存区

◆ acl_vstream_nonb_readn()

ACL_API int acl_vstream_nonb_readn	(	ACL_VSTREAM *	fp,
		char *	buf,
		int	size
	)

从流中非阻塞地一次性最大读取 size 个字节

参数

fp	{ACL_VSTREAM*} 数据流指针
buf	{char*} 用户传来的内存缓存区
size	{int} buf 缓存区的空间大小

返回: {int} 所读取的字节数 n, 如果 n == ACL_VSTREAM_EOF 表明出错, 否则 n >= 0 正确.

◆ acl_vstream_peekfd()

ACL_API int acl_vstream_peekfd ( ACL_VSTREAM * fp )

功能: 探测流中有多少数据, 包含缓冲区中的数据与系统缓冲区的数据

参数

fp	{ACL_VSTREAM*} 流指针, 不能为空

返回: ret {int}, ret > 0 OK; ret <= 0 Error 注: 仅适应于网络套接字

◆ acl_vstream_printf()

ACL_API int const char ACL_API int acl_vstream_printf	(	const char *	,
			...
	)

向标准输出打印信息

参数

... 变参序列

返回: {int}, ACL_VSTREAM_EOF: 表示写出错, > 0: 表示成功写了 dlen 个字节的数据

◆ acl_vstream_probe_status()

ACL_API int acl_vstream_probe_status ( ACL_VSTREAM * fp )

判断一个给定的数据流是否已经被系统关闭了，当数据流缓存区没有数据时，该函数会调用系统的读函数（即读一个字节）来判断是否socket出错或已经关闭；如成功读取一个字节，则说明socket正常，同时将所读的数据放回缓存区, 如果读返回ACL_VSTREAM_EOF, 便需要判断错误号是否被关闭

参数

fp	{ACL_VSTREAM*} 数据流指针

返回: {int}, 0 说明该socket正常; -1 该socket出错或已经被系统关闭

◆ acl_vstream_puts()

ACL_API int acl_vstream_puts ( const char * s )

向标准输出流中写入一行数据

参数

s	{const char*} 源字符串

返回: {int} 0 成功; ACL_VSTREAM_EOF 失败

◆ acl_vstream_read()

ACL_API int acl_vstream_read	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen
	)

从数据流中一次性读取 n 个数据, 该 n 有可能会小于用户所需要的 maxlen

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{void*} 用户的数据缓冲区指针地址
maxlen	{size_t} vptr 数据缓冲区的空间大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示出错, 应该关闭本地数据流, ret > 0: 表示读到了 ret 个字节的数据注: 如果缓冲区内有数据, 则直接把缓冲区内的数据复制到用户的缓冲区然后直接返回; 如果缓冲区内无数据, 则需要调用系统读操作(有可能会阻塞在系统读操作上), 该次调用返回后则把读到数据复制到用户缓冲区返回. 在这两种情况下都不能保证读到的字节数等于所要求的字节数, 若想读到所要求的字节后才返回则请调用 vstream_loop_readn() 函数.

◆ acl_vstream_read_peek()

ACL_API int acl_vstream_read_peek	(	ACL_VSTREAM *	fp,
		ACL_VSTRING *	buf
	)

一次性从 ACL_VSTREAM 流或系统缓存区中读取不固定长度的数据

参数

fp	{ACL_VSTREAM*} 数据流
buf	{ACL_VSTRING*} 数据缓冲区

返回: ret {int}, ret == ACL_VSTREAM_EOF 时，如果 acl_last_error() 系统错误号为 ACL_EWOULDBLOCK 或 ACL_EAGAIN，则表示在非阻塞套接字上未读到数据，否则，表示出错，应该关闭该流对象； ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据.

◆ acl_vstream_read_peek3()

ACL_API int acl_vstream_read_peek3	(	ACL_VSTREAM *	fp,
		void *	buf,
		size_t	size
	)

一次性从 ACL_VSTREAM 流或系统缓存区中读取不固定长度的数据

参数

fp	{ACL_VSTREAM*} 数据流
buf	{void*} 数据缓冲区
size	{size_t} buf 长度

返回: ret {int}, ret == ACL_VSTREAM_EOF 时，如果 acl_last_error() 系统错误号为 ACL_EWOULDBLOCK 或 ACL_EAGAIN，则表示在非阻塞套接字上未读到数据，否则，表示出错，应该关闭该流对象； ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据.

◆ acl_vstream_readn()

ACL_API int acl_vstream_readn	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen
	)

循环读取 maxlen 个数据, 直到读到 maxlen 个字节为止或读出错

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{void*} 用户的数据缓冲区指针地址
maxlen	{size_t} vptr 数据缓冲区的空间大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭本地数据流 n > 0: 成功读取了 maxlen 个字节的数据如果实际读取的字节数与 maxlen 不相等也返回错误(ACL_VSTREAM_EOF)

◆ acl_vstream_readn_peek()

ACL_API int acl_vstream_readn_peek	(	ACL_VSTREAM *	fp,
		ACL_VSTRING *	buf,
		int	cnt,
		int *	ready
	)

一次性从 ACL_VSTREAM 流或系统缓存区中读取固定长度的数据, 如果未读到所要求的数据, 也将数据拷贝至用户内存缓冲区, 如果读到所要求的数据, 则将 ready 标志位置位.

参数

fp	{ACL_VSTREAM*} 数据流
buf	{ACL_VSTRING*} 数据缓冲区
cnt	{int} 所需要读的数据的长度
ready	{int*} 是否按要求读到所需数据的标志位指针, 不能为空

返回: ret {int}, ret == ACL_VSTREAM_EOF 时，如果 acl_last_error() 系统错误号为 ACL_EWOULDBLOCK 或 ACL_EAGAIN，则表示在非阻塞套接字上未读到数据，否则，表示出错，应该关闭该流对象； ret >= 0: 成功从 fp 数据流的缓冲区中读取了 ret 个字节的数据, (*ready) != 0: 表示读到了所要求长度的数据.

◆ acl_vstream_readtags()

ACL_API int acl_vstream_readtags	(	ACL_VSTREAM *	fp,
		void *	vptr,
		size_t	maxlen,
		const char *	tag,
		size_t	taglen
	)

从数据流中获得以字符串为标志结束位的内容

参数

fp	{ACL_VSTREAM*} 类型指针
vptr	{void*} 数据存储缓冲区
maxlen	{size_t} vptr 缓冲区大小
tag	{const char*} 字符串标志
taglen	{size_t} tag 中内容的长度大小

返回: ret {int}, ret == ACL_VSTREAM_EOF: 读出错或对方关闭了连接, 应该关闭本地数据流, n > 0: 读到了 n 个字节的数据, 如果读到了所需要的标志串, 则 fp 流中 (fp->flag & ACL_VSTREAM_FLAG_TAGYES) 不等于 0.

◆ acl_vstream_reset()

ACL_API void acl_vstream_reset ( ACL_VSTREAM * fp )

重新复位数据流的内部数据指针及计数值

参数

fp	{ACL_VSTREAM*} 数据流

◆ acl_vstream_set_fdtype()

ACL_API int acl_vstream_set_fdtype	(	ACL_VSTREAM *	fp,
		int	type
	)

设置数据流的类型，该函数将根据所给类型设定用于该数据流上的读、写、关闭函数

参数

fp	{ACL_VSTREAM*} 流指针, 不能为空
type	{int} 数据流的类型，defined above: ACL_VSTREAM_TYPE_XXX

返回: ret {int}, ret >= 0 OK; ret < 0 Error

◆ acl_vstream_set_local()

ACL_API void acl_vstream_set_local	(	ACL_VSTREAM *	fp,
		const char *	addr
	)

当 ACL_VSTREAM 为网络流时，此函数设置本地地址

参数

fp	{ACL_VSTREAM*} 网络流，非空
addr	{const char*} 本地地址，非空

◆ acl_vstream_set_local_addr()

ACL_API int acl_vstream_set_local_addr	(	ACL_VSTREAM *	fp,
		const struct sockaddr *	sa
	)

当 ACL_VSTREAM 为网络流时，此函数设置本地地址

参数

fp	{ACL_VSTREAM*} 网络流，非空
sa	{const sockaddr*} 本地地址，非空

返回: {int} 返回值 == 0 表示成功，< 0 表示失败

◆ acl_vstream_set_path()

ACL_API void acl_vstream_set_path	(	ACL_VSTREAM *	fp,
		const char *	path
	)

当 ACL_VSTREAM 为文件流时，设置文件流的路径

参数

fp	{ACL_VSTREAM*} 文件流
path	{const char*} 文件路径

◆ acl_vstream_set_peer()

ACL_API void acl_vstream_set_peer	(	ACL_VSTREAM *	fp,
		const char *	addr
	)

当 ACL_VSTREAM 为网络流时，此函数设置远程连接地址

参数

fp	{ACL_VSTREAM*} 网络流，非空
addr	{const char*} 远程连接地址，非空

◆ acl_vstream_set_peer_addr()

ACL_API int acl_vstream_set_peer_addr	(	ACL_VSTREAM *	fp,
		const struct sockaddr *	sa
	)

当 ACL_VSTREAM 为网络流时，此函数设置远程连接地址

参数

fp	{ACL_VSTREAM*} 网络流，非空
sa	{const struct sockaddr *} 远程连接地址，非空

返回: {int} 返回值 == 0 表示成功，< 0 表示失败

◆ acl_vstream_strerror()

ACL_API const char* acl_vstream_strerror ( ACL_VSTREAM * fp )

取得当前数据流的错误状态

参数

fp	{ACL_VSTREAM*} 数据流

返回: {const char*} 错误描述

◆ acl_vstream_ungetc()

ACL_API int acl_vstream_ungetc	(	ACL_VSTREAM *	fp,
		int	ch
	)

将一个字符放回数据流中

参数

fp	{ACL_VSTREAM*} 数据流指针
ch	{int} 字符的 ASCII 码

返回: {int} 字符的 ASCII 码, 该函数应不会出错, 除非内部内存分配失败而产生 core 文件.

◆ acl_vstream_unread()

ACL_API int acl_vstream_unread	(	ACL_VSTREAM *	fp,
		const void *	ptr,
		size_t	length
	)

将指定长度的数据放回至数据流中

参数

fp	{ACL_VSTREAM*} 数据流指针
ptr	{const void *} 需要放回至流中的数据的起始地址
length	{size_t} 需要放回至流中的数据的长度

返回: {int} 被成功放回至流中的数据长度, 应该永不会出错, 除非内部内存分配失败而自动产生 core 文件!

◆ acl_vstream_vfprintf()

ACL_API int acl_vstream_vfprintf	(	ACL_VSTREAM *	fp,
		const char *	fmt,
		va_list	ap
	)

带格式的流输出, 类似于 vfprintf()

参数

fp	{ACL_VSTREAM*} 数据流
fmt	{const char*} 数据格式
ap	{va_list}

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 dlen 个字节的数据

◆ acl_vstream_write()

ACL_API int acl_vstream_write	(	ACL_VSTREAM *	fp,
		const void *	vptr,
		int	dlen
	)

一次性写入流操作, 返回实际写入的字节数.

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{const void*} 数据区指针地址
dlen	{int} 待写的数据区数据长度

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 ret 个字节的数据

◆ acl_vstream_writen()

ACL_API int acl_vstream_writen	(	ACL_VSTREAM *	fp,
		const void *	vptr,
		size_t	dlen
	)

循环向数据流中写 dlen 个字节的数据直至写完或出错为止

参数

fp	{ACL_VSTREAM*} 数据流
vptr	{const char*} 数据区指针地址
dlen	{size_t} 待写的数据区数据长度

返回: ret {int}, ret == ACL_VSTREAM_EOF: 表示写出错, 应该关闭本地数据流, ret > 0: 表示成功写了 dlen 个字节的数据

◆ acl_vstream_writev()

ACL_API int acl_vstream_writev	(	ACL_VSTREAM *	fp,
		const struct iovec *	vector,
		int	count
	)

一次性写入流操作，采用 writev 模式，返回实际写入的字节数

参数

fp	{ACL_VSTREAM*}
vector	{const struct iovec*}
count	{int} vector 数组的长度

返回: {int} 返回成功写入的字节数，如果出错，则返回 ACL_VSTREAM_EOF

◆ acl_vstream_writevn()

ACL_API int acl_vstream_writevn	(	ACL_VSTREAM *	fp,
		const struct iovec *	vector,
		int	count
	)

采用 writev 模式往流中写，直至全部数据写完为止或出错

参数

fp	{ACL_VSTREAM*}
vector	{const struct iovec*}
count	{int} vector 数组的长度

返回: {int} 返回成功写入的字节数，如果出错，则返回 ACL_VSTREAM_EOF

变量说明

◆ acl_vstream_fstd

ACL_API ACL_VSTREAM acl_vstream_fstd[]

pre-defined streams

◆ fmt

ACL_API int const char* fmt

在文件 acl_vstream.h 第 633 行定义.