← Back to branch summary

~ubuntu-branches/ubuntu/trusty/serf/trusty-proposed

« back to all changes in this revision

Viewing changes to incoming.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Samuelson
  • Date: 2011-06-03 03:18:07 UTC
  • mto: (9.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20110603031807-6y8ky58ac0q82etq
Tags: upstream-0.7.2
Import upstream version 0.7.2

Show diffs side-by-side

added added

removed removed

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