Home | History | Annotate | Line # | Download | only in librumpuser
sp_common.c revision 1.28 
      1 /*      $NetBSD: sp_common.c,v 1.28 2011/02/15 10:37:07 pooka Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2010, 2011 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 /*
     29  * Common client/server sysproxy routines.  #included.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 
     34 #include <sys/types.h>
     35 #include <sys/mman.h>
     36 #include <sys/queue.h>
     37 #include <sys/socket.h>
     38 #include <sys/un.h>
     39 #include <sys/syslimits.h>
     40 
     41 #include <arpa/inet.h>
     42 #include <netinet/in.h>
     43 #include <netinet/tcp.h>
     44 
     45 #include <assert.h>
     46 #include <errno.h>
     47 #include <fcntl.h>
     48 #include <inttypes.h>
     49 #include <poll.h>
     50 #include <pthread.h>
     51 #include <stdarg.h>
     52 #include <stddef.h>
     53 #include <stdio.h>
     54 #include <stdlib.h>
     55 #include <string.h>
     56 #include <unistd.h>
     57 
     58 //#define DEBUG
     59 #ifdef DEBUG
     60 #define DPRINTF(x) mydprintf x
     61 static void
     62 mydprintf(const char *fmt, ...)
     63 {
     64 	va_list ap;
     65 
     66 	va_start(ap, fmt);
     67 	vfprintf(stderr, fmt, ap);
     68 	va_end(ap);
     69 }
     70 #else
     71 #define DPRINTF(x)
     72 #endif
     73 
     74 #ifndef HOSTOPS
     75 #define host_poll poll
     76 #define host_read read
     77 #define host_sendto sendto
     78 #define host_setsockopt setsockopt
     79 #endif
     80 
     81 /*
     82  * Bah, I hate writing on-off-wire conversions in C
     83  */
     84 
     85 enum { RUMPSP_REQ, RUMPSP_RESP, RUMPSP_ERROR };
     86 enum {	RUMPSP_HANDSHAKE,
     87 	RUMPSP_SYSCALL,
     88 	RUMPSP_COPYIN, RUMPSP_COPYINSTR,
     89 	RUMPSP_COPYOUT, RUMPSP_COPYOUTSTR,
     90 	RUMPSP_ANONMMAP,
     91 	RUMPSP_PREFORK,
     92 	RUMPSP_RAISE };
     93 
     94 enum { HANDSHAKE_GUEST, HANDSHAKE_AUTH, HANDSHAKE_FORK, HANDSHAKE_EXEC };
     95 
     96 #define AUTHLEN 4 /* 128bit fork auth */
     97 
     98 struct rsp_hdr {
     99 	uint64_t rsp_len;
    100 	uint64_t rsp_reqno;
    101 	uint16_t rsp_class;
    102 	uint16_t rsp_type;
    103 	/*
    104 	 * We want this structure 64bit-aligned for typecast fun,
    105 	 * so might as well use the following for something.
    106 	 */
    107 	union {
    108 		uint32_t sysnum;
    109 		uint32_t error;
    110 		uint32_t handshake;
    111 		uint32_t signo;
    112 	} u;
    113 };
    114 #define HDRSZ sizeof(struct rsp_hdr)
    115 #define rsp_sysnum u.sysnum
    116 #define rsp_error u.error
    117 #define rsp_handshake u.handshake
    118 #define rsp_signo u.signo
    119 
    120 #define MAXBANNER 96
    121 
    122 /*
    123  * Data follows the header.  We have two types of structured data.
    124  */
    125 
    126 /* copyin/copyout */
    127 struct rsp_copydata {
    128 	size_t rcp_len;
    129 	void *rcp_addr;
    130 	uint8_t rcp_data[0];
    131 };
    132 
    133 /* syscall response */
    134 struct rsp_sysresp {
    135 	int rsys_error;
    136 	register_t rsys_retval[2];
    137 };
    138 
    139 struct handshake_fork {
    140 	uint32_t rf_auth[4];
    141 	int rf_cancel;
    142 };
    143 
    144 struct respwait {
    145 	uint64_t rw_reqno;
    146 	void *rw_data;
    147 	size_t rw_dlen;
    148 	int rw_done;
    149 	int rw_error;
    150 
    151 	pthread_cond_t rw_cv;
    152 
    153 	TAILQ_ENTRY(respwait) rw_entries;
    154 };
    155 
    156 struct prefork;
    157 struct spclient {
    158 	int spc_fd;
    159 	int spc_refcnt;
    160 	int spc_state;
    161 
    162 	pthread_mutex_t spc_mtx;
    163 	pthread_cond_t spc_cv;
    164 
    165 	struct lwp *spc_mainlwp;
    166 	pid_t spc_pid;
    167 
    168 	TAILQ_HEAD(, respwait) spc_respwait;
    169 
    170 	/* rest of the fields are zeroed upon disconnect */
    171 #define SPC_ZEROFF offsetof(struct spclient, spc_pfd)
    172 	struct pollfd *spc_pfd;
    173 
    174 	struct rsp_hdr spc_hdr;
    175 	uint8_t *spc_buf;
    176 	size_t spc_off;
    177 
    178 	uint64_t spc_nextreq;
    179 	uint64_t spc_syscallreq;
    180 	uint64_t spc_generation;
    181 	int spc_ostatus, spc_istatus;
    182 	int spc_reconnecting;
    183 
    184 	LIST_HEAD(, prefork) spc_pflist;
    185 };
    186 #define SPCSTATUS_FREE 0
    187 #define SPCSTATUS_BUSY 1
    188 #define SPCSTATUS_WANTED 2
    189 
    190 #define SPCSTATE_NEW     0
    191 #define SPCSTATE_RUNNING 1
    192 #define SPCSTATE_DYING   2
    193 
    194 typedef int (*addrparse_fn)(const char *, struct sockaddr **, int);
    195 typedef int (*connecthook_fn)(int);
    196 typedef void (*cleanup_fn)(struct sockaddr *);
    197 
    198 static int readframe(struct spclient *);
    199 static void handlereq(struct spclient *);
    200 
    201 static __inline void
    202 spcresetbuf(struct spclient *spc)
    203 {
    204 
    205 	spc->spc_buf = NULL;
    206 	spc->spc_off = 0;
    207 }
    208 
    209 static __inline void
    210 spcfreebuf(struct spclient *spc)
    211 {
    212 
    213 	free(spc->spc_buf);
    214 	spcresetbuf(spc);
    215 }
    216 
    217 static void
    218 sendlockl(struct spclient *spc)
    219 {
    220 
    221 	while (spc->spc_ostatus != SPCSTATUS_FREE) {
    222 		spc->spc_ostatus = SPCSTATUS_WANTED;
    223 		pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);
    224 	}
    225 	spc->spc_ostatus = SPCSTATUS_BUSY;
    226 }
    227 
    228 static void __unused
    229 sendlock(struct spclient *spc)
    230 {
    231 
    232 	pthread_mutex_lock(&spc->spc_mtx);
    233 	sendlockl(spc);
    234 	pthread_mutex_unlock(&spc->spc_mtx);
    235 }
    236 
    237 static void
    238 sendunlockl(struct spclient *spc)
    239 {
    240 
    241 	if (spc->spc_ostatus == SPCSTATUS_WANTED)
    242 		pthread_cond_broadcast(&spc->spc_cv);
    243 	spc->spc_ostatus = SPCSTATUS_FREE;
    244 }
    245 
    246 static void
    247 sendunlock(struct spclient *spc)
    248 {
    249 
    250 	pthread_mutex_lock(&spc->spc_mtx);
    251 	sendunlockl(spc);
    252 	pthread_mutex_unlock(&spc->spc_mtx);
    253 }
    254 
    255 static int
    256 dosend(struct spclient *spc, const void *data, size_t dlen)
    257 {
    258 	struct pollfd pfd;
    259 	const uint8_t *sdata = data;
    260 	ssize_t n;
    261 	size_t sent;
    262 	int fd = spc->spc_fd;
    263 
    264 	pfd.fd = fd;
    265 	pfd.events = POLLOUT;
    266 
    267 	for (sent = 0, n = 0; sent < dlen; ) {
    268 		if (n) {
    269 			if (host_poll(&pfd, 1, INFTIM) == -1) {
    270 				if (errno == EINTR)
    271 					continue;
    272 				return errno;
    273 			}
    274 		}
    275 
    276 		n = host_sendto(fd, sdata + sent, dlen - sent,
    277 		    MSG_NOSIGNAL, NULL, 0);
    278 		if (n == -1)  {
    279 			if (errno == EPIPE)
    280 				return ENOTCONN;
    281 			if (errno != EAGAIN)
    282 				return errno;
    283 			continue;
    284 		}
    285 		if (n == 0) {
    286 			return ENOTCONN;
    287 		}
    288 		sent += n;
    289 	}
    290 
    291 	return 0;
    292 }
    293 
    294 static void
    295 doputwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)
    296 {
    297 
    298 	rw->rw_data = NULL;
    299 	rw->rw_dlen = rw->rw_done = rw->rw_error = 0;
    300 	pthread_cond_init(&rw->rw_cv, NULL);
    301 
    302 	pthread_mutex_lock(&spc->spc_mtx);
    303 	rw->rw_reqno = rhdr->rsp_reqno = spc->spc_nextreq++;
    304 	TAILQ_INSERT_TAIL(&spc->spc_respwait, rw, rw_entries);
    305 }
    306 
    307 static void __unused
    308 putwait_locked(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)
    309 {
    310 
    311 	doputwait(spc, rw, rhdr);
    312 	pthread_mutex_unlock(&spc->spc_mtx);
    313 }
    314 
    315 static void
    316 putwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)
    317 {
    318 
    319 	doputwait(spc, rw, rhdr);
    320 	sendlockl(spc);
    321 	pthread_mutex_unlock(&spc->spc_mtx);
    322 }
    323 
    324 static void
    325 dounputwait(struct spclient *spc, struct respwait *rw)
    326 {
    327 
    328 	TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);
    329 	pthread_mutex_unlock(&spc->spc_mtx);
    330 	pthread_cond_destroy(&rw->rw_cv);
    331 
    332 }
    333 
    334 static void __unused
    335 unputwait_locked(struct spclient *spc, struct respwait *rw)
    336 {
    337 
    338 	pthread_mutex_lock(&spc->spc_mtx);
    339 	dounputwait(spc, rw);
    340 }
    341 
    342 static void
    343 unputwait(struct spclient *spc, struct respwait *rw)
    344 {
    345 
    346 	pthread_mutex_lock(&spc->spc_mtx);
    347 	sendunlockl(spc);
    348 
    349 	dounputwait(spc, rw);
    350 }
    351 
    352 static void
    353 kickwaiter(struct spclient *spc)
    354 {
    355 	struct respwait *rw;
    356 	int error = 0;
    357 
    358 	pthread_mutex_lock(&spc->spc_mtx);
    359 	TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) {
    360 		if (rw->rw_reqno == spc->spc_hdr.rsp_reqno)
    361 			break;
    362 	}
    363 	if (rw == NULL) {
    364 		DPRINTF(("no waiter found, invalid reqno %" PRIu64 "?\n",
    365 		    spc->spc_hdr.rsp_reqno));
    366 		pthread_mutex_unlock(&spc->spc_mtx);
    367 		spcfreebuf(spc);
    368 		return;
    369 	}
    370 	DPRINTF(("rump_sp: client %p woke up waiter at %p\n", spc, rw));
    371 	rw->rw_data = spc->spc_buf;
    372 	rw->rw_done = 1;
    373 	rw->rw_dlen = (size_t)(spc->spc_off - HDRSZ);
    374 	if (spc->spc_hdr.rsp_class == RUMPSP_ERROR) {
    375 		error = rw->rw_error = spc->spc_hdr.rsp_error;
    376 	}
    377 	pthread_cond_signal(&rw->rw_cv);
    378 	pthread_mutex_unlock(&spc->spc_mtx);
    379 
    380 	if (error)
    381 		spcfreebuf(spc);
    382 	else
    383 		spcresetbuf(spc);
    384 }
    385 
    386 static void
    387 kickall(struct spclient *spc)
    388 {
    389 	struct respwait *rw;
    390 
    391 	/* DIAGASSERT(mutex_owned(spc_lock)) */
    392 	TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries)
    393 		pthread_cond_broadcast(&rw->rw_cv);
    394 }
    395 
    396 static int
    397 readframe(struct spclient *spc)
    398 {
    399 	int fd = spc->spc_fd;
    400 	size_t left;
    401 	size_t framelen;
    402 	ssize_t n;
    403 
    404 	/* still reading header? */
    405 	if (spc->spc_off < HDRSZ) {
    406 		DPRINTF(("rump_sp: readframe getting header at offset %zu\n",
    407 		    spc->spc_off));
    408 
    409 		left = HDRSZ - spc->spc_off;
    410 		/*LINTED: cast ok */
    411 		n = host_read(fd, (uint8_t*)&spc->spc_hdr + spc->spc_off, left);
    412 		if (n == 0) {
    413 			return -1;
    414 		}
    415 		if (n == -1) {
    416 			if (errno == EAGAIN)
    417 				return 0;
    418 			return -1;
    419 		}
    420 
    421 		spc->spc_off += n;
    422 		if (spc->spc_off < HDRSZ)
    423 			return -1;
    424 
    425 		/*LINTED*/
    426 		framelen = spc->spc_hdr.rsp_len;
    427 
    428 		if (framelen < HDRSZ) {
    429 			return -1;
    430 		} else if (framelen == HDRSZ) {
    431 			return 1;
    432 		}
    433 
    434 		spc->spc_buf = malloc(framelen - HDRSZ);
    435 		if (spc->spc_buf == NULL) {
    436 			return -1;
    437 		}
    438 		memset(spc->spc_buf, 0, framelen - HDRSZ);
    439 
    440 		/* "fallthrough" */
    441 	} else {
    442 		/*LINTED*/
    443 		framelen = spc->spc_hdr.rsp_len;
    444 	}
    445 
    446 	left = framelen - spc->spc_off;
    447 
    448 	DPRINTF(("rump_sp: readframe getting body at offset %zu, left %zu\n",
    449 	    spc->spc_off, left));
    450 
    451 	if (left == 0)
    452 		return 1;
    453 	n = host_read(fd, spc->spc_buf + (spc->spc_off - HDRSZ), left);
    454 	if (n == 0) {
    455 		return -1;
    456 	}
    457 	if (n == -1) {
    458 		if (errno == EAGAIN)
    459 			return 0;
    460 		return -1;
    461 	}
    462 	spc->spc_off += n;
    463 	left -= n;
    464 
    465 	/* got everything? */
    466 	if (left == 0)
    467 		return 1;
    468 	else
    469 		return 0;
    470 }
    471 
    472 static int
    473 tcp_parse(const char *addr, struct sockaddr **sa, int allow_wildcard)
    474 {
    475 	struct sockaddr_in sin;
    476 	char buf[64];
    477 	const char *p;
    478 	size_t l;
    479 	int port;
    480 
    481 	memset(&sin, 0, sizeof(sin));
    482 	sin.sin_len = sizeof(sin);
    483 	sin.sin_family = AF_INET;
    484 
    485 	p = strchr(addr, ':');
    486 	if (!p) {
    487 		fprintf(stderr, "rump_sp_tcp: missing port specifier\n");
    488 		return EINVAL;
    489 	}
    490 
    491 	l = p - addr;
    492 	if (l > sizeof(buf)-1) {
    493 		fprintf(stderr, "rump_sp_tcp: address too long\n");
    494 		return EINVAL;
    495 	}
    496 	strncpy(buf, addr, l);
    497 	buf[l] = '\0';
    498 
    499 	/* special INADDR_ANY treatment */
    500 	if (strcmp(buf, "*") == 0 || strcmp(buf, "0") == 0) {
    501 		sin.sin_addr.s_addr = INADDR_ANY;
    502 	} else {
    503 		switch (inet_pton(AF_INET, buf, &sin.sin_addr)) {
    504 		case 1:
    505 			break;
    506 		case 0:
    507 			fprintf(stderr, "rump_sp_tcp: cannot parse %s\n", buf);
    508 			return EINVAL;
    509 		case -1:
    510 			fprintf(stderr, "rump_sp_tcp: inet_pton failed\n");
    511 			return errno;
    512 		default:
    513 			assert(/*CONSTCOND*/0);
    514 			return EINVAL;
    515 		}
    516 	}
    517 
    518 	if (!allow_wildcard && sin.sin_addr.s_addr == INADDR_ANY) {
    519 		fprintf(stderr, "rump_sp_tcp: client needs !INADDR_ANY\n");
    520 		return EINVAL;
    521 	}
    522 
    523 	/* advance to port number & parse */
    524 	p++;
    525 	l = strspn(p, "0123456789");
    526 	if (l == 0) {
    527 		fprintf(stderr, "rump_sp_tcp: port now found: %s\n", p);
    528 		return EINVAL;
    529 	}
    530 	strncpy(buf, p, l);
    531 	buf[l] = '\0';
    532 
    533 	if (*(p+l) != '/' && *(p+l) != '\0') {
    534 		fprintf(stderr, "rump_sp_tcp: junk at end of port: %s\n", addr);
    535 		return EINVAL;
    536 	}
    537 
    538 	port = atoi(buf);
    539 	if (port < 0 || port >= (1<<(8*sizeof(in_port_t)))) {
    540 		fprintf(stderr, "rump_sp_tcp: port %d out of range\n", port);
    541 		return ERANGE;
    542 	}
    543 	sin.sin_port = htons(port);
    544 
    545 	*sa = malloc(sizeof(sin));
    546 	if (*sa == NULL)
    547 		return errno;
    548 	memcpy(*sa, &sin, sizeof(sin));
    549 	return 0;
    550 }
    551 
    552 static int
    553 tcp_connecthook(int s)
    554 {
    555 	int x;
    556 
    557 	x = 1;
    558 	host_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &x, sizeof(x));
    559 
    560 	return 0;
    561 }
    562 
    563 static char parsedurl[256];
    564 
    565 /*ARGSUSED*/
    566 static int
    567 unix_parse(const char *addr, struct sockaddr **sa, int allow_wildcard)
    568 {
    569 	struct sockaddr_un sun;
    570 	size_t slen;
    571 	int savepath = 0;
    572 
    573 	if (strlen(addr) > sizeof(sun.sun_path))
    574 		return ENAMETOOLONG;
    575 
    576 	/*
    577 	 * The pathname can be all kinds of spaghetti elementals,
    578 	 * so meek and obidient we accept everything.  However, use
    579 	 * full path for easy cleanup in case someone gives a relative
    580 	 * one and the server does a chdir() between now than the
    581 	 * cleanup.
    582 	 */
    583 	memset(&sun, 0, sizeof(sun));
    584 	sun.sun_family = AF_LOCAL;
    585 	if (*addr != '/') {
    586 		char mywd[PATH_MAX];
    587 
    588 		if (getcwd(mywd, sizeof(mywd)) == NULL) {
    589 			fprintf(stderr, "warning: cannot determine cwd, "
    590 			    "omitting socket cleanup\n");
    591 		} else {
    592 			if (strlen(addr) + strlen(mywd) > sizeof(sun.sun_path))
    593 				return ENAMETOOLONG;
    594 			strlcpy(sun.sun_path, mywd, sizeof(sun.sun_path));
    595 			strlcat(sun.sun_path, "/", sizeof(sun.sun_path));
    596 			savepath = 1;
    597 		}
    598 	}
    599 	strlcat(sun.sun_path, addr, sizeof(sun.sun_path));
    600 	sun.sun_len = SUN_LEN(&sun);
    601 	slen = sun.sun_len+1; /* get the 0 too */
    602 
    603 	if (savepath && *parsedurl == '\0') {
    604 		snprintf(parsedurl, sizeof(parsedurl),
    605 		    "unix://%s", sun.sun_path);
    606 	}
    607 
    608 	*sa = malloc(slen);
    609 	if (*sa == NULL)
    610 		return errno;
    611 	memcpy(*sa, &sun, slen);
    612 
    613 	return 0;
    614 }
    615 
    616 static void
    617 unix_cleanup(struct sockaddr *sa)
    618 {
    619 	struct sockaddr_un *sun = (void *)sa;
    620 
    621 	/*
    622 	 * cleanup only absolute paths.  see unix_parse() above
    623 	 */
    624 	if (*sun->sun_path == '/') {
    625 		unlink(sun->sun_path);
    626 	}
    627 }
    628 
    629 /*ARGSUSED*/
    630 static int
    631 notsupp(void)
    632 {
    633 
    634 	fprintf(stderr, "rump_sp: support not yet implemented\n");
    635 	return EOPNOTSUPP;
    636 }
    637 
    638 static int
    639 success(void)
    640 {
    641 
    642 	return 0;
    643 }
    644 
    645 struct {
    646 	const char *id;
    647 	int domain;
    648 	addrparse_fn ap;
    649 	connecthook_fn connhook;
    650 	cleanup_fn cleanup;
    651 } parsetab[] = {
    652 	{ "tcp", PF_INET, tcp_parse, tcp_connecthook, (cleanup_fn)success },
    653 	{ "unix", PF_LOCAL, unix_parse, (connecthook_fn)success, unix_cleanup },
    654 	{ "tcp6", PF_INET6, (addrparse_fn)notsupp, (connecthook_fn)success,
    655 			    (cleanup_fn)success },
    656 };
    657 #define NPARSE (sizeof(parsetab)/sizeof(parsetab[0]))
    658 
    659 static int
    660 parseurl(const char *url, struct sockaddr **sap, unsigned *idxp,
    661 	int allow_wildcard)
    662 {
    663 	char id[16];
    664 	const char *p, *p2;
    665 	size_t l;
    666 	unsigned i;
    667 	int error;
    668 
    669 	/*
    670 	 * Parse the url
    671 	 */
    672 
    673 	p = url;
    674 	p2 = strstr(p, "://");
    675 	if (!p2) {
    676 		fprintf(stderr, "rump_sp: invalid locator ``%s''\n", p);
    677 		return EINVAL;
    678 	}
    679 	l = p2-p;
    680 	if (l > sizeof(id)-1) {
    681 		fprintf(stderr, "rump_sp: identifier too long in ``%s''\n", p);
    682 		return EINVAL;
    683 	}
    684 
    685 	strncpy(id, p, l);
    686 	id[l] = '\0';
    687 	p2 += 3; /* beginning of address */
    688 
    689 	for (i = 0; i < NPARSE; i++) {
    690 		if (strcmp(id, parsetab[i].id) == 0) {
    691 			error = parsetab[i].ap(p2, sap, allow_wildcard);
    692 			if (error)
    693 				return error;
    694 			break;
    695 		}
    696 	}
    697 	if (i == NPARSE) {
    698 		fprintf(stderr, "rump_sp: invalid identifier ``%s''\n", p);
    699 		return EINVAL;
    700 	}
    701 
    702 	*idxp = i;
    703 	return 0;
    704 }
    705