1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This file is a module that provides an interface to managing
31 * concurrent sessions executed in either a separate thread or a
32 * separate process. Threads are used only if the compile time flag
33 * DCS_MULTI_THREAD is set. Otherwise, a new process is forked for
34 * each session.
35 *
36 * Multiple processes are used to enable full Internationalization
37 * support. This support requires that each session is able to set
38 * its own locale for use in reporting errors to the user. Currently,
39 * this is not possible using multiple threads because the locale
40 * can not be set for an individual thread. For this reason, multiple
41 * processes are supported until proper locale support is provided
42 * for multiple threads.
43 *
44 * When Solaris supports a different locale in each thread, all
45 * code used to enable using multiple processes should be removed.
46 * To simplify this process, all references to DCS_MULTI_THREAD can
47 * be found in this file.
48 */
49
50 #include <stdlib.h>
51 #include <stdio.h>
52 #include <unistd.h>
53 #include <string.h>
54 #include <errno.h>
55 #include <signal.h>
56 #include <syslog.h>
57 #include <locale.h>
58 #include <sys/socket.h>
59
60 #ifdef DCS_MULTI_THREAD
61 #include <thread.h>
62 #include <pthread.h>
63 #else /* DCS_MULTI_THREAD */
64 #include <sys/types.h>
65 #include <sys/wait.h>
66 #endif /* DCS_MULTI_THREAD */
67
68 #include "dcs.h"
69 #include "rdr_messages.h"
70 #include "rdr_param_types.h"
71
72
73 #define DCS_DEFAULT_LOCALE "C"
74
75
76 /* session allocation/deallocation functions */
77 static int ses_alloc(void);
78 static int ses_free(void);
79
80 /* handler functions */
81 static void *ses_handler(void *arg);
82 #ifndef DCS_MULTI_THREAD
83 static void exit_handler(int sig, siginfo_t *info, void *context);
84 #endif /* !DCS_MULTI_THREAD */
85
86 /* session accounting functions */
87 #ifdef DCS_MULTI_THREAD
88 static void ses_thr_exit(void);
89 #endif /* DCS_MULTI_THREAD */
90
91
92 /*
93 * Global structure that holds all relevant information
94 * about the current session. If multiple threads are
95 * used, the thread specific data mechanism is used. This
96 * requires a data key to access the thread's private
97 * session information.
98 */
99 #ifdef DCS_MULTI_THREAD
100 thread_key_t ses_key = THR_ONCE_KEY;
101 #else /* DCS_MULTI_THREAD */
102 session_t *ses;
103 #endif /* DCS_MULTI_THREAD */
104
105
106 /*
107 * Information about the current number of active sessions.
108 * If multiple threads are used, synchronization objects
109 * are required.
110 */
111 static ulong_t sessions = 0;
112
113 #ifdef DCS_MULTI_THREAD
114 static mutex_t sessions_lock = DEFAULTMUTEX;
115 static cond_t sessions_cv = DEFAULTCV;
116 #endif /* DCS_MULTI_THREAD */
117
118
119 /*
120 * ses_start:
121 *
122 * Start the session handler. If multiple threads are used, create a new
123 * thread that runs the ses_handler() function. If multiple processes
124 * are used, fork a new process and call ses_handler().
125 */
126 int
ses_start(int fd)127 ses_start(int fd)
128 {
129 #ifdef DCS_MULTI_THREAD
130
131 int thr_err;
132
133
134 mutex_lock(&sessions_lock);
135 sessions++;
136 mutex_unlock(&sessions_lock);
137
138 thr_err = thr_create(NULL, 0, ses_handler, (void *)fd,
139 THR_DETACHED | THR_NEW_LWP, NULL);
140
141 return ((thr_err) ? -1 : 0);
142
143 #else /* DCS_MULTI_THREAD */
144
145 int pid;
146
147
148 pid = fork();
149
150 if (pid == -1) {
151 (void) rdr_close(fd);
152 return (-1);
153 }
154
155 /*
156 * Parent:
157 */
158 if (pid) {
159 /* close the child's fd */
160 (void) close(fd);
161
162 sessions++;
163
164 return (0);
165 }
166
167 /*
168 * Child:
169 */
170 ses_handler((void *)fd);
171
172 /*
173 * Prevent return to parent's loop
174 */
175 exit(0);
176
177 /* NOTREACHED */
178
179 #endif /* DCS_MULTI_THREAD */
180 }
181
182
183 /*
184 * ses_close:
185 *
186 * Initiate the closure of a session by sending an RDR_SES_END message
187 * to the client. It does not attempt to close the network connection.
188 */
189 int
ses_close(int err_code)190 ses_close(int err_code)
191 {
192 session_t *sp;
193 cfga_params_t req_data;
194 rdr_msg_hdr_t req_hdr;
195 int snd_status;
196 static char *op_name = "session close";
197
198
199 /* get the current session information */
200 if ((sp = curr_ses()) == NULL) {
201 ses_close(DCS_ERROR);
202 return (-1);
203 }
204
205 /* check if already sent session end */
206 if (sp->state == DCS_SES_END) {
207 return (0);
208 }
209
210 /* prepare header information */
211 init_msg(&req_hdr);
212 req_hdr.message_opcode = RDR_SES_END;
213 req_hdr.data_type = RDR_REQUEST;
214 req_hdr.status = err_code;
215
216 /* no operation specific data */
217 (void) memset(&req_data, 0, sizeof (req_data));
218
219 PRINT_MSG_DBG(DCS_SEND, &req_hdr);
220
221 /* send the message */
222 snd_status = rdr_snd_msg(sp->fd, &req_hdr, &req_data, DCS_SND_TIMEOUT);
223
224 if (snd_status == RDR_ABORTED) {
225 abort_handler();
226 }
227
228 if (snd_status != RDR_OK) {
229 dcs_log_msg(LOG_ERR, DCS_OP_REPLY_ERR, op_name);
230 }
231
232 /*
233 * Setting the session state to DCS_SES_END will
234 * cause the session handler to terminate the
235 * network connection. This should happen whether
236 * or not the session end message that was just
237 * sent was received successfully.
238 */
239 sp->state = DCS_SES_END;
240 return (0);
241 }
242
243
244 /*
245 * ses_abort:
246 *
247 * Attempt to abort an active session. If multiple threads are used,
248 * the parameter represents a thread_t identifier. If multiple
249 * processes are used, the parameter represents a pid. In either
250 * case, use this identifier to send a SIGINT signal to the approprate
251 * session.
252 */
253 int
ses_abort(long ses_id)254 ses_abort(long ses_id)
255 {
256 DCS_DBG(DBG_SES, "killing session %d", ses_id);
257
258 #ifdef DCS_MULTI_THREAD
259
260 if (thr_kill(ses_id, SIGINT) != 0) {
261 /*
262 * If the thread cannot be found, we will assume
263 * that the session was able to exit normally. In
264 * this case, there is no error since the desired
265 * result has already been achieved.
266 */
267 if (errno == ESRCH) {
268 return (0);
269 }
270 return (-1);
271 }
272
273 #else /* DCS_MULTI_THREAD */
274
275 if (kill(ses_id, SIGINT) == -1) {
276 /*
277 * If the process cannot be found, we will assume
278 * that the session was able to exit normally. In
279 * this case, there is no error since the desired
280 * result has already been achieved.
281 */
282 if (errno == ESRCH) {
283 return (0);
284 }
285 return (-1);
286 }
287
288 #endif /* DCS_MULTI_THREAD */
289
290 return (0);
291 }
292
293
294 /*
295 * ses_abort_enable:
296 *
297 * Enter a mode where the current session can be aborted. This mode
298 * will persist until ses_abort_disable() is called.
299 *
300 * A signal handler for SIGINT must be installed prior to calling this
301 * function. If this is not the case, and multiple threads are used,
302 * the default handler for SIGINT will cause the entire process to
303 * exit, rather than just the current session. If multiple processes
304 * are used, the default handler for SIGINT will not affect the main
305 * process, but it will prevent both sides from gracefully closing
306 * the session.
307 */
308 void
ses_abort_enable(void)309 ses_abort_enable(void)
310 {
311 sigset_t unblock_set;
312
313
314 /* unblock SIGINT */
315 sigemptyset(&unblock_set);
316 sigaddset(&unblock_set, SIGINT);
317 (void) sigprocmask(SIG_UNBLOCK, &unblock_set, NULL);
318 }
319
320
321 /*
322 * ses_abort_disable:
323 *
324 * Exit the mode where the current session can be aborted. This
325 * will leave the mode entered by ses_abort_enable().
326 */
327 void
ses_abort_disable(void)328 ses_abort_disable(void)
329 {
330 sigset_t block_set;
331
332
333 /* block SIGINT */
334 sigemptyset(&block_set);
335 sigaddset(&block_set, SIGINT);
336 (void) sigprocmask(SIG_BLOCK, &block_set, NULL);
337 }
338
339
340 /*
341 * ses_setlocale:
342 *
343 * Set the locale for the current session. Currently, if multiple threads
344 * are used, the 'C' locale is specified for all cases. Once there is support
345 * for setting a thread specific locale, the requested locale will be used.
346 * If multiple processes are used, an attempt is made to set the locale of
347 * the process to the locale passed in as a parameter.
348 */
349 int
ses_setlocale(char * locale)350 ses_setlocale(char *locale)
351 {
352 char *new_locale;
353
354 /* sanity check */
355 if (locale == NULL) {
356 locale = DCS_DEFAULT_LOCALE;
357 }
358
359 #ifdef DCS_MULTI_THREAD
360
361 /*
362 * Reserved for setting the locale on a per thread
363 * basis. Currently there is no Solaris support for
364 * this, so use the default locale.
365 */
366 new_locale = setlocale(LC_ALL, DCS_DEFAULT_LOCALE);
367
368 #else /* DCS_MULTI_THREAD */
369
370 new_locale = setlocale(LC_ALL, locale);
371
372 #endif /* DCS_MULTI_THREAD */
373
374 if ((new_locale == NULL) || (strcmp(new_locale, locale) != 0)) {
375 /* silently fall back to C locale */
376 new_locale = setlocale(LC_ALL, DCS_DEFAULT_LOCALE);
377 }
378
379 DCS_DBG(DBG_SES, "using '%s' locale", new_locale);
380
381 return (0);
382 }
383
384
385 /*
386 * ses_init_signals:
387 *
388 * Initialize the set of signals to be blocked. It is assumed that the
389 * mask parameter initially contains all signals. If multiple threads
390 * are used, this is the correct behavior and the mask is not altered.
391 * If multiple processes are used, session accounting is performed in
392 * a SIGCHLD handler and so SIGCHLD must not be blocked. The action of
393 * initializing this handler is also performed in this function.
394 */
395 /* ARGSUSED */
396 void
ses_init_signals(sigset_t * mask)397 ses_init_signals(sigset_t *mask)
398 {
399 #ifndef DCS_MULTI_THREAD
400
401 struct sigaction act;
402
403
404 /* unblock SIGCHLD */
405 (void) sigdelset(mask, SIGCHLD);
406
407 /*
408 * Establish a handler for SIGCHLD
409 */
410 (void) memset(&act, 0, sizeof (act));
411 act.sa_sigaction = exit_handler;
412 act.sa_flags = SA_SIGINFO;
413
414 (void) sigaction(SIGCHLD, &act, NULL);
415
416 #endif /* !DCS_MULTI_THREAD */
417 }
418
419
420 /*
421 * ses_sleep:
422 *
423 * Sleep for a specified amount of time, but don't prevent the
424 * session from being aborted.
425 */
426 void
ses_sleep(int sec)427 ses_sleep(int sec)
428 {
429 ses_abort_enable();
430 sleep(sec);
431 ses_abort_disable();
432 }
433
434
435 /*
436 * ses_wait:
437 *
438 * Wait for the number of active sessions to drop below the maximum
439 * allowed number of active sessions. If multiple threads are used,
440 * the thread waits on a condition variable until a child thread
441 * signals that it is going to exit. If multiple processes are used,
442 * the process waits until at least one child process exits.
443 */
444 static void
ses_wait(void)445 ses_wait(void)
446 {
447 #ifdef DCS_MULTI_THREAD
448
449 mutex_lock(&sessions_lock);
450
451 while (sessions >= max_sessions) {
452 cond_wait(&sessions_cv, &sessions_lock);
453 }
454
455 mutex_unlock(&sessions_lock);
456
457 #else /* DCS_MULTI_THREAD */
458
459 if (sessions >= max_sessions) {
460 (void) wait(NULL);
461 }
462
463 #endif /* DCS_MULTI_THREAD */
464 }
465
466
467 /*
468 * ses_poll:
469 *
470 * Poll on the file descriptors passed in as a parameter. Before polling,
471 * a check is performed to see if the number of active sessions is less
472 * than the maximum number of active sessions allowed. If the limit for
473 * active sessions is reached, the poll will be delayed until at least
474 * one session exits.
475 */
476 int
ses_poll(struct pollfd fds[],nfds_t nfds,int timeout)477 ses_poll(struct pollfd fds[], nfds_t nfds, int timeout)
478 {
479 int err;
480
481
482 ses_wait();
483
484 err = poll(fds, nfds, timeout);
485
486 return (err);
487 }
488
489
490 /*
491 * curr_ses:
492 *
493 * Return a pointer to the global session information. If multiple threads
494 * are being used, this will point to a thread specific instance of a
495 * session structure.
496 */
497 session_t *
curr_ses(void)498 curr_ses(void)
499 {
500 #ifdef DCS_MULTI_THREAD
501
502 return (pthread_getspecific(ses_key));
503
504 #else /* DCS_MULTI_THREAD */
505
506 return (ses);
507
508 #endif /* DCS_MULTI_THREAD */
509 }
510
511
512 /*
513 * curr_ses_id:
514 *
515 * Return the session identifier. This is either the thread_t identifier
516 * of the thread, or the pid of the process.
517 */
518 long
curr_ses_id(void)519 curr_ses_id(void)
520 {
521 #ifdef DCS_MULTI_THREAD
522
523 return (thr_self());
524
525 #else /* DCS_MULTI_THREAD */
526
527 return (getpid());
528
529 #endif /* DCS_MULTI_THREAD */
530 }
531
532
533 /*
534 * ses_handler:
535 *
536 * Handle initialization and processing of a session. Initializes a session
537 * and enters a loop which waits for requests. When a request comes in, it
538 * is dispatched. When the session is terminated, the loop exits and the
539 * session is cleaned up.
540 */
541 static void *
ses_handler(void * arg)542 ses_handler(void *arg)
543 {
544 session_t *sp;
545 rdr_msg_hdr_t op_hdr;
546 cfga_params_t op_data;
547 int rcv_status;
548 sigset_t block_set;
549 struct sigaction act;
550
551 static char *dcs_state_str[] = {
552 "unknown state",
553 "DCS_CONNECTED",
554 "DCS_SES_REQ",
555 "DCS_SES_ESTBL",
556 "DCS_CONF_PENDING",
557 "DCS_CONF_DONE",
558 "DCS_SES_END"
559 };
560
561
562 if (ses_alloc() == -1) {
563 (void) rdr_close((int)arg);
564 return ((void *)-1);
565 }
566
567 if ((sp = curr_ses()) == NULL) {
568 ses_close(DCS_ERROR);
569 return (NULL);
570 }
571
572 /* initialize session information */
573 memset(sp, 0, sizeof (session_t));
574 sp->state = DCS_CONNECTED;
575 sp->random_resp = lrand48();
576 sp->fd = (int)arg;
577 sp->id = curr_ses_id();
578
579 /* initially, block all signals and cancels */
580 (void) sigfillset(&block_set);
581 (void) sigprocmask(SIG_BLOCK, &block_set, NULL);
582
583 /* set the abort handler for this session */
584 (void) memset(&act, 0, sizeof (act));
585 act.sa_handler = abort_handler;
586 (void) sigaction(SIGINT, &act, NULL);
587
588 DCS_DBG(DBG_SES, "session handler starting...");
589
590 /*
591 * Process all requests in the session until the
592 * session is terminated
593 */
594 for (;;) {
595
596 DCS_DBG(DBG_STATE, "session state: %s",
597 dcs_state_str[sp->state]);
598
599 if (sp->state == DCS_SES_END) {
600 break;
601 }
602
603 (void) memset(&op_hdr, 0, sizeof (op_hdr));
604 (void) memset(&op_data, 0, sizeof (op_data));
605
606 rcv_status = rdr_rcv_msg(sp->fd, &op_hdr, &op_data,
607 DCS_RCV_TIMEOUT);
608
609 if (rcv_status != RDR_OK) {
610
611 switch (rcv_status) {
612
613 case RDR_TIMEOUT:
614 DCS_DBG(DBG_SES, "receive timed out");
615 break;
616
617 case RDR_DISCONNECT:
618 dcs_log_msg(LOG_NOTICE, DCS_DISCONNECT);
619 break;
620
621 case RDR_ABORTED:
622 dcs_log_msg(LOG_INFO, DCS_SES_ABORTED);
623 break;
624
625 case RDR_MSG_INVAL:
626 /*
627 * Only log invalid messages if a session has
628 * already been established. Logging invalid
629 * session request messages could flood syslog.
630 */
631 if (sp->state != DCS_CONNECTED) {
632 dcs_log_msg(LOG_WARNING, DCS_MSG_INVAL);
633 } else {
634 DCS_DBG(DBG_SES, "received an invalid "
635 "message");
636 }
637
638 break;
639
640 default:
641 dcs_log_msg(LOG_ERR, DCS_RECEIVE_ERR);
642 break;
643 }
644
645 /*
646 * We encountered an unrecoverable error,
647 * so exit this session handler.
648 */
649 break;
650
651 } else {
652 /* handle the message */
653 dcs_dispatch_message(&op_hdr, &op_data);
654 rdr_cleanup_params(op_hdr.message_opcode, &op_data);
655 }
656 }
657
658 DCS_DBG(DBG_SES, "connection closed");
659
660 /* clean up */
661 (void) rdr_close(sp->fd);
662 (void) ses_free();
663
664 #ifdef DCS_MULTI_THREAD
665 ses_thr_exit();
666 #endif /* DCS_MULTI_THREAD */
667
668 return (0);
669 }
670
671
672 /*
673 * abort_handler:
674 *
675 * Handle a request to abort a session. This function should be installed
676 * as the signal handler for SIGINT. It sends a message to the client
677 * indicating that the session was aborted, and that the operation failed
678 * as a result. The session then terminates, and the thread or process
679 * handling the session exits.
680 */
681 void
abort_handler(void)682 abort_handler(void)
683 {
684 session_t *sp;
685 rdr_msg_hdr_t op_hdr;
686 cfga_params_t op_data;
687
688
689 /* get the current session information */
690 if ((sp = curr_ses()) == NULL) {
691 ses_close(DCS_ERROR);
692 #ifdef DCS_MULTI_THREAD
693 ses_thr_exit();
694 thr_exit(0);
695 #else /* DCS_MULTI_THREAD */
696 exit(0);
697 #endif /* DCS_MULTI_THREAD */
698 }
699
700 DCS_DBG(DBG_MSG, "abort_handler()");
701
702 /* prepare header information */
703 init_msg(&op_hdr);
704 op_hdr.message_opcode = sp->curr_msg.hdr->message_opcode;
705 op_hdr.data_type = RDR_REPLY;
706 op_hdr.status = DCS_SES_ABORTED;
707
708 /* no operation specific data */
709 (void) memset(&op_data, 0, sizeof (op_data));
710
711 PRINT_MSG_DBG(DCS_SEND, &op_hdr);
712
713 (void) rdr_snd_msg(sp->fd, &op_hdr, &op_data, DCS_SND_TIMEOUT);
714
715 DCS_DBG(DBG_INFO, "abort_handler: connection closed");
716
717 /* clean up */
718 rdr_cleanup_params(op_hdr.message_opcode, sp->curr_msg.params);
719 (void) rdr_close(sp->fd);
720 (void) ses_free();
721
722 dcs_log_msg(LOG_INFO, DCS_SES_ABORTED);
723
724 #ifdef DCS_MULTI_THREAD
725 ses_thr_exit();
726 thr_exit(0);
727 #else /* DCS_MULTI_THREAD */
728 exit(0);
729 #endif /* DCS_MULTI_THREAD */
730 }
731
732
733 #ifndef DCS_MULTI_THREAD
734
735 /*
736 * exit_handler:
737 *
738 * If multiple processes are used, this function is used to record
739 * the fact that a child process has exited. In order to make sure
740 * that all zombie processes are released, a waitpid() is performed
741 * for the child that has exited.
742 */
743 /* ARGSUSED */
744 static void
exit_handler(int sig,siginfo_t * info,void * context)745 exit_handler(int sig, siginfo_t *info, void *context)
746 {
747 sessions--;
748
749 if (info != NULL) {
750 (void) waitpid(info->si_pid, NULL, 0);
751 }
752 }
753
754 #endif /* !DCS_MULTI_THREAD */
755
756
757 /*
758 * ses_alloc:
759 *
760 * Allocate the memory required for the global session structure.
761 * If multiple threads are used, create a thread specific data
762 * key. This will only occur the first time that this function
763 * gets called.
764 */
765 static int
ses_alloc(void)766 ses_alloc(void)
767 {
768 session_t *sp;
769
770 #ifdef DCS_MULTI_THREAD
771
772 int thr_err;
773
774 thr_err = thr_keycreate_once(&ses_key, NULL);
775 if (thr_err)
776 return (-1);
777
778 #endif /* DCS_MULTI_THREAD */
779
780 DCS_DBG(DBG_SES, "allocating session memory");
781
782 sp = (session_t *)malloc(sizeof (session_t));
783
784 if (!sp) {
785 dcs_log_msg(LOG_ERR, DCS_INT_ERR, "malloc", strerror(errno));
786 return (-1);
787 }
788
789 #ifdef DCS_MULTI_THREAD
790
791 thr_err = thr_setspecific(ses_key, sp);
792
793 return ((thr_err) ? -1 : 0);
794
795 #else /* DCS_MULTI_THREAD */
796
797 /* make the data global */
798 ses = sp;
799
800 return (0);
801
802 #endif /* DCS_MULTI_THREAD */
803 }
804
805
806 /*
807 * ses_free:
808 *
809 * Deallocate the memory associated with the global session structure.
810 */
811 static int
ses_free(void)812 ses_free(void)
813 {
814 session_t *sp;
815
816
817 DCS_DBG(DBG_SES, "freeing session memory");
818
819 if ((sp = curr_ses()) == NULL) {
820 ses_close(DCS_ERROR);
821 return (-1);
822 }
823
824 if (sp) {
825 (void) free((void *)sp);
826 }
827
828 return (0);
829 }
830
831
832 #ifdef DCS_MULTI_THREAD
833
834 /*
835 * ses_thr_exit:
836 *
837 * If multiple threads are used, this function is used to record the
838 * fact that a child thread has exited. In addition, the condition
839 * variable is signaled so that the main thread can wakeup and begin
840 * accepting connections again.
841 */
842 static void
ses_thr_exit()843 ses_thr_exit()
844 {
845 mutex_lock(&sessions_lock);
846
847 sessions--;
848
849 cond_signal(&sessions_cv);
850
851 mutex_unlock(&sessions_lock);
852 }
853
854 #endif /* DCS_MULTI_THREAD */
855