← Back to branch summary

~ubuntu-branches/ubuntu/hardy/apache2/hardy-proposed

« back to all changes in this revision

Viewing changes to srclib/apr/file_io/win32/open.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Fritsch
  • Date: 2008-01-17 20:27:56 UTC
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: james.westby@ubuntu.com-20080117202756-hv38rjknhwa2ilwi
Tags: upstream-2.2.8
Import upstream version 2.2.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
srclib/apr/file_io/win32/open.c
31
31
#endif
32
32
#include "apr_arch_misc.h"
33
33
#include "apr_arch_inherit.h"
 
34
#include <io.h>
34
35
 
35
36
#if APR_HAS_UNICODE_FS
36
37
apr_status_t utf8_to_unicode_path(apr_wchar_t* retstr, apr_size_t retlen, 
227
228
 
228
229
    if (file->filehand != INVALID_HANDLE_VALUE) {
229
230
 
 
231
        if (file->buffered) {
 
232
            /* XXX: flush here is not mutex protected */
 
233
            flush_rv = apr_file_flush((apr_file_t *)thefile);
 
234
        }
 
235
 
230
236
        /* In order to avoid later segfaults with handle 'reuse',
231
237
         * we must protect against the case that a dup2'ed handle
232
238
         * is being closed, and invalidate the corresponding StdHandle 
 
239
         * We also tell msvcrt when stdhandles are closed.
233
240
         */
234
 
        if (file->filehand == GetStdHandle(STD_ERROR_HANDLE)) {
235
 
            SetStdHandle(STD_ERROR_HANDLE, INVALID_HANDLE_VALUE);
236
 
        }
237
 
        if (file->filehand == GetStdHandle(STD_OUTPUT_HANDLE)) {
238
 
            SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);
239
 
        }
240
 
        if (file->filehand == GetStdHandle(STD_INPUT_HANDLE)) {
241
 
            SetStdHandle(STD_INPUT_HANDLE, INVALID_HANDLE_VALUE);
242
 
        }
 
241
        if (file->flags & APR_STD_FLAGS)
 
242
        {
 
243
            if ((file->flags & APR_STD_FLAGS) == APR_STDERR_FLAG) {
 
244
                _close(2);
 
245
                SetStdHandle(STD_ERROR_HANDLE, INVALID_HANDLE_VALUE);
 
246
            }
 
247
            else if ((file->flags & APR_STD_FLAGS) == APR_STDOUT_FLAG) {
 
248
                _close(1);
 
249
                SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);
 
250
            }
 
251
            else if ((file->flags & APR_STD_FLAGS) == APR_STDIN_FLAG) {
 
252
                _close(0);
 
253
                SetStdHandle(STD_INPUT_HANDLE, INVALID_HANDLE_VALUE);
 
254
            }
 
255
        }
 
256
        else
 
257
            CloseHandle(file->filehand);
243
258
 
244
 
        if (file->buffered) {
245
 
            /* XXX: flush here is not mutex protected */
246
 
            flush_rv = apr_file_flush((apr_file_t *)thefile);
247
 
        }
248
 
        CloseHandle(file->filehand);
249
259
        file->filehand = INVALID_HANDLE_VALUE;
250
260
    }
251
261
    if (file->pOverlapped && file->pOverlapped->hEvent) {
574
584
 
575
585
    apr_set_os_error(APR_SUCCESS);
576
586
    file_handle = GetStdHandle(STD_ERROR_HANDLE);
577
 
    if (!file_handle || (file_handle == INVALID_HANDLE_VALUE)) {
578
 
        apr_status_t rv = apr_get_os_error();
579
 
        if (rv == APR_SUCCESS) {
580
 
            return APR_EINVAL;
581
 
        }
582
 
        return rv;
583
 
    }
 
587
    if (!file_handle)
 
588
        file_handle = INVALID_HANDLE_VALUE;
584
589
 
585
 
    return apr_os_file_put(thefile, &file_handle, 0, pool);
 
590
    return apr_os_file_put(thefile, &file_handle,
 
591
                           APR_WRITE | APR_STDERR_FLAG, pool);
586
592
#endif
587
593
}
588
594
 
595
601
 
596
602
    apr_set_os_error(APR_SUCCESS);
597
603
    file_handle = GetStdHandle(STD_OUTPUT_HANDLE);
598
 
    if (!file_handle || (file_handle == INVALID_HANDLE_VALUE)) {
599
 
        apr_status_t rv = apr_get_os_error();
600
 
        if (rv == APR_SUCCESS) {
601
 
            return APR_EINVAL;
602
 
        }
603
 
        return rv;
604
 
    }
 
604
    if (!file_handle)
 
605
        file_handle = INVALID_HANDLE_VALUE;
605
606
 
606
 
    return apr_os_file_put(thefile, &file_handle, 0, pool);
 
607
    return apr_os_file_put(thefile, &file_handle,
 
608
                           APR_WRITE | APR_STDOUT_FLAG, pool);
607
609
#endif
608
610
}
609
611
 
616
618
 
617
619
    apr_set_os_error(APR_SUCCESS);
618
620
    file_handle = GetStdHandle(STD_INPUT_HANDLE);
619
 
    if (!file_handle || (file_handle == INVALID_HANDLE_VALUE)) {
620
 
        apr_status_t rv = apr_get_os_error();
621
 
        if (rv == APR_SUCCESS) {
622
 
            return APR_EINVAL;
623
 
        }
624
 
        return rv;
625
 
    }
 
621
    if (!file_handle)
 
622
        file_handle = INVALID_HANDLE_VALUE;
626
623
 
627
 
    return apr_os_file_put(thefile, &file_handle, 0, pool);
 
624
    return apr_os_file_put(thefile, &file_handle,
 
625
                           APR_READ | APR_STDIN_FLAG, pool);
628
626
#endif
629
627
}
630
628