sp_common.c revision 1.11
1 /* $NetBSD: sp_common.c,v 1.11 2010/11/26 14:37:08 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 2010 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 40 #include <arpa/inet.h> 41 #include <netinet/in.h> 42 #include <netinet/tcp.h> 43 44 #include <assert.h> 45 #include <errno.h> 46 #include <fcntl.h> 47 #include <poll.h> 48 #include <pthread.h> 49 #include <stdarg.h> 50 #include <stddef.h> 51 #include <stdio.h> 52 #include <stdlib.h> 53 #include <string.h> 54 #include <unistd.h> 55 56 //#define DEBUG 57 #ifdef DEBUG 58 #define DPRINTF(x) mydprintf x 59 static void 60 mydprintf(const char *fmt, ...) 61 { 62 va_list ap; 63 64 va_start(ap, fmt); 65 vfprintf(stderr, fmt, ap); 66 va_end(ap); 67 } 68 #else 69 #define DPRINTF(x) 70 #endif 71 72 /* 73 * Bah, I hate writing on-off-wire conversions in C 74 */ 75 76 enum { RUMPSP_REQ, RUMPSP_RESP }; 77 enum { RUMPSP_SYSCALL, 78 RUMPSP_COPYIN, RUMPSP_COPYINSTR, 79 RUMPSP_COPYOUT, RUMPSP_COPYOUTSTR, 80 RUMPSP_ANONMMAP }; 81 82 struct rsp_hdr { 83 uint64_t rsp_len; 84 uint64_t rsp_reqno; 85 uint16_t rsp_class; 86 uint16_t rsp_type; 87 /* 88 * We want this structure 64bit-aligned for typecast fun, 89 * so might as well use the following for something. 90 */ 91 uint32_t rsp_sysnum; 92 }; 93 #define HDRSZ sizeof(struct rsp_hdr) 94 95 /* 96 * Data follows the header. We have two types of structured data. 97 */ 98 99 /* copyin/copyout */ 100 struct rsp_copydata { 101 size_t rcp_len; 102 void *rcp_addr; 103 uint8_t rcp_data[0]; 104 }; 105 106 /* syscall response */ 107 struct rsp_sysresp { 108 int rsys_error; 109 register_t rsys_retval[2]; 110 }; 111 112 struct respwait { 113 uint64_t rw_reqno; 114 void *rw_data; 115 size_t rw_dlen; 116 117 pthread_cond_t rw_cv; 118 119 TAILQ_ENTRY(respwait) rw_entries; 120 }; 121 122 struct spclient { 123 int spc_fd; 124 int spc_refcnt; 125 int spc_dying; 126 127 pthread_mutex_t spc_mtx; 128 pthread_cond_t spc_cv; 129 130 struct lwp *spc_mainlwp; 131 pid_t spc_pid; 132 133 TAILQ_HEAD(, respwait) spc_respwait; 134 135 /* rest of the fields are zeroed upon disconnect */ 136 #define SPC_ZEROFF offsetof(struct spclient, spc_pid) 137 struct pollfd *spc_pfd; 138 139 struct rsp_hdr spc_hdr; 140 uint8_t *spc_buf; 141 size_t spc_off; 142 143 uint64_t spc_nextreq; 144 int spc_ostatus, spc_istatus; 145 }; 146 #define SPCSTATUS_FREE 0 147 #define SPCSTATUS_BUSY 1 148 #define SPCSTATUS_WANTED 2 149 150 typedef int (*addrparse_fn)(const char *, struct sockaddr **, int); 151 typedef int (*connecthook_fn)(int); 152 153 static int readframe(struct spclient *); 154 static void handlereq(struct spclient *); 155 156 static void 157 sendlock(struct spclient *spc) 158 { 159 160 pthread_mutex_lock(&spc->spc_mtx); 161 while (spc->spc_ostatus != SPCSTATUS_FREE) { 162 spc->spc_ostatus = SPCSTATUS_WANTED; 163 pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx); 164 } 165 spc->spc_ostatus = SPCSTATUS_BUSY; 166 pthread_mutex_unlock(&spc->spc_mtx); 167 } 168 169 static void 170 sendunlock(struct spclient *spc) 171 { 172 173 pthread_mutex_lock(&spc->spc_mtx); 174 if (spc->spc_ostatus == SPCSTATUS_WANTED) 175 pthread_cond_broadcast(&spc->spc_cv); 176 spc->spc_ostatus = SPCSTATUS_FREE; 177 pthread_mutex_unlock(&spc->spc_mtx); 178 } 179 180 static int 181 dosend(struct spclient *spc, const void *data, size_t dlen) 182 { 183 struct pollfd pfd; 184 const uint8_t *sdata = data; 185 ssize_t n; 186 size_t sent; 187 int fd = spc->spc_fd; 188 189 pfd.fd = fd; 190 pfd.events = POLLOUT; 191 192 for (sent = 0, n = 0; sent < dlen; ) { 193 if (n) { 194 if (poll(&pfd, 1, INFTIM) == -1) { 195 if (errno == EINTR) 196 continue; 197 return errno; 198 } 199 } 200 201 n = send(fd, sdata + sent, dlen - sent, MSG_NOSIGNAL); 202 if (n == 0) { 203 return EFAULT; 204 } 205 if (n == -1) { 206 if (errno != EAGAIN) 207 return EFAULT; 208 continue; 209 } 210 sent += n; 211 } 212 213 return 0; 214 } 215 216 static void 217 putwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr) 218 { 219 220 rw->rw_data = NULL; 221 rw->rw_dlen = 0; 222 pthread_cond_init(&rw->rw_cv, NULL); 223 224 pthread_mutex_lock(&spc->spc_mtx); 225 rw->rw_reqno = rhdr->rsp_reqno = spc->spc_nextreq++; 226 TAILQ_INSERT_TAIL(&spc->spc_respwait, rw, rw_entries); 227 } 228 229 static void 230 unputwait(struct spclient *spc, struct respwait *rw) 231 { 232 233 TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries); 234 pthread_mutex_unlock(&spc->spc_mtx); 235 pthread_cond_destroy(&rw->rw_cv); 236 } 237 238 static void 239 kickwaiter(struct spclient *spc) 240 { 241 struct respwait *rw; 242 243 pthread_mutex_lock(&spc->spc_mtx); 244 TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) { 245 if (rw->rw_reqno == spc->spc_hdr.rsp_reqno) 246 break; 247 } 248 if (rw == NULL) { 249 printf("PANIC: no waiter\n"); 250 abort(); 251 return; 252 } 253 DPRINTF(("rump_sp: client %p woke up waiter at %p\n", spc, rw)); 254 rw->rw_data = spc->spc_buf; 255 rw->rw_dlen = (size_t)(spc->spc_off - HDRSZ); 256 pthread_cond_signal(&rw->rw_cv); 257 pthread_mutex_unlock(&spc->spc_mtx); 258 259 spc->spc_buf = NULL; 260 spc->spc_off = 0; 261 } 262 263 static void 264 kickall(struct spclient *spc) 265 { 266 struct respwait *rw; 267 268 /* DIAGASSERT(mutex_owned(spc_lock)) */ 269 TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) 270 pthread_cond_signal(&rw->rw_cv); 271 } 272 273 static int 274 waitresp(struct spclient *spc, struct respwait *rw) 275 { 276 struct pollfd pfd; 277 int rv = 0; 278 279 while (rw->rw_data == NULL && spc->spc_dying == 0) { 280 /* are we free to receive? */ 281 if (spc->spc_istatus == SPCSTATUS_FREE) { 282 int gotresp; 283 284 spc->spc_istatus = SPCSTATUS_BUSY; 285 pthread_mutex_unlock(&spc->spc_mtx); 286 287 pfd.fd = spc->spc_fd; 288 pfd.events = POLLIN; 289 290 for (gotresp = 0; !gotresp; ) { 291 switch (readframe(spc)) { 292 case 0: 293 poll(&pfd, 1, INFTIM); 294 continue; 295 case -1: 296 rv = errno; 297 spc->spc_dying = 1; 298 goto cleanup; 299 default: 300 break; 301 } 302 303 switch (spc->spc_hdr.rsp_class) { 304 case RUMPSP_RESP: 305 kickwaiter(spc); 306 gotresp = spc->spc_hdr.rsp_reqno == 307 rw->rw_reqno; 308 break; 309 case RUMPSP_REQ: 310 handlereq(spc); 311 break; 312 default: 313 /* panic */ 314 break; 315 } 316 } 317 cleanup: 318 pthread_mutex_lock(&spc->spc_mtx); 319 if (spc->spc_istatus == SPCSTATUS_WANTED) 320 kickall(spc); 321 spc->spc_istatus = SPCSTATUS_FREE; 322 } else { 323 spc->spc_istatus = SPCSTATUS_WANTED; 324 pthread_cond_wait(&rw->rw_cv, &spc->spc_mtx); 325 } 326 } 327 328 TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries); 329 pthread_mutex_unlock(&spc->spc_mtx); 330 331 pthread_cond_destroy(&rw->rw_cv); 332 333 if (rv == 0 && spc->spc_dying) 334 rv = ENOTCONN; 335 return rv; 336 } 337 338 static int 339 readframe(struct spclient *spc) 340 { 341 int fd = spc->spc_fd; 342 size_t left; 343 size_t framelen; 344 ssize_t n; 345 346 /* still reading header? */ 347 if (spc->spc_off < HDRSZ) { 348 DPRINTF(("rump_sp: readframe getting header at offset %zu\n", 349 spc->spc_off)); 350 351 left = HDRSZ - spc->spc_off; 352 /*LINTED: cast ok */ 353 n = read(fd, (uint8_t *)&spc->spc_hdr + spc->spc_off, left); 354 if (n == 0) { 355 return -1; 356 } 357 if (n == -1) { 358 if (errno == EAGAIN) 359 return 0; 360 return -1; 361 } 362 363 spc->spc_off += n; 364 if (spc->spc_off < HDRSZ) 365 return -1; 366 367 /*LINTED*/ 368 framelen = spc->spc_hdr.rsp_len; 369 370 if (framelen < HDRSZ) { 371 return -1; 372 } else if (framelen == HDRSZ) { 373 return 1; 374 } 375 376 spc->spc_buf = malloc(framelen - HDRSZ); 377 if (spc->spc_buf == NULL) { 378 return -1; 379 } 380 memset(spc->spc_buf, 0, framelen - HDRSZ); 381 382 /* "fallthrough" */ 383 } else { 384 /*LINTED*/ 385 framelen = spc->spc_hdr.rsp_len; 386 } 387 388 left = framelen - spc->spc_off; 389 390 DPRINTF(("rump_sp: readframe getting body at offset %zu, left %zu\n", 391 spc->spc_off, left)); 392 393 if (left == 0) 394 return 1; 395 n = read(fd, spc->spc_buf + (spc->spc_off - HDRSZ), left); 396 if (n == 0) { 397 return -1; 398 } 399 if (n == -1) { 400 if (errno == EAGAIN) 401 return 0; 402 return -1; 403 } 404 spc->spc_off += n; 405 left -= n; 406 407 /* got everything? */ 408 if (left == 0) 409 return 1; 410 else 411 return 0; 412 } 413 414 static int 415 tcp_parse(const char *addr, struct sockaddr **sa, int allow_wildcard) 416 { 417 struct sockaddr_in sin; 418 char buf[64]; 419 const char *p; 420 size_t l; 421 int port; 422 423 memset(&sin, 0, sizeof(sin)); 424 sin.sin_len = sizeof(sin); 425 sin.sin_family = AF_INET; 426 427 p = strchr(addr, ':'); 428 if (!p) { 429 fprintf(stderr, "rump_sp_tcp: missing port specifier\n"); 430 return EINVAL; 431 } 432 433 l = p - addr; 434 if (l > sizeof(buf)-1) { 435 fprintf(stderr, "rump_sp_tcp: address too long\n"); 436 return EINVAL; 437 } 438 strncpy(buf, addr, l); 439 buf[l] = '\0'; 440 441 /* special INADDR_ANY treatment */ 442 if (strcmp(buf, "*") == 0 || strcmp(buf, "0") == 0) { 443 sin.sin_addr.s_addr = INADDR_ANY; 444 } else { 445 switch (inet_pton(AF_INET, buf, &sin.sin_addr)) { 446 case 1: 447 break; 448 case 0: 449 fprintf(stderr, "rump_sp_tcp: cannot parse %s\n", buf); 450 return EINVAL; 451 case -1: 452 fprintf(stderr, "rump_sp_tcp: inet_pton failed\n"); 453 return errno; 454 default: 455 assert(/*CONSTCOND*/0); 456 return EINVAL; 457 } 458 } 459 460 if (!allow_wildcard && sin.sin_addr.s_addr == INADDR_ANY) { 461 fprintf(stderr, "rump_sp_tcp: client needs !INADDR_ANY\n"); 462 return EINVAL; 463 } 464 465 /* advance to port number & parse */ 466 p++; 467 l = strspn(p, "0123456789"); 468 if (l == 0) { 469 fprintf(stderr, "rump_sp_tcp: port now found: %s\n", p); 470 return EINVAL; 471 } 472 strncpy(buf, p, l); 473 buf[l] = '\0'; 474 475 if (*(p+l) != '/' && *(p+l) != '\0') { 476 fprintf(stderr, "rump_sp_tcp: junk at end of port: %s\n", addr); 477 return EINVAL; 478 } 479 480 port = atoi(buf); 481 if (port < 0 || port >= (1<<(8*sizeof(in_port_t)))) { 482 fprintf(stderr, "rump_sp_tcp: port %d out of range\n", port); 483 return ERANGE; 484 } 485 sin.sin_port = htons(port); 486 487 *sa = malloc(sizeof(sin)); 488 if (*sa == NULL) 489 return errno; 490 memcpy(*sa, &sin, sizeof(sin)); 491 return 0; 492 } 493 494 static int 495 tcp_connecthook(int s) 496 { 497 int x; 498 499 x = 1; 500 setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &x, sizeof(x)); 501 502 return 0; 503 } 504 505 /*ARGSUSED*/ 506 static int 507 unix_parse(const char *addr, struct sockaddr **sa, int allow_wildcard) 508 { 509 struct sockaddr_un sun; 510 size_t slen; 511 512 if (strlen(addr) > sizeof(sun.sun_path)) 513 return ENAMETOOLONG; 514 515 /* 516 * The pathname can be all kinds of spaghetti elementals, 517 * so meek and obidient we accept everything. 518 */ 519 memset(&sun, 0, sizeof(sun)); 520 sun.sun_family = AF_LOCAL; 521 strlcpy(sun.sun_path, addr, sizeof(sun.sun_path)); 522 sun.sun_len = slen = SUN_LEN(&sun); 523 524 *sa = malloc(slen); 525 if (*sa == NULL) 526 return errno; 527 memcpy(*sa, &sun, slen); 528 529 return 0; 530 } 531 532 /*ARGSUSED*/ 533 static int 534 notsupp(void) 535 { 536 537 fprintf(stderr, "rump_sp: support not yet implemented\n"); 538 return EOPNOTSUPP; 539 } 540 541 static int 542 success(void) 543 { 544 545 return 0; 546 } 547 548 struct { 549 const char *id; 550 int domain; 551 addrparse_fn ap; 552 connecthook_fn connhook; 553 } parsetab[] = { 554 { "tcp", PF_INET, tcp_parse, tcp_connecthook }, 555 { "unix", PF_LOCAL, unix_parse, (connecthook_fn)success }, 556 { "tcp6", PF_INET6, (addrparse_fn)notsupp, (connecthook_fn)success }, 557 }; 558 #define NPARSE (sizeof(parsetab)/sizeof(parsetab[0])) 559 560 static int 561 parseurl(const char *url, struct sockaddr **sap, unsigned *idxp, 562 int allow_wildcard) 563 { 564 char id[16]; 565 const char *p, *p2; 566 size_t l; 567 unsigned i; 568 int error; 569 570 /* 571 * Parse the url 572 */ 573 574 p = url; 575 p2 = strstr(p, "://"); 576 if (!p2) { 577 fprintf(stderr, "rump_sp: invalid locator ``%s''\n", p); 578 return EINVAL; 579 } 580 l = p2-p; 581 if (l > sizeof(id)-1) { 582 fprintf(stderr, "rump_sp: identifier too long in ``%s''\n", p); 583 return EINVAL; 584 } 585 586 strncpy(id, p, l); 587 id[l] = '\0'; 588 p2 += 3; /* beginning of address */ 589 590 for (i = 0; i < NPARSE; i++) { 591 if (strcmp(id, parsetab[i].id) == 0) { 592 error = parsetab[i].ap(p2, sap, allow_wildcard); 593 if (error) 594 return error; 595 break; 596 } 597 } 598 if (i == NPARSE) { 599 fprintf(stderr, "rump_sp: invalid identifier ``%s''\n", p); 600 return EINVAL; 601 } 602 603 *idxp = i; 604 return 0; 605 } 606
Indexes created Wed Sep 24 05:09:52 GMT 2025