1 /*
2 * streams.c : stream encapsulation routines for the ra_svn protocol
3 *
4 * ====================================================================
5 * Licensed to the Apache Software Foundation (ASF) under one
6 * or more contributor license agreements. See the NOTICE file
7 * distributed with this work for additional information
8 * regarding copyright ownership. The ASF licenses this file
9 * to you under the Apache License, Version 2.0 (the
10 * "License"); you may not use this file except in compliance
11 * with the License. You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing,
16 * software distributed under the License is distributed on an
17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
18 * KIND, either express or implied. See the License for the
19 * specific language governing permissions and limitations
20 * under the License.
21 * ====================================================================
22 */
23
24
25
26 #include <apr_general.h>
27 #include <apr_network_io.h>
28 #include <apr_poll.h>
29
30 #include "svn_types.h"
31 #include "svn_error.h"
32 #include "svn_pools.h"
33 #include "svn_io.h"
34 #include "svn_private_config.h"
35
36 #include "ra_svn.h"
37
38 struct svn_ra_svn__stream_st {
39 svn_stream_t *stream;
40 void *baton;
41 ra_svn_pending_fn_t pending_fn;
42 ra_svn_timeout_fn_t timeout_fn;
43 };
44
45 typedef struct sock_baton_t {
46 apr_socket_t *sock;
47 apr_pool_t *pool;
48 } sock_baton_t;
49
50 typedef struct file_baton_t {
51 apr_file_t *in_file;
52 apr_file_t *out_file;
53 apr_pool_t *pool;
54 } file_baton_t;
55
56 /* Returns TRUE if PFD has pending data, FALSE otherwise. */
pending(apr_pollfd_t * pfd,apr_pool_t * pool)57 static svn_boolean_t pending(apr_pollfd_t *pfd, apr_pool_t *pool)
58 {
59 apr_status_t status;
60 int n;
61
62 pfd->p = pool;
63 pfd->reqevents = APR_POLLIN;
64 status = apr_poll(pfd, 1, &n, 0);
65 return (status == APR_SUCCESS && n);
66 }
67
68 /* Functions to implement a file backed svn_ra_svn__stream_t. */
69
70 /* Implements svn_read_fn_t */
71 static svn_error_t *
file_read_cb(void * baton,char * buffer,apr_size_t * len)72 file_read_cb(void *baton, char *buffer, apr_size_t *len)
73 {
74 file_baton_t *b = baton;
75 apr_status_t status = apr_file_read(b->in_file, buffer, len);
76
77 if (status && !APR_STATUS_IS_EOF(status))
78 return svn_error_wrap_apr(status, _("Can't read from connection"));
79 if (*len == 0)
80 return svn_error_create(SVN_ERR_RA_SVN_CONNECTION_CLOSED, NULL, NULL);
81 return SVN_NO_ERROR;
82 }
83
84 /* Implements svn_write_fn_t */
85 static svn_error_t *
file_write_cb(void * baton,const char * buffer,apr_size_t * len)86 file_write_cb(void *baton, const char *buffer, apr_size_t *len)
87 {
88 file_baton_t *b = baton;
89 apr_status_t status = apr_file_write(b->out_file, buffer, len);
90 if (status)
91 return svn_error_wrap_apr(status, _("Can't write to connection"));
92 return SVN_NO_ERROR;
93 }
94
95 /* Implements ra_svn_timeout_fn_t */
96 static void
file_timeout_cb(void * baton,apr_interval_time_t interval)97 file_timeout_cb(void *baton, apr_interval_time_t interval)
98 {
99 file_baton_t *b = baton;
100 apr_file_pipe_timeout_set(b->out_file, interval);
101 }
102
103 /* Implements ra_svn_pending_fn_t */
104 static svn_boolean_t
file_pending_cb(void * baton)105 file_pending_cb(void *baton)
106 {
107 file_baton_t *b = baton;
108 apr_pollfd_t pfd;
109
110 pfd.desc_type = APR_POLL_FILE;
111 pfd.desc.f = b->in_file;
112
113 return pending(&pfd, b->pool);
114 }
115
116 svn_ra_svn__stream_t *
svn_ra_svn__stream_from_files(apr_file_t * in_file,apr_file_t * out_file,apr_pool_t * pool)117 svn_ra_svn__stream_from_files(apr_file_t *in_file,
118 apr_file_t *out_file,
119 apr_pool_t *pool)
120 {
121 file_baton_t *b = apr_palloc(pool, sizeof(*b));
122
123 b->in_file = in_file;
124 b->out_file = out_file;
125 b->pool = pool;
126
127 return svn_ra_svn__stream_create(b, file_read_cb, file_write_cb,
128 file_timeout_cb, file_pending_cb,
129 pool);
130 }
131
132 /* Functions to implement a socket backed svn_ra_svn__stream_t. */
133
134 /* Implements svn_read_fn_t */
135 static svn_error_t *
sock_read_cb(void * baton,char * buffer,apr_size_t * len)136 sock_read_cb(void *baton, char *buffer, apr_size_t *len)
137 {
138 sock_baton_t *b = baton;
139 apr_status_t status;
140 apr_interval_time_t interval;
141
142 status = apr_socket_timeout_get(b->sock, &interval);
143 if (status)
144 return svn_error_wrap_apr(status, _("Can't get socket timeout"));
145
146 /* Always block on read.
147 * During pipelining, we set the timeout to 0 for some write
148 * operations so that we can try them without blocking. If APR had
149 * separate timeouts for read and write, we would only set the
150 * write timeout, but it doesn't. So here, we revert back to blocking.
151 */
152 apr_socket_timeout_set(b->sock, -1);
153 status = apr_socket_recv(b->sock, buffer, len);
154 apr_socket_timeout_set(b->sock, interval);
155
156 if (status && !APR_STATUS_IS_EOF(status))
157 return svn_error_wrap_apr(status, _("Can't read from connection"));
158 if (*len == 0)
159 return svn_error_create(SVN_ERR_RA_SVN_CONNECTION_CLOSED, NULL, NULL);
160 return SVN_NO_ERROR;
161 }
162
163 /* Implements svn_write_fn_t */
164 static svn_error_t *
sock_write_cb(void * baton,const char * buffer,apr_size_t * len)165 sock_write_cb(void *baton, const char *buffer, apr_size_t *len)
166 {
167 sock_baton_t *b = baton;
168 apr_status_t status = apr_socket_send(b->sock, buffer, len);
169 if (status)
170 return svn_error_wrap_apr(status, _("Can't write to connection"));
171 return SVN_NO_ERROR;
172 }
173
174 /* Implements ra_svn_timeout_fn_t */
175 static void
sock_timeout_cb(void * baton,apr_interval_time_t interval)176 sock_timeout_cb(void *baton, apr_interval_time_t interval)
177 {
178 sock_baton_t *b = baton;
179 apr_socket_timeout_set(b->sock, interval);
180 }
181
182 /* Implements ra_svn_pending_fn_t */
183 static svn_boolean_t
sock_pending_cb(void * baton)184 sock_pending_cb(void *baton)
185 {
186 sock_baton_t *b = baton;
187 apr_pollfd_t pfd;
188
189 pfd.desc_type = APR_POLL_SOCKET;
190 pfd.desc.s = b->sock;
191
192 return pending(&pfd, b->pool);
193 }
194
195 svn_ra_svn__stream_t *
svn_ra_svn__stream_from_sock(apr_socket_t * sock,apr_pool_t * pool)196 svn_ra_svn__stream_from_sock(apr_socket_t *sock,
197 apr_pool_t *pool)
198 {
199 sock_baton_t *b = apr_palloc(pool, sizeof(*b));
200
201 b->sock = sock;
202 b->pool = pool;
203
204 return svn_ra_svn__stream_create(b, sock_read_cb, sock_write_cb,
205 sock_timeout_cb, sock_pending_cb,
206 pool);
207 }
208
209 svn_ra_svn__stream_t *
svn_ra_svn__stream_create(void * baton,svn_read_fn_t read_cb,svn_write_fn_t write_cb,ra_svn_timeout_fn_t timeout_cb,ra_svn_pending_fn_t pending_cb,apr_pool_t * pool)210 svn_ra_svn__stream_create(void *baton,
211 svn_read_fn_t read_cb,
212 svn_write_fn_t write_cb,
213 ra_svn_timeout_fn_t timeout_cb,
214 ra_svn_pending_fn_t pending_cb,
215 apr_pool_t *pool)
216 {
217 svn_ra_svn__stream_t *s = apr_palloc(pool, sizeof(*s));
218 s->stream = svn_stream_empty(pool);
219 svn_stream_set_baton(s->stream, baton);
220 if (read_cb)
221 svn_stream_set_read(s->stream, read_cb);
222 if (write_cb)
223 svn_stream_set_write(s->stream, write_cb);
224 s->baton = baton;
225 s->timeout_fn = timeout_cb;
226 s->pending_fn = pending_cb;
227 return s;
228 }
229
230 svn_error_t *
svn_ra_svn__stream_write(svn_ra_svn__stream_t * stream,const char * data,apr_size_t * len)231 svn_ra_svn__stream_write(svn_ra_svn__stream_t *stream,
232 const char *data, apr_size_t *len)
233 {
234 return svn_stream_write(stream->stream, data, len);
235 }
236
237 svn_error_t *
svn_ra_svn__stream_read(svn_ra_svn__stream_t * stream,char * data,apr_size_t * len)238 svn_ra_svn__stream_read(svn_ra_svn__stream_t *stream, char *data,
239 apr_size_t *len)
240 {
241 return svn_stream_read(stream->stream, data, len);
242 }
243
244 void
svn_ra_svn__stream_timeout(svn_ra_svn__stream_t * stream,apr_interval_time_t interval)245 svn_ra_svn__stream_timeout(svn_ra_svn__stream_t *stream,
246 apr_interval_time_t interval)
247 {
248 stream->timeout_fn(stream->baton, interval);
249 }
250
251 svn_boolean_t
svn_ra_svn__stream_pending(svn_ra_svn__stream_t * stream)252 svn_ra_svn__stream_pending(svn_ra_svn__stream_t *stream)
253 {
254 return stream->pending_fn(stream->baton);
255 }
256