| 1 |
/* ==================================================================== |
| 2 |
* Licensed to the Apache Software Foundation (ASF) under one |
| 3 |
* or more contributor license agreements. See the NOTICE file |
| 4 |
* distributed with this work for additional information |
| 5 |
* regarding copyright ownership. The ASF licenses this file |
| 6 |
* to you under the Apache License, Version 2.0 (the |
| 7 |
* "License"); you may not use this file except in compliance |
| 8 |
* with the License. You may obtain a copy of the License at |
| 9 |
* |
| 10 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 11 |
* |
| 12 |
* Unless required by applicable law or agreed to in writing, |
| 13 |
* software distributed under the License is distributed on an |
| 14 |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| 15 |
* KIND, either express or implied. See the License for the |
| 16 |
* specific language governing permissions and limitations |
| 17 |
* under the License. |
| 18 |
* ==================================================================== |
| 19 |
*/ |
| 20 |
|
| 21 |
#include <apr_pools.h> |
| 22 |
#include <apr_poll.h> |
| 23 |
#include <apr_version.h> |
| 24 |
|
| 25 |
#include "serf.h" |
| 26 |
#include "serf_bucket_util.h" |
| 27 |
|
| 28 |
#include "serf_private.h" |
| 29 |
|
| 30 |
static apr_status_t read_from_client(serf_incoming_t *client) |
| 31 |
{ |
| 32 |
return APR_ENOTIMPL; |
| 33 |
} |
| 34 |
|
| 35 |
static apr_status_t write_to_client(serf_incoming_t *client) |
| 36 |
{ |
| 37 |
return APR_ENOTIMPL; |
| 38 |
} |
| 39 |
|
| 40 |
apr_status_t serf__process_client(serf_incoming_t *client, apr_int16_t events) |
| 41 |
{ |
| 42 |
apr_status_t rv; |
| 43 |
if ((events & APR_POLLIN) != 0) { |
| 44 |
rv = read_from_client(client); |
| 45 |
if (rv) { |
| 46 |
return rv; |
| 47 |
} |
| 48 |
} |
| 49 |
|
| 50 |
if ((events & APR_POLLHUP) != 0) { |
| 51 |
return APR_ECONNRESET; |
| 52 |
} |
| 53 |
|
| 54 |
if ((events & APR_POLLERR) != 0) { |
| 55 |
return APR_EGENERAL; |
| 56 |
} |
| 57 |
|
| 58 |
if ((events & APR_POLLOUT) != 0) { |
| 59 |
rv = write_to_client(client); |
| 60 |
if (rv) { |
| 61 |
return rv; |
| 62 |
} |
| 63 |
} |
| 64 |
|
| 65 |
return APR_SUCCESS; |
| 66 |
} |
| 67 |
|
| 68 |
apr_status_t serf__process_listener(serf_listener_t *l) |
| 69 |
{ |
| 70 |
apr_status_t rv; |
| 71 |
apr_socket_t *in; |
| 72 |
apr_pool_t *p; |
| 73 |
/* THIS IS NOT OPTIMAL */ |
| 74 |
apr_pool_create(&p, l->pool); |
| 75 |
|
| 76 |
rv = apr_socket_accept(&in, l->skt, p); |
| 77 |
|
| 78 |
if (rv) { |
| 79 |
apr_pool_destroy(p); |
| 80 |
return rv; |
| 81 |
} |
| 82 |
|
| 83 |
rv = l->accept_func(l->ctx, l, l->accept_baton, in, p); |
| 84 |
|
| 85 |
if (rv) { |
| 86 |
apr_pool_destroy(p); |
| 87 |
return rv; |
| 88 |
} |
| 89 |
|
| 90 |
return rv; |
| 91 |
} |
| 92 |
|
| 93 |
|
| 94 |
apr_status_t serf_incoming_create( |
| 95 |
serf_incoming_t **client, |
| 96 |
serf_context_t *ctx, |
| 97 |
apr_socket_t *insock, |
| 98 |
void *request_baton, |
| 99 |
serf_incoming_request_cb_t request, |
| 100 |
apr_pool_t *pool) |
| 101 |
{ |
| 102 |
apr_status_t rv; |
| 103 |
serf_incoming_t *ic = apr_palloc(pool, sizeof(*ic)); |
| 104 |
|
| 105 |
ic->ctx = ctx; |
| 106 |
ic->baton.type = SERF_IO_CLIENT; |
| 107 |
ic->baton.u.client = ic; |
| 108 |
ic->request_baton = request_baton; |
| 109 |
ic->request = request; |
| 110 |
ic->skt = insock; |
| 111 |
ic->desc.desc_type = APR_POLL_SOCKET; |
| 112 |
ic->desc.desc.s = ic->skt; |
| 113 |
ic->desc.reqevents = APR_POLLIN; |
| 114 |
|
| 115 |
rv = ctx->pollset_add(ctx->pollset_baton, |
| 116 |
&ic->desc, &ic->baton); |
| 117 |
*client = ic; |
| 118 |
|
| 119 |
return rv; |
| 120 |
} |
| 121 |
|
| 122 |
|
| 123 |
apr_status_t serf_listener_create( |
| 124 |
serf_listener_t **listener, |
| 125 |
serf_context_t *ctx, |
| 126 |
const char *host, |
| 127 |
apr_uint16_t port, |
| 128 |
void *accept_baton, |
| 129 |
serf_accept_client_t accept, |
| 130 |
apr_pool_t *pool) |
| 131 |
{ |
| 132 |
apr_sockaddr_t *sa; |
| 133 |
apr_status_t rv; |
| 134 |
serf_listener_t *l = apr_palloc(pool, sizeof(*l)); |
| 135 |
|
| 136 |
l->ctx = ctx; |
| 137 |
l->baton.type = SERF_IO_LISTENER; |
| 138 |
l->baton.u.listener = l; |
| 139 |
l->accept_func = accept; |
| 140 |
l->accept_baton = accept_baton; |
| 141 |
|
| 142 |
apr_pool_create(&l->pool, pool); |
| 143 |
|
| 144 |
rv = apr_sockaddr_info_get(&sa, host, APR_UNSPEC, port, 0, l->pool); |
| 145 |
if (rv) |
| 146 |
return rv; |
| 147 |
|
| 148 |
rv = apr_socket_create(&l->skt, sa->family, |
| 149 |
SOCK_STREAM, |
| 150 |
#if APR_MAJOR_VERSION > 0 |
| 151 |
APR_PROTO_TCP, |
| 152 |
#endif |
| 153 |
l->pool); |
| 154 |
if (rv) |
| 155 |
return rv; |
| 156 |
|
| 157 |
rv = apr_socket_opt_set(l->skt, APR_SO_REUSEADDR, 1); |
| 158 |
if (rv) |
| 159 |
return rv; |
| 160 |
|
| 161 |
rv = apr_socket_bind(l->skt, sa); |
| 162 |
if (rv) |
| 163 |
return rv; |
| 164 |
|
| 165 |
rv = apr_socket_listen(l->skt, 5); |
| 166 |
if (rv) |
| 167 |
return rv; |
| 168 |
|
| 169 |
l->desc.desc_type = APR_POLL_SOCKET; |
| 170 |
l->desc.desc.s = l->skt; |
| 171 |
l->desc.reqevents = APR_POLLIN; |
| 172 |
|
| 173 |
rv = ctx->pollset_add(ctx->pollset_baton, |
| 174 |
&l->desc, &l->baton); |
| 175 |
if (rv) |
| 176 |
return rv; |
| 177 |
|
| 178 |
*listener = l; |
| 179 |
|
| 180 |
return APR_SUCCESS; |
| 181 |
} |
