usr.sbin/nscd/query.c

153 on_query_startup(struct query_state *qstate)
165 	assert(qstate != NULL);
177 	if (recvmsg(qstate->sockfd, &mhdr, 0) == -1) {
191 	qstate->uid = cred->cmcred_uid;
192 	qstate->gid = cred->cmcred_gid;
199 	if (check_query_eids(qstate) != 0) {
217 		qstate->process_func = on_write_request_read1;
220 		qstate->process_func = on_read_request_read1;
223 		qstate->process_func = on_transform_request_read1;
226 		qstate->process_func = on_mp_write_session_request_read1;
229 		qstate->process_func = on_mp_read_session_request_read1;
236 	qstate->kevent_watermark = 0;
248 on_rw_mapper(struct query_state *qstate)
254 	if (qstate->kevent_watermark == 0) {
255 		qstate->kevent_watermark = sizeof(int);
257 		result = qstate->read_func(qstate, &elem_type, sizeof(int));
265 			qstate->kevent_watermark = sizeof(size_t);
266 			qstate->process_func = on_write_request_read1;
269 			qstate->kevent_watermark = sizeof(size_t);
270 			qstate->process_func = on_read_request_read1;
286 on_query_destroy(struct query_state *qstate)
290 	finalize_comm_element(&qstate->response);
291 	finalize_comm_element(&qstate->request);
303 on_write_request_read1(struct query_state *qstate)
309 	if (qstate->kevent_watermark == 0)
310 		qstate->kevent_watermark = sizeof(size_t) * 3;
312 		init_comm_element(&qstate->request, CET_WRITE_REQUEST);
313 		write_request = get_cache_write_request(&qstate->request);
315 		result = qstate->read_func(qstate, &write_request->entry_length,
317 		result += qstate->read_func(qstate,
319 		result += qstate->read_func(qstate,
341 			qstate->eid_str_length);
343 		memcpy(write_request->cache_key, qstate->eid_str,
344 			qstate->eid_str_length);
352 		qstate->kevent_watermark = write_request->entry_length +
355 		qstate->process_func = on_write_request_read2;
363 on_write_request_read2(struct query_state *qstate)
369 	write_request = get_cache_write_request(&qstate->request);
371 	result = qstate->read_func(qstate, write_request->entry,
373 	result += qstate->read_func(qstate, write_request->cache_key +
374 		qstate->eid_str_length, write_request->cache_key_size);
376 		result += qstate->read_func(qstate, write_request->data,
379 	if (result != (ssize_t)qstate->kevent_watermark) {
383 	write_request->cache_key_size += qstate->eid_str_length;
385 	qstate->kevent_watermark = 0;
387 		qstate->process_func = on_write_request_process;
389 	    	qstate->process_func = on_negative_write_request_process;
395 on_write_request_process(struct query_state *qstate)
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);
406 	qstate->config_entry = configuration_find_entry(
409 	if (qstate->config_entry == NULL) {
417 	if (qstate->config_entry->enabled == 0) {
426 	if (qstate->config_entry->perform_actual_lookups != 0) {
437 		qstate->config_entry->positive_cache_params.cep.entry_name);
440 		configuration_lock_entry(qstate->config_entry, CELT_POSITIVE);
441 		qstate->config_entry->positive_cache_entry = c_entry;
447 		configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE);
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,
459 	qstate->kevent_filter = EVFILT_WRITE;
460 	qstate->kevent_watermark = sizeof(int);
461 	qstate->process_func = on_write_response_write1;
468 on_negative_write_request_process(struct query_state *qstate)
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);
479 	qstate->config_entry = configuration_find_entry	(
482 	if (qstate->config_entry == NULL) {
491 	if (qstate->config_entry->enabled == 0) {
500 	if (qstate->config_entry->perform_actual_lookups != 0) {
509 		if (check_query_eids(qstate) != 0) {
518 		qstate->config_entry->negative_cache_params.cep.entry_name);
521 		configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE);
522 		qstate->config_entry->negative_cache_entry = c_entry;
528 		configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE);
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,
539 	qstate->kevent_filter = EVFILT_WRITE;
540 	qstate->kevent_watermark = sizeof(int);
541 	qstate->process_func = on_write_response_write1;
548 on_write_response_write1(struct query_state *qstate)
554 	write_response = get_cache_write_response(&qstate->response);
555 	result = qstate->write_func(qstate, &write_response->error_code,
562 	finalize_comm_element(&qstate->request);
563 	finalize_comm_element(&qstate->response);
565 	qstate->kevent_watermark = sizeof(int);
566 	qstate->kevent_filter = EVFILT_READ;
567 	qstate->process_func = on_rw_mapper;
580 on_read_request_read1(struct query_state *qstate)
586 	if (qstate->kevent_watermark == 0)
587 		qstate->kevent_watermark = sizeof(size_t) * 2;
589 		init_comm_element(&qstate->request, CET_READ_REQUEST);
590 		read_request = get_cache_read_request(&qstate->request);
592 		result = qstate->read_func(qstate,
594 		result += qstate->read_func(qstate,
614 			qstate->eid_str_length);
616 		memcpy(read_request->cache_key, qstate->eid_str,
617 			qstate->eid_str_length);
619 		qstate->kevent_watermark = read_request->entry_length +
621 		qstate->process_func = on_read_request_read2;
629 on_read_request_read2(struct query_state *qstate)
635 	read_request = get_cache_read_request(&qstate->request);
637 	result = qstate->read_func(qstate, read_request->entry,
639 	result += qstate->read_func(qstate,
640 		read_request->cache_key + qstate->eid_str_length,
643 	if (result != (ssize_t)qstate->kevent_watermark) {
647 	read_request->cache_key_size += qstate->eid_str_length;
649 	qstate->kevent_watermark = 0;
650 	qstate->process_func = on_read_request_process;
657 on_read_request_process(struct query_state *qstate)
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);
672 	qstate->config_entry = configuration_find_entry(
674 	if (qstate->config_entry == NULL) {
683 	if (qstate->config_entry->enabled == 0) {
696 	if (qstate->config_entry->perform_actual_lookups != 0)
697 		memset(read_request->cache_key, 0, qstate->eid_str_length);
700 		if (check_query_eids(qstate) != 0) {
710 		qstate->config_entry->positive_cache_params.cep.entry_name);
712 		qstate->config_entry->negative_cache_params.cep.entry_name);
715 		configuration_lock_entry(qstate->config_entry, CELT_POSITIVE);
716 		qstate->config_entry->positive_cache_entry = c_entry;
732 		configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE);
734 		configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE);
735 		qstate->config_entry->negative_cache_entry = neg_c_entry;
753 		configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE);
756 			(qstate->config_entry->perform_actual_lookups != 0)) {
769 						qstate->eid_str_length,
771 						qstate->eid_str_length,
778 						qstate->config_entry,
786 						qstate->config_entry,
791 						  qstate->config_entry,
799 						  qstate->config_entry,
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,
818 	qstate->kevent_filter = EVFILT_WRITE;
820 		qstate->kevent_watermark = sizeof(int) + sizeof(size_t);
822 		qstate->kevent_watermark = sizeof(int);
823 	qstate->process_func = on_read_response_write1;
830 on_read_response_write1(struct query_state *qstate)
836 	read_response = get_cache_read_response(&qstate->response);
838 	result = qstate->write_func(qstate, &read_response->error_code,
842 		result += qstate->write_func(qstate, &read_response->data_size,
844 		if (result != (ssize_t)qstate->kevent_watermark) {
849 		qstate->kevent_watermark = read_response->data_size;
850 		qstate->process_func = on_read_response_write2;
852 		if (result != (ssize_t)qstate->kevent_watermark) {
857 		qstate->kevent_watermark = 0;
858 		qstate->process_func = NULL;
866 on_read_response_write2(struct query_state *qstate)
872 	read_response = get_cache_read_response(&qstate->response);
874 		result = qstate->write_func(qstate, read_response->data,
876 		if (result != (ssize_t)qstate->kevent_watermark) {
882 	finalize_comm_element(&qstate->request);
883 	finalize_comm_element(&qstate->response);
885 	qstate->kevent_watermark = sizeof(int);
886 	qstate->kevent_filter = EVFILT_READ;
887 	qstate->process_func = on_rw_mapper;
900 on_transform_request_read1(struct query_state *qstate)
906 	if (qstate->kevent_watermark == 0)
907 		qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
909 		init_comm_element(&qstate->request, CET_TRANSFORM_REQUEST);
911 			get_cache_transform_request(&qstate->request);
913 		result = qstate->read_func(qstate,
915 		result += qstate->read_func(qstate,
939 			qstate->process_func = on_transform_request_read2;
941 			qstate->process_func = on_transform_request_process;
943 		qstate->kevent_watermark = transform_request->entry_length;
951 on_transform_request_read2(struct query_state *qstate)
957 	transform_request = get_cache_transform_request(&qstate->request);
959 	result = qstate->read_func(qstate, transform_request->entry,
962 	if (result != (ssize_t)qstate->kevent_watermark) {
967 	qstate->kevent_watermark = 0;
968 	qstate->process_func = on_transform_request_process;
975 on_transform_request_process(struct query_state *qstate)
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);
997 				    qstate->eid_str, qstate->eid_str_length);
1000 			qstate->config_entry = configuration_find_entry(
1003 			if (qstate->config_entry == NULL) {
1012 			if (qstate->config_entry->perform_actual_lookups != 0) {
1021 			clear_config_entry_part(qstate->config_entry,
1022 				qstate->eid_str, qstate->eid_str_length);
1026 		if (qstate->euid != 0)
1038 				qstate->config_entry = configuration_find_entry(
1042 				if (qstate->config_entry == NULL) {
1051 				clear_config_entry(qstate->config_entry);
1060 	qstate->kevent_watermark = 0;
1061 	qstate->process_func = on_transform_response_write1;
1067 on_transform_response_write1(struct query_state *qstate)
1073 	transform_response = get_cache_transform_response(&qstate->response);
1074 	result = qstate->write_func(qstate, &transform_response->error_code,
1081 	finalize_comm_element(&qstate->request);
1082 	finalize_comm_element(&qstate->response);
1084 	qstate->kevent_watermark = 0;
1085 	qstate->process_func = NULL;
1095 check_query_eids(struct query_state *qstate)
1098 	return ((qstate->uid != qstate->euid) || (qstate->gid != qstate->egid) ? -1 : 0);
1102  * Uses the qstate fields to process an "alternate" read - when the buffer is
1106 query_io_buffer_read(struct query_state *qstate, void *buf, size_t nbytes)
1112 	if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
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;
1124 	memcpy(buf, qstate->io_buffer_p, result);
1125 	qstate->io_buffer_p += result;
1128 		free(qstate->io_buffer);
1129 		qstate->io_buffer = NULL;
1131 		qstate->write_func = query_socket_write;
1132 		qstate->read_func = query_socket_read;
1140  * Uses the qstate fields to process an "alternate" write - when the buffer is
1144 query_io_buffer_write(struct query_state *qstate, const void *buf,
1151 	if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
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;
1163 	memcpy(qstate->io_buffer_p, buf, result);
1164 	qstate->io_buffer_p += result;
1167 		qstate->use_alternate_io = 1;
1168 		qstate->io_buffer_p = qstate->io_buffer;
1170 		qstate->write_func = query_socket_write;
1171 		qstate->read_func = query_socket_read;
1182 query_socket_read(struct query_state *qstate, void *buf, size_t nbytes)
1187 	if (qstate->socket_failed != 0) {
1192 	result = read(qstate->sockfd, buf, nbytes);
1194 		qstate->socket_failed = 1;
1204 query_socket_write(struct query_state *qstate, const void *buf, size_t nbytes)
1209 	if (qstate->socket_failed != 0) {
1214 	result = write(qstate->sockfd, buf, nbytes);
1216 		qstate->socket_failed = 1;
1266 destroy_query_state(struct query_state *qstate)
1270 	if (qstate->eid_str != NULL)
1271 	    free(qstate->eid_str);
1273 	if (qstate->io_buffer != NULL)
1274 		free(qstate->io_buffer);
1276 	qstate->destroy_func(qstate);
1277 	free(qstate);