← Back to branch summary

~ubuntu-branches/debian/wheezy/apache2/wheezy

« back to all changes in this revision

Viewing changes to srclib/apr-util/test/testssl.c

  • Committer: Package Import Robot
  • Author(s): Stefan Fritsch, Stefan Fritsch, Arno Töll
  • Date: 2012-02-01 21:49:04 UTC
  • mfrom: (0.13.15)
  • Revision ID: package-import@ubuntu.com-20120201214904-nlchebp6wu7z55jw
Tags: 2.2.22-1
http://bugs.debian.org/653801
[ Stefan Fritsch ]
* New upstream release, urgency medium due to security fixes:
  - Fix CVE-2012-0021: mod_log_config: DoS with '%{cookiename}C' log format
  - Fix CVE-2012-0031: Unprivileged child process could cause the parent to
    crash at shutdown
  - Fix CVE-2012-0053: Exposure of "httpOnly" cookies in code 400 error
    message.
* Move httxt2dbm to apache2-utils
* Adjust debian/control to point to new git repository.

[ Arno Töll ]
* Fix "typo in /etc/apache2/apache2.conf" (Closes: #653801)

Show diffs side-by-side

added added

removed removed

Lines of Context:
srclib/apr-util/test/testssl.c
 
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
 * testssl: Simple APR SSL sockets test.
 
18
 */
 
19
 
 
20
#include "apr.h"
 
21
#include "apr_general.h"
 
22
#include "apr_pools.h"
 
23
#include "apr_errno.h"
 
24
#include "apr_getopt.h"
 
25
#include "apr_time.h"
 
26
#define APR_WANT_STRFUNC
 
27
#include "apr_want.h"
 
28
 
 
29
#include "apr_ssl.h"
 
30
#include "apr_network_io.h"
 
31
 
 
32
#if APR_HAVE_STDIO_H
 
33
#include <stdio.h>
 
34
#endif
 
35
#if APR_HAVE_UNISTD_H
 
36
#include <unistd.h>
 
37
#endif
 
38
#include <stdlib.h>     /* for atexit(), malloc() */
 
39
#include <string.h>
 
40
 
 
41
struct sslTestCase {
 
42
    char *host;
 
43
    int port;
 
44
    const char *request;
 
45
    int result;
 
46
} tests[] = {
 
47
    { "svn.apache.org", 443, "GET / HTTP/1.0\n\n", 1 },
 
48
    { NULL }
 
49
};
 
50
 
 
51
static apr_ssl_socket_t *createSocket(apr_ssl_factory_t *asf, 
 
52
                                      apr_pollset_t *pollset,
 
53
                                      apr_pool_t *pool, int blocking)
 
54
{
 
55
    apr_ssl_socket_t *sock;
 
56
    apr_status_t rv;
 
57
    printf("::Creating SSL socket\n");
 
58
    rv = apr_ssl_socket_create(&sock, AF_INET, SOCK_STREAM, 0, asf, NULL);
 
59
    if (rv != APR_SUCCESS) {
 
60
        printf("\tFailed to create socket\n");
 
61
        return NULL;
 
62
    }
 
63
    rv = apr_pollset_add_ssl_socket(pollset, sock);
 
64
    if (rv != APR_SUCCESS) {
 
65
        printf("\tFailed to add to pollset\n");
 
66
        return NULL;
 
67
    }
 
68
    printf("\tOK\n");
 
69
    return sock;
 
70
}
 
71
 
 
72
static apr_status_t connectSocket(apr_ssl_socket_t *sock,
 
73
                                  const char *host, int port,
 
74
                                  apr_pool_t *pool)
 
75
{
 
76
    apr_status_t rv;
 
77
    apr_sockaddr_t *remoteSA;
 
78
 
 
79
    printf("::Connecting socket\n");
 
80
    rv = apr_sockaddr_info_get(&remoteSA, host, APR_UNSPEC, port, 0, pool);
 
81
    if (rv != APR_SUCCESS) {
 
82
        printf("\tFailed to get address for '%s', port %d\n", host, port);
 
83
        return rv;
 
84
    }
 
85
    rv = apr_ssl_socket_connect(sock, remoteSA);
 
86
    if (rv != APR_SUCCESS) {
 
87
        printf("\tFailed to connect to '%s' port %d\n", host, port);
 
88
        return rv;
 
89
    }
 
90
    printf("\tOK\n");
 
91
    return rv;
 
92
}
 
93
 
 
94
static apr_status_t socketRead(apr_ssl_socket_t *sock,
 
95
                               apr_pollset_t *pollset,
 
96
                               char *buf, apr_size_t *len)
 
97
{
 
98
    int lrv;
 
99
    const apr_pollfd_t *descs = NULL;
 
100
    apr_status_t rv;
 
101
 
 
102
    printf("::Reading from socket\n");
 
103
    rv = apr_ssl_socket_set_poll_events(sock, APR_POLLIN);
 
104
    if (rv != APR_SUCCESS) {
 
105
        printf("\tUnable to change socket poll events!\n");
 
106
        return rv;
 
107
    }
 
108
 
 
109
    rv = apr_pollset_poll(pollset, 30 * APR_USEC_PER_SEC, &lrv, &descs);
 
110
    if (APR_STATUS_IS_TIMEUP(rv)) {
 
111
        printf("\tTime up!\n");
 
112
        return rv;
 
113
    }
 
114
 
 
115
    if (lrv != 1) {
 
116
        printf("\tIncorrect return count, %d\n", lrv);
 
117
        return rv;
 
118
    }
 
119
    if (descs[0].client_data != sock) {
 
120
        printf("\tWrong socket returned?!\n");
 
121
        return rv;
 
122
    }
 
123
    if ((descs[0].rtnevents & APR_POLLIN) == 0) {
 
124
        printf("\tSocket wasn't ready? huh? req [%08x] vs rtn [%08x]\n",
 
125
               descs[0].reqevents, descs[0].rtnevents);
 
126
        return rv;
 
127
    }
 
128
    rv = apr_ssl_socket_recv(sock, buf, len);
 
129
    if (rv == APR_SUCCESS)
 
130
        printf("\tOK, read %d bytes\n", *len);
 
131
    else
 
132
        printf("\tFailed\n");
 
133
    return rv;
 
134
}
 
135
 
 
136
static apr_status_t socketWrite(apr_ssl_socket_t *sock,
 
137
                                apr_pollset_t *pollset,
 
138
                                const char *buf, apr_size_t *len)
 
139
{
 
140
    int lrv;
 
141
    const apr_pollfd_t *descs = NULL;
 
142
    apr_status_t rv;
 
143
 
 
144
    printf("::Writing to socket\n");
 
145
    rv = apr_ssl_socket_set_poll_events(sock, APR_POLLOUT);
 
146
    if (rv != APR_SUCCESS) {
 
147
        printf("\tUnable to change socket poll events!\n");
 
148
        return rv;
 
149
    }
 
150
 
 
151
    rv = apr_pollset_poll(pollset, 30 * APR_USEC_PER_SEC, &lrv, &descs);
 
152
    if (APR_STATUS_IS_TIMEUP(rv)) {
 
153
        printf("\tTime up!\n");
 
154
        return rv;
 
155
    }
 
156
    if (lrv != 1) {
 
157
        printf("\tIncorrect return count, %d\n", lrv);
 
158
        return rv;
 
159
    }
 
160
    if (descs[0].client_data != sock) {
 
161
        printf("\tWrong socket returned?!\n");
 
162
        return rv;
 
163
    }
 
164
    if ((descs[0].rtnevents & APR_POLLOUT) == 0) {
 
165
        printf("\tSocket wasn't ready? huh?\n");
 
166
        return rv;
 
167
    }
 
168
    rv = apr_ssl_socket_send(sock, buf, len);
 
169
    if (rv == APR_SUCCESS)
 
170
        printf("\tOK, wrote %d bytes\n", *len);
 
171
    else
 
172
        printf("\tFailed\n");
 
173
    return rv;
 
174
}
 
175
 
 
176
apr_status_t socketClose(apr_ssl_socket_t *sock, apr_pollset_t *pollset)
 
177
{
 
178
    apr_status_t rv;
 
179
    printf("::Closing socket\n");
 
180
    rv = apr_pollset_remove_ssl_socket(sock);
 
181
    if (rv != APR_SUCCESS)
 
182
        printf("\tUnable to remove socket from pollset?\n");
 
183
    rv = apr_ssl_socket_close(sock);
 
184
    if (rv != APR_SUCCESS)
 
185
        printf("\tFailed to close SSL socket\n");
 
186
    else
 
187
        printf("\tOK\n");
 
188
    return rv;
 
189
}
 
190
 
 
191
 
 
192
int main(int argc, const char * const * argv)
 
193
{
 
194
    apr_pool_t *pool;
 
195
    apr_ssl_factory_t *asf = NULL;
 
196
    apr_status_t rv;
 
197
    apr_pollset_t *pollset;
 
198
 
 
199
    (void) apr_initialize();
 
200
    apr_pool_create(&pool, NULL);
 
201
    atexit(apr_terminate);
 
202
 
 
203
    printf("SSL Library: %s\n", apr_ssl_library_name());
 
204
 
 
205
    if (apr_pollset_create(&pollset, 1, pool, 0) != APR_SUCCESS) {
 
206
        printf("Failed to create pollset!\n");
 
207
        exit(1);
 
208
    }
 
209
 
 
210
    if (apr_ssl_factory_create(&asf, NULL, NULL, NULL, 
 
211
                               APR_SSL_FACTORY_CLIENT, pool) != APR_SUCCESS) {
 
212
        fprintf(stderr, "Unable to create client factory\n");
 
213
    } else {
 
214
        int i;
 
215
        for(i = 0; tests[i].host; i++) {
 
216
            apr_ssl_socket_t *sslSock = createSocket(asf, pollset, pool, 0);
 
217
            if (!sslSock)
 
218
                continue;
 
219
 
 
220
            rv = connectSocket(sslSock, tests[i].host, tests[i].port, pool);
 
221
            if (rv == APR_SUCCESS) {
 
222
                apr_size_t len = strlen(tests[i].request);
 
223
                rv = socketWrite(sslSock, pollset, tests[i].request, &len);
 
224
                if (rv == APR_SUCCESS) {
 
225
                    char buffer[4096];
 
226
                    len = 4096;
 
227
                    rv = socketRead(sslSock, pollset, buffer, &len);
 
228
                }
 
229
            }
 
230
            socketClose(sslSock, pollset);
 
231
        }
 
232
    }
 
233
 
 
234
    apr_pollset_destroy(pollset);
 
235
    apr_pool_destroy(pool);
 
236
 
 
237
    return 0;
 
238
}
 
239
 
 
240