1 /*- 2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27 28 #include <sys/types.h> 29 #include <sys/event.h> 30 #include <sys/socket.h> 31 #include <sys/time.h> 32 33 #include <assert.h> 34 #include <errno.h> 35 #include <nsswitch.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <unistd.h> 40 41 #include "config.h" 42 #include "debug.h" 43 #include "query.h" 44 #include "log.h" 45 #include "mp_ws_query.h" 46 #include "mp_rs_query.h" 47 #include "singletons.h" 48 49 static const char negative_data[1] = { 0 }; 50 51 extern void get_time_func(struct timeval *); 52 53 static void clear_config_entry(struct configuration_entry *); 54 static void clear_config_entry_part(struct configuration_entry *, 55 const char *, size_t); 56 57 static int on_query_startup(struct query_state *); 58 static void on_query_destroy(struct query_state *); 59 60 static int on_read_request_read1(struct query_state *); 61 static int on_read_request_read2(struct query_state *); 62 static int on_read_request_process(struct query_state *); 63 static int on_read_response_write1(struct query_state *); 64 static int on_read_response_write2(struct query_state *); 65 66 static int on_rw_mapper(struct query_state *); 67 68 static int on_transform_request_read1(struct query_state *); 69 static int on_transform_request_read2(struct query_state *); 70 static int on_transform_request_process(struct query_state *); 71 static int on_transform_response_write1(struct query_state *); 72 73 static int on_write_request_read1(struct query_state *); 74 static int on_write_request_read2(struct query_state *); 75 static int on_negative_write_request_process(struct query_state *); 76 static int on_write_request_process(struct query_state *); 77 static int on_write_response_write1(struct query_state *); 78 79 /* 80 * Clears the specified configuration entry (clears the cache for positive and 81 * negative entries) and also for all multipart entries. 82 */ 83 static void 84 clear_config_entry(struct configuration_entry *config_entry) 85 { 86 size_t i; 87 88 TRACE_IN(clear_config_entry); 89 configuration_lock_entry(config_entry, CELT_POSITIVE); 90 if (config_entry->positive_cache_entry != NULL) 91 transform_cache_entry( 92 config_entry->positive_cache_entry, 93 CTT_CLEAR); 94 configuration_unlock_entry(config_entry, CELT_POSITIVE); 95 96 configuration_lock_entry(config_entry, CELT_NEGATIVE); 97 if (config_entry->negative_cache_entry != NULL) 98 transform_cache_entry( 99 config_entry->negative_cache_entry, 100 CTT_CLEAR); 101 configuration_unlock_entry(config_entry, CELT_NEGATIVE); 102 103 configuration_lock_entry(config_entry, CELT_MULTIPART); 104 for (i = 0; i < config_entry->mp_cache_entries_size; ++i) 105 transform_cache_entry( 106 config_entry->mp_cache_entries[i], 107 CTT_CLEAR); 108 configuration_unlock_entry(config_entry, CELT_MULTIPART); 109 110 TRACE_OUT(clear_config_entry); 111 } 112 113 /* 114 * Clears the specified configuration entry by deleting only the elements, 115 * that are owned by the user with specified eid_str. 116 */ 117 static void 118 clear_config_entry_part(struct configuration_entry *config_entry, 119 const char *eid_str, size_t eid_str_length) 120 { 121 cache_entry *start, *finish, *mp_entry; 122 TRACE_IN(clear_config_entry_part); 123 configuration_lock_entry(config_entry, CELT_POSITIVE); 124 if (config_entry->positive_cache_entry != NULL) 125 transform_cache_entry_part( 126 config_entry->positive_cache_entry, 127 CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT); 128 configuration_unlock_entry(config_entry, CELT_POSITIVE); 129 130 configuration_lock_entry(config_entry, CELT_NEGATIVE); 131 if (config_entry->negative_cache_entry != NULL) 132 transform_cache_entry_part( 133 config_entry->negative_cache_entry, 134 CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT); 135 configuration_unlock_entry(config_entry, CELT_NEGATIVE); 136 137 configuration_lock_entry(config_entry, CELT_MULTIPART); 138 if (configuration_entry_find_mp_cache_entries(config_entry, 139 eid_str, &start, &finish) == 0) { 140 for (mp_entry = start; mp_entry != finish; ++mp_entry) 141 transform_cache_entry(*mp_entry, CTT_CLEAR); 142 } 143 configuration_unlock_entry(config_entry, CELT_MULTIPART); 144 145 TRACE_OUT(clear_config_entry_part); 146 } 147 148 /* 149 * This function is assigned to the query_state structue on its creation. 150 * It's main purpose is to receive credentials from the client. 151 */ 152 static int 153 on_query_startup(struct query_state *qstate) 154 { 155 union { 156 struct cmsghdr hdr; 157 char pad[CMSG_SPACE(sizeof(struct cmsgcred))]; 158 } cmsg; 159 struct msghdr mhdr; 160 struct iovec iov; 161 struct cmsgcred *cred; 162 int elem_type; 163 164 TRACE_IN(on_query_startup); 165 assert(qstate != NULL); 166 167 memset(&mhdr, 0, sizeof(mhdr)); 168 mhdr.msg_iov = &iov; 169 mhdr.msg_iovlen = 1; 170 mhdr.msg_control = &cmsg; 171 mhdr.msg_controllen = sizeof(cmsg); 172 173 memset(&iov, 0, sizeof(iov)); 174 iov.iov_base = &elem_type; 175 iov.iov_len = sizeof(elem_type); 176 177 if (recvmsg(qstate->sockfd, &mhdr, 0) == -1) { 178 TRACE_OUT(on_query_startup); 179 return (-1); 180 } 181 182 if (mhdr.msg_controllen != CMSG_SPACE(sizeof(struct cmsgcred)) || 183 cmsg.hdr.cmsg_len != CMSG_LEN(sizeof(struct cmsgcred)) || 184 cmsg.hdr.cmsg_level != SOL_SOCKET || 185 cmsg.hdr.cmsg_type != SCM_CREDS) { 186 TRACE_OUT(on_query_startup); 187 return (-1); 188 } 189 190 cred = (struct cmsgcred *)CMSG_DATA(&cmsg); 191 qstate->uid = cred->cmcred_uid; 192 qstate->gid = cred->cmcred_gid; 193 194 #if defined(NS_NSCD_EID_CHECKING) || defined(NS_STRICT_NSCD_EID_CHECKING) 195 /* 196 * This check is probably a bit redundant - per-user cache is always separated 197 * by the euid/egid pair 198 */ 199 if (check_query_eids(qstate) != 0) { 200 #ifdef NS_STRICT_NSCD_EID_CHECKING 201 TRACE_OUT(on_query_startup); 202 return (-1); 203 #else 204 if ((elem_type != CET_READ_REQUEST) && 205 (elem_type != CET_MP_READ_SESSION_REQUEST) && 206 (elem_type != CET_WRITE_REQUEST) && 207 (elem_type != CET_MP_WRITE_SESSION_REQUEST)) { 208 TRACE_OUT(on_query_startup); 209 return (-1); 210 } 211 #endif 212 } 213 #endif 214 215 switch (elem_type) { 216 case CET_WRITE_REQUEST: 217 qstate->process_func = on_write_request_read1; 218 break; 219 case CET_READ_REQUEST: 220 qstate->process_func = on_read_request_read1; 221 break; 222 case CET_TRANSFORM_REQUEST: 223 qstate->process_func = on_transform_request_read1; 224 break; 225 case CET_MP_WRITE_SESSION_REQUEST: 226 qstate->process_func = on_mp_write_session_request_read1; 227 break; 228 case CET_MP_READ_SESSION_REQUEST: 229 qstate->process_func = on_mp_read_session_request_read1; 230 break; 231 default: 232 TRACE_OUT(on_query_startup); 233 return (-1); 234 } 235 236 qstate->kevent_watermark = 0; 237 TRACE_OUT(on_query_startup); 238 return (0); 239 } 240 241 /* 242 * on_rw_mapper is used to process multiple read/write requests during 243 * one connection session. It's never called in the beginning (on query_state 244 * creation) as it does not process the multipart requests and does not 245 * receive credentials 246 */ 247 static int 248 on_rw_mapper(struct query_state *qstate) 249 { 250 ssize_t result; 251 int elem_type; 252 253 TRACE_IN(on_rw_mapper); 254 if (qstate->kevent_watermark == 0) { 255 qstate->kevent_watermark = sizeof(int); 256 } else { 257 result = qstate->read_func(qstate, &elem_type, sizeof(int)); 258 if (result != sizeof(int)) { 259 TRACE_OUT(on_rw_mapper); 260 return (-1); 261 } 262 263 switch (elem_type) { 264 case CET_WRITE_REQUEST: 265 qstate->kevent_watermark = sizeof(size_t); 266 qstate->process_func = on_write_request_read1; 267 break; 268 case CET_READ_REQUEST: 269 qstate->kevent_watermark = sizeof(size_t); 270 qstate->process_func = on_read_request_read1; 271 break; 272 default: 273 TRACE_OUT(on_rw_mapper); 274 return (-1); 275 break; 276 } 277 } 278 TRACE_OUT(on_rw_mapper); 279 return (0); 280 } 281 282 /* 283 * The default query_destroy function 284 */ 285 static void 286 on_query_destroy(struct query_state *qstate) 287 { 288 289 TRACE_IN(on_query_destroy); 290 finalize_comm_element(&qstate->response); 291 finalize_comm_element(&qstate->request); 292 TRACE_OUT(on_query_destroy); 293 } 294 295 /* 296 * The functions below are used to process write requests. 297 * - on_write_request_read1 and on_write_request_read2 read the request itself 298 * - on_write_request_process processes it (if the client requests to 299 * cache the negative result, the on_negative_write_request_process is used) 300 * - on_write_response_write1 sends the response 301 */ 302 static int 303 on_write_request_read1(struct query_state *qstate) 304 { 305 struct cache_write_request *write_request; 306 ssize_t result; 307 308 TRACE_IN(on_write_request_read1); 309 if (qstate->kevent_watermark == 0) 310 qstate->kevent_watermark = sizeof(size_t) * 3; 311 else { 312 init_comm_element(&qstate->request, CET_WRITE_REQUEST); 313 write_request = get_cache_write_request(&qstate->request); 314 315 result = qstate->read_func(qstate, &write_request->entry_length, 316 sizeof(size_t)); 317 result += qstate->read_func(qstate, 318 &write_request->cache_key_size, sizeof(size_t)); 319 result += qstate->read_func(qstate, 320 &write_request->data_size, sizeof(size_t)); 321 322 if (result != sizeof(size_t) * 3) { 323 TRACE_OUT(on_write_request_read1); 324 return (-1); 325 } 326 327 if (BUFSIZE_INVALID(write_request->entry_length) || 328 BUFSIZE_INVALID(write_request->cache_key_size) || 329 (BUFSIZE_INVALID(write_request->data_size) && 330 (write_request->data_size != 0))) { 331 TRACE_OUT(on_write_request_read1); 332 return (-1); 333 } 334 335 write_request->entry = calloc(1, 336 write_request->entry_length + 1); 337 assert(write_request->entry != NULL); 338 339 write_request->cache_key = calloc(1, 340 write_request->cache_key_size + 341 qstate->eid_str_length); 342 assert(write_request->cache_key != NULL); 343 memcpy(write_request->cache_key, qstate->eid_str, 344 qstate->eid_str_length); 345 346 if (write_request->data_size != 0) { 347 write_request->data = calloc(1, 348 write_request->data_size); 349 assert(write_request->data != NULL); 350 } 351 352 qstate->kevent_watermark = write_request->entry_length + 353 write_request->cache_key_size + 354 write_request->data_size; 355 qstate->process_func = on_write_request_read2; 356 } 357 358 TRACE_OUT(on_write_request_read1); 359 return (0); 360 } 361 362 static int 363 on_write_request_read2(struct query_state *qstate) 364 { 365 struct cache_write_request *write_request; 366 ssize_t result; 367 368 TRACE_IN(on_write_request_read2); 369 write_request = get_cache_write_request(&qstate->request); 370 371 result = qstate->read_func(qstate, write_request->entry, 372 write_request->entry_length); 373 result += qstate->read_func(qstate, write_request->cache_key + 374 qstate->eid_str_length, write_request->cache_key_size); 375 if (write_request->data_size != 0) 376 result += qstate->read_func(qstate, write_request->data, 377 write_request->data_size); 378 379 if (result != (ssize_t)qstate->kevent_watermark) { 380 TRACE_OUT(on_write_request_read2); 381 return (-1); 382 } 383 write_request->cache_key_size += qstate->eid_str_length; 384 385 qstate->kevent_watermark = 0; 386 if (write_request->data_size != 0) 387 qstate->process_func = on_write_request_process; 388 else 389 qstate->process_func = on_negative_write_request_process; 390 TRACE_OUT(on_write_request_read2); 391 return (0); 392 } 393 394 static int 395 on_write_request_process(struct query_state *qstate) 396 { 397 struct cache_write_request *write_request; 398 struct cache_write_response *write_response; 399 cache_entry c_entry; 400 401 TRACE_IN(on_write_request_process); 402 init_comm_element(&qstate->response, CET_WRITE_RESPONSE); 403 write_response = get_cache_write_response(&qstate->response); 404 write_request = get_cache_write_request(&qstate->request); 405 406 qstate->config_entry = configuration_find_entry( 407 s_configuration, write_request->entry); 408 409 if (qstate->config_entry == NULL) { 410 write_response->error_code = ENOENT; 411 412 LOG_ERR_2("write_request", "can't find configuration" 413 " entry '%s'. aborting request", write_request->entry); 414 goto fin; 415 } 416 417 if (qstate->config_entry->enabled == 0) { 418 write_response->error_code = EACCES; 419 420 LOG_ERR_2("write_request", 421 "configuration entry '%s' is disabled", 422 write_request->entry); 423 goto fin; 424 } 425 426 if (qstate->config_entry->perform_actual_lookups != 0) { 427 write_response->error_code = EOPNOTSUPP; 428 429 LOG_ERR_2("write_request", 430 "entry '%s' performs lookups by itself: " 431 "can't write to it", write_request->entry); 432 goto fin; 433 } 434 435 configuration_lock_rdlock(s_configuration); 436 c_entry = find_cache_entry(s_cache, 437 qstate->config_entry->positive_cache_params.cep.entry_name); 438 configuration_unlock(s_configuration); 439 if (c_entry != NULL) { 440 configuration_lock_entry(qstate->config_entry, CELT_POSITIVE); 441 qstate->config_entry->positive_cache_entry = c_entry; 442 write_response->error_code = cache_write(c_entry, 443 write_request->cache_key, 444 write_request->cache_key_size, 445 write_request->data, 446 write_request->data_size); 447 configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE); 448 449 if ((qstate->config_entry->common_query_timeout.tv_sec != 0) || 450 (qstate->config_entry->common_query_timeout.tv_usec != 0)) 451 memcpy(&qstate->timeout, 452 &qstate->config_entry->common_query_timeout, 453 sizeof(struct timeval)); 454 455 } else 456 write_response->error_code = -1; 457 458 fin: 459 qstate->kevent_filter = EVFILT_WRITE; 460 qstate->kevent_watermark = sizeof(int); 461 qstate->process_func = on_write_response_write1; 462 463 TRACE_OUT(on_write_request_process); 464 return (0); 465 } 466 467 static int 468 on_negative_write_request_process(struct query_state *qstate) 469 { 470 struct cache_write_request *write_request; 471 struct cache_write_response *write_response; 472 cache_entry c_entry; 473 474 TRACE_IN(on_negative_write_request_process); 475 init_comm_element(&qstate->response, CET_WRITE_RESPONSE); 476 write_response = get_cache_write_response(&qstate->response); 477 write_request = get_cache_write_request(&qstate->request); 478 479 qstate->config_entry = configuration_find_entry ( 480 s_configuration, write_request->entry); 481 482 if (qstate->config_entry == NULL) { 483 write_response->error_code = ENOENT; 484 485 LOG_ERR_2("negative_write_request", 486 "can't find configuration" 487 " entry '%s'. aborting request", write_request->entry); 488 goto fin; 489 } 490 491 if (qstate->config_entry->enabled == 0) { 492 write_response->error_code = EACCES; 493 494 LOG_ERR_2("negative_write_request", 495 "configuration entry '%s' is disabled", 496 write_request->entry); 497 goto fin; 498 } 499 500 if (qstate->config_entry->perform_actual_lookups != 0) { 501 write_response->error_code = EOPNOTSUPP; 502 503 LOG_ERR_2("negative_write_request", 504 "entry '%s' performs lookups by itself: " 505 "can't write to it", write_request->entry); 506 goto fin; 507 } else { 508 #ifdef NS_NSCD_EID_CHECKING 509 if (check_query_eids(qstate) != 0) { 510 write_response->error_code = EPERM; 511 goto fin; 512 } 513 #endif 514 } 515 516 configuration_lock_rdlock(s_configuration); 517 c_entry = find_cache_entry(s_cache, 518 qstate->config_entry->negative_cache_params.cep.entry_name); 519 configuration_unlock(s_configuration); 520 if (c_entry != NULL) { 521 configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE); 522 qstate->config_entry->negative_cache_entry = c_entry; 523 write_response->error_code = cache_write(c_entry, 524 write_request->cache_key, 525 write_request->cache_key_size, 526 negative_data, 527 sizeof(negative_data)); 528 configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE); 529 530 if ((qstate->config_entry->common_query_timeout.tv_sec != 0) || 531 (qstate->config_entry->common_query_timeout.tv_usec != 0)) 532 memcpy(&qstate->timeout, 533 &qstate->config_entry->common_query_timeout, 534 sizeof(struct timeval)); 535 } else 536 write_response->error_code = -1; 537 538 fin: 539 qstate->kevent_filter = EVFILT_WRITE; 540 qstate->kevent_watermark = sizeof(int); 541 qstate->process_func = on_write_response_write1; 542 543 TRACE_OUT(on_negative_write_request_process); 544 return (0); 545 } 546 547 static int 548 on_write_response_write1(struct query_state *qstate) 549 { 550 struct cache_write_response *write_response; 551 ssize_t result; 552 553 TRACE_IN(on_write_response_write1); 554 write_response = get_cache_write_response(&qstate->response); 555 result = qstate->write_func(qstate, &write_response->error_code, 556 sizeof(int)); 557 if (result != sizeof(int)) { 558 TRACE_OUT(on_write_response_write1); 559 return (-1); 560 } 561 562 finalize_comm_element(&qstate->request); 563 finalize_comm_element(&qstate->response); 564 565 qstate->kevent_watermark = sizeof(int); 566 qstate->kevent_filter = EVFILT_READ; 567 qstate->process_func = on_rw_mapper; 568 569 TRACE_OUT(on_write_response_write1); 570 return (0); 571 } 572 573 /* 574 * The functions below are used to process read requests. 575 * - on_read_request_read1 and on_read_request_read2 read the request itself 576 * - on_read_request_process processes it 577 * - on_read_response_write1 and on_read_response_write2 send the response 578 */ 579 static int 580 on_read_request_read1(struct query_state *qstate) 581 { 582 struct cache_read_request *read_request; 583 ssize_t result; 584 585 TRACE_IN(on_read_request_read1); 586 if (qstate->kevent_watermark == 0) 587 qstate->kevent_watermark = sizeof(size_t) * 2; 588 else { 589 init_comm_element(&qstate->request, CET_READ_REQUEST); 590 read_request = get_cache_read_request(&qstate->request); 591 592 result = qstate->read_func(qstate, 593 &read_request->entry_length, sizeof(size_t)); 594 result += qstate->read_func(qstate, 595 &read_request->cache_key_size, sizeof(size_t)); 596 597 if (result != sizeof(size_t) * 2) { 598 TRACE_OUT(on_read_request_read1); 599 return (-1); 600 } 601 602 if (BUFSIZE_INVALID(read_request->entry_length) || 603 BUFSIZE_INVALID(read_request->cache_key_size)) { 604 TRACE_OUT(on_read_request_read1); 605 return (-1); 606 } 607 608 read_request->entry = calloc(1, 609 read_request->entry_length + 1); 610 assert(read_request->entry != NULL); 611 612 read_request->cache_key = calloc(1, 613 read_request->cache_key_size + 614 qstate->eid_str_length); 615 assert(read_request->cache_key != NULL); 616 memcpy(read_request->cache_key, qstate->eid_str, 617 qstate->eid_str_length); 618 619 qstate->kevent_watermark = read_request->entry_length + 620 read_request->cache_key_size; 621 qstate->process_func = on_read_request_read2; 622 } 623 624 TRACE_OUT(on_read_request_read1); 625 return (0); 626 } 627 628 static int 629 on_read_request_read2(struct query_state *qstate) 630 { 631 struct cache_read_request *read_request; 632 ssize_t result; 633 634 TRACE_IN(on_read_request_read2); 635 read_request = get_cache_read_request(&qstate->request); 636 637 result = qstate->read_func(qstate, read_request->entry, 638 read_request->entry_length); 639 result += qstate->read_func(qstate, 640 read_request->cache_key + qstate->eid_str_length, 641 read_request->cache_key_size); 642 643 if (result != (ssize_t)qstate->kevent_watermark) { 644 TRACE_OUT(on_read_request_read2); 645 return (-1); 646 } 647 read_request->cache_key_size += qstate->eid_str_length; 648 649 qstate->kevent_watermark = 0; 650 qstate->process_func = on_read_request_process; 651 652 TRACE_OUT(on_read_request_read2); 653 return (0); 654 } 655 656 static int 657 on_read_request_process(struct query_state *qstate) 658 { 659 struct cache_read_request *read_request; 660 struct cache_read_response *read_response; 661 cache_entry c_entry, neg_c_entry; 662 663 struct agent *lookup_agent; 664 struct common_agent *c_agent; 665 int res; 666 667 TRACE_IN(on_read_request_process); 668 init_comm_element(&qstate->response, CET_READ_RESPONSE); 669 read_response = get_cache_read_response(&qstate->response); 670 read_request = get_cache_read_request(&qstate->request); 671 672 qstate->config_entry = configuration_find_entry( 673 s_configuration, read_request->entry); 674 if (qstate->config_entry == NULL) { 675 read_response->error_code = ENOENT; 676 677 LOG_ERR_2("read_request", 678 "can't find configuration " 679 "entry '%s'. aborting request", read_request->entry); 680 goto fin; 681 } 682 683 if (qstate->config_entry->enabled == 0) { 684 read_response->error_code = EACCES; 685 686 LOG_ERR_2("read_request", 687 "configuration entry '%s' is disabled", 688 read_request->entry); 689 goto fin; 690 } 691 692 /* 693 * if we perform lookups by ourselves, then we don't need to separate 694 * cache entries by euid and egid 695 */ 696 if (qstate->config_entry->perform_actual_lookups != 0) 697 memset(read_request->cache_key, 0, qstate->eid_str_length); 698 else { 699 #ifdef NS_NSCD_EID_CHECKING 700 if (check_query_eids(qstate) != 0) { 701 /* if the lookup is not self-performing, we check for clients euid/egid */ 702 read_response->error_code = EPERM; 703 goto fin; 704 } 705 #endif 706 } 707 708 configuration_lock_rdlock(s_configuration); 709 c_entry = find_cache_entry(s_cache, 710 qstate->config_entry->positive_cache_params.cep.entry_name); 711 neg_c_entry = find_cache_entry(s_cache, 712 qstate->config_entry->negative_cache_params.cep.entry_name); 713 configuration_unlock(s_configuration); 714 if ((c_entry != NULL) && (neg_c_entry != NULL)) { 715 configuration_lock_entry(qstate->config_entry, CELT_POSITIVE); 716 qstate->config_entry->positive_cache_entry = c_entry; 717 read_response->error_code = cache_read(c_entry, 718 read_request->cache_key, 719 read_request->cache_key_size, NULL, 720 &read_response->data_size); 721 722 if (read_response->error_code == -2) { 723 read_response->data = malloc( 724 read_response->data_size); 725 assert(read_response->data != NULL); 726 read_response->error_code = cache_read(c_entry, 727 read_request->cache_key, 728 read_request->cache_key_size, 729 read_response->data, 730 &read_response->data_size); 731 } 732 configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE); 733 734 configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE); 735 qstate->config_entry->negative_cache_entry = neg_c_entry; 736 if (read_response->error_code == -1) { 737 read_response->error_code = cache_read(neg_c_entry, 738 read_request->cache_key, 739 read_request->cache_key_size, NULL, 740 &read_response->data_size); 741 742 if (read_response->error_code == -2) { 743 read_response->data = malloc( 744 read_response->data_size); 745 assert(read_response->data != NULL); 746 read_response->error_code = cache_read(neg_c_entry, 747 read_request->cache_key, 748 read_request->cache_key_size, 749 read_response->data, 750 &read_response->data_size); 751 } 752 } 753 configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE); 754 755 if ((read_response->error_code == -1) && 756 (qstate->config_entry->perform_actual_lookups != 0)) { 757 free(read_response->data); 758 read_response->data = NULL; 759 read_response->data_size = 0; 760 761 lookup_agent = find_agent(s_agent_table, 762 read_request->entry, COMMON_AGENT); 763 764 if ((lookup_agent != NULL) && 765 (lookup_agent->type == COMMON_AGENT)) { 766 c_agent = (struct common_agent *)lookup_agent; 767 res = c_agent->lookup_func( 768 read_request->cache_key + 769 qstate->eid_str_length, 770 read_request->cache_key_size - 771 qstate->eid_str_length, 772 &read_response->data, 773 &read_response->data_size); 774 775 if (res == NS_SUCCESS) { 776 read_response->error_code = 0; 777 configuration_lock_entry( 778 qstate->config_entry, 779 CELT_POSITIVE); 780 cache_write(c_entry, 781 read_request->cache_key, 782 read_request->cache_key_size, 783 read_response->data, 784 read_response->data_size); 785 configuration_unlock_entry( 786 qstate->config_entry, 787 CELT_POSITIVE); 788 } else if ((res == NS_NOTFOUND) || 789 (res == NS_RETURN)) { 790 configuration_lock_entry( 791 qstate->config_entry, 792 CELT_NEGATIVE); 793 cache_write(neg_c_entry, 794 read_request->cache_key, 795 read_request->cache_key_size, 796 negative_data, 797 sizeof(negative_data)); 798 configuration_unlock_entry( 799 qstate->config_entry, 800 CELT_NEGATIVE); 801 802 read_response->error_code = 0; 803 read_response->data = NULL; 804 read_response->data_size = 0; 805 } 806 } 807 } 808 809 if ((qstate->config_entry->common_query_timeout.tv_sec != 0) || 810 (qstate->config_entry->common_query_timeout.tv_usec != 0)) 811 memcpy(&qstate->timeout, 812 &qstate->config_entry->common_query_timeout, 813 sizeof(struct timeval)); 814 } else 815 read_response->error_code = -1; 816 817 fin: 818 qstate->kevent_filter = EVFILT_WRITE; 819 if (read_response->error_code == 0) 820 qstate->kevent_watermark = sizeof(int) + sizeof(size_t); 821 else 822 qstate->kevent_watermark = sizeof(int); 823 qstate->process_func = on_read_response_write1; 824 825 TRACE_OUT(on_read_request_process); 826 return (0); 827 } 828 829 static int 830 on_read_response_write1(struct query_state *qstate) 831 { 832 struct cache_read_response *read_response; 833 ssize_t result; 834 835 TRACE_IN(on_read_response_write1); 836 read_response = get_cache_read_response(&qstate->response); 837 838 result = qstate->write_func(qstate, &read_response->error_code, 839 sizeof(int)); 840 841 if (read_response->error_code == 0) { 842 result += qstate->write_func(qstate, &read_response->data_size, 843 sizeof(size_t)); 844 if (result != (ssize_t)qstate->kevent_watermark) { 845 TRACE_OUT(on_read_response_write1); 846 return (-1); 847 } 848 849 qstate->kevent_watermark = read_response->data_size; 850 qstate->process_func = on_read_response_write2; 851 } else { 852 if (result != (ssize_t)qstate->kevent_watermark) { 853 TRACE_OUT(on_read_response_write1); 854 return (-1); 855 } 856 857 qstate->kevent_watermark = 0; 858 qstate->process_func = NULL; 859 } 860 861 TRACE_OUT(on_read_response_write1); 862 return (0); 863 } 864 865 static int 866 on_read_response_write2(struct query_state *qstate) 867 { 868 struct cache_read_response *read_response; 869 ssize_t result; 870 871 TRACE_IN(on_read_response_write2); 872 read_response = get_cache_read_response(&qstate->response); 873 if (read_response->data_size > 0) { 874 result = qstate->write_func(qstate, read_response->data, 875 read_response->data_size); 876 if (result != (ssize_t)qstate->kevent_watermark) { 877 TRACE_OUT(on_read_response_write2); 878 return (-1); 879 } 880 } 881 882 finalize_comm_element(&qstate->request); 883 finalize_comm_element(&qstate->response); 884 885 qstate->kevent_watermark = sizeof(int); 886 qstate->kevent_filter = EVFILT_READ; 887 qstate->process_func = on_rw_mapper; 888 TRACE_OUT(on_read_response_write2); 889 return (0); 890 } 891 892 /* 893 * The functions below are used to process write requests. 894 * - on_transform_request_read1 and on_transform_request_read2 read the 895 * request itself 896 * - on_transform_request_process processes it 897 * - on_transform_response_write1 sends the response 898 */ 899 static int 900 on_transform_request_read1(struct query_state *qstate) 901 { 902 struct cache_transform_request *transform_request; 903 ssize_t result; 904 905 TRACE_IN(on_transform_request_read1); 906 if (qstate->kevent_watermark == 0) 907 qstate->kevent_watermark = sizeof(size_t) + sizeof(int); 908 else { 909 init_comm_element(&qstate->request, CET_TRANSFORM_REQUEST); 910 transform_request = 911 get_cache_transform_request(&qstate->request); 912 913 result = qstate->read_func(qstate, 914 &transform_request->entry_length, sizeof(size_t)); 915 result += qstate->read_func(qstate, 916 &transform_request->transformation_type, sizeof(int)); 917 918 if (result != sizeof(size_t) + sizeof(int)) { 919 TRACE_OUT(on_transform_request_read1); 920 return (-1); 921 } 922 923 if ((transform_request->transformation_type != TT_USER) && 924 (transform_request->transformation_type != TT_ALL)) { 925 TRACE_OUT(on_transform_request_read1); 926 return (-1); 927 } 928 929 if (transform_request->entry_length != 0) { 930 if (BUFSIZE_INVALID(transform_request->entry_length)) { 931 TRACE_OUT(on_transform_request_read1); 932 return (-1); 933 } 934 935 transform_request->entry = calloc(1, 936 transform_request->entry_length + 1); 937 assert(transform_request->entry != NULL); 938 939 qstate->process_func = on_transform_request_read2; 940 } else 941 qstate->process_func = on_transform_request_process; 942 943 qstate->kevent_watermark = transform_request->entry_length; 944 } 945 946 TRACE_OUT(on_transform_request_read1); 947 return (0); 948 } 949 950 static int 951 on_transform_request_read2(struct query_state *qstate) 952 { 953 struct cache_transform_request *transform_request; 954 ssize_t result; 955 956 TRACE_IN(on_transform_request_read2); 957 transform_request = get_cache_transform_request(&qstate->request); 958 959 result = qstate->read_func(qstate, transform_request->entry, 960 transform_request->entry_length); 961 962 if (result != (ssize_t)qstate->kevent_watermark) { 963 TRACE_OUT(on_transform_request_read2); 964 return (-1); 965 } 966 967 qstate->kevent_watermark = 0; 968 qstate->process_func = on_transform_request_process; 969 970 TRACE_OUT(on_transform_request_read2); 971 return (0); 972 } 973 974 static int 975 on_transform_request_process(struct query_state *qstate) 976 { 977 struct cache_transform_request *transform_request; 978 struct cache_transform_response *transform_response; 979 struct configuration_entry *config_entry; 980 size_t i, size; 981 982 TRACE_IN(on_transform_request_process); 983 init_comm_element(&qstate->response, CET_TRANSFORM_RESPONSE); 984 transform_response = get_cache_transform_response(&qstate->response); 985 transform_request = get_cache_transform_request(&qstate->request); 986 987 switch (transform_request->transformation_type) { 988 case TT_USER: 989 if (transform_request->entry == NULL) { 990 size = configuration_get_entries_size(s_configuration); 991 for (i = 0; i < size; ++i) { 992 config_entry = configuration_get_entry( 993 s_configuration, i); 994 995 if (config_entry->perform_actual_lookups == 0) 996 clear_config_entry_part(config_entry, 997 qstate->eid_str, qstate->eid_str_length); 998 } 999 } else { 1000 qstate->config_entry = configuration_find_entry( 1001 s_configuration, transform_request->entry); 1002 1003 if (qstate->config_entry == NULL) { 1004 LOG_ERR_2("transform_request", 1005 "can't find configuration" 1006 " entry '%s'. aborting request", 1007 transform_request->entry); 1008 transform_response->error_code = -1; 1009 goto fin; 1010 } 1011 1012 if (qstate->config_entry->perform_actual_lookups != 0) { 1013 LOG_ERR_2("transform_request", 1014 "can't transform the cache entry %s" 1015 ", because it ised for actual lookups", 1016 transform_request->entry); 1017 transform_response->error_code = -1; 1018 goto fin; 1019 } 1020 1021 clear_config_entry_part(qstate->config_entry, 1022 qstate->eid_str, qstate->eid_str_length); 1023 } 1024 break; 1025 case TT_ALL: 1026 if (qstate->euid != 0) 1027 transform_response->error_code = -1; 1028 else { 1029 if (transform_request->entry == NULL) { 1030 size = configuration_get_entries_size( 1031 s_configuration); 1032 for (i = 0; i < size; ++i) { 1033 clear_config_entry( 1034 configuration_get_entry( 1035 s_configuration, i)); 1036 } 1037 } else { 1038 qstate->config_entry = configuration_find_entry( 1039 s_configuration, 1040 transform_request->entry); 1041 1042 if (qstate->config_entry == NULL) { 1043 LOG_ERR_2("transform_request", 1044 "can't find configuration" 1045 " entry '%s'. aborting request", 1046 transform_request->entry); 1047 transform_response->error_code = -1; 1048 goto fin; 1049 } 1050 1051 clear_config_entry(qstate->config_entry); 1052 } 1053 } 1054 break; 1055 default: 1056 transform_response->error_code = -1; 1057 } 1058 1059 fin: 1060 qstate->kevent_watermark = 0; 1061 qstate->process_func = on_transform_response_write1; 1062 TRACE_OUT(on_transform_request_process); 1063 return (0); 1064 } 1065 1066 static int 1067 on_transform_response_write1(struct query_state *qstate) 1068 { 1069 struct cache_transform_response *transform_response; 1070 ssize_t result; 1071 1072 TRACE_IN(on_transform_response_write1); 1073 transform_response = get_cache_transform_response(&qstate->response); 1074 result = qstate->write_func(qstate, &transform_response->error_code, 1075 sizeof(int)); 1076 if (result != sizeof(int)) { 1077 TRACE_OUT(on_transform_response_write1); 1078 return (-1); 1079 } 1080 1081 finalize_comm_element(&qstate->request); 1082 finalize_comm_element(&qstate->response); 1083 1084 qstate->kevent_watermark = 0; 1085 qstate->process_func = NULL; 1086 TRACE_OUT(on_transform_response_write1); 1087 return (0); 1088 } 1089 1090 /* 1091 * Checks if the client's euid and egid do not differ from its uid and gid. 1092 * Returns 0 on success. 1093 */ 1094 int 1095 check_query_eids(struct query_state *qstate) 1096 { 1097 1098 return ((qstate->uid != qstate->euid) || (qstate->gid != qstate->egid) ? -1 : 0); 1099 } 1100 1101 /* 1102 * Uses the qstate fields to process an "alternate" read - when the buffer is 1103 * too large to be received during one socket read operation 1104 */ 1105 ssize_t 1106 query_io_buffer_read(struct query_state *qstate, void *buf, size_t nbytes) 1107 { 1108 size_t remaining; 1109 ssize_t result; 1110 1111 TRACE_IN(query_io_buffer_read); 1112 if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL)) 1113 return (-1); 1114 1115 assert(qstate->io_buffer_p <= 1116 qstate->io_buffer + qstate->io_buffer_size); 1117 remaining = qstate->io_buffer + qstate->io_buffer_size - 1118 qstate->io_buffer_p; 1119 if (nbytes < remaining) 1120 result = nbytes; 1121 else 1122 result = remaining; 1123 1124 memcpy(buf, qstate->io_buffer_p, result); 1125 qstate->io_buffer_p += result; 1126 1127 if (remaining == 0) { 1128 free(qstate->io_buffer); 1129 qstate->io_buffer = NULL; 1130 1131 qstate->write_func = query_socket_write; 1132 qstate->read_func = query_socket_read; 1133 } 1134 1135 TRACE_OUT(query_io_buffer_read); 1136 return (result); 1137 } 1138 1139 /* 1140 * Uses the qstate fields to process an "alternate" write - when the buffer is 1141 * too large to be sent during one socket write operation 1142 */ 1143 ssize_t 1144 query_io_buffer_write(struct query_state *qstate, const void *buf, 1145 size_t nbytes) 1146 { 1147 size_t remaining; 1148 ssize_t result; 1149 1150 TRACE_IN(query_io_buffer_write); 1151 if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL)) 1152 return (-1); 1153 1154 assert(qstate->io_buffer_p <= 1155 qstate->io_buffer + qstate->io_buffer_size); 1156 remaining = qstate->io_buffer + qstate->io_buffer_size - 1157 qstate->io_buffer_p; 1158 if (nbytes < remaining) 1159 result = nbytes; 1160 else 1161 result = remaining; 1162 1163 memcpy(qstate->io_buffer_p, buf, result); 1164 qstate->io_buffer_p += result; 1165 1166 if (remaining == 0) { 1167 qstate->use_alternate_io = 1; 1168 qstate->io_buffer_p = qstate->io_buffer; 1169 1170 qstate->write_func = query_socket_write; 1171 qstate->read_func = query_socket_read; 1172 } 1173 1174 TRACE_OUT(query_io_buffer_write); 1175 return (result); 1176 } 1177 1178 /* 1179 * The default "read" function, which reads data directly from socket 1180 */ 1181 ssize_t 1182 query_socket_read(struct query_state *qstate, void *buf, size_t nbytes) 1183 { 1184 ssize_t result; 1185 1186 TRACE_IN(query_socket_read); 1187 if (qstate->socket_failed != 0) { 1188 TRACE_OUT(query_socket_read); 1189 return (-1); 1190 } 1191 1192 result = read(qstate->sockfd, buf, nbytes); 1193 if (result < 0 || (size_t)result < nbytes) 1194 qstate->socket_failed = 1; 1195 1196 TRACE_OUT(query_socket_read); 1197 return (result); 1198 } 1199 1200 /* 1201 * The default "write" function, which writes data directly to socket 1202 */ 1203 ssize_t 1204 query_socket_write(struct query_state *qstate, const void *buf, size_t nbytes) 1205 { 1206 ssize_t result; 1207 1208 TRACE_IN(query_socket_write); 1209 if (qstate->socket_failed != 0) { 1210 TRACE_OUT(query_socket_write); 1211 return (-1); 1212 } 1213 1214 result = write(qstate->sockfd, buf, nbytes); 1215 if (result < 0 || (size_t)result < nbytes) 1216 qstate->socket_failed = 1; 1217 1218 TRACE_OUT(query_socket_write); 1219 return (result); 1220 } 1221 1222 /* 1223 * Initializes the query_state structure by filling it with the default values. 1224 */ 1225 struct query_state * 1226 init_query_state(int sockfd, size_t kevent_watermark, uid_t euid, gid_t egid) 1227 { 1228 struct query_state *retval; 1229 1230 TRACE_IN(init_query_state); 1231 retval = calloc(1, sizeof(*retval)); 1232 assert(retval != NULL); 1233 1234 retval->sockfd = sockfd; 1235 retval->kevent_filter = EVFILT_READ; 1236 retval->kevent_watermark = kevent_watermark; 1237 1238 retval->euid = euid; 1239 retval->egid = egid; 1240 retval->uid = retval->gid = -1; 1241 1242 if (asprintf(&retval->eid_str, "%d_%d_", retval->euid, 1243 retval->egid) == -1) { 1244 free(retval); 1245 return (NULL); 1246 } 1247 retval->eid_str_length = strlen(retval->eid_str); 1248 1249 init_comm_element(&retval->request, CET_UNDEFINED); 1250 init_comm_element(&retval->response, CET_UNDEFINED); 1251 retval->process_func = on_query_startup; 1252 retval->destroy_func = on_query_destroy; 1253 1254 retval->write_func = query_socket_write; 1255 retval->read_func = query_socket_read; 1256 1257 get_time_func(&retval->creation_time); 1258 retval->timeout.tv_sec = s_configuration->query_timeout; 1259 retval->timeout.tv_usec = 0; 1260 1261 TRACE_OUT(init_query_state); 1262 return (retval); 1263 } 1264 1265 void 1266 destroy_query_state(struct query_state *qstate) 1267 { 1268 1269 TRACE_IN(destroy_query_state); 1270 if (qstate->eid_str != NULL) 1271 free(qstate->eid_str); 1272 1273 if (qstate->io_buffer != NULL) 1274 free(qstate->io_buffer); 1275 1276 qstate->destroy_func(qstate); 1277 free(qstate); 1278 TRACE_OUT(destroy_query_state); 1279 } 1280