-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathnbd-server.c
2113 lines (1929 loc) · 58.6 KB
/
nbd-server.c
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
/*
* Network Block Device - server
*
* Copyright 1996-1998 Pavel Machek, distribute under GPL
* Copyright 2001-2004 Wouter Verhelst <[email protected]>
* Copyright 2002 Anton Altaparmakov <[email protected]>
*
* Version 1.0 - hopefully 64-bit-clean
* Version 1.1 - merging enhancements from Josh Parsons, <[email protected]>
* Version 1.2 - autodetect size of block devices, thanx to Peter T. Breuer" <[email protected]>
* Version 1.5 - can compile on Unix systems that don't have 64 bit integer
* type, or don't have 64 bit file offsets by defining FS_32BIT
* in compile options for nbd-server *only*. This can be done
* with make FSCHOICE=-DFS_32BIT nbd-server. (I don't have the
* original autoconf input file, or I would make it a configure
* option.) Ken Yap <[email protected]>.
* Version 1.6 - fix autodetection of block device size and really make 64 bit
* clean on 32 bit machines. Anton Altaparmakov <[email protected]>
* Version 2.0 - Version synchronised with client
* Version 2.1 - Reap zombie client processes when they exit. Removed
* (uncommented) the _IO magic, it's no longer necessary. Wouter
* Verhelst <[email protected]>
* Version 2.2 - Auto switch to read-only mode (usefull for floppies).
* Version 2.3 - Fixed code so that Large File Support works. This
* removes the FS_32BIT compile-time directive; define
* _FILE_OFFSET_BITS=64 and _LARGEFILE_SOURCE if you used to be
* using FS_32BIT. This will allow you to use files >2GB instead of
* having to use the -m option. Wouter Verhelst <[email protected]>
* Version 2.4 - Added code to keep track of children, so that we can
* properly kill them from initscripts. Add a call to daemon(),
* so that processes don't think they have to wait for us, which is
* interesting for initscripts as well. Wouter Verhelst
* Version 2.5 - Bugfix release: forgot to reset child_arraysize to
* zero after fork()ing, resulting in nbd-server going berserk
* when it receives a signal with at least one child open. Wouter
* Verhelst <[email protected]>
* 10/10/2003 - Added socket option SO_KEEPALIVE (sf.net bug 819235);
* rectified type of mainloop::size_host (sf.net bugs 814435 and
* 817385); close the PID file after writing to it, so that the
* daemon can actually be found. Wouter Verhelst
* 10/10/2003 - Size of the data "size_host" was wrong and so was not
* correctly put in network endianness. Many types were corrected
* (size_t and off_t instead of int). <[email protected]>
* Version 2.6 - Some code cleanup.
* Version 2.7 - Better build system.
* 11/02/2004 - Doxygenified the source, modularized it a bit. Needs a
* lot more work, but this is a start. Wouter Verhelst
* 16/03/2010 - Add IPv6 support.
* Kitt Tientanopajai <[email protected]>
* Neutron Soutmun <[email protected]>
* Suriya Soutmun <[email protected]>
*/
/* Includes LFS defines, which defines behaviours of some of the following
* headers, so must come before those */
#include "lfs.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/select.h> /* select */
#include <sys/wait.h> /* wait */
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include <sys/param.h>
#ifdef HAVE_SYS_MOUNT_H
#include <sys/mount.h> /* For BLKGETSIZE */
#endif
#include <signal.h> /* sigaction */
#include <errno.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <netdb.h>
#include <syslog.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <strings.h>
#include <dirent.h>
#include <unistd.h>
#include <getopt.h>
#include <pwd.h>
#include <grp.h>
#include <glib.h>
/* used in cliserv.h, so must come first */
#define MY_NAME "nbd_server"
#include "cliserv.h"
/** Default position of the config file */
#ifndef SYSCONFDIR
#define SYSCONFDIR "/etc"
#endif
#define CFILE SYSCONFDIR "/nbd-server/config"
/** Where our config file actually is */
gchar* config_file_pos;
/** What user we're running as */
gchar* runuser=NULL;
/** What group we're running as */
gchar* rungroup=NULL;
/** whether to export using the old negotiation protocol (port-based) */
gboolean do_oldstyle=FALSE;
/** Logging macros, now nothing goes to syslog unless you say ISSERVER */
#ifdef ISSERVER
#define msg2(a,b) syslog(a,b)
#define msg3(a,b,c) syslog(a,b,c)
#define msg4(a,b,c,d) syslog(a,b,c,d)
#else
#define msg2(a,b) g_message(b)
#define msg3(a,b,c) g_message(b,c)
#define msg4(a,b,c,d) g_message(b,c,d)
#endif
/* Debugging macros */
//#define DODBG
#ifdef DODBG
#define DEBUG( a ) printf( a )
#define DEBUG2( a,b ) printf( a,b )
#define DEBUG3( a,b,c ) printf( a,b,c )
#define DEBUG4( a,b,c,d ) printf( a,b,c,d )
#else
#define DEBUG( a )
#define DEBUG2( a,b )
#define DEBUG3( a,b,c )
#define DEBUG4( a,b,c,d )
#endif
#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION ""
#endif
/**
* The highest value a variable of type off_t can reach. This is a signed
* integer, so set all bits except for the leftmost one.
**/
#define OFFT_MAX ~((off_t)1<<(sizeof(off_t)*8-1))
#define LINELEN 256 /**< Size of static buffer used to read the
authorization file (yuck) */
#define BUFSIZE (1024*1024) /**< Size of buffer that can hold requests */
#define DIFFPAGESIZE 4096 /**< diff file uses those chunks */
#define F_READONLY 1 /**< flag to tell us a file is readonly */
#define F_MULTIFILE 2 /**< flag to tell us a file is exported using -m */
#define F_COPYONWRITE 4 /**< flag to tell us a file is exported using
copyonwrite */
#define F_AUTOREADONLY 8 /**< flag to tell us a file is set to autoreadonly */
#define F_SPARSE 16 /**< flag to tell us copyronwrite should use a sparse file */
#define F_SDP 32 /**< flag to tell us the export should be done using the Socket Direct Protocol for RDMA */
#define F_SYNC 64 /**< Whether to fsync() after a write */
GHashTable *children;
char pidfname[256]; /**< name of our PID file */
char pidftemplate[256]; /**< template to be used for the filename of the PID file */
char default_authname[] = SYSCONFDIR "/nbd-server/allow"; /**< default name of allow file */
int modernsock=0; /**< Socket for the modern handler. Not used
if a client was only specified on the
command line; only port used if
oldstyle is set to false (and then the
command-line client isn't used, gna gna) */
char* modern_listen; /**< listenaddr value for modernsock */
/**
* Types of virtuatlization
**/
typedef enum {
VIRT_NONE=0, /**< No virtualization */
VIRT_IPLIT, /**< Literal IP address as part of the filename */
VIRT_IPHASH, /**< Replacing all dots in an ip address by a / before
doing the same as in IPLIT */
VIRT_CIDR, /**< Every subnet in its own directory */
} VIRT_STYLE;
/**
* Variables associated with a server.
**/
typedef struct {
gchar* exportname; /**< (unprocessed) filename of the file we're exporting */
off_t expected_size; /**< size of the exported file as it was told to
us through configuration */
gchar* listenaddr; /**< The IP address we're listening on */
unsigned int port; /**< port we're exporting this file at */
char* authname; /**< filename of the authorization file */
int flags; /**< flags associated with this exported file */
int socket; /**< The socket of this server. */
int socket_family; /**< family of the socket */
VIRT_STYLE virtstyle;/**< The style of virtualization, if any */
uint8_t cidrlen; /**< The length of the mask when we use
CIDR-style virtualization */
gchar* prerun; /**< command to be ran after connecting a client,
but before starting to serve */
gchar* postrun; /**< command that will be ran after the client
disconnects */
gchar* servename; /**< name of the export as selected by nbd-client */
} SERVER;
/**
* Variables associated with a client socket.
**/
typedef struct {
int fhandle; /**< file descriptor */
off_t startoff; /**< starting offset of this file */
} FILE_INFO;
typedef struct {
off_t exportsize; /**< size of the file we're exporting */
char *clientname; /**< peer */
char *exportname; /**< (processed) filename of the file we're exporting */
GArray *export; /**< array of FILE_INFO of exported files;
array size is always 1 unless we're
doing the multiple file option */
int net; /**< The actual client socket */
SERVER *server; /**< The server this client is getting data from */
char* difffilename; /**< filename of the copy-on-write file, if any */
int difffile; /**< filedescriptor of copyonwrite file. @todo
shouldn't this be an array too? (cfr export) Or
make -m and -c mutually exclusive */
u32 difffilelen; /**< number of pages in difffile */
u32 *difmap; /**< see comment on the global difmap for this one */
gboolean modern; /**< client was negotiated using modern negotiation protocol */
} CLIENT;
/**
* Type of configuration file values
**/
typedef enum {
PARAM_INT, /**< This parameter is an integer */
PARAM_STRING, /**< This parameter is a string */
PARAM_BOOL, /**< This parameter is a boolean */
} PARAM_TYPE;
/**
* Configuration file values
**/
typedef struct {
gchar *paramname; /**< Name of the parameter, as it appears in
the config file */
gboolean required; /**< Whether this is a required (as opposed to
optional) parameter */
PARAM_TYPE ptype; /**< Type of the parameter. */
gpointer target; /**< Pointer to where the data of this
parameter should be written. If ptype is
PARAM_BOOL, the data is or'ed rather than
overwritten. */
gint flagval; /**< Flag mask for this parameter in case ptype
is PARAM_BOOL. */
} PARAM;
/**
* Check whether a client is allowed to connect. Works with an authorization
* file which contains one line per machine, no wildcards.
*
* @param opts The client who's trying to connect.
* @return 0 - authorization refused, 1 - OK
**/
int authorized_client(CLIENT *opts) {
const char *ERRMSG="Invalid entry '%s' in authfile '%s', so, refusing all connections.";
FILE *f ;
char line[LINELEN];
char *tmp;
struct in_addr addr;
struct in_addr client;
struct in_addr cltemp;
int len;
if ((f=fopen(opts->server->authname,"r"))==NULL) {
msg4(LOG_INFO,"Can't open authorization file %s (%s).",
opts->server->authname,strerror(errno)) ;
return 1 ;
}
inet_aton(opts->clientname, &client);
while (fgets(line,LINELEN,f)!=NULL) {
if((tmp=index(line, '/'))) {
if(strlen(line)<=tmp-line) {
msg4(LOG_CRIT, ERRMSG, line, opts->server->authname);
return 0;
}
*(tmp++)=0;
if(!inet_aton(line,&addr)) {
msg4(LOG_CRIT, ERRMSG, line, opts->server->authname);
return 0;
}
len=strtol(tmp, NULL, 0);
addr.s_addr>>=32-len;
addr.s_addr<<=32-len;
memcpy(&cltemp,&client,sizeof(client));
cltemp.s_addr>>=32-len;
cltemp.s_addr<<=32-len;
if(addr.s_addr == cltemp.s_addr) {
return 1;
}
}
if (strncmp(line,opts->clientname,strlen(opts->clientname))==0) {
fclose(f);
return 1;
}
}
fclose(f);
return 0;
}
/**
* Read data from a file descriptor into a buffer
*
* @param f a file descriptor
* @param buf a buffer
* @param len the number of bytes to be read
**/
inline void readit(int f, void *buf, size_t len) {
ssize_t res;
while (len > 0) {
DEBUG("*");
if ((res = read(f, buf, len)) <= 0) {
if(errno != EAGAIN) {
err("Read failed: %m");
}
} else {
len -= res;
buf += res;
}
}
}
/**
* Write data from a buffer into a filedescriptor
*
* @param f a file descriptor
* @param buf a buffer containing data
* @param len the number of bytes to be written
**/
inline void writeit(int f, void *buf, size_t len) {
ssize_t res;
while (len > 0) {
DEBUG("+");
if ((res = write(f, buf, len)) <= 0)
err("Send failed: %m");
len -= res;
buf += res;
}
}
/**
* Print out a message about how to use nbd-server. Split out to a separate
* function so that we can call it from multiple places
*/
void usage() {
printf("This is nbd-server version " VERSION "\n");
printf("Usage: [ip:|ip6@]port file_to_export [size][kKmM] [-l authorize_file] [-r] [-m] [-c] [-C configuration file] [-p PID file name] [-o section name]\n"
"\t-r|--read-only\t\tread only\n"
"\t-m|--multi-file\t\tmultiple file\n"
"\t-c|--copy-on-write\tcopy on write\n"
"\t-C|--config-file\tspecify an alternate configuration file\n"
"\t-l|--authorize-file\tfile with list of hosts that are allowed to\n\t\t\t\tconnect.\n"
"\t-p|--pid-file\t\tspecify a filename to write our PID to\n"
"\t-o|--output-config\toutput a config file section for what you\n\t\t\t\tspecified on the command line, with the\n\t\t\t\tspecified section name\n\n"
"\tif port is set to 0, stdin is used (for running from inetd)\n"
"\tif file_to_export contains '%%s', it is substituted with the IP\n"
"\t\taddress of the machine trying to connect\n"
"\tif ip is set, it contains the local IP address on which we're listening.\n\tif not, the server will listen on all local IP addresses\n");
printf("Using configuration file %s\n", CFILE);
}
/* Dumps a config file section of the given SERVER*, and exits. */
void dump_section(SERVER* serve, gchar* section_header) {
printf("[%s]\n", section_header);
printf("\texportname = %s\n", serve->exportname);
printf("\tlistenaddr = %s\n", serve->listenaddr);
printf("\tport = %d\n", serve->port);
if(serve->flags & F_READONLY) {
printf("\treadonly = true\n");
}
if(serve->flags & F_MULTIFILE) {
printf("\tmultifile = true\n");
}
if(serve->flags & F_COPYONWRITE) {
printf("\tcopyonwrite = true\n");
}
if(serve->expected_size) {
printf("\tfilesize = %lld\n", (long long int)serve->expected_size);
}
if(serve->authname) {
printf("\tauthfile = %s\n", serve->authname);
}
exit(EXIT_SUCCESS);
}
/**
* Parse the command line.
*
* @param argc the argc argument to main()
* @param argv the argv argument to main()
**/
SERVER* cmdline(int argc, char *argv[]) {
int i=0;
int nonspecial=0;
int c;
struct option long_options[] = {
{"read-only", no_argument, NULL, 'r'},
{"multi-file", no_argument, NULL, 'm'},
{"copy-on-write", no_argument, NULL, 'c'},
{"authorize-file", required_argument, NULL, 'l'},
{"config-file", required_argument, NULL, 'C'},
{"pid-file", required_argument, NULL, 'p'},
{"output-config", required_argument, NULL, 'o'},
{0,0,0,0}
};
SERVER *serve;
off_t es;
size_t last;
char suffix;
gboolean do_output=FALSE;
gchar* section_header="";
gchar** addr_port;
if(argc==1) {
return NULL;
}
serve=g_new0(SERVER, 1);
serve->authname = g_strdup(default_authname);
serve->virtstyle=VIRT_IPLIT;
while((c=getopt_long(argc, argv, "-C:cl:mo:rp:", long_options, &i))>=0) {
switch (c) {
case 1:
/* non-option argument */
switch(nonspecial++) {
case 0:
if(strchr(optarg, ':') == strrchr(optarg, ':')) {
addr_port=g_strsplit(optarg, ":", 2);
/* Check for "@" - maybe user using this separator
for IPv4 address */
if(!addr_port[1]) {
g_strfreev(addr_port);
addr_port=g_strsplit(optarg, "@", 2);
}
} else {
addr_port=g_strsplit(optarg, "@", 2);
}
if(addr_port[1]) {
serve->port=strtol(addr_port[1], NULL, 0);
serve->listenaddr=g_strdup(addr_port[0]);
} else {
serve->listenaddr=NULL;
serve->port=strtol(addr_port[0], NULL, 0);
}
g_strfreev(addr_port);
break;
case 1:
serve->exportname = g_strdup(optarg);
if(serve->exportname[0] != '/') {
fprintf(stderr, "E: The to be exported file needs to be an absolute filename!\n");
exit(EXIT_FAILURE);
}
break;
case 2:
last=strlen(optarg)-1;
suffix=optarg[last];
if (suffix == 'k' || suffix == 'K' ||
suffix == 'm' || suffix == 'M')
optarg[last] = '\0';
es = (off_t)atoll(optarg);
switch (suffix) {
case 'm':
case 'M': es <<= 10;
case 'k':
case 'K': es <<= 10;
default : break;
}
serve->expected_size = es;
break;
}
break;
case 'r':
serve->flags |= F_READONLY;
break;
case 'm':
serve->flags |= F_MULTIFILE;
break;
case 'o':
do_output = TRUE;
section_header = g_strdup(optarg);
break;
case 'p':
strncpy(pidftemplate, optarg, 256);
break;
case 'c':
serve->flags |=F_COPYONWRITE;
break;
case 'C':
g_free(config_file_pos);
config_file_pos=g_strdup(optarg);
break;
case 'l':
g_free(serve->authname);
serve->authname=g_strdup(optarg);
break;
default:
usage();
exit(EXIT_FAILURE);
break;
}
}
/* What's left: the port to export, the name of the to be exported
* file, and, optionally, the size of the file, in that order. */
if(nonspecial<2) {
g_free(serve);
serve=NULL;
} else {
do_oldstyle = TRUE;
}
if(do_output) {
if(!serve) {
g_critical("Need a complete configuration on the command line to output a config file section!");
exit(EXIT_FAILURE);
}
dump_section(serve, section_header);
}
return serve;
}
/**
* Error codes for config file parsing
**/
typedef enum {
CFILE_NOTFOUND, /**< The configuration file is not found */
CFILE_MISSING_GENERIC, /**< The (required) group "generic" is missing */
CFILE_KEY_MISSING, /**< A (required) key is missing */
CFILE_VALUE_INVALID, /**< A value is syntactically invalid */
CFILE_VALUE_UNSUPPORTED,/**< A value is not supported in this build */
CFILE_PROGERR, /**< Programmer error */
CFILE_NO_EXPORTS, /**< A config file was specified that does not
define any exports */
CFILE_INCORRECT_PORT, /**< The reserved port was specified for an
old-style export. */
} CFILE_ERRORS;
/**
* Remove a SERVER from memory. Used from the hash table
**/
void remove_server(gpointer s) {
SERVER *server;
server=(SERVER*)s;
g_free(server->exportname);
if(server->authname)
g_free(server->authname);
if(server->listenaddr)
g_free(server->listenaddr);
if(server->prerun)
g_free(server->prerun);
if(server->postrun)
g_free(server->postrun);
g_free(server);
}
/**
* duplicate server
* @param s the old server we want to duplicate
* @return new duplicated server
**/
SERVER* dup_serve(SERVER *s) {
SERVER *serve = NULL;
serve=g_new0(SERVER, 1);
if(serve == NULL)
return NULL;
if(s->exportname)
serve->exportname = g_strdup(s->exportname);
serve->expected_size = s->expected_size;
if(s->listenaddr)
serve->listenaddr = g_strdup(s->listenaddr);
serve->port = s->port;
if(s->authname)
serve->authname = strdup(s->authname);
serve->flags = s->flags;
serve->socket = serve->socket;
serve->socket_family = serve->socket_family;
serve->cidrlen = s->cidrlen;
if(s->prerun)
serve->prerun = g_strdup(s->prerun);
if(s->postrun)
serve->postrun = g_strdup(s->postrun);
if(s->servename)
serve->servename = g_strdup(s->servename);
return serve;
}
/**
* append new server to array
* @param s server
* @param a server array
* @return 0 success, -1 error
*/
int append_serve(SERVER *s, GArray *a) {
SERVER *ns = NULL;
struct addrinfo hints;
struct addrinfo *ai = NULL;
struct addrinfo *rp = NULL;
char host[NI_MAXHOST];
gchar *port = NULL;
int e;
int ret;
if(!s) {
err("Invalid parsing server");
return -1;
}
port = g_strdup_printf("%d", s->port);
memset(&hints,'\0',sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
hints.ai_protocol = IPPROTO_TCP;
e = getaddrinfo(s->listenaddr, port, &hints, &ai);
if (port)
g_free(port);
if(e == 0) {
for (rp = ai; rp != NULL; rp = rp->ai_next) {
e = getnameinfo(rp->ai_addr, rp->ai_addrlen, host, sizeof(host), NULL, 0, NI_NUMERICHOST);
if (e != 0) { // error
fprintf(stderr, "getnameinfo: %s\n", gai_strerror(e));
continue;
}
// duplicate server and set listenaddr to resolved IP address
ns = dup_serve (s);
if (ns) {
ns->listenaddr = g_strdup(host);
ns->socket_family = rp->ai_family;
g_array_append_val(a, *ns);
free(ns);
ns = NULL;
}
}
ret = 0;
} else {
fprintf(stderr, "getaddrinfo failed on listen host/address: %s (%s)\n", s->listenaddr ? s->listenaddr : "any", gai_strerror(e));
ret = -1;
}
if (ai)
freeaddrinfo(ai);
return ret;
}
/**
* Parse the config file.
*
* @param f the name of the config file
* @param e a GError. @see CFILE_ERRORS for what error values this function can
* return.
* @return a Array of SERVER* pointers, If the config file is empty or does not
* exist, returns an empty GHashTable; if the config file contains an
* error, returns NULL, and e is set appropriately
**/
GArray* parse_cfile(gchar* f, GError** e) {
const char* DEFAULT_ERROR = "Could not parse %s in group %s: %s";
const char* MISSING_REQUIRED_ERROR = "Could not find required value %s in group %s: %s";
SERVER s;
gchar *virtstyle=NULL;
PARAM lp[] = {
{ "exportname", TRUE, PARAM_STRING, NULL, 0 },
{ "port", TRUE, PARAM_INT, NULL, 0 },
{ "authfile", FALSE, PARAM_STRING, NULL, 0 },
{ "filesize", FALSE, PARAM_INT, NULL, 0 },
{ "virtstyle", FALSE, PARAM_STRING, NULL, 0 },
{ "prerun", FALSE, PARAM_STRING, NULL, 0 },
{ "postrun", FALSE, PARAM_STRING, NULL, 0 },
{ "readonly", FALSE, PARAM_BOOL, NULL, F_READONLY },
{ "multifile", FALSE, PARAM_BOOL, NULL, F_MULTIFILE },
{ "copyonwrite", FALSE, PARAM_BOOL, NULL, F_COPYONWRITE },
{ "sparse_cow", FALSE, PARAM_BOOL, NULL, F_SPARSE },
{ "sdp", FALSE, PARAM_BOOL, NULL, F_SDP },
{ "sync", FALSE, PARAM_BOOL, NULL, F_SYNC },
{ "listenaddr", FALSE, PARAM_STRING, NULL, 0 },
};
const int lp_size=sizeof(lp)/sizeof(PARAM);
PARAM gp[] = {
{ "user", FALSE, PARAM_STRING, &runuser, 0 },
{ "group", FALSE, PARAM_STRING, &rungroup, 0 },
{ "oldstyle", FALSE, PARAM_BOOL, &do_oldstyle, 1 },
{ "listenaddr", FALSE, PARAM_STRING, &modern_listen, 0 },
};
PARAM* p=gp;
int p_size=sizeof(gp)/sizeof(PARAM);
GKeyFile *cfile;
GError *err = NULL;
const char *err_msg=NULL;
GQuark errdomain;
GArray *retval=NULL;
gchar **groups;
gboolean value;
gchar* startgroup;
gint i;
gint j;
errdomain = g_quark_from_string("parse_cfile");
cfile = g_key_file_new();
retval = g_array_new(FALSE, TRUE, sizeof(SERVER));
if(!g_key_file_load_from_file(cfile, f, G_KEY_FILE_KEEP_COMMENTS |
G_KEY_FILE_KEEP_TRANSLATIONS, &err)) {
g_set_error(e, errdomain, CFILE_NOTFOUND, "Could not open config file %s.", f);
g_key_file_free(cfile);
return retval;
}
startgroup = g_key_file_get_start_group(cfile);
if(!startgroup || strcmp(startgroup, "generic")) {
g_set_error(e, errdomain, CFILE_MISSING_GENERIC, "Config file does not contain the [generic] group!");
g_key_file_free(cfile);
return NULL;
}
groups = g_key_file_get_groups(cfile, NULL);
for(i=0;groups[i];i++) {
memset(&s, '\0', sizeof(SERVER));
lp[0].target=&(s.exportname);
lp[1].target=&(s.port);
lp[2].target=&(s.authname);
lp[3].target=&(s.expected_size);
lp[4].target=&(virtstyle);
lp[5].target=&(s.prerun);
lp[6].target=&(s.postrun);
lp[7].target=lp[8].target=lp[9].target=
lp[10].target=lp[11].target=
lp[12].target=&(s.flags);
lp[13].target=&(s.listenaddr);
/* After the [generic] group, start parsing exports */
if(i==1) {
p=lp;
p_size=lp_size;
}
for(j=0;j<p_size;j++) {
g_assert(p[j].target != NULL);
g_assert(p[j].ptype==PARAM_INT||p[j].ptype==PARAM_STRING||p[j].ptype==PARAM_BOOL);
switch(p[j].ptype) {
case PARAM_INT:
*((gint*)p[j].target) =
g_key_file_get_integer(cfile,
groups[i],
p[j].paramname,
&err);
break;
case PARAM_STRING:
*((gchar**)p[j].target) =
g_key_file_get_string(cfile,
groups[i],
p[j].paramname,
&err);
break;
case PARAM_BOOL:
value = g_key_file_get_boolean(cfile,
groups[i],
p[j].paramname, &err);
if(!err) {
if(value) {
*((gint*)p[j].target) |= p[j].flagval;
} else {
*((gint*)p[j].target) &= ~(p[j].flagval);
}
}
break;
}
if(!strcmp(p[j].paramname, "port") && !strcmp(p[j].target, NBD_DEFAULT_PORT)) {
g_set_error(e, errdomain, CFILE_INCORRECT_PORT, "Config file specifies default port for oldstyle export");
g_key_file_free(cfile);
return NULL;
}
if(err) {
if(err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
if(!p[j].required) {
/* Ignore not-found error for optional values */
g_clear_error(&err);
continue;
} else {
err_msg = MISSING_REQUIRED_ERROR;
}
} else {
err_msg = DEFAULT_ERROR;
}
g_set_error(e, errdomain, CFILE_VALUE_INVALID, err_msg, p[j].paramname, groups[i], err->message);
g_array_free(retval, TRUE);
g_error_free(err);
g_key_file_free(cfile);
return NULL;
}
}
if(virtstyle) {
if(!strncmp(virtstyle, "none", 4)) {
s.virtstyle=VIRT_NONE;
} else if(!strncmp(virtstyle, "ipliteral", 9)) {
s.virtstyle=VIRT_IPLIT;
} else if(!strncmp(virtstyle, "iphash", 6)) {
s.virtstyle=VIRT_IPHASH;
} else if(!strncmp(virtstyle, "cidrhash", 8)) {
s.virtstyle=VIRT_CIDR;
if(strlen(virtstyle)<10) {
g_set_error(e, errdomain, CFILE_VALUE_INVALID, "Invalid value %s for parameter virtstyle in group %s: missing length", virtstyle, groups[i]);
g_array_free(retval, TRUE);
g_key_file_free(cfile);
return NULL;
}
s.cidrlen=strtol(virtstyle+8, NULL, 0);
} else {
g_set_error(e, errdomain, CFILE_VALUE_INVALID, "Invalid value %s for parameter virtstyle in group %s", virtstyle, groups[i]);
g_array_free(retval, TRUE);
g_key_file_free(cfile);
return NULL;
}
if(s.port && !do_oldstyle) {
g_warning("A port was specified, but oldstyle exports were not requested. This may not do what you expect.");
g_warning("Please read 'man 5 nbd-server' and search for oldstyle for more info");
}
} else {
s.virtstyle=VIRT_IPLIT;
}
/* Don't need to free this, it's not our string */
virtstyle=NULL;
/* Don't append values for the [generic] group */
if(i>0) {
s.socket_family = AF_UNSPEC;
s.servename = groups[i];
append_serve(&s, retval);
} else {
if(!do_oldstyle) {
lp[1].required = 0;
}
}
#ifndef WITH_SDP
if(s.flags & F_SDP) {
g_set_error(e, errdomain, CFILE_VALUE_UNSUPPORTED, "This nbd-server was built without support for SDP, yet group %s uses it", groups[i]);
g_array_free(retval, TRUE);
g_key_file_free(cfile);
return NULL;
}
#endif
}
if(i==1) {
g_set_error(e, errdomain, CFILE_NO_EXPORTS, "The config file does not specify any exports");
}
g_key_file_free(cfile);
return retval;
}
/**
* Signal handler for SIGCHLD
* @param s the signal we're handling (must be SIGCHLD, or something
* is severely wrong)
**/
void sigchld_handler(int s) {
int status;
int* i;
pid_t pid;
while((pid=waitpid(-1, &status, WNOHANG)) > 0) {
if(WIFEXITED(status)) {
msg3(LOG_INFO, "Child exited with %d", WEXITSTATUS(status));
}
i=g_hash_table_lookup(children, &pid);
if(!i) {
msg3(LOG_INFO, "SIGCHLD received for an unknown child with PID %ld", (long)pid);
} else {
DEBUG2("Removing %d from the list of children", pid);
g_hash_table_remove(children, &pid);
}
}
}
/**
* Kill a child. Called from sigterm_handler::g_hash_table_foreach.
*
* @param key the key
* @param value the value corresponding to the above key
* @param user_data a pointer which we always set to 1, so that we know what
* will happen next.
**/
void killchild(gpointer key, gpointer value, gpointer user_data) {
pid_t *pid=value;
int *parent=user_data;
kill(*pid, SIGTERM);
*parent=1;
}
/**
* Handle SIGTERM and dispatch it to our children
* @param s the signal we're handling (must be SIGTERM, or something
* is severely wrong).
**/
void sigterm_handler(int s) {
int parent=0;
g_hash_table_foreach(children, killchild, &parent);
if(parent) {
unlink(pidfname);
}
exit(EXIT_SUCCESS);
}
/**
* Detect the size of a file.
*
* @param fhandle An open filedescriptor
* @return the size of the file, or OFFT_MAX if detection was
* impossible.
**/
off_t size_autodetect(int fhandle) {
off_t es;
u64 bytes;
struct stat stat_buf;
int error;
#ifdef HAVE_SYS_MOUNT_H
#ifdef HAVE_SYS_IOCTL_H
#ifdef BLKGETSIZE64
DEBUG("looking for export size with ioctl BLKGETSIZE64\n");
if (!ioctl(fhandle, BLKGETSIZE64, &bytes) && bytes) {
return (off_t)bytes;
}
#endif /* BLKGETSIZE64 */
#endif /* HAVE_SYS_IOCTL_H */
#endif /* HAVE_SYS_MOUNT_H */
DEBUG("looking for fhandle size with fstat\n");
stat_buf.st_size = 0;
error = fstat(fhandle, &stat_buf);
if (!error) {
if(stat_buf.st_size > 0)
return (off_t)stat_buf.st_size;
} else {
err("fstat failed: %m");
}
DEBUG("looking for fhandle size with lseek SEEK_END\n");
es = lseek(fhandle, (off_t)0, SEEK_END);
if (es > ((off_t)0)) {
return es;
} else {
DEBUG2("lseek failed: %d", errno==EBADF?1:(errno==ESPIPE?2:(errno==EINVAL?3:4)));
}
err("Could not find size of exported block device: %m");
return OFFT_MAX;
}
/**
* Get the file handle and offset, given an export offset.
*
* @param export An array of export files
* @param a The offset to get corresponding file/offset for
* @param fhandle [out] File descriptor
* @param foffset [out] Offset into fhandle
* @param maxbytes [out] Tells how many bytes can be read/written
* from fhandle starting at foffset (0 if there is no limit)
* @return 0 on success, -1 on failure
**/
int get_filepos(GArray* export, off_t a, int* fhandle, off_t* foffset, size_t* maxbytes ) {
/* Negative offset not allowed */
if(a < 0)
return -1;
/* Binary search for last file with starting offset <= a */
FILE_INFO fi;
int start = 0;
int end = export->len - 1;
while( start <= end ) {
int mid = (start + end) / 2;
fi = g_array_index(export, FILE_INFO, mid);
if( fi.startoff < a ) {
start = mid + 1;