-
Notifications
You must be signed in to change notification settings - Fork 3
/
stap-serverd.cxx
1981 lines (1754 loc) · 58.1 KB
/
stap-serverd.cxx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
SSL server program listens on a port, accepts client connection, reads
the data into a temporary file, calls the systemtap translator and
then transmits the resulting file back to the client.
Copyright (C) 2011-2013 Red Hat Inc.
This file is part of systemtap, and is free software. You can
redistribute it and/or modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <fstream>
#include <string>
#include <cerrno>
#include <cassert>
#include <climits>
#include <iostream>
#include <map>
extern "C" {
#include <unistd.h>
#include <getopt.h>
#include <wordexp.h>
#include <glob.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <sys/types.h>
#include <pwd.h>
#include <semaphore.h>
#include <nspr.h>
#include <ssl.h>
#include <nss.h>
#include <keyhi.h>
#include <regex.h>
#if HAVE_AVAHI
#include <avahi-client/publish.h>
#include <avahi-common/alternative.h>
#include <avahi-common/thread-watch.h>
#include <avahi-common/malloc.h>
#include <avahi-common/error.h>
#endif
}
#include "util.h"
#include "nsscommon.h"
#include "cscommon.h"
#include "cmdline.h"
using namespace std;
static void cleanup ();
static PRStatus spawn_and_wait (const vector<string> &argv, int *result,
const char* fd0, const char* fd1, const char* fd2,
const char *pwd, const vector<string>& envVec = vector<string> ());
/* getopt variables */
extern int optind;
/* File scope statics. Set during argument parsing and initialization. */
static bool use_db_password;
static unsigned short port;
static long max_threads;
static string cert_db_path;
static string stap_options;
static string uname_r;
static string arch;
static string cert_serial_number;
static string B_options;
static string I_options;
static string R_option;
static string D_options;
static bool keep_temp;
sem_t sem_client;
static int pending_interrupts;
#define CONCURRENCY_TIMEOUT_S 3
// Message handling.
// Server_error messages are printed to stderr and logged, if requested.
static void
server_error (const string &msg, int logit = true)
{
cerr << msg << endl << flush;
// Log it, but avoid repeated messages to the terminal.
if (logit && log_ok ())
log (msg);
}
// client_error messages are treated as server errors and also printed to the client's stderr.
static void
client_error (const string &msg, string stapstderr)
{
server_error (msg);
if (! stapstderr.empty ())
{
ofstream errfile;
errfile.open (stapstderr.c_str (), ios_base::app);
if (! errfile.good ())
server_error (_F("Could not open client stderr file %s: %s", stapstderr.c_str (),
strerror (errno)));
else
errfile << "Server: " << msg << endl;
// NB: No need to close errfile
}
}
// Messages from the nss common code are treated as server errors.
extern "C"
void
nsscommon_error (const char *msg, int logit)
{
server_error (msg, logit);
}
// Fatal errors are treated as server errors but also result in termination
// of the server.
static void
fatal (const string &msg)
{
server_error (msg);
cleanup ();
exit (1);
}
// Argument handling
static void
process_a (const string &arg)
{
arch = arg;
stap_options += " -a " + arg;
}
static void
process_r (const string &arg)
{
if (arg[0] == '/') // fully specified path
uname_r = kernel_release_from_build_tree (arg);
else
uname_r = arg;
stap_options += " -r " + arg; // Pass the argument to stap directly.
}
static void
process_log (const char *arg)
{
start_log (arg);
}
static void
parse_options (int argc, char **argv)
{
// Examine the command line. This is the command line for us (stap-serverd) not the command
// line for spawned stap instances.
optind = 1;
while (true)
{
char *num_endptr;
long port_tmp;
// NB: The values of these enumerators must not conflict with the values of ordinary
// characters, since those are returned by getopt_long for short options.
enum {
LONG_OPT_PORT = 256,
LONG_OPT_SSL,
LONG_OPT_LOG,
LONG_OPT_MAXTHREADS
};
static struct option long_options[] = {
{ "port", 1, NULL, LONG_OPT_PORT },
{ "ssl", 1, NULL, LONG_OPT_SSL },
{ "log", 1, NULL, LONG_OPT_LOG },
{ "max-threads", 1, NULL, LONG_OPT_MAXTHREADS },
{ NULL, 0, NULL, 0 }
};
int grc = getopt_long (argc, argv, "a:B:D:I:kPr:R:", long_options, NULL);
if (grc < 0)
break;
switch (grc)
{
case 'a':
process_a (optarg);
break;
case 'B':
B_options += string (" -") + (char)grc + optarg;
stap_options += string (" -") + (char)grc + optarg;
break;
case 'D':
D_options += string (" -") + (char)grc + optarg;
stap_options += string (" -") + (char)grc + optarg;
break;
case 'I':
I_options += string (" -") + (char)grc + optarg;
stap_options += string (" -") + (char)grc + optarg;
break;
case 'k':
keep_temp = true;
break;
case 'P':
use_db_password = true;
break;
case 'r':
process_r (optarg);
break;
case 'R':
R_option = string (" -") + (char)grc + optarg;
stap_options += string (" -") + (char)grc + optarg;
break;
case LONG_OPT_PORT:
port_tmp = strtol (optarg, &num_endptr, 10);
if (*num_endptr != '\0')
fatal (_F("%s: cannot parse number '--port=%s'", argv[0], optarg));
else if (port_tmp < 0 || port_tmp > 65535)
fatal (_F("%s: invalid entry: port must be between 0 and 65535 '--port=%s'", argv[0],
optarg));
else
port = (unsigned short) port_tmp;
break;
case LONG_OPT_SSL:
cert_db_path = optarg;
break;
case LONG_OPT_LOG:
process_log (optarg);
break;
case LONG_OPT_MAXTHREADS:
max_threads = strtol (optarg, &num_endptr, 0);
if (*num_endptr != '\0')
fatal (_F("%s: cannot parse number '--max-threads=%s'", argv[0], optarg));
else if (max_threads < 0)
fatal (_F("%s: invalid entry: max threads must not be negative '--max-threads=%s'",
argv[0], optarg));
break;
case '?':
// Invalid/unrecognized option given. Message has already been issued.
break;
default:
// Reached when one added a getopt option but not a corresponding switch/case:
if (optarg)
server_error (_F("%s: unhandled option '%c %s'", argv[0], (char)grc, optarg));
else
server_error (_F("%s: unhandled option '%c'", argv[0], (char)grc));
break;
}
}
for (int i = optind; i < argc; i++)
server_error (_F("%s: unrecognized argument '%s'", argv[0], argv[i]));
}
static string
server_cert_file ()
{
return server_cert_db_path () + "/stap.cert";
}
// Signal handling. When an interrupt is received, kill any spawned processes
// and exit.
extern "C"
void
handle_interrupt (int sig)
{
pending_interrupts++;
if(pending_interrupts >= 2)
{
log (_F("Received another signal %d, exiting (forced)", sig));
_exit(0);
}
log (_F("Received signal %d, exiting", sig));
}
static void
setup_signals (sighandler_t handler)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
sigemptyset (&sa.sa_mask);
if (handler != SIG_IGN)
{
sigaddset (&sa.sa_mask, SIGHUP);
sigaddset (&sa.sa_mask, SIGPIPE);
sigaddset (&sa.sa_mask, SIGINT);
sigaddset (&sa.sa_mask, SIGTERM);
sigaddset (&sa.sa_mask, SIGTTIN);
sigaddset (&sa.sa_mask, SIGTTOU);
sigaddset (&sa.sa_mask, SIGXFSZ);
sigaddset (&sa.sa_mask, SIGXCPU);
}
sa.sa_flags = SA_RESTART;
sigaction (SIGHUP, &sa, NULL);
sigaction (SIGPIPE, &sa, NULL);
sigaction (SIGINT, &sa, NULL);
sigaction (SIGTERM, &sa, NULL);
sigaction (SIGTTIN, &sa, NULL);
sigaction (SIGTTOU, &sa, NULL);
sigaction (SIGXFSZ, &sa, NULL);
sigaction (SIGXCPU, &sa, NULL);
}
#if HAVE_AVAHI
static AvahiEntryGroup *avahi_group = NULL;
static AvahiThreadedPoll *avahi_threaded_poll = NULL;
static char *avahi_service_name = NULL;
static AvahiClient *avahi_client = 0;
static void create_services (AvahiClient *c);
static void
entry_group_callback (
AvahiEntryGroup *g,
AvahiEntryGroupState state,
AVAHI_GCC_UNUSED void *userdata
) {
assert(g == avahi_group || avahi_group == NULL);
avahi_group = g;
// Called whenever the entry group state changes.
switch (state)
{
case AVAHI_ENTRY_GROUP_ESTABLISHED:
// The entry group has been established successfully.
log (_F("Avahi service '%s' successfully established.", avahi_service_name));
break;
case AVAHI_ENTRY_GROUP_COLLISION: {
char *n;
// A service name collision with a remote service.
// happened. Let's pick a new name.
n = avahi_alternative_service_name (avahi_service_name);
avahi_free (avahi_service_name);
avahi_service_name = n;
server_error (_F("Avahi service name collision, renaming service to '%s'", avahi_service_name));
// And recreate the services.
create_services (avahi_entry_group_get_client (g));
break;
}
case AVAHI_ENTRY_GROUP_FAILURE:
// Some kind of failure happened.
server_error (_F("Avahi entry group failure: %s",
avahi_strerror (avahi_client_errno (avahi_entry_group_get_client (g)))));
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
break;
}
}
static void
create_services (AvahiClient *c) {
assert (c);
// If this is the first time we're called, let's create a new
// entry group if necessary.
if (! avahi_group)
if (! (avahi_group = avahi_entry_group_new (c, entry_group_callback, NULL)))
{
server_error (_F("avahi_entry_group_new () failed: %s",
avahi_strerror (avahi_client_errno (c))));
goto fail;
}
// If the group is empty (either because it was just created, or
// because it was reset previously, add our entries.
if (avahi_entry_group_is_empty (avahi_group))
{
log (_F("Adding Avahi service '%s'", avahi_service_name));
// Create the txt tags that will be registered with our service.
string sysinfo = "sysinfo=" + uname_r + " " + arch;
string certinfo = "certinfo=" + cert_serial_number;
string version = string ("version=") + CURRENT_CS_PROTOCOL_VERSION;;
string optinfo = "optinfo=";
string separator;
// These option strings already have a leading space.
if (! R_option.empty ())
{
optinfo += R_option.substr(1);
separator = " ";
}
if (! B_options.empty ())
{
optinfo += separator + B_options.substr(1);
separator = " ";
}
if (! D_options.empty ())
{
optinfo += separator + D_options.substr(1);
separator = " ";
}
if (! I_options.empty ())
optinfo += separator + I_options.substr(1);
// We will now add our service to the entry group. Only services with the
// same name should be put in the same entry group.
int ret;
if ((ret = avahi_entry_group_add_service (avahi_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
(AvahiPublishFlags)0,
avahi_service_name, "_stap._tcp", NULL, NULL, port,
sysinfo.c_str (), optinfo.c_str (),
version.c_str (), certinfo.c_str (), NULL)) < 0)
{
if (ret == AVAHI_ERR_COLLISION)
goto collision;
server_error (_F("Failed to add _stap._tcp service: %s", avahi_strerror (ret)));
goto fail;
}
// Tell the server to register the service.
if ((ret = avahi_entry_group_commit (avahi_group)) < 0)
{
server_error (_F("Failed to commit avahi entry group: %s", avahi_strerror (ret)));
goto fail;
}
}
return;
collision:
// A service name collision with a local service happened. Let's
// pick a new name.
char *n;
n = avahi_alternative_service_name (avahi_service_name);
avahi_free(avahi_service_name);
avahi_service_name = n;
server_error (_F("Avahi service name collision, renaming service to '%s'", avahi_service_name));
avahi_entry_group_reset (avahi_group);
create_services (c);
return;
fail:
avahi_entry_group_reset (avahi_group);
}
static void avahi_cleanup_client () {
// This also frees the entry group, if any
if (avahi_client) {
avahi_client_free (avahi_client);
avahi_client = 0;
avahi_group = 0;
}
}
static void
client_callback (AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata)
{
assert(c);
// Called whenever the client or server state changes.
switch (state)
{
case AVAHI_CLIENT_S_RUNNING:
// The server has startup successfully and registered its host
// name on the network, so it's time to create our services.
create_services (c);
break;
case AVAHI_CLIENT_FAILURE:
server_error (_F("Avahi client failure: %s", avahi_strerror (avahi_client_errno (c))));
if (avahi_client_errno (c) == AVAHI_ERR_DISCONNECTED)
{
// The client has been disconnected; probably because the avahi daemon has been
// restarted. We can free the client here and try to reconnect using a new one.
// Passing AVAHI_CLIENT_NO_FAIL allows the new client to be
// created, even if the avahi daemon is not running. Our service will be advertised
// if/when the daemon is started.
avahi_cleanup_client ();
int error;
avahi_client = avahi_client_new (avahi_threaded_poll_get (avahi_threaded_poll),
(AvahiClientFlags)AVAHI_CLIENT_NO_FAIL,
client_callback, NULL, & error);
}
break;
case AVAHI_CLIENT_S_COLLISION:
// Let's drop our registered services. When the server is back
// in AVAHI_SERVER_RUNNING state we will register them
// again with the new host name.
// Fall through ...
case AVAHI_CLIENT_S_REGISTERING:
// The server records are now being established. This
// might be caused by a host name change. We need to wait
// for our own records to register until the host name is
// properly esatblished.
if (avahi_group)
avahi_entry_group_reset (avahi_group);
break;
case AVAHI_CLIENT_CONNECTING:
// The avahi-daemon is not currently running. Our service will be advertised
// if/when the deamon is started.
server_error (_F("The Avahi daemon is not running. Avahi service '%s' will be established when the deamon is started", avahi_service_name));
break;
}
}
static void
avahi_cleanup () {
if (avahi_service_name)
log (_F("Removing Avahi service '%s'", avahi_service_name));
// Stop the avahi client, if it's running
if (avahi_threaded_poll)
avahi_threaded_poll_stop (avahi_threaded_poll);
// Clean up the avahi objects. The order of freeing these is significant.
avahi_cleanup_client ();
if (avahi_threaded_poll) {
avahi_threaded_poll_free (avahi_threaded_poll);
avahi_threaded_poll = 0;
}
if (avahi_service_name) {
avahi_free (avahi_service_name);
avahi_service_name = 0;
}
}
// The entry point for the avahi client thread.
static void
avahi_publish_service (CERTCertificate *cert)
{
cert_serial_number = get_cert_serial_number (cert);
string buf;
try
{
buf = "Systemtap Compile Server, pid=" + lex_cast (getpid ());
}
catch (const runtime_error &e)
{
server_error(_F("Failed to cast pid '%d' to a string: %s", getpid(), e.what()));
return;
}
avahi_service_name = avahi_strdup (buf.c_str ());
// Allocate main loop object.
if (! (avahi_threaded_poll = avahi_threaded_poll_new ()))
{
server_error (_("Failed to create avahi threaded poll object."));
return;
}
// Always allocate a new client. Passing AVAHI_CLIENT_NO_FAIL allows the client to be
// created, even if the avahi daemon is not running. Our service will be advertised
// if/when the daemon is started.
int error;
avahi_client = avahi_client_new (avahi_threaded_poll_get (avahi_threaded_poll),
(AvahiClientFlags)AVAHI_CLIENT_NO_FAIL,
client_callback, NULL, & error);
// Check whether creating the client object succeeded.
if (! avahi_client)
{
server_error (_F("Failed to create avahi client: %s", avahi_strerror(error)));
return;
}
// Run the main loop.
avahi_threaded_poll_start (avahi_threaded_poll);
return;
}
#endif // HAVE_AVAHI
static void
advertise_presence (CERTCertificate *cert __attribute ((unused)))
{
#if HAVE_AVAHI
avahi_publish_service (cert);
#else
server_error (_("Unable to advertise presence on the network. Avahi is not available"));
#endif
}
static void
unadvertise_presence ()
{
#if HAVE_AVAHI
avahi_cleanup ();
#endif
}
static void
initialize (int argc, char **argv) {
pending_interrupts = 0;
setup_signals (& handle_interrupt);
// Seed the random number generator. Used to generate noise used during key generation.
srand (time (NULL));
// Initial values.
use_db_password = false;
port = 0;
max_threads = sysconf( _SC_NPROCESSORS_ONLN ); // Default to number of processors
keep_temp = false;
struct utsname utsname;
uname (& utsname);
uname_r = utsname.release;
arch = normalize_machine (utsname.machine);
// Parse the arguments. This also starts the server log, if any, and should be done before
// any messages are issued.
parse_options (argc, argv);
// PR11197: security prophylactics.
// Reject use as root, except via a special environment variable.
if (! getenv ("STAP_PR11197_OVERRIDE")) {
if (geteuid () == 0)
fatal ("For security reasons, invocation of stap-serverd as root is not supported.");
}
struct passwd *pw = getpwuid (geteuid ());
if (! pw)
fatal (_F("Unable to determine effective user name: %s", strerror (errno)));
string username = pw->pw_name;
pid_t pid = getpid ();
log (_F("===== compile server pid %d starting as %s =====", pid, username.c_str ()));
// Where is the ssl certificate/key database?
if (cert_db_path.empty ())
cert_db_path = server_cert_db_path ();
// Make sure NSPR is initialized. Must be done before NSS is initialized
PR_Init (PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
/* Set the cert database password callback. */
PK11_SetPasswordFunc (nssPasswordCallback);
}
static void
cleanup ()
{
unadvertise_presence ();
end_log ();
}
/* Function: readDataFromSocket()
*
* Purpose: Read data from the socket into a temporary file.
*
*/
static PRInt32
readDataFromSocket(PRFileDesc *sslSocket, const char *requestFileName)
{
PRFileDesc *local_file_fd = 0;
PRInt32 numBytesExpected;
PRInt32 numBytesRead;
PRInt32 numBytesWritten;
PRInt32 totalBytes = 0;
#define READ_BUFFER_SIZE 4096
char buffer[READ_BUFFER_SIZE];
// Read the number of bytes to be received.
/* XXX: impose a limit to prevent disk space consumption DoS */
numBytesRead = PR_Read_Complete (sslSocket, & numBytesExpected,
(PRInt32)sizeof (numBytesExpected));
if (numBytesRead == 0) /* EOF */
{
server_error (_("Error reading size of request file"));
goto done;
}
if (numBytesRead < 0)
{
server_error (_("Error in PR_Read"));
nssError ();
goto done;
}
/* Convert numBytesExpected from network byte order to host byte order. */
numBytesExpected = ntohl (numBytesExpected);
/* If 0 bytes are expected, then we were contacted only to obtain our certificate.
There is no client request. */
if (numBytesExpected == 0)
return 0;
/* Open the output file. */
local_file_fd = PR_Open(requestFileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
PR_IRUSR | PR_IWUSR);
if (local_file_fd == NULL)
{
server_error (_F("Could not open output file %s", requestFileName));
nssError ();
return -1;
}
// Read until EOF or until the expected number of bytes has been read.
for (totalBytes = 0; totalBytes < numBytesExpected; totalBytes += numBytesRead)
{
// No need for PR_Read_Complete here, since we're already managing multiple
// reads to a fixed size buffer.
numBytesRead = PR_Read (sslSocket, buffer, READ_BUFFER_SIZE);
if (numBytesRead == 0)
break; /* EOF */
if (numBytesRead < 0)
{
server_error (_("Error in PR_Read"));
nssError ();
goto done;
}
/* Write to the request file. */
numBytesWritten = PR_Write(local_file_fd, buffer, numBytesRead);
if (numBytesWritten < 0 || (numBytesWritten != numBytesRead))
{
server_error (_F("Could not write to output file %s", requestFileName));
nssError ();
goto done;
}
}
if (totalBytes != numBytesExpected)
{
server_error (_F("Expected %d bytes, got %d while reading client request from socket",
numBytesExpected, totalBytes));
goto done;
}
done:
if (local_file_fd)
PR_Close (local_file_fd);
return totalBytes;
}
/* Function: setupSSLSocket()
*
* Purpose: Configure a socket for SSL.
*
*
*/
static PRFileDesc *
setupSSLSocket (PRFileDesc *tcpSocket, CERTCertificate *cert, SECKEYPrivateKey *privKey)
{
PRFileDesc *sslSocket;
SSLKEAType certKEA;
SECStatus secStatus;
/* Inport the socket into SSL. */
sslSocket = SSL_ImportFD (NULL, tcpSocket);
if (sslSocket == NULL)
{
server_error (_("Could not import socket into SSL"));
nssError ();
return NULL;
}
/* Set the appropriate flags. */
secStatus = SSL_OptionSet (sslSocket, SSL_SECURITY, PR_TRUE);
if (secStatus != SECSuccess)
{
server_error (_("Error setting SSL security for socket"));
nssError ();
return NULL;
}
secStatus = SSL_OptionSet(sslSocket, SSL_HANDSHAKE_AS_SERVER, PR_TRUE);
if (secStatus != SECSuccess)
{
server_error (_("Error setting handshake as server for socket"));
nssError ();
return NULL;
}
secStatus = SSL_OptionSet(sslSocket, SSL_REQUEST_CERTIFICATE, PR_FALSE);
if (secStatus != SECSuccess)
{
server_error (_("Error setting SSL client authentication mode for socket"));
nssError ();
return NULL;
}
secStatus = SSL_OptionSet(sslSocket, SSL_REQUIRE_CERTIFICATE, PR_FALSE);
if (secStatus != SECSuccess)
{
server_error (_("Error setting SSL client authentication mode for socket"));
nssError ();
return NULL;
}
/* Set the appropriate callback routines. */
#if 0 /* use the default */
secStatus = SSL_AuthCertificateHook (sslSocket, myAuthCertificate, CERT_GetDefaultCertDB());
if (secStatus != SECSuccess)
{
nssError ();
server_error (_("Error in SSL_AuthCertificateHook"));
return NULL;
}
#endif
#if 0 /* Use the default */
secStatus = SSL_BadCertHook(sslSocket, (SSLBadCertHandler)myBadCertHandler, &certErr);
if (secStatus != SECSuccess)
{
nssError ();
server_error (_("Error in SSL_BadCertHook"));
return NULL;
}
#endif
#if 0 /* no handshake callback */
secStatus = SSL_HandshakeCallback(sslSocket, myHandshakeCallback, NULL);
if (secStatus != SECSuccess)
{
server_error (_("Error in SSL_HandshakeCallback"));
nssError ();
return NULL;
}
#endif
certKEA = NSS_FindCertKEAType (cert);
secStatus = SSL_ConfigSecureServer (sslSocket, cert, privKey, certKEA);
if (secStatus != SECSuccess)
{
server_error (_("Error configuring SSL server"));
nssError ();
return NULL;
}
return sslSocket;
}
#if 0 /* No client authentication (for now) and not authenticating after each transaction. */
/* Function: authenticateSocket()
*
* Purpose: Perform client authentication on the socket.
*
*/
static SECStatus
authenticateSocket (PRFileDesc *sslSocket, PRBool requireCert)
{
CERTCertificate *cert;
SECStatus secStatus;
/* Returns NULL if client authentication is not enabled or if the
* client had no certificate. */
cert = SSL_PeerCertificate(sslSocket);
if (cert)
{
/* Client had a certificate, so authentication is through. */
CERT_DestroyCertificate(cert);
return SECSuccess;
}
/* Request client to authenticate itself. */
secStatus = SSL_OptionSet(sslSocket, SSL_REQUEST_CERTIFICATE, PR_TRUE);
if (secStatus != SECSuccess)
{
server_error (_("Error in SSL_OptionSet:SSL_REQUEST_CERTIFICATE"));
nssError ();
return SECFailure;
}
/* If desired, require client to authenticate itself. Note
* SSL_REQUEST_CERTIFICATE must also be on, as above. */
secStatus = SSL_OptionSet(sslSocket, SSL_REQUIRE_CERTIFICATE, requireCert);
if (secStatus != SECSuccess)
{
server_error (_("Error in SSL_OptionSet:SSL_REQUIRE_CERTIFICATE"));
nssError ();
return SECFailure;
}
/* Having changed socket configuration parameters, redo handshake. */
secStatus = SSL_ReHandshake(sslSocket, PR_TRUE);
if (secStatus != SECSuccess)
{
server_error (_("Error in SSL_ReHandshake"));
nssError ();
return SECFailure;
}
/* Force the handshake to complete before moving on. */
secStatus = SSL_ForceHandshake(sslSocket);
if (secStatus != SECSuccess)
{
server_error (_("Error in SSL_ForceHandshake"));
nssError ();
return SECFailure;
}
return SECSuccess;
}
#endif /* No client authentication and not authenticating after each transaction. */
/* Function: writeDataToSocket
*
* Purpose: Write the server's response back to the socket.
*
*/
static SECStatus
writeDataToSocket(PRFileDesc *sslSocket, const char *responseFileName)
{
PRFileDesc *local_file_fd = PR_Open (responseFileName, PR_RDONLY, 0);
if (local_file_fd == NULL)
{
server_error (_F("Could not open input file %s", responseFileName));
nssError ();
return SECFailure;
}
/* Transmit the local file across the socket.
*/
int numBytes = PR_TransmitFile (sslSocket, local_file_fd,
NULL, 0,
PR_TRANSMITFILE_KEEP_OPEN,
PR_INTERVAL_NO_TIMEOUT);
/* Error in transmission. */
SECStatus secStatus = SECSuccess;
if (numBytes < 0)
{
server_error (_("Error writing response to socket"));
nssError ();
secStatus = SECFailure;
}
PR_Close (local_file_fd);
return secStatus;
}
static void
get_stap_locale (const string &staplang, vector<string> &envVec, string stapstderr, cs_protocol_version *client_version)
{
// If the client version is < 1.6, then no file containing environment
// variables defining the locale has been passed.
if (*client_version < "1.6")
return;
/* Go through each line of the file, verify it, then add it to the vector */
ifstream langfile;
langfile.open(staplang.c_str());
if (!langfile.is_open())
{
// Not fatal. Proceed with the environment we have.
server_error(_F("Unable to open file %s for reading: %s", staplang.c_str(),
strerror (errno)));
return;
}
/* Unpackage internationalization variables and verify their contents */
map<string, string> envMap; /* To temporarily store the entire array of strings */
string line;
const set<string> &locVars = localization_variables();
/* Copy the global environ variable into the map */
if(environ != NULL)
{
for (unsigned i=0; environ[i]; i++)
{
string line = (string)environ[i];
/* Find the first '=' sign */
size_t pos = line.find("=");
/* Make sure it found an '=' sign */
if(pos != string::npos)
/* Everything before the '=' sign is the key, and everything after is the value. */
envMap[line.substr(0, pos)] = line.substr(pos+1);
}
}
/* Create regular expression objects to verify lines read from file. Should not allow
spaces, ctrl characters, etc */
regex_t checkre;
if ((regcomp(&checkre, "^[a-zA-Z0-9@_.=-]*$", REG_EXTENDED | REG_NOSUB) != 0))
{
// Not fatal. Proceed with the environment we have.
server_error(_F("Error in regcomp: %s", strerror (errno)));
return;
}
while (1)
{
getline(langfile, line);
if (!langfile.good())
break;
/* Extract key and value from the line. Note: value may contain "=". */
string key;
string value;
size_t pos;
pos = line.find("=");
if (pos == string::npos)
{
client_error(_F("Localization key=value line '%s' cannot be parsed", line.c_str()), stapstderr);
continue;
}