diff options
Diffstat (limited to 'rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2')
18 files changed, 1796 insertions, 0 deletions
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/Makefile.in b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/Makefile.in new file mode 100644 index 00000000..a87f4242 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/Makefile.in @@ -0,0 +1,31 @@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +TARGETS = \ + dir.lo \ + fileacc.lo \ + filedup.lo \ + filestat.lo \ + open.lo \ + pipe.lo \ + readwrite.lo \ + seek.lo \ + flock.lo \ + maperrorcode.lo \ + fullrw.lo \ + filepath.lo \ + filepath_util.lo \ + filesys.lo \ + mktemp.lo \ + copy.lo \ + tempdir.lo + +# bring in rules.mk for standard functionality +@INCLUDE_RULES@ + +INCDIR=../../include +OSDIR=$(INCDIR)/arch/@OSDIR@ +DEFOSDIR=$(INCDIR)/arch/@DEFAULT_OSDIR@ +INCLUDES=-I$(INCDIR) -I$(OSDIR) -I$(DEFOSDIR) + +# DO NOT REMOVE diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/copy.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/copy.c new file mode 100644 index 00000000..f4ce010f --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/copy.c @@ -0,0 +1 @@ +#include "../unix/copy.c" diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/dir.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/dir.c new file mode 100644 index 00000000..dc194e3b --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/dir.c @@ -0,0 +1,175 @@ +/* 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. + */ + +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include "apr_strings.h" +#include "apr_portable.h" +#include <string.h> + +static apr_status_t dir_cleanup(void *thedir) +{ + apr_dir_t *dir = thedir; + return apr_dir_close(dir); +} + + + +APR_DECLARE(apr_status_t) apr_dir_open(apr_dir_t **new, const char *dirname, apr_pool_t *pool) +{ + apr_dir_t *thedir = (apr_dir_t *)apr_palloc(pool, sizeof(apr_dir_t)); + + if (thedir == NULL) + return APR_ENOMEM; + + thedir->pool = pool; + thedir->dirname = apr_pstrdup(pool, dirname); + + if (thedir->dirname == NULL) + return APR_ENOMEM; + + thedir->handle = 0; + thedir->validentry = FALSE; + *new = thedir; + apr_pool_cleanup_register(pool, thedir, dir_cleanup, apr_pool_cleanup_null); + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_dir_close(apr_dir_t *thedir) +{ + int rv = 0; + + if (thedir->handle) { + rv = DosFindClose(thedir->handle); + + if (rv == 0) { + thedir->handle = 0; + } + } + + return APR_FROM_OS_ERROR(rv); +} + + + +APR_DECLARE(apr_status_t) apr_dir_read(apr_finfo_t *finfo, apr_int32_t wanted, + apr_dir_t *thedir) +{ + int rv; + ULONG entries = 1; + + if (thedir->handle == 0) { + thedir->handle = HDIR_CREATE; + rv = DosFindFirst(apr_pstrcat(thedir->pool, thedir->dirname, "/*", NULL), &thedir->handle, + FILE_ARCHIVED|FILE_DIRECTORY|FILE_SYSTEM|FILE_HIDDEN|FILE_READONLY, + &thedir->entry, sizeof(thedir->entry), &entries, FIL_STANDARD); + } else { + rv = DosFindNext(thedir->handle, &thedir->entry, sizeof(thedir->entry), &entries); + } + + finfo->pool = thedir->pool; + finfo->fname = NULL; + finfo->valid = 0; + + if (rv == 0 && entries == 1) { + thedir->validentry = TRUE; + + /* We passed a name off the stack that has popped */ + finfo->fname = NULL; + finfo->size = thedir->entry.cbFile; + finfo->csize = thedir->entry.cbFileAlloc; + + /* Only directories & regular files show up in directory listings */ + finfo->filetype = (thedir->entry.attrFile & FILE_DIRECTORY) ? APR_DIR : APR_REG; + + apr_os2_time_to_apr_time(&finfo->mtime, thedir->entry.fdateLastWrite, + thedir->entry.ftimeLastWrite); + apr_os2_time_to_apr_time(&finfo->atime, thedir->entry.fdateLastAccess, + thedir->entry.ftimeLastAccess); + apr_os2_time_to_apr_time(&finfo->ctime, thedir->entry.fdateCreation, + thedir->entry.ftimeCreation); + + finfo->name = thedir->entry.achName; + finfo->valid = APR_FINFO_NAME | APR_FINFO_MTIME | APR_FINFO_ATIME | + APR_FINFO_CTIME | APR_FINFO_TYPE | APR_FINFO_SIZE | + APR_FINFO_CSIZE; + + return APR_SUCCESS; + } + + thedir->validentry = FALSE; + + if (rv) + return APR_FROM_OS_ERROR(rv); + + return APR_ENOENT; +} + + + +APR_DECLARE(apr_status_t) apr_dir_rewind(apr_dir_t *thedir) +{ + return apr_dir_close(thedir); +} + + + +APR_DECLARE(apr_status_t) apr_dir_make(const char *path, apr_fileperms_t perm, apr_pool_t *pool) +{ + return APR_FROM_OS_ERROR(DosCreateDir(path, NULL)); +} + + + +apr_status_t apr_dir_make_recursive(const char *path, apr_fileperms_t perm, + apr_pool_t *pool) +{ + return APR_ENOTIMPL; +} + + + +APR_DECLARE(apr_status_t) apr_dir_remove(const char *path, apr_pool_t *pool) +{ + return APR_FROM_OS_ERROR(DosDeleteDir(path)); +} + + + +APR_DECLARE(apr_status_t) apr_os_dir_get(apr_os_dir_t **thedir, apr_dir_t *dir) +{ + if (dir == NULL) { + return APR_ENODIR; + } + *thedir = &dir->handle; + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_os_dir_put(apr_dir_t **dir, apr_os_dir_t *thedir, + apr_pool_t *pool) +{ + if ((*dir) == NULL) { + (*dir) = (apr_dir_t *)apr_pcalloc(pool, sizeof(apr_dir_t)); + (*dir)->pool = pool; + } + (*dir)->handle = *thedir; + return APR_SUCCESS; +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fileacc.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fileacc.c new file mode 100644 index 00000000..b5c1afd5 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fileacc.c @@ -0,0 +1,18 @@ +/* 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. + */ + +#include "../unix/fileacc.c" + diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filedup.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filedup.c new file mode 100644 index 00000000..0077d2d6 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filedup.c @@ -0,0 +1,124 @@ +/* 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. + */ + +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include "apr_strings.h" +#include <string.h> +#include "apr_arch_inherit.h" + +static apr_status_t file_dup(apr_file_t **new_file, apr_file_t *old_file, apr_pool_t *p) +{ + int rv; + apr_file_t *dup_file; + + if (*new_file == NULL) { + dup_file = (apr_file_t *)apr_palloc(p, sizeof(apr_file_t)); + + if (dup_file == NULL) { + return APR_ENOMEM; + } + + dup_file->filedes = -1; + } else { + dup_file = *new_file; + } + + dup_file->pool = p; + rv = DosDupHandle(old_file->filedes, &dup_file->filedes); + + if (rv) { + return APR_FROM_OS_ERROR(rv); + } + + dup_file->fname = apr_pstrdup(dup_file->pool, old_file->fname); + dup_file->buffered = old_file->buffered; + dup_file->isopen = old_file->isopen; + dup_file->flags = old_file->flags & ~APR_INHERIT; + /* TODO - dup pipes correctly */ + dup_file->pipe = old_file->pipe; + + if (*new_file == NULL) { + apr_pool_cleanup_register(dup_file->pool, dup_file, apr_file_cleanup, + apr_pool_cleanup_null); + *new_file = dup_file; + } + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_dup(apr_file_t **new_file, apr_file_t *old_file, apr_pool_t *p) +{ + if (*new_file) { + apr_file_close(*new_file); + (*new_file)->filedes = -1; + } + + return file_dup(new_file, old_file, p); +} + + + +APR_DECLARE(apr_status_t) apr_file_dup2(apr_file_t *new_file, apr_file_t *old_file, apr_pool_t *p) +{ + return file_dup(&new_file, old_file, p); +} + + + +APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file, + apr_file_t *old_file, + apr_pool_t *p) +{ + *new_file = (apr_file_t *)apr_palloc(p, sizeof(apr_file_t)); + memcpy(*new_file, old_file, sizeof(apr_file_t)); + (*new_file)->pool = p; + + if (old_file->buffered) { + (*new_file)->buffer = apr_palloc(p, APR_FILE_BUFSIZE); + + if (old_file->direction == 1) { + memcpy((*new_file)->buffer, old_file->buffer, old_file->bufpos); + } + else { + memcpy((*new_file)->buffer, old_file->buffer, old_file->dataRead); + } + + if (old_file->mutex) { + apr_thread_mutex_create(&((*new_file)->mutex), + APR_THREAD_MUTEX_DEFAULT, p); + apr_thread_mutex_destroy(old_file->mutex); + } + } + + if (old_file->fname) { + (*new_file)->fname = apr_pstrdup(p, old_file->fname); + } + + if (!(old_file->flags & APR_FILE_NOCLEANUP)) { + apr_pool_cleanup_register(p, (void *)(*new_file), + apr_file_cleanup, + apr_file_cleanup); + } + + old_file->filedes = -1; + apr_pool_cleanup_kill(old_file->pool, (void *)old_file, + apr_file_cleanup); + return APR_SUCCESS; +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath.c new file mode 100644 index 00000000..9422faa9 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath.c @@ -0,0 +1,16 @@ +/* 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. + */ +#include "../win32/filepath.c" diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath_util.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath_util.c new file mode 100644 index 00000000..a89c173e --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filepath_util.c @@ -0,0 +1 @@ +#include "../unix/filepath_util.c" diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filestat.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filestat.c new file mode 100644 index 00000000..2e5dc24b --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filestat.c @@ -0,0 +1,237 @@ +/* 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. + */ + +#define INCL_DOS +#define INCL_DOSERRORS +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include <sys/time.h> +#include "apr_strings.h" + + +static void FS3_to_finfo(apr_finfo_t *finfo, FILESTATUS3 *fstatus) +{ + finfo->protection = (fstatus->attrFile & FILE_READONLY) ? 0x555 : 0x777; + + if (fstatus->attrFile & FILE_DIRECTORY) + finfo->filetype = APR_DIR; + else + finfo->filetype = APR_REG; + /* XXX: No other possible types from FS3? */ + + finfo->user = 0; + finfo->group = 0; + finfo->inode = 0; + finfo->device = 0; + finfo->size = fstatus->cbFile; + finfo->csize = fstatus->cbFileAlloc; + apr_os2_time_to_apr_time(&finfo->atime, fstatus->fdateLastAccess, + fstatus->ftimeLastAccess ); + apr_os2_time_to_apr_time(&finfo->mtime, fstatus->fdateLastWrite, + fstatus->ftimeLastWrite ); + apr_os2_time_to_apr_time(&finfo->ctime, fstatus->fdateCreation, + fstatus->ftimeCreation ); + finfo->valid = APR_FINFO_TYPE | APR_FINFO_PROT | APR_FINFO_SIZE + | APR_FINFO_CSIZE | APR_FINFO_MTIME + | APR_FINFO_CTIME | APR_FINFO_ATIME | APR_FINFO_LINK; +} + + + +static apr_status_t handle_type(apr_filetype_e *ftype, HFILE file) +{ + ULONG filetype, fileattr, rc; + + rc = DosQueryHType(file, &filetype, &fileattr); + + if (rc == 0) { + switch (filetype & 0xff) { + case 0: + *ftype = APR_REG; + break; + + case 1: + *ftype = APR_CHR; + break; + + case 2: + *ftype = APR_PIPE; + break; + + default: + /* Brian, is this correct??? + */ + *ftype = APR_UNKFILE; + break; + } + + return APR_SUCCESS; + } + return APR_FROM_OS_ERROR(rc); +} + + + +APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, apr_int32_t wanted, + apr_file_t *thefile) +{ + ULONG rc; + FILESTATUS3 fstatus; + + if (thefile->isopen) { + if (thefile->buffered) { + apr_status_t rv = apr_file_flush(thefile); + + if (rv != APR_SUCCESS) { + return rv; + } + } + + rc = DosQueryFileInfo(thefile->filedes, FIL_STANDARD, &fstatus, sizeof(fstatus)); + } + else + rc = DosQueryPathInfo(thefile->fname, FIL_STANDARD, &fstatus, sizeof(fstatus)); + + if (rc == 0) { + FS3_to_finfo(finfo, &fstatus); + finfo->fname = thefile->fname; + + if (finfo->filetype == APR_REG) { + if (thefile->isopen) { + return handle_type(&finfo->filetype, thefile->filedes); + } + } else { + return APR_SUCCESS; + } + } + + finfo->protection = 0; + finfo->filetype = APR_NOFILE; + return APR_FROM_OS_ERROR(rc); +} + +APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname, apr_fileperms_t perms) +{ + return APR_ENOTIMPL; +} + + +APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, const char *fname, + apr_int32_t wanted, apr_pool_t *cont) +{ + ULONG rc; + FILESTATUS3 fstatus; + + finfo->protection = 0; + finfo->filetype = APR_NOFILE; + finfo->name = NULL; + rc = DosQueryPathInfo(fname, FIL_STANDARD, &fstatus, sizeof(fstatus)); + + if (rc == 0) { + FS3_to_finfo(finfo, &fstatus); + finfo->fname = fname; + + if (wanted & APR_FINFO_NAME) { + ULONG count = 1; + HDIR hDir = HDIR_SYSTEM; + FILEFINDBUF3 ffb; + rc = DosFindFirst(fname, &hDir, + FILE_DIRECTORY|FILE_HIDDEN|FILE_SYSTEM|FILE_ARCHIVED, + &ffb, sizeof(ffb), &count, FIL_STANDARD); + if (rc == 0 && count == 1) { + finfo->name = apr_pstrdup(cont, ffb.achName); + finfo->valid |= APR_FINFO_NAME; + } + } + } else if (rc == ERROR_INVALID_ACCESS) { + memset(finfo, 0, sizeof(apr_finfo_t)); + finfo->valid = APR_FINFO_TYPE | APR_FINFO_PROT; + finfo->protection = 0666; + finfo->filetype = APR_CHR; + + if (wanted & APR_FINFO_NAME) { + finfo->name = apr_pstrdup(cont, fname); + finfo->valid |= APR_FINFO_NAME; + } + } else { + return APR_FROM_OS_ERROR(rc); + } + + return (wanted & ~finfo->valid) ? APR_INCOMPLETE : APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname, + apr_int32_t wanted, apr_pool_t *cont) +{ + return apr_stat(finfo, fname, wanted, cont); +} + + + +APR_DECLARE(apr_status_t) apr_file_attrs_set(const char *fname, + apr_fileattrs_t attributes, + apr_fileattrs_t attr_mask, + apr_pool_t *cont) +{ + FILESTATUS3 fs3; + ULONG rc; + + /* Don't do anything if we can't handle the requested attributes */ + if (!(attr_mask & (APR_FILE_ATTR_READONLY + | APR_FILE_ATTR_HIDDEN))) + return APR_SUCCESS; + + rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs3, sizeof(fs3)); + if (rc == 0) { + ULONG old_attr = fs3.attrFile; + + if (attr_mask & APR_FILE_ATTR_READONLY) + { + if (attributes & APR_FILE_ATTR_READONLY) { + fs3.attrFile |= FILE_READONLY; + } else { + fs3.attrFile &= ~FILE_READONLY; + } + } + + if (attr_mask & APR_FILE_ATTR_HIDDEN) + { + if (attributes & APR_FILE_ATTR_HIDDEN) { + fs3.attrFile |= FILE_HIDDEN; + } else { + fs3.attrFile &= ~FILE_HIDDEN; + } + } + + if (fs3.attrFile != old_attr) { + rc = DosSetPathInfo(fname, FIL_STANDARD, &fs3, sizeof(fs3), 0); + } + } + + return APR_FROM_OS_ERROR(rc); +} + + +/* ### Somebody please write this! */ +APR_DECLARE(apr_status_t) apr_file_mtime_set(const char *fname, + apr_time_t mtime, + apr_pool_t *pool) +{ + return APR_ENOTIMPL; +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filesys.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filesys.c new file mode 100644 index 00000000..ae43bc0a --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/filesys.c @@ -0,0 +1,148 @@ +/* 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. + */ + +#include "apr.h" +#include "apr_arch_file_io.h" +#include "apr_strings.h" +#include "apr_lib.h" +#include <ctype.h> + +/* OS/2 Exceptions: + * + * Note that trailing spaces and trailing periods are never recorded + * in the file system. + * + * Leading spaces and periods are accepted, however. + * The * ? < > codes all have wildcard side effects + * The " / \ : are exclusively component separator tokens + * The system doesn't accept | for any (known) purpose + * Oddly, \x7f _is_ acceptable ;) + */ + +const char c_is_fnchar[256] = +{/* Reject all ctrl codes... */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + /* " * / : < > ? */ + 1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,0, 1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,0, + /* \ */ + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1, + /* | */ + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1, + /* High bit codes are accepted */ + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 +}; + + +#define IS_SLASH(c) (c == '/' || c == '\\') + + +apr_status_t filepath_root_test(char *path, apr_pool_t *p) +{ + char drive = apr_toupper(path[0]); + + if (drive >= 'A' && drive <= 'Z' && path[1] == ':' && IS_SLASH(path[2])) + return APR_SUCCESS; + + return APR_EBADPATH; +} + + +apr_status_t filepath_drive_get(char **rootpath, char drive, + apr_int32_t flags, apr_pool_t *p) +{ + char path[APR_PATH_MAX]; + char *pos; + ULONG rc; + ULONG bufsize = sizeof(path) - 3; + + path[0] = drive; + path[1] = ':'; + path[2] = '/'; + + rc = DosQueryCurrentDir(apr_toupper(drive) - 'A', path+3, &bufsize); + + if (rc) { + return APR_FROM_OS_ERROR(rc); + } + + if (!(flags & APR_FILEPATH_NATIVE)) { + for (pos=path; *pos; pos++) { + if (*pos == '\\') + *pos = '/'; + } + } + + *rootpath = apr_pstrdup(p, path); + return APR_SUCCESS; +} + + +apr_status_t filepath_root_case(char **rootpath, char *root, apr_pool_t *p) +{ + if (root[0] && apr_islower(root[0]) && root[1] == ':') { + *rootpath = apr_pstrdup(p, root); + (*rootpath)[0] = apr_toupper((*rootpath)[0]); + } + else { + *rootpath = root; + } + return APR_SUCCESS; +} + + +APR_DECLARE(apr_status_t) apr_filepath_get(char **defpath, apr_int32_t flags, + apr_pool_t *p) +{ + char path[APR_PATH_MAX]; + ULONG drive; + ULONG drivemap; + ULONG rv, pathlen = sizeof(path) - 3; + char *pos; + + DosQueryCurrentDisk(&drive, &drivemap); + path[0] = '@' + drive; + strcpy(path+1, ":\\"); + rv = DosQueryCurrentDir(drive, path+3, &pathlen); + + *defpath = apr_pstrdup(p, path); + + if (!(flags & APR_FILEPATH_NATIVE)) { + for (pos=*defpath; *pos; pos++) { + if (*pos == '\\') + *pos = '/'; + } + } + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_filepath_set(const char *path, apr_pool_t *p) +{ + ULONG rv = 0; + + if (path[1] == ':') + rv = DosSetDefaultDisk(apr_toupper(path[0]) - '@'); + + if (rv == 0) + rv = DosSetCurrentDir(path); + + return APR_FROM_OS_ERROR(rv); +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/flock.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/flock.c new file mode 100644 index 00000000..ec940220 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/flock.c @@ -0,0 +1,37 @@ +/* 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. + */ + +#include "apr_arch_file_io.h" + +APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type) +{ + FILELOCK lockrange = { 0, 0x7fffffff }; + ULONG rc; + + rc = DosSetFileLocks(thefile->filedes, NULL, &lockrange, + (type & APR_FLOCK_NONBLOCK) ? 0 : (ULONG)-1, + (type & APR_FLOCK_TYPEMASK) == APR_FLOCK_SHARED); + return APR_FROM_OS_ERROR(rc); +} + +APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile) +{ + FILELOCK unlockrange = { 0, 0x7fffffff }; + ULONG rc; + + rc = DosSetFileLocks(thefile->filedes, &unlockrange, NULL, 0, 0); + return APR_FROM_OS_ERROR(rc); +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fullrw.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fullrw.c new file mode 100644 index 00000000..cf629488 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/fullrw.c @@ -0,0 +1 @@ +#include "../unix/fullrw.c" diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/maperrorcode.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/maperrorcode.c new file mode 100644 index 00000000..282338bb --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/maperrorcode.c @@ -0,0 +1,95 @@ +/* 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. + */ + +#define INCL_DOSERRORS +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include <errno.h> +#include <string.h> +#include "apr_errno.h" + +static int errormap[][2] = { + { NO_ERROR, APR_SUCCESS }, + { ERROR_FILE_NOT_FOUND, APR_ENOENT }, + { ERROR_PATH_NOT_FOUND, APR_ENOENT }, + { ERROR_TOO_MANY_OPEN_FILES, APR_EMFILE }, + { ERROR_ACCESS_DENIED, APR_EACCES }, + { ERROR_SHARING_VIOLATION, APR_EACCES }, + { ERROR_INVALID_PARAMETER, APR_EINVAL }, + { ERROR_OPEN_FAILED, APR_ENOENT }, + { ERROR_DISK_FULL, APR_ENOSPC }, + { ERROR_FILENAME_EXCED_RANGE, APR_ENAMETOOLONG }, + { ERROR_INVALID_FUNCTION, APR_EINVAL }, + { ERROR_INVALID_HANDLE, APR_EBADF }, + { ERROR_NEGATIVE_SEEK, APR_ESPIPE }, + { ERROR_NO_SIGNAL_SENT, ESRCH }, + { ERROR_NO_DATA, APR_EAGAIN }, + { SOCEINTR, EINTR }, + { SOCEWOULDBLOCK, EWOULDBLOCK }, + { SOCEINPROGRESS, EINPROGRESS }, + { SOCEALREADY, EALREADY }, + { SOCENOTSOCK, ENOTSOCK }, + { SOCEDESTADDRREQ, EDESTADDRREQ }, + { SOCEMSGSIZE, EMSGSIZE }, + { SOCEPROTOTYPE, EPROTOTYPE }, + { SOCENOPROTOOPT, ENOPROTOOPT }, + { SOCEPROTONOSUPPORT, EPROTONOSUPPORT }, + { SOCESOCKTNOSUPPORT, ESOCKTNOSUPPORT }, + { SOCEOPNOTSUPP, EOPNOTSUPP }, + { SOCEPFNOSUPPORT, EPFNOSUPPORT }, + { SOCEAFNOSUPPORT, EAFNOSUPPORT }, + { SOCEADDRINUSE, EADDRINUSE }, + { SOCEADDRNOTAVAIL, EADDRNOTAVAIL }, + { SOCENETDOWN, ENETDOWN }, + { SOCENETUNREACH, ENETUNREACH }, + { SOCENETRESET, ENETRESET }, + { SOCECONNABORTED, ECONNABORTED }, + { SOCECONNRESET, ECONNRESET }, + { SOCENOBUFS, ENOBUFS }, + { SOCEISCONN, EISCONN }, + { SOCENOTCONN, ENOTCONN }, + { SOCESHUTDOWN, ESHUTDOWN }, + { SOCETOOMANYREFS, ETOOMANYREFS }, + { SOCETIMEDOUT, ETIMEDOUT }, + { SOCECONNREFUSED, ECONNREFUSED }, + { SOCELOOP, ELOOP }, + { SOCENAMETOOLONG, ENAMETOOLONG }, + { SOCEHOSTDOWN, EHOSTDOWN }, + { SOCEHOSTUNREACH, EHOSTUNREACH }, + { SOCENOTEMPTY, ENOTEMPTY }, + { SOCEPIPE, EPIPE } +}; + +#define MAPSIZE (sizeof(errormap)/sizeof(errormap[0])) + +int apr_canonical_error(apr_status_t err) +{ + int rv = -1, index; + + if (err < APR_OS_START_SYSERR) + return err; + + err -= APR_OS_START_SYSERR; + + for (index=0; index<MAPSIZE && errormap[index][0] != err; index++); + + if (index<MAPSIZE) + rv = errormap[index][1]; + else + fprintf(stderr, "apr_canonical_error: Unknown OS/2 error code %d\n", err ); + + return rv; +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/mktemp.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/mktemp.c new file mode 100644 index 00000000..9e852360 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/mktemp.c @@ -0,0 +1 @@ +#include "../unix/mktemp.c" diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/open.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/open.c new file mode 100644 index 00000000..0994e7cf --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/open.c @@ -0,0 +1,244 @@ +/* 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. + */ + +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include "apr_portable.h" +#include "apr_strings.h" +#include "apr_arch_inherit.h" +#include <string.h> + +apr_status_t apr_file_cleanup(void *thefile) +{ + apr_file_t *file = thefile; + return apr_file_close(file); +} + + + +APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new, const char *fname, apr_int32_t flag, apr_fileperms_t perm, apr_pool_t *pool) +{ + int oflags = 0; + int mflags = OPEN_FLAGS_FAIL_ON_ERROR|OPEN_SHARE_DENYNONE; + int rv; + ULONG action; + apr_file_t *dafile = (apr_file_t *)apr_palloc(pool, sizeof(apr_file_t)); + + dafile->pool = pool; + dafile->isopen = FALSE; + dafile->eof_hit = FALSE; + dafile->buffer = NULL; + dafile->flags = flag; + dafile->blocking = BLK_ON; + + if ((flag & APR_READ) && (flag & APR_WRITE)) { + mflags |= OPEN_ACCESS_READWRITE; + } else if (flag & APR_READ) { + mflags |= OPEN_ACCESS_READONLY; + } else if (flag & APR_WRITE) { + mflags |= OPEN_ACCESS_WRITEONLY; + } else { + dafile->filedes = -1; + return APR_EACCES; + } + + dafile->buffered = (flag & APR_BUFFERED) > 0; + + if (dafile->buffered) { + dafile->buffer = apr_palloc(pool, APR_FILE_BUFSIZE); + rv = apr_thread_mutex_create(&dafile->mutex, 0, pool); + + if (rv) + return rv; + } + + if (flag & APR_CREATE) { + oflags |= OPEN_ACTION_CREATE_IF_NEW; + + if (!(flag & APR_EXCL) && !(flag & APR_TRUNCATE)) { + oflags |= OPEN_ACTION_OPEN_IF_EXISTS; + } + } + + if ((flag & APR_EXCL) && !(flag & APR_CREATE)) + return APR_EACCES; + + if (flag & APR_TRUNCATE) { + oflags |= OPEN_ACTION_REPLACE_IF_EXISTS; + } else if ((oflags & 0xFF) == 0) { + oflags |= OPEN_ACTION_OPEN_IF_EXISTS; + } + + rv = DosOpen(fname, &(dafile->filedes), &action, 0, 0, oflags, mflags, NULL); + + if (rv == 0 && (flag & APR_APPEND)) { + ULONG newptr; + rv = DosSetFilePtr(dafile->filedes, 0, FILE_END, &newptr ); + + if (rv) + DosClose(dafile->filedes); + } + + if (rv != 0) + return APR_FROM_OS_ERROR(rv); + + dafile->isopen = TRUE; + dafile->fname = apr_pstrdup(pool, fname); + dafile->filePtr = 0; + dafile->bufpos = 0; + dafile->dataRead = 0; + dafile->direction = 0; + dafile->pipe = FALSE; + + if (!(flag & APR_FILE_NOCLEANUP)) { + apr_pool_cleanup_register(dafile->pool, dafile, apr_file_cleanup, apr_file_cleanup); + } + + *new = dafile; + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file) +{ + ULONG rc; + apr_status_t status; + + if (file && file->isopen) { + apr_file_flush(file); + rc = DosClose(file->filedes); + + if (rc == 0) { + file->isopen = FALSE; + status = APR_SUCCESS; + + if (file->flags & APR_DELONCLOSE) { + status = APR_FROM_OS_ERROR(DosDelete(file->fname)); + } + } else { + return APR_FROM_OS_ERROR(rc); + } + } + + if (file->buffered) + apr_thread_mutex_destroy(file->mutex); + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *pool) +{ + ULONG rc = DosDelete(path); + return APR_FROM_OS_ERROR(rc); +} + + + +APR_DECLARE(apr_status_t) apr_file_rename(const char *from_path, const char *to_path, + apr_pool_t *p) +{ + ULONG rc = DosMove(from_path, to_path); + + if (rc == ERROR_ACCESS_DENIED || rc == ERROR_ALREADY_EXISTS) { + rc = DosDelete(to_path); + + if (rc == 0 || rc == ERROR_FILE_NOT_FOUND) { + rc = DosMove(from_path, to_path); + } + } + + return APR_FROM_OS_ERROR(rc); +} + + + +APR_DECLARE(apr_status_t) apr_os_file_get(apr_os_file_t *thefile, apr_file_t *file) +{ + *thefile = file->filedes; + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_os_file_put(apr_file_t **file, apr_os_file_t *thefile, apr_int32_t flags, apr_pool_t *pool) +{ + apr_os_file_t *dafile = thefile; + + (*file) = apr_palloc(pool, sizeof(apr_file_t)); + (*file)->pool = pool; + (*file)->filedes = *dafile; + (*file)->isopen = TRUE; + (*file)->eof_hit = FALSE; + (*file)->flags = flags; + (*file)->pipe = FALSE; + (*file)->buffered = (flags & APR_BUFFERED) > 0; + + if ((*file)->buffered) { + apr_status_t rv; + + (*file)->buffer = apr_palloc(pool, APR_FILE_BUFSIZE); + rv = apr_thread_mutex_create(&(*file)->mutex, 0, pool); + + if (rv) + return rv; + } + return APR_SUCCESS; +} + + +APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr) +{ + if (!fptr->isopen || fptr->eof_hit == 1) { + return APR_EOF; + } + return APR_SUCCESS; +} + + +APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *pool) +{ + apr_os_file_t fd = 2; + + return apr_os_file_put(thefile, &fd, 0, pool); +} + + + +APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *pool) +{ + apr_os_file_t fd = 1; + + return apr_os_file_put(thefile, &fd, 0, pool); +} + + +APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *pool) +{ + apr_os_file_t fd = 0; + + return apr_os_file_put(thefile, &fd, 0, pool); +} + +APR_POOL_IMPLEMENT_ACCESSOR(file); + +APR_IMPLEMENT_INHERIT_SET(file, flags, pool, apr_file_cleanup) + +APR_IMPLEMENT_INHERIT_UNSET(file, flags, pool, apr_file_cleanup) + diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/pipe.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/pipe.c new file mode 100644 index 00000000..ee2b2b00 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/pipe.c @@ -0,0 +1,177 @@ +/* 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. + */ + +#define INCL_DOSERRORS +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_general.h" +#include "apr_lib.h" +#include "apr_strings.h" +#include "apr_portable.h" +#include <string.h> +#include <process.h> + +APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool) +{ + ULONG filedes[2]; + ULONG rc, action; + static int id = 0; + char pipename[50]; + + sprintf(pipename, "/pipe/%d.%d", getpid(), id++); + rc = DosCreateNPipe(pipename, filedes, NP_ACCESS_INBOUND, NP_NOWAIT|1, 4096, 4096, 0); + + if (rc) + return APR_FROM_OS_ERROR(rc); + + rc = DosConnectNPipe(filedes[0]); + + if (rc && rc != ERROR_PIPE_NOT_CONNECTED) { + DosClose(filedes[0]); + return APR_FROM_OS_ERROR(rc); + } + + rc = DosOpen (pipename, filedes+1, &action, 0, FILE_NORMAL, + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW, + OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYREADWRITE, + NULL); + + if (rc) { + DosClose(filedes[0]); + return APR_FROM_OS_ERROR(rc); + } + + (*in) = (apr_file_t *)apr_palloc(pool, sizeof(apr_file_t)); + rc = DosCreateEventSem(NULL, &(*in)->pipeSem, DC_SEM_SHARED, FALSE); + + if (rc) { + DosClose(filedes[0]); + DosClose(filedes[1]); + return APR_FROM_OS_ERROR(rc); + } + + rc = DosSetNPipeSem(filedes[0], (HSEM)(*in)->pipeSem, 1); + + if (!rc) { + rc = DosSetNPHState(filedes[0], NP_WAIT); + } + + if (rc) { + DosClose(filedes[0]); + DosClose(filedes[1]); + DosCloseEventSem((*in)->pipeSem); + return APR_FROM_OS_ERROR(rc); + } + + (*in)->pool = pool; + (*in)->filedes = filedes[0]; + (*in)->fname = apr_pstrdup(pool, pipename); + (*in)->isopen = TRUE; + (*in)->buffered = FALSE; + (*in)->flags = 0; + (*in)->pipe = 1; + (*in)->timeout = -1; + (*in)->blocking = BLK_ON; + apr_pool_cleanup_register(pool, *in, apr_file_cleanup, apr_pool_cleanup_null); + + (*out) = (apr_file_t *)apr_palloc(pool, sizeof(apr_file_t)); + (*out)->pool = pool; + (*out)->filedes = filedes[1]; + (*out)->fname = apr_pstrdup(pool, pipename); + (*out)->isopen = TRUE; + (*out)->buffered = FALSE; + (*out)->flags = 0; + (*out)->pipe = 1; + (*out)->timeout = -1; + (*out)->blocking = BLK_ON; + apr_pool_cleanup_register(pool, *out, apr_file_cleanup, apr_pool_cleanup_null); + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename, apr_fileperms_t perm, apr_pool_t *pool) +{ + /* Not yet implemented, interface not suitable */ + return APR_ENOTIMPL; +} + + + +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout) +{ + if (thepipe->pipe == 1) { + thepipe->timeout = timeout; + + if (thepipe->timeout >= 0) { + if (thepipe->blocking != BLK_OFF) { + thepipe->blocking = BLK_OFF; + return APR_FROM_OS_ERROR(DosSetNPHState(thepipe->filedes, NP_NOWAIT)); + } + } + else if (thepipe->timeout == -1) { + if (thepipe->blocking != BLK_ON) { + thepipe->blocking = BLK_ON; + return APR_FROM_OS_ERROR(DosSetNPHState(thepipe->filedes, NP_WAIT)); + } + } + } + return APR_EINVAL; +} + + + +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout) +{ + if (thepipe->pipe == 1) { + *timeout = thepipe->timeout; + return APR_SUCCESS; + } + return APR_EINVAL; +} + + + +APR_DECLARE(apr_status_t) apr_os_pipe_put_ex(apr_file_t **file, + apr_os_file_t *thefile, + int register_cleanup, + apr_pool_t *pool) +{ + (*file) = apr_pcalloc(pool, sizeof(apr_file_t)); + (*file)->pool = pool; + (*file)->isopen = TRUE; + (*file)->pipe = 1; + (*file)->blocking = BLK_UNKNOWN; /* app needs to make a timeout call */ + (*file)->timeout = -1; + (*file)->filedes = *thefile; + + if (register_cleanup) { + apr_pool_cleanup_register(pool, *file, apr_file_cleanup, + apr_pool_cleanup_null); + } + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_os_pipe_put(apr_file_t **file, + apr_os_file_t *thefile, + apr_pool_t *pool) +{ + return apr_os_pipe_put_ex(file, thefile, 0, pool); +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/readwrite.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/readwrite.c new file mode 100644 index 00000000..f25a4210 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/readwrite.c @@ -0,0 +1,370 @@ +/* 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. + */ + +#define INCL_DOS +#define INCL_DOSERRORS + +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include "apr_strings.h" + +#include <malloc.h> + +APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes) +{ + ULONG rc = 0; + ULONG bytesread; + + if (!thefile->isopen) { + *nbytes = 0; + return APR_EBADF; + } + + if (thefile->buffered) { + char *pos = (char *)buf; + ULONG blocksize; + ULONG size = *nbytes; + + apr_thread_mutex_lock(thefile->mutex); + + if (thefile->direction == 1) { + int rv = apr_file_flush(thefile); + + if (rv != APR_SUCCESS) { + apr_thread_mutex_unlock(thefile->mutex); + return rv; + } + + thefile->bufpos = 0; + thefile->direction = 0; + thefile->dataRead = 0; + } + + while (rc == 0 && size > 0) { + if (thefile->bufpos >= thefile->dataRead) { + ULONG bytesread; + rc = DosRead(thefile->filedes, thefile->buffer, + APR_FILE_BUFSIZE, &bytesread); + + if (bytesread == 0) { + if (rc == 0) + thefile->eof_hit = TRUE; + break; + } + + thefile->dataRead = bytesread; + thefile->filePtr += thefile->dataRead; + thefile->bufpos = 0; + } + + blocksize = size > thefile->dataRead - thefile->bufpos ? thefile->dataRead - thefile->bufpos : size; + memcpy(pos, thefile->buffer + thefile->bufpos, blocksize); + thefile->bufpos += blocksize; + pos += blocksize; + size -= blocksize; + } + + *nbytes = rc == 0 ? pos - (char *)buf : 0; + apr_thread_mutex_unlock(thefile->mutex); + + if (*nbytes == 0 && rc == 0 && thefile->eof_hit) { + return APR_EOF; + } + + return APR_FROM_OS_ERROR(rc); + } else { + if (thefile->pipe) + DosResetEventSem(thefile->pipeSem, &rc); + + rc = DosRead(thefile->filedes, buf, *nbytes, &bytesread); + + if (rc == ERROR_NO_DATA && thefile->timeout != 0) { + int rcwait = DosWaitEventSem(thefile->pipeSem, thefile->timeout >= 0 ? thefile->timeout / 1000 : SEM_INDEFINITE_WAIT); + + if (rcwait == 0) { + rc = DosRead(thefile->filedes, buf, *nbytes, &bytesread); + } + else if (rcwait == ERROR_TIMEOUT) { + *nbytes = 0; + return APR_TIMEUP; + } + } + + if (rc) { + *nbytes = 0; + return APR_FROM_OS_ERROR(rc); + } + + *nbytes = bytesread; + + if (bytesread == 0) { + thefile->eof_hit = TRUE; + return APR_EOF; + } + + return APR_SUCCESS; + } +} + + + +APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes) +{ + ULONG rc = 0; + ULONG byteswritten; + + if (!thefile->isopen) { + *nbytes = 0; + return APR_EBADF; + } + + if (thefile->buffered) { + char *pos = (char *)buf; + int blocksize; + int size = *nbytes; + + apr_thread_mutex_lock(thefile->mutex); + + if ( thefile->direction == 0 ) { + // Position file pointer for writing at the offset we are logically reading from + ULONG offset = thefile->filePtr - thefile->dataRead + thefile->bufpos; + if (offset != thefile->filePtr) + DosSetFilePtr(thefile->filedes, offset, FILE_BEGIN, &thefile->filePtr ); + thefile->bufpos = thefile->dataRead = 0; + thefile->direction = 1; + } + + while (rc == 0 && size > 0) { + if (thefile->bufpos == APR_FILE_BUFSIZE) // write buffer is full + rc = apr_file_flush(thefile); + + blocksize = size > APR_FILE_BUFSIZE - thefile->bufpos ? APR_FILE_BUFSIZE - thefile->bufpos : size; + memcpy(thefile->buffer + thefile->bufpos, pos, blocksize); + thefile->bufpos += blocksize; + pos += blocksize; + size -= blocksize; + } + + apr_thread_mutex_unlock(thefile->mutex); + return APR_FROM_OS_ERROR(rc); + } else { + if (thefile->flags & APR_APPEND) { + FILELOCK all = { 0, 0x7fffffff }; + ULONG newpos; + rc = DosSetFileLocks(thefile->filedes, NULL, &all, -1, 0); + + if (rc == 0) { + rc = DosSetFilePtr(thefile->filedes, 0, FILE_END, &newpos); + + if (rc == 0) { + rc = DosWrite(thefile->filedes, buf, *nbytes, &byteswritten); + } + + DosSetFileLocks(thefile->filedes, &all, NULL, -1, 0); + } + } else { + rc = DosWrite(thefile->filedes, buf, *nbytes, &byteswritten); + } + + if (rc) { + *nbytes = 0; + return APR_FROM_OS_ERROR(rc); + } + + *nbytes = byteswritten; + return APR_SUCCESS; + } +} + + + +#ifdef HAVE_WRITEV + +APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec, apr_size_t nvec, apr_size_t *nbytes) +{ + int bytes; + if ((bytes = writev(thefile->filedes, vec, nvec)) < 0) { + *nbytes = 0; + return errno; + } + else { + *nbytes = bytes; + return APR_SUCCESS; + } +} +#endif + + + +APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile) +{ + ULONG rc; + ULONG byteswritten; + + if (!thefile->isopen) { + return APR_EBADF; + } + + rc = DosWrite(thefile->filedes, &ch, 1, &byteswritten); + + if (rc) { + return APR_FROM_OS_ERROR(rc); + } + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile) +{ + apr_off_t offset = -1; + return apr_file_seek(thefile, APR_CUR, &offset); +} + + +APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile) +{ + ULONG rc; + apr_size_t bytesread; + + if (!thefile->isopen) { + return APR_EBADF; + } + + bytesread = 1; + rc = apr_file_read(thefile, ch, &bytesread); + + if (rc) { + return rc; + } + + if (bytesread == 0) { + thefile->eof_hit = TRUE; + return APR_EOF; + } + + return APR_SUCCESS; +} + + + +APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile) +{ + apr_size_t len; + + len = strlen(str); + return apr_file_write(thefile, str, &len); +} + + +APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile) +{ + if (thefile->buffered) { + ULONG written = 0; + int rc = 0; + + if (thefile->direction == 1 && thefile->bufpos) { + rc = DosWrite(thefile->filedes, thefile->buffer, thefile->bufpos, &written); + thefile->filePtr += written; + + if (rc == 0) + thefile->bufpos = 0; + } + + return APR_FROM_OS_ERROR(rc); + } else { + /* There isn't anything to do if we aren't buffering the output + * so just return success. + */ + return APR_SUCCESS; + } +} + + +APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len, apr_file_t *thefile) +{ + apr_size_t readlen; + apr_status_t rv = APR_SUCCESS; + int i; + + for (i = 0; i < len-1; i++) { + readlen = 1; + rv = apr_file_read(thefile, str+i, &readlen); + + if (rv != APR_SUCCESS) { + break; + } + + if (readlen != 1) { + rv = APR_EOF; + break; + } + + if (str[i] == '\n') { + i++; + break; + } + } + str[i] = 0; + if (i > 0) { + /* we stored chars; don't report EOF or any other errors; + * the app will find out about that on the next call + */ + return APR_SUCCESS; + } + return rv; +} + + + +APR_DECLARE_NONSTD(int) apr_file_printf(apr_file_t *fptr, + const char *format, ...) +{ + int cc; + va_list ap; + char *buf; + int len; + + buf = malloc(HUGE_STRING_LEN); + if (buf == NULL) { + return 0; + } + va_start(ap, format); + len = apr_vsnprintf(buf, HUGE_STRING_LEN, format, ap); + cc = apr_file_puts(buf, fptr); + va_end(ap); + free(buf); + return (cc == APR_SUCCESS) ? len : -1; +} + + + +apr_status_t apr_file_check_read(apr_file_t *fd) +{ + int rc; + + if (!fd->pipe) + return APR_SUCCESS; /* Not a pipe, assume no waiting */ + + rc = DosWaitEventSem(fd->pipeSem, SEM_IMMEDIATE_RETURN); + + if (rc == ERROR_TIMEOUT) + return APR_TIMEUP; + + return APR_FROM_OS_ERROR(rc); +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/seek.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/seek.c new file mode 100644 index 00000000..6fdfe8e8 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/seek.c @@ -0,0 +1,119 @@ +/* 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. + */ + +#include "apr_arch_file_io.h" +#include "apr_file_io.h" +#include "apr_lib.h" +#include <string.h> +#include <io.h> + + +static apr_status_t setptr(apr_file_t *thefile, unsigned long pos ) +{ + long newbufpos; + ULONG rc; + + if (thefile->direction == 1) { + apr_status_t rv = apr_file_flush(thefile); + + if (rv != APR_SUCCESS) { + return rv; + } + + thefile->bufpos = thefile->direction = thefile->dataRead = 0; + } + + newbufpos = pos - (thefile->filePtr - thefile->dataRead); + if (newbufpos >= 0 && newbufpos <= thefile->dataRead) { + thefile->bufpos = newbufpos; + rc = 0; + } else { + rc = DosSetFilePtr(thefile->filedes, pos, FILE_BEGIN, &thefile->filePtr ); + + if ( !rc ) + thefile->bufpos = thefile->dataRead = 0; + } + + return APR_FROM_OS_ERROR(rc); +} + + + +APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset) +{ + if (!thefile->isopen) { + return APR_EBADF; + } + + thefile->eof_hit = 0; + + if (thefile->buffered) { + int rc = EINVAL; + apr_finfo_t finfo; + + switch (where) { + case APR_SET: + rc = setptr(thefile, *offset); + break; + + case APR_CUR: + rc = setptr(thefile, thefile->filePtr - thefile->dataRead + thefile->bufpos + *offset); + break; + + case APR_END: + rc = apr_file_info_get(&finfo, APR_FINFO_NORM, thefile); + if (rc == APR_SUCCESS) + rc = setptr(thefile, finfo.size + *offset); + break; + } + + *offset = thefile->filePtr - thefile->dataRead + thefile->bufpos; + return rc; + } else { + switch (where) { + case APR_SET: + where = FILE_BEGIN; + break; + + case APR_CUR: + where = FILE_CURRENT; + break; + + case APR_END: + where = FILE_END; + break; + } + + return APR_FROM_OS_ERROR(DosSetFilePtr(thefile->filedes, *offset, where, (ULONG *)offset)); + } +} + + + +APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *fp, apr_off_t offset) +{ + int rc = DosSetFileSize(fp->filedes, offset); + + if (rc != 0) { + return APR_FROM_OS_ERROR(rc); + } + + if (fp->buffered) { + return setptr(fp, offset); + } + + return APR_SUCCESS; +} diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/tempdir.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/tempdir.c new file mode 100644 index 00000000..6823569f --- /dev/null +++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/os2/tempdir.c @@ -0,0 +1 @@ +#include "../unix/tempdir.c" |