1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18#include <nks/fsio.h>
19#include <nks/errno.h>
20
21#include "apr_arch_file_io.h"
22#include "apr_strings.h"
23#include "apr_portable.h"
24#include "apr_arch_inherit.h"
25
26static apr_status_t pipeblock(apr_file_t *thepipe)
27{
28#ifdef USE_FLAGS
29	unsigned long	flags;
30
31	if (fcntl(thepipe->filedes, F_GETFL, &flags) != -1)
32	{
33		flags &= ~FNDELAY;
34		fcntl(thepipe->filedes, F_SETFL, flags);
35	}
36#else
37        errno = 0;
38		fcntl(thepipe->filedes, F_SETFL, 0);
39#endif
40
41    if (errno)
42        return errno;
43
44    thepipe->blocking = BLK_ON;
45    return APR_SUCCESS;
46}
47
48static apr_status_t pipenonblock(apr_file_t *thepipe)
49{
50#ifdef USE_FLAGS
51	unsigned long	flags;
52
53    errno = 0;
54	if (fcntl(thepipe->filedes, F_GETFL, &flags) != -1)
55	{
56		flags |= FNDELAY;
57		fcntl(thepipe->filedes, F_SETFL, flags);
58	}
59#else
60        errno = 0;
61		fcntl(thepipe->filedes, F_SETFL, FNDELAY);
62#endif
63
64    if (errno)
65        return errno;
66
67    thepipe->blocking = BLK_OFF;
68    return APR_SUCCESS;
69}
70
71APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
72{
73    if (thepipe->is_pipe == 1) {
74        thepipe->timeout = timeout;
75        if (timeout >= 0) {
76            if (thepipe->blocking != BLK_OFF) { /* blocking or unknown state */
77                return pipenonblock(thepipe);
78            }
79        }
80        else {
81            if (thepipe->blocking != BLK_ON) { /* non-blocking or unknown state */
82                return pipeblock(thepipe);
83            }
84        }
85        return APR_SUCCESS;
86    }
87    return APR_EINVAL;
88}
89
90APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
91{
92    if (thepipe->is_pipe == 1) {
93        *timeout = thepipe->timeout;
94        return APR_SUCCESS;
95    }
96    return APR_EINVAL;
97}
98
99APR_DECLARE(apr_status_t) apr_os_pipe_put_ex(apr_file_t **file,
100                                             apr_os_file_t *thefile,
101                                             int register_cleanup,
102                                             apr_pool_t *pool)
103{
104    int *dafile = thefile;
105
106    (*file) = apr_pcalloc(pool, sizeof(apr_file_t));
107    (*file)->pool = pool;
108    (*file)->eof_hit = 0;
109    (*file)->is_pipe = 1;
110    (*file)->blocking = BLK_UNKNOWN; /* app needs to make a timeout call */
111    (*file)->timeout = -1;
112    (*file)->ungetchar = -1; /* no char avail */
113    (*file)->filedes = *dafile;
114    if (!register_cleanup) {
115        (*file)->flags = APR_FOPEN_NOCLEANUP;
116    }
117    (*file)->buffered = 0;
118#if APR_HAS_THREADS
119    (*file)->thlock = NULL;
120#endif
121    if (register_cleanup) {
122        apr_pool_cleanup_register((*file)->pool, (void *)(*file),
123                                  apr_unix_file_cleanup,
124                                  apr_pool_cleanup_null);
125    }
126    return APR_SUCCESS;
127}
128
129APR_DECLARE(apr_status_t) apr_os_pipe_put(apr_file_t **file,
130                                          apr_os_file_t *thefile,
131                                          apr_pool_t *pool)
132{
133    return apr_os_pipe_put_ex(file, thefile, 0, pool);
134}
135
136APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool)
137{
138	int     	filedes[2];
139
140    if (pipe(filedes) == -1) {
141        return errno;
142    }
143
144    (*in) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
145    (*out) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
146
147    (*in)->pool     =
148    (*out)->pool    = pool;
149    (*in)->filedes   = filedes[0];
150    (*out)->filedes  = filedes[1];
151    (*in)->flags     = APR_INHERIT;
152    (*out)->flags    = APR_INHERIT;
153    (*in)->is_pipe      =
154    (*out)->is_pipe     = 1;
155    (*out)->fname    =
156    (*in)->fname     = NULL;
157    (*in)->buffered  =
158    (*out)->buffered = 0;
159    (*in)->blocking  =
160    (*out)->blocking = BLK_ON;
161    (*in)->timeout   =
162    (*out)->timeout  = -1;
163    (*in)->ungetchar = -1;
164    (*in)->thlock    =
165    (*out)->thlock   = NULL;
166    (void) apr_pollset_create(&(*in)->pollset, 1, pool, 0);
167    (void) apr_pollset_create(&(*out)->pollset, 1, pool, 0);
168
169    apr_pool_cleanup_register((*in)->pool, (void *)(*in), apr_unix_file_cleanup,
170                         apr_pool_cleanup_null);
171    apr_pool_cleanup_register((*out)->pool, (void *)(*out), apr_unix_file_cleanup,
172                         apr_pool_cleanup_null);
173
174    return APR_SUCCESS;
175}
176
177APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in,
178                                                  apr_file_t **out,
179                                                  apr_int32_t blocking,
180                                                  apr_pool_t *pool)
181{
182    apr_status_t status;
183
184    if ((status = apr_file_pipe_create(in, out, pool)) != APR_SUCCESS)
185        return status;
186
187    switch (blocking) {
188        case APR_FULL_BLOCK:
189            break;
190        case APR_READ_BLOCK:
191            apr_file_pipe_timeout_set(*out, 0);
192            break;
193        case APR_WRITE_BLOCK:
194            apr_file_pipe_timeout_set(*in, 0);
195            break;
196        default:
197            apr_file_pipe_timeout_set(*out, 0);
198            apr_file_pipe_timeout_set(*in, 0);
199    }
200
201    return APR_SUCCESS;
202}
203
204APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename,
205                                                    apr_fileperms_t perm, apr_pool_t *pool)
206{
207    return APR_ENOTIMPL;
208}
209
210
211
212