contrib/serf/context.c

/* ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

#include <apr_pools.h>
#include <apr_poll.h>
#include <apr_version.h>

#include "serf.h"
#include "serf_bucket_util.h"

#include "serf_private.h"

/**
 * Callback function (implements serf_progress_t). Takes a number of bytes
 * read @a read and bytes written @a written, adds those to the total for this
 * context and notifies an interested party (if any).
 */
void serf__context_progress_delta(
    void *progress_baton,
    apr_off_t read,
    apr_off_t written)
{
    serf_context_t *ctx = progress_baton;

    ctx->progress_read += read;
    ctx->progress_written += written;

    if (ctx->progress_func)
        ctx->progress_func(ctx->progress_baton,
                           ctx->progress_read,
                           ctx->progress_written);
}


/* Check for dirty connections and update their pollsets accordingly. */
static apr_status_t check_dirty_pollsets(serf_context_t *ctx)
{
    int i;

    /* if we're not dirty, return now. */
    if (!ctx->dirty_pollset) {
        return APR_SUCCESS;
    }

    for (i = ctx->conns->nelts; i--; ) {
        serf_connection_t *conn = GET_CONN(ctx, i);
        apr_status_t status;

        /* if this connection isn't dirty, skip it. */
        if (!conn->dirty_conn) {
            continue;
        }

        /* reset this connection's flag before we update. */
        conn->dirty_conn = 0;

        if ((status = serf__conn_update_pollset(conn)) != APR_SUCCESS)
            return status;
    }

    /* reset our context flag now */
    ctx->dirty_pollset = 0;

    return APR_SUCCESS;
}


static apr_status_t pollset_add(void *user_baton,
                                apr_pollfd_t *pfd,
                                void *serf_baton)
{
    serf_pollset_t *s = (serf_pollset_t*)user_baton;
    pfd->client_data = serf_baton;
    return apr_pollset_add(s->pollset, pfd);
}

static apr_status_t pollset_rm(void *user_baton,
                               apr_pollfd_t *pfd,
                               void *serf_baton)
{
    serf_pollset_t *s = (serf_pollset_t*)user_baton;
    pfd->client_data = serf_baton;
    return apr_pollset_remove(s->pollset, pfd);
}


void serf_config_proxy(serf_context_t *ctx,
                       apr_sockaddr_t *address)
{
    ctx->proxy_address = address;
}


void serf_config_credentials_callback(serf_context_t *ctx,
                                      serf_credentials_callback_t cred_cb)
{
    ctx->cred_cb = cred_cb;
}


void serf_config_authn_types(serf_context_t *ctx,
                             int authn_types)
{
    ctx->authn_types = authn_types;
}


serf_context_t *serf_context_create_ex(
    void *user_baton,
    serf_socket_add_t addf,
    serf_socket_remove_t rmf,
    apr_pool_t *pool)
{
    serf_context_t *ctx = apr_pcalloc(pool, sizeof(*ctx));

    ctx->pool = pool;

    if (user_baton != NULL) {
        ctx->pollset_baton = user_baton;
        ctx->pollset_add = addf;
        ctx->pollset_rm = rmf;
    }
    else {
        /* build the pollset with a (default) number of connections */
        serf_pollset_t *ps = apr_pcalloc(pool, sizeof(*ps));

        /* ### TODO: As of APR 1.4.x apr_pollset_create_ex can return a status
           ### other than APR_SUCCESS, so we should handle it.
           ### Probably move creation of the pollset to later when we have
           ### the possibility of returning status to the caller.
         */
#ifdef BROKEN_WSAPOLL
        /* APR 1.4.x switched to using WSAPoll() on Win32, but it does not
         * properly handle errors on a non-blocking sockets (such as
         * connecting to a server where no listener is active).
         *
         * So, sadly, we must force using select() on Win32.
         *
         * http://mail-archives.apache.org/mod_mbox/apr-dev/201105.mbox/%3CBANLkTin3rBCecCBRvzUA5B-14u-NWxR_Kg@mail.gmail.com%3E
         */
        (void) apr_pollset_create_ex(&ps->pollset, MAX_CONN, pool, 0,
                                     APR_POLLSET_SELECT);
#else
        (void) apr_pollset_create(&ps->pollset, MAX_CONN, pool, 0);
#endif
        ctx->pollset_baton = ps;
        ctx->pollset_add = pollset_add;
        ctx->pollset_rm = pollset_rm;
    }

    /* default to a single connection since that is the typical case */
    ctx->conns = apr_array_make(pool, 1, sizeof(serf_connection_t *));

    /* Initialize progress status */
    ctx->progress_read = 0;
    ctx->progress_written = 0;

    ctx->authn_types = SERF_AUTHN_ALL;
    ctx->server_authn_info = apr_hash_make(pool);

    return ctx;
}


serf_context_t *serf_context_create(apr_pool_t *pool)
{
    return serf_context_create_ex(NULL, NULL, NULL, pool);
}

apr_status_t serf_context_prerun(serf_context_t *ctx)
{
    apr_status_t status = APR_SUCCESS;
    if ((status = serf__open_connections(ctx)) != APR_SUCCESS)
        return status;

    if ((status = check_dirty_pollsets(ctx)) != APR_SUCCESS)
        return status;
    return status;
}


apr_status_t serf_event_trigger(
    serf_context_t *s,
    void *serf_baton,
    const apr_pollfd_t *desc)
{
    apr_pollfd_t tdesc = { 0 };
    apr_status_t status = APR_SUCCESS;
    serf_io_baton_t *io = serf_baton;

    if (io->type == SERF_IO_CONN) {
        serf_connection_t *conn = io->u.conn;
        serf_context_t *ctx = conn->ctx;

        /* If this connection has already failed, return the error again, and try
         * to remove it from the pollset again
         */
        if (conn->status) {
            tdesc.desc_type = APR_POLL_SOCKET;
            tdesc.desc.s = conn->skt;
            tdesc.reqevents = conn->reqevents;
            ctx->pollset_rm(ctx->pollset_baton,
                            &tdesc, &conn->baton);
            return conn->status;
        }
        /* apr_pollset_poll() can return a conn multiple times... */
        if ((conn->seen_in_pollset & desc->rtnevents) != 0 ||
            (conn->seen_in_pollset & APR_POLLHUP) != 0) {
            return APR_SUCCESS;
        }

        conn->seen_in_pollset |= desc->rtnevents;

        if ((conn->status = serf__process_connection(conn,
                                         desc->rtnevents)) != APR_SUCCESS) {

            /* it's possible that the connection was already reset and thus the
               socket cleaned up. */
            if (conn->skt) {
                tdesc.desc_type = APR_POLL_SOCKET;
                tdesc.desc.s = conn->skt;
                tdesc.reqevents = conn->reqevents;
                ctx->pollset_rm(ctx->pollset_baton,
                                &tdesc, &conn->baton);
            }
            return conn->status;
        }
    }
    else if (io->type == SERF_IO_LISTENER) {
        serf_listener_t *l = io->u.listener;

        status = serf__process_listener(l);

        if (status) {
            return status;
        }
    }
    else if (io->type == SERF_IO_CLIENT) {
        serf_incoming_t *c = io->u.client;

        status = serf__process_client(c, desc->rtnevents);

        if (status) {
            return status;
        }
    }
    return status;
}


apr_status_t serf_context_run(
    serf_context_t *ctx,
    apr_short_interval_time_t duration,
    apr_pool_t *pool)
{
    apr_status_t status;
    apr_int32_t num;
    const apr_pollfd_t *desc;
    serf_pollset_t *ps = (serf_pollset_t*)ctx->pollset_baton;

    if ((status = serf_context_prerun(ctx)) != APR_SUCCESS) {
        return status;
    }

    if ((status = apr_pollset_poll(ps->pollset, duration, &num,
                                   &desc)) != APR_SUCCESS) {
        /* EINTR indicates a handled signal happened during the poll call,
           ignore, the application can safely retry. */
        if (APR_STATUS_IS_EINTR(status))
            return APR_SUCCESS;

        /* ### do we still need to dispatch stuff here?
           ### look at the potential return codes. map to our defined
           ### return values? ...
        */

        /* Use the strict documented error for poll timeouts, to allow proper
           handling of the other timeout types when returned from
           serf_event_trigger */
        if (APR_STATUS_IS_TIMEUP(status))
            return APR_TIMEUP; /* Return the documented error */
        return status;
    }

    while (num--) {
        serf_io_baton_t *io  = desc->client_data;

        status = serf_event_trigger(ctx, io, desc);
        if (status) {
            return status;
        }

        desc++;
    }

    return APR_SUCCESS;
}


void serf_context_set_progress_cb(
    serf_context_t *ctx,
    const serf_progress_t progress_func,
    void *progress_baton)
{
    ctx->progress_func = progress_func;
    ctx->progress_baton = progress_baton;
}


serf_bucket_t *serf_context_bucket_socket_create(
    serf_context_t *ctx,
    apr_socket_t *skt,
    serf_bucket_alloc_t *allocator)
{
    serf_bucket_t *bucket = serf_bucket_socket_create(skt, allocator);

    /* Use serf's default bytes read/written callback */
    serf_bucket_socket_set_read_progress_cb(bucket,
                                            serf__context_progress_delta,
                                            ctx);

    return bucket;
}


/* ### this really ought to go somewhere else, but... meh.  */
void serf_lib_version(int *major, int *minor, int *patch)
{
    *major = SERF_MAJOR_VERSION;
    *minor = SERF_MINOR_VERSION;
    *patch = SERF_PATCH_VERSION;
}


const char *serf_error_string(apr_status_t errcode)
{
    switch (errcode)
    {
    case SERF_ERROR_CLOSING:
        return "The connection is closing";
    case SERF_ERROR_REQUEST_LOST:
        return "A request has been lost";
    case SERF_ERROR_WAIT_CONN:
        return "The connection is blocked, pending further action";
    case SERF_ERROR_DECOMPRESSION_FAILED:
        return "An error occurred during decompression";
    case SERF_ERROR_BAD_HTTP_RESPONSE:
        return "The server sent an improper HTTP response";
    case SERF_ERROR_TRUNCATED_HTTP_RESPONSE:
        return "The server sent a truncated HTTP response body.";
    case SERF_ERROR_ABORTED_CONNECTION:
        return "The server unexpectedly closed the connection.";
    case SERF_ERROR_SSL_COMM_FAILED:
        return "An error occurred during SSL communication";
    case SERF_ERROR_SSL_CERT_FAILED:
        return "An SSL certificate related error occurred ";
    case SERF_ERROR_AUTHN_FAILED:
        return "An error occurred during authentication";
    case SERF_ERROR_AUTHN_NOT_SUPPORTED:
        return "The requested authentication type(s) are not supported";
    case SERF_ERROR_AUTHN_MISSING_ATTRIBUTE:
        return "An authentication attribute is missing";
    case SERF_ERROR_AUTHN_INITALIZATION_FAILED:
        return "Initialization of an authentication type failed";
    case SERF_ERROR_SSLTUNNEL_SETUP_FAILED:
        return "The proxy server returned an error while setting up the "
               "SSL tunnel.";
    default:
        return NULL;
    }

    /* NOTREACHED  */
}
Revision:	9268
Committed:	Mon Feb 20 02:52:22 2017 UTC (7 years, 2 months ago) by laffer1
Content type:	text/plain
File size:	11892 byte(s)
Log Message:	merge in serf 1.3.9
#	Content
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	/**
31	* Callback function (implements serf_progress_t). Takes a number of bytes
32	* read @a read and bytes written @a written, adds those to the total for this
33	* context and notifies an interested party (if any).
34	*/
35	void serf__context_progress_delta(
36	void *progress_baton,
37	apr_off_t read,
38	apr_off_t written)
39	{
40	serf_context_t *ctx = progress_baton;
41
42	ctx->progress_read += read;
43	ctx->progress_written += written;
44
45	if (ctx->progress_func)
46	ctx->progress_func(ctx->progress_baton,
47	ctx->progress_read,
48	ctx->progress_written);
49	}
50
51
52	/* Check for dirty connections and update their pollsets accordingly. */
53	static apr_status_t check_dirty_pollsets(serf_context_t *ctx)
54	{
55	int i;
56
57	/* if we're not dirty, return now. */
58	if (!ctx->dirty_pollset) {
59	return APR_SUCCESS;
60	}
61
62	for (i = ctx->conns->nelts; i--; ) {
63	serf_connection_t *conn = GET_CONN(ctx, i);
64	apr_status_t status;
65
66	/* if this connection isn't dirty, skip it. */
67	if (!conn->dirty_conn) {
68	continue;
69	}
70
71	/* reset this connection's flag before we update. */
72	conn->dirty_conn = 0;
73
74	if ((status = serf__conn_update_pollset(conn)) != APR_SUCCESS)
75	return status;
76	}
77
78	/* reset our context flag now */
79	ctx->dirty_pollset = 0;
80
81	return APR_SUCCESS;
82	}
83
84
85	static apr_status_t pollset_add(void *user_baton,
86	apr_pollfd_t *pfd,
87	void *serf_baton)
88	{
89	serf_pollset_t s = (serf_pollset_t)user_baton;
90	pfd->client_data = serf_baton;
91	return apr_pollset_add(s->pollset, pfd);
92	}
93
94	static apr_status_t pollset_rm(void *user_baton,
95	apr_pollfd_t *pfd,
96	void *serf_baton)
97	{
98	serf_pollset_t s = (serf_pollset_t)user_baton;
99	pfd->client_data = serf_baton;
100	return apr_pollset_remove(s->pollset, pfd);
101	}
102
103
104	void serf_config_proxy(serf_context_t *ctx,
105	apr_sockaddr_t *address)
106	{
107	ctx->proxy_address = address;
108	}
109
110
111	void serf_config_credentials_callback(serf_context_t *ctx,
112	serf_credentials_callback_t cred_cb)
113	{
114	ctx->cred_cb = cred_cb;
115	}
116
117
118	void serf_config_authn_types(serf_context_t *ctx,
119	int authn_types)
120	{
121	ctx->authn_types = authn_types;
122	}
123
124
125	serf_context_t *serf_context_create_ex(
126	void *user_baton,
127	serf_socket_add_t addf,
128	serf_socket_remove_t rmf,
129	apr_pool_t *pool)
130	{
131	serf_context_t ctx = apr_pcalloc(pool, sizeof(ctx));
132
133	ctx->pool = pool;
134
135	if (user_baton != NULL) {
136	ctx->pollset_baton = user_baton;
137	ctx->pollset_add = addf;
138	ctx->pollset_rm = rmf;
139	}
140	else {
141	/* build the pollset with a (default) number of connections */
142	serf_pollset_t ps = apr_pcalloc(pool, sizeof(ps));
143
144	/* ### TODO: As of APR 1.4.x apr_pollset_create_ex can return a status
145	### other than APR_SUCCESS, so we should handle it.
146	### Probably move creation of the pollset to later when we have
147	### the possibility of returning status to the caller.
148	*/
149	#ifdef BROKEN_WSAPOLL
150	/* APR 1.4.x switched to using WSAPoll() on Win32, but it does not
151	* properly handle errors on a non-blocking sockets (such as
152	* connecting to a server where no listener is active).
153	*
154	* So, sadly, we must force using select() on Win32.
155	*
156	* http://mail-archives.apache.org/mod_mbox/apr-dev/201105.mbox/%3CBANLkTin3rBCecCBRvzUA5B-14u-NWxR_Kg@mail.gmail.com%3E
157	*/
158	(void) apr_pollset_create_ex(&ps->pollset, MAX_CONN, pool, 0,
159	APR_POLLSET_SELECT);
160	#else
161	(void) apr_pollset_create(&ps->pollset, MAX_CONN, pool, 0);
162	#endif
163	ctx->pollset_baton = ps;
164	ctx->pollset_add = pollset_add;
165	ctx->pollset_rm = pollset_rm;
166	}
167
168	/* default to a single connection since that is the typical case */
169	ctx->conns = apr_array_make(pool, 1, sizeof(serf_connection_t *));
170
171	/* Initialize progress status */
172	ctx->progress_read = 0;
173	ctx->progress_written = 0;
174
175	ctx->authn_types = SERF_AUTHN_ALL;
176	ctx->server_authn_info = apr_hash_make(pool);
177
178	return ctx;
179	}
180
181
182	serf_context_t serf_context_create(apr_pool_t pool)
183	{
184	return serf_context_create_ex(NULL, NULL, NULL, pool);
185	}
186
187	apr_status_t serf_context_prerun(serf_context_t *ctx)
188	{
189	apr_status_t status = APR_SUCCESS;
190	if ((status = serf__open_connections(ctx)) != APR_SUCCESS)
191	return status;
192
193	if ((status = check_dirty_pollsets(ctx)) != APR_SUCCESS)
194	return status;
195	return status;
196	}
197
198
199	apr_status_t serf_event_trigger(
200	serf_context_t *s,
201	void *serf_baton,
202	const apr_pollfd_t *desc)
203	{
204	apr_pollfd_t tdesc = { 0 };
205	apr_status_t status = APR_SUCCESS;
206	serf_io_baton_t *io = serf_baton;
207
208	if (io->type == SERF_IO_CONN) {
209	serf_connection_t *conn = io->u.conn;
210	serf_context_t *ctx = conn->ctx;
211
212	/* If this connection has already failed, return the error again, and try
213	* to remove it from the pollset again
214	*/
215	if (conn->status) {
216	tdesc.desc_type = APR_POLL_SOCKET;
217	tdesc.desc.s = conn->skt;
218	tdesc.reqevents = conn->reqevents;
219	ctx->pollset_rm(ctx->pollset_baton,
220	&tdesc, &conn->baton);
221	return conn->status;
222	}
223	/* apr_pollset_poll() can return a conn multiple times... */
224	if ((conn->seen_in_pollset & desc->rtnevents) != 0 \|\|
225	(conn->seen_in_pollset & APR_POLLHUP) != 0) {
226	return APR_SUCCESS;
227	}
228
229	conn->seen_in_pollset \|= desc->rtnevents;
230
231	if ((conn->status = serf__process_connection(conn,
232	desc->rtnevents)) != APR_SUCCESS) {
233
234	/* it's possible that the connection was already reset and thus the
235	socket cleaned up. */
236	if (conn->skt) {
237	tdesc.desc_type = APR_POLL_SOCKET;
238	tdesc.desc.s = conn->skt;
239	tdesc.reqevents = conn->reqevents;
240	ctx->pollset_rm(ctx->pollset_baton,
241	&tdesc, &conn->baton);
242	}
243	return conn->status;
244	}
245	}
246	else if (io->type == SERF_IO_LISTENER) {
247	serf_listener_t *l = io->u.listener;
248
249	status = serf__process_listener(l);
250
251	if (status) {
252	return status;
253	}
254	}
255	else if (io->type == SERF_IO_CLIENT) {
256	serf_incoming_t *c = io->u.client;
257
258	status = serf__process_client(c, desc->rtnevents);
259
260	if (status) {
261	return status;
262	}
263	}
264	return status;
265	}
266
267
268	apr_status_t serf_context_run(
269	serf_context_t *ctx,
270	apr_short_interval_time_t duration,
271	apr_pool_t *pool)
272	{
273	apr_status_t status;
274	apr_int32_t num;
275	const apr_pollfd_t *desc;
276	serf_pollset_t ps = (serf_pollset_t)ctx->pollset_baton;
277
278	if ((status = serf_context_prerun(ctx)) != APR_SUCCESS) {
279	return status;
280	}
281
282	if ((status = apr_pollset_poll(ps->pollset, duration, &num,
283	&desc)) != APR_SUCCESS) {
284	/* EINTR indicates a handled signal happened during the poll call,
285	ignore, the application can safely retry. */
286	if (APR_STATUS_IS_EINTR(status))
287	return APR_SUCCESS;
288
289	/* ### do we still need to dispatch stuff here?
290	### look at the potential return codes. map to our defined
291	### return values? ...
292	*/
293
294	/* Use the strict documented error for poll timeouts, to allow proper
295	handling of the other timeout types when returned from
296	serf_event_trigger */
297	if (APR_STATUS_IS_TIMEUP(status))
298	return APR_TIMEUP; /* Return the documented error */
299	return status;
300	}
301
302	while (num--) {
303	serf_io_baton_t *io = desc->client_data;
304
305	status = serf_event_trigger(ctx, io, desc);
306	if (status) {
307	return status;
308	}
309
310	desc++;
311	}
312
313	return APR_SUCCESS;
314	}
315
316
317	void serf_context_set_progress_cb(
318	serf_context_t *ctx,
319	const serf_progress_t progress_func,
320	void *progress_baton)
321	{
322	ctx->progress_func = progress_func;
323	ctx->progress_baton = progress_baton;
324	}
325
326
327	serf_bucket_t *serf_context_bucket_socket_create(
328	serf_context_t *ctx,
329	apr_socket_t *skt,
330	serf_bucket_alloc_t *allocator)
331	{
332	serf_bucket_t *bucket = serf_bucket_socket_create(skt, allocator);
333
334	/* Use serf's default bytes read/written callback */
335	serf_bucket_socket_set_read_progress_cb(bucket,
336	serf__context_progress_delta,
337	ctx);
338
339	return bucket;
340	}
341
342
343	/* ### this really ought to go somewhere else, but... meh. */
344	void serf_lib_version(int major, int minor, int *patch)
345	{
346	*major = SERF_MAJOR_VERSION;
347	*minor = SERF_MINOR_VERSION;
348	*patch = SERF_PATCH_VERSION;
349	}
350
351
352	const char *serf_error_string(apr_status_t errcode)
353	{
354	switch (errcode)
355	{
356	case SERF_ERROR_CLOSING:
357	return "The connection is closing";
358	case SERF_ERROR_REQUEST_LOST:
359	return "A request has been lost";
360	case SERF_ERROR_WAIT_CONN:
361	return "The connection is blocked, pending further action";
362	case SERF_ERROR_DECOMPRESSION_FAILED:
363	return "An error occurred during decompression";
364	case SERF_ERROR_BAD_HTTP_RESPONSE:
365	return "The server sent an improper HTTP response";
366	case SERF_ERROR_TRUNCATED_HTTP_RESPONSE:
367	return "The server sent a truncated HTTP response body.";
368	case SERF_ERROR_ABORTED_CONNECTION:
369	return "The server unexpectedly closed the connection.";
370	case SERF_ERROR_SSL_COMM_FAILED:
371	return "An error occurred during SSL communication";
372	case SERF_ERROR_SSL_CERT_FAILED:
373	return "An SSL certificate related error occurred ";
374	case SERF_ERROR_AUTHN_FAILED:
375	return "An error occurred during authentication";
376	case SERF_ERROR_AUTHN_NOT_SUPPORTED:
377	return "The requested authentication type(s) are not supported";
378	case SERF_ERROR_AUTHN_MISSING_ATTRIBUTE:
379	return "An authentication attribute is missing";
380	case SERF_ERROR_AUTHN_INITALIZATION_FAILED:
381	return "Initialization of an authentication type failed";
382	case SERF_ERROR_SSLTUNNEL_SETUP_FAILED:
383	return "The proxy server returned an error while setting up the "
384	"SSL tunnel.";
385	default:
386	return NULL;
387	}
388
389	/* NOTREACHED */
390	}