apr_file_io.h

Go to the documentation of this file.

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef APR_FILE_IO_H
#define APR_FILE_IO_H
 
#include "apr.h"
#include "apr_pools.h"
#include "apr_time.h"
#include "apr_errno.h"
#include "apr_file_info.h"
#include "apr_inherit.h"
 
#define APR_WANT_STDIO          
#define APR_WANT_IOVEC          
#include "apr_want.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/* Note to implementors: Values in the range 0x00100000--0x80000000
   are reserved for platform-specific values. */
 
#define APR_FOPEN_READ       0x00001  
#define APR_FOPEN_WRITE      0x00002  
#define APR_FOPEN_CREATE     0x00004  
#define APR_FOPEN_APPEND     0x00008  
#define APR_FOPEN_TRUNCATE   0x00010  
#define APR_FOPEN_BINARY     0x00020  
#define APR_FOPEN_EXCL       0x00040  
#define APR_FOPEN_BUFFERED   0x00080  
#define APR_FOPEN_DELONCLOSE 0x00100  
#define APR_FOPEN_XTHREAD    0x00200  
#define APR_FOPEN_SHARELOCK  0x00400  
#define APR_FOPEN_NOCLEANUP  0x00800  
#define APR_FOPEN_SENDFILE_ENABLED 0x01000 
#define APR_FOPEN_LARGEFILE   0x04000 
#define APR_FOPEN_SPARSE      0x08000 
#define APR_FOPEN_ROTATING  0x10000 
#define APR_FOPEN_MANUAL_ROTATE  0x20000 
#define APR_FOPEN_NONBLOCK    0x40000 
/* backcompat */
#define APR_READ             APR_FOPEN_READ       
#define APR_WRITE            APR_FOPEN_WRITE      
#define APR_CREATE           APR_FOPEN_CREATE     
#define APR_APPEND           APR_FOPEN_APPEND     
#define APR_TRUNCATE         APR_FOPEN_TRUNCATE   
#define APR_BINARY           APR_FOPEN_BINARY     
#define APR_EXCL             APR_FOPEN_EXCL       
#define APR_BUFFERED         APR_FOPEN_BUFFERED   
#define APR_DELONCLOSE       APR_FOPEN_DELONCLOSE 
#define APR_XTHREAD          APR_FOPEN_XTHREAD    
#define APR_SHARELOCK        APR_FOPEN_SHARELOCK  
#define APR_FILE_NOCLEANUP   APR_FOPEN_NOCLEANUP  
#define APR_SENDFILE_ENABLED APR_FOPEN_SENDFILE_ENABLED 
#define APR_LARGEFILE        APR_FOPEN_LARGEFILE  
/* flags for apr_file_seek */
#define APR_SET SEEK_SET
#define APR_CUR SEEK_CUR
#define APR_END SEEK_END
/* flags for apr_file_attrs_set */
#define APR_FILE_ATTR_READONLY   0x01          
#define APR_FILE_ATTR_EXECUTABLE 0x02          
#define APR_FILE_ATTR_HIDDEN     0x04          
#if defined(DOXYGEN)
#define APR_MAX_IOVEC_SIZE 1024                
#elif defined(IOV_MAX)
#define APR_MAX_IOVEC_SIZE IOV_MAX
#elif defined(MAX_IOVEC)
#define APR_MAX_IOVEC_SIZE MAX_IOVEC
#else
#define APR_MAX_IOVEC_SIZE 1024
#endif
typedef apr_uint32_t apr_fileattrs_t;
 
typedef int       apr_seek_where_t;
 
typedef struct apr_file_t         apr_file_t;
 
/* File lock types/flags */
#define APR_FLOCK_SHARED        1       
#define APR_FLOCK_EXCLUSIVE     2       
#define APR_FLOCK_TYPEMASK      0x000F  
#define APR_FLOCK_NONBLOCK      0x0010  
APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **newf, const char *fname,
                                        apr_int32_t flag, apr_fileperms_t perm,
                                        apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file);
 
APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_rename(const char *from_path,
                                          const char *to_path,
                                          apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_link(const char *from_path,
                                          const char *to_path);
 
APR_DECLARE(apr_status_t) apr_file_copy(const char *from_path,
                                        const char *to_path,
                                        apr_fileperms_t perms,
                                        apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_append(const char *from_path,
                                          const char *to_path,
                                          apr_fileperms_t perms,
                                          apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr);
 
APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile,
                                               apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile,
                                               apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile,
                                              apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_open_flags_stderr(apr_file_t **thefile,
                                                     apr_int32_t flags,
                                                     apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_open_flags_stdout(apr_file_t **thefile,
                                                     apr_int32_t flags,
                                                     apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_open_flags_stdin(apr_file_t **thefile,
                                                     apr_int32_t flags,
                                                     apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf,
                                        apr_size_t *nbytes);
 
APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf,
                                         apr_size_t *nbytes);
 
APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile,
                                          const struct iovec *vec,
                                          apr_size_t nvec, apr_size_t *nbytes);
 
APR_DECLARE(apr_status_t) apr_file_read_full(apr_file_t *thefile, void *buf,
                                             apr_size_t nbytes,
                                             apr_size_t *bytes_read);
 
APR_DECLARE(apr_status_t) apr_file_write_full(apr_file_t *thefile,
                                              const void *buf,
                                              apr_size_t nbytes,
                                              apr_size_t *bytes_written);
 
 
APR_DECLARE(apr_status_t) apr_file_writev_full(apr_file_t *thefile,
                                               const struct iovec *vec,
                                               apr_size_t nvec,
                                               apr_size_t *nbytes);
APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len,
                                        apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_pipe_wait(apr_file_t *thepipe,
                                             apr_wait_type_t direction);
 
APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_sync(apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_datasync(apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_dup(apr_file_t **new_file,
                                       apr_file_t *old_file,
                                       apr_pool_t *p);
 
APR_DECLARE(apr_status_t) apr_file_dup2(apr_file_t *new_file,
                                        apr_file_t *old_file,
                                        apr_pool_t *p);
 
APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
                                            apr_file_t *old_file,
                                            apr_pool_t *p);
 
APR_DECLARE(apr_status_t) apr_file_buffer_set(apr_file_t *thefile,
                                              char * buffer,
                                              apr_size_t bufsize);
 
APR_DECLARE(apr_size_t) apr_file_buffer_size_get(apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile,
                                   apr_seek_where_t where,
                                   apr_off_t *offset);
 
APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in,
                                               apr_file_t **out,
                                               apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in,
                                                  apr_file_t **out,
                                                  apr_int32_t blocking,
                                                  apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
                                                     apr_file_t **out,
                                                     apr_int32_t blocking,
                                                     apr_pool_t *pool_in,
                                                     apr_pool_t *pool_out);
 
APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename,
                                                    apr_fileperms_t perm,
                                                    apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe,
                                               apr_interval_time_t *timeout);
 
APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe,
                                                  apr_interval_time_t timeout);
 
APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type);
 
APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_name_get(const char **new_path,
                                            apr_file_t *thefile);
 
APR_DECLARE(apr_status_t) apr_file_data_get(void **data, const char *key,
                                            apr_file_t *file);
 
APR_DECLARE(apr_status_t) apr_file_data_set(apr_file_t *file, void *data,
                                            const char *key,
                                            apr_status_t (*cleanup)(void *));
 
APR_DECLARE_NONSTD(int) apr_file_printf(apr_file_t *fptr,
                                        const char *format, ...)
        __attribute__((format(printf,2,3)));
 
APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname,
                                             apr_fileperms_t perms);
 
APR_DECLARE(apr_status_t) apr_file_attrs_set(const char *fname,
                                             apr_fileattrs_t attributes,
                                             apr_fileattrs_t attr_mask,
                                             apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_mtime_set(const char *fname,
                                             apr_time_t mtime,
                                             apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_dir_make(const char *path, apr_fileperms_t perm,
                                       apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_dir_make_recursive(const char *path,
                                                 apr_fileperms_t perm,
                                                 apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_dir_remove(const char *path, apr_pool_t *pool);
 
APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo,
                                            apr_int32_t wanted,
                                            apr_file_t *thefile);
 
 
APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *fp, apr_off_t offset);
 
APR_DECLARE(apr_int32_t) apr_file_flags_get(apr_file_t *f);
 
APR_POOL_DECLARE_ACCESSOR(file);
 
APR_DECLARE_INHERIT_SET(file);
 
APR_DECLARE_INHERIT_UNSET(file);
 
APR_DECLARE(apr_status_t) apr_file_mktemp(apr_file_t **fp, char *templ,
                                          apr_int32_t flags, apr_pool_t *p);
 
 
APR_DECLARE(apr_status_t) apr_temp_dir_get(const char **temp_dir,
                                           apr_pool_t *p);
 
 
APR_DECLARE(apr_status_t) apr_file_rotating_check(apr_file_t *thefile);
APR_DECLARE(apr_status_t) apr_file_rotating_manual_check(apr_file_t *thefile, apr_time_t time);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* ! APR_FILE_IO_H */