(root)/mandos/release
» Revision
237.2.157
(compared to revision 237.2.189)
: plugins.d/mandos-client.c
To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 237.2.157
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.157
- Committer: Teddy Hogeborn
- Date: 2009-10-24 19:17:52 UTC
- mto: (24.1.146 mandos) (237.12.2 mandos-persistent) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 270.
- Revision ID: teddy@fukt.bsnet.se-20091024191752-7g6xlf6wpp2pdexb
Convert some programs to use the exit codes from <sysexits.h>. Change
all programs using the "argp" parsing functions to use them correctly;
checking return value, using argp_error() to report parse errors etc.
* plugin-runner.c: Use <sysexits.h> exit codes. Always use fallback,
even on option errors, except for "--help", etc.
(getplugin): Make sure "errno" is set correctly on return.
(main): Declare our own "--help", "--usage", and "--version"
options which do not cause the fallback to be invoked.
In all other options, use fallback on any error.
(parse_opt, parse_opt_config_file): Reset errno at start and return
errno. No need to check "arg"
for NULL. New "--help",
"--usage", and "--version"
options.
(parse_opt): Accept empty string as global option. Do not print
errors which will be detected and reported later. Do
"argp_error()" on parse error or empty plugin names.
* plugins.d/mandos-client.c: Use <sysexits.h> exit codes. Do not
return successful exit code on "--help",
etc. since this would give the wrong
message to "plugin-runner".
(main): Declare our own "--help", "--usage", and "--version"
options which do not return a successful exit code.
(parse_opt): Reset errno at start and return errno. Do
"argp_error()" on parse errors. New "--help",
"--usage", and "--version" options.
* plugins.d/password-prompt.c: Use exit codes from <sysexits.h>. Do
not return successful exit code on
"--help", etc. since this would give
the wrong message to "plugin-runner".
(main): Declare our own "--help", "--usage", and "--version" options
which do not return a successful exit code. Do
close(STDOUT_FILENO) after writing to check its return code.
(parse_opt): Reset errno at start and return errno.
all programs using the "argp" parsing functions to use them correctly;
checking return value, using argp_error() to report parse errors etc.
* plugin-runner.c: Use <sysexits.h> exit codes. Always use fallback,
even on option errors, except for "--help", etc.
(getplugin): Make sure "errno" is set correctly on return.
(main): Declare our own "--help", "--usage", and "--version"
options which do not cause the fallback to be invoked.
In all other options, use fallback on any error.
(parse_opt, parse_opt_config_file): Reset errno at start and return
errno. No need to check "arg"
for NULL. New "--help",
"--usage", and "--version"
options.
(parse_opt): Accept empty string as global option. Do not print
errors which will be detected and reported later. Do
"argp_error()" on parse error or empty plugin names.
* plugins.d/mandos-client.c: Use <sysexits.h> exit codes. Do not
return successful exit code on "--help",
etc. since this would give the wrong
message to "plugin-runner".
(main): Declare our own "--help", "--usage", and "--version"
options which do not return a successful exit code.
(parse_opt): Reset errno at start and return errno. Do
"argp_error()" on parse errors. New "--help",
"--usage", and "--version" options.
* plugins.d/password-prompt.c: Use exit codes from <sysexits.h>. Do
not return successful exit code on
"--help", etc. since this would give
the wrong message to "plugin-runner".
(main): Declare our own "--help", "--usage", and "--version" options
which do not return a successful exit code. Do
close(STDOUT_FILENO) after writing to check its return code.
(parse_opt): Reset errno at start and return errno.
added
removed
plugins.d/mandos-client.c
43
43
stdout, ferror(), remove() */
44
44
#include <stdint.h> /* uint16_t, uint32_t */
45
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
47
srand(), strtof(), abort() */
48
48
#include <stdbool.h> /* bool, false, true */
49
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
50
strerror(), asprintf(), strcpy() */
82
82
#include <signal.h> /* sigemptyset(), sigaddset(),
83
83
sigaction(), SIGTERM, sig_atomic_t,
84
84
raise() */
85
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
86
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
85
#include <sysexits.h> /* EX_OSERR, EX_USAGE */
87
86
88
87
#ifdef __linux__
89
88
#include <sys/klog.h> /* klogctl() */
127
126
static const char mandos_protocol_version[] = "1";
128
127
const char *argp_program_version = "mandos-client " VERSION;
129
128
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
130
static const char sys_class_net[] = "/sys/class/net";
131
char *connect_to = NULL;
132
129
133
130
/* Used for passing in values through the Avahi callback functions */
134
131
typedef struct {
556
553
gnutls_session_t session;
557
554
int pf; /* Protocol family */
558
555
559
errno = 0;
560
561
556
if(quit_now){
562
errno = EINTR;
563
557
return -1;
564
558
}
565
559
572
566
break;
573
567
default:
574
568
fprintf(stderr, "Bad address family: %d\n", af);
575
errno = EINVAL;
576
569
return -1;
577
570
}
578
571
588
581
589
582
tcp_sd = socket(pf, SOCK_STREAM, 0);
590
583
if(tcp_sd < 0){
591
int e = errno;
592
584
perror("socket");
593
errno = e;
594
585
goto mandos_end;
595
586
}
596
587
597
588
if(quit_now){
598
errno = EINTR;
599
589
goto mandos_end;
600
590
}
601
591
608
598
ret = inet_pton(af, ip, &to.in.sin_addr);
609
599
}
610
600
if(ret < 0 ){
611
int e = errno;
612
601
perror("inet_pton");
613
errno = e;
614
602
goto mandos_end;
615
603
}
616
604
if(ret == 0){
617
int e = errno;
618
605
fprintf(stderr, "Bad address: %s\n", ip);
619
errno = e;
620
606
goto mandos_end;
621
607
}
622
608
if(af == AF_INET6){
630
616
if(if_index == AVAHI_IF_UNSPEC){
631
617
fprintf(stderr, "An IPv6 link-local address is incomplete"
632
618
" without a network interface\n");
633
errno = EINVAL;
634
619
goto mandos_end;
635
620
}
636
621
/* Set the network interface number as scope */
643
628
}
644
629
645
630
if(quit_now){
646
errno = EINTR;
647
631
goto mandos_end;
648
632
}
649
633
680
664
}
681
665
682
666
if(quit_now){
683
errno = EINTR;
684
667
goto mandos_end;
685
668
}
686
669
690
673
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
691
674
}
692
675
if(ret < 0){
693
int e = errno;
694
676
perror("connect");
695
errno = e;
696
677
goto mandos_end;
697
678
}
698
679
699
680
if(quit_now){
700
errno = EINTR;
701
681
goto mandos_end;
702
682
}
703
683
708
688
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
709
689
out_size - written));
710
690
if(ret == -1){
711
int e = errno;
712
691
perror("write");
713
errno = e;
714
692
goto mandos_end;
715
693
}
716
694
written += (size_t)ret;
726
704
}
727
705
728
706
if(quit_now){
729
errno = EINTR;
730
707
goto mandos_end;
731
708
}
732
709
}
736
713
}
737
714
738
715
if(quit_now){
739
errno = EINTR;
740
716
goto mandos_end;
741
717
}
742
718
743
719
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
744
720
745
721
if(quit_now){
746
errno = EINTR;
747
722
goto mandos_end;
748
723
}
749
724
750
725
do {
751
726
ret = gnutls_handshake(session);
752
727
if(quit_now){
753
errno = EINTR;
754
728
goto mandos_end;
755
729
}
756
730
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
760
734
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
761
735
gnutls_perror(ret);
762
736
}
763
errno = EPROTO;
764
737
goto mandos_end;
765
738
}
766
739
774
747
while(true){
775
748
776
749
if(quit_now){
777
errno = EINTR;
778
750
goto mandos_end;
779
751
}
780
752
781
753
buffer_capacity = incbuffer(&buffer, buffer_length,
782
754
buffer_capacity);
783
755
if(buffer_capacity == 0){
784
int e = errno;
785
756
perror("incbuffer");
786
errno = e;
787
757
goto mandos_end;
788
758
}
789
759
790
760
if(quit_now){
791
errno = EINTR;
792
761
goto mandos_end;
793
762
}
794
763
807
776
ret = gnutls_handshake(session);
808
777
809
778
if(quit_now){
810
errno = EINTR;
811
779
goto mandos_end;
812
780
}
813
781
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
814
782
if(ret < 0){
815
783
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
816
784
gnutls_perror(ret);
817
errno = EPROTO;
818
785
goto mandos_end;
819
786
}
820
787
break;
822
789
fprintf(stderr, "Unknown error while reading data from"
823
790
" encrypted session with Mandos server\n");
824
791
gnutls_bye(session, GNUTLS_SHUT_RDWR);
825
errno = EIO;
826
792
goto mandos_end;
827
793
}
828
794
} else {
835
801
}
836
802
837
803
if(quit_now){
838
errno = EINTR;
839
804
goto mandos_end;
840
805
}
841
806
842
807
do {
843
808
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
844
809
if(quit_now){
845
errno = EINTR;
846
810
goto mandos_end;
847
811
}
848
812
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
857
821
written = 0;
858
822
while(written < (size_t) decrypted_buffer_size){
859
823
if(quit_now){
860
errno = EINTR;
861
824
goto mandos_end;
862
825
}
863
826
865
828
(size_t)decrypted_buffer_size - written,
866
829
stdout);
867
830
if(ret == 0 and ferror(stdout)){
868
int e = errno;
869
831
if(debug){
870
832
fprintf(stderr, "Error writing encrypted data: %s\n",
871
833
strerror(errno));
872
834
}
873
errno = e;
874
835
goto mandos_end;
875
836
}
876
837
written += (size_t)ret;
882
843
/* Shutdown procedure */
883
844
884
845
mandos_end:
885
{
886
int e = errno;
887
free(decrypted_buffer);
888
free(buffer);
889
if(tcp_sd >= 0){
890
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
891
}
892
if(ret == -1){
893
if(e == 0){
894
e = errno;
895
}
896
perror("close");
897
}
898
gnutls_deinit(session);
899
if(quit_now){
900
e = EINTR;
901
retval = -1;
902
}
903
errno = e;
846
free(decrypted_buffer);
847
free(buffer);
848
if(tcp_sd >= 0){
849
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
850
}
851
if(ret == -1){
852
perror("close");
853
}
854
gnutls_deinit(session);
855
if(quit_now){
856
retval = -1;
904
857
}
905
858
return retval;
906
859
}
1022
975
errno = old_errno;
1023
976
}
1024
977
1025
/*
1026
* This function determines if a directory entry in /sys/class/net
1027
* corresponds to an acceptable network device.
1028
* (This function is passed to scandir(3) as a filter function.)
1029
*/
1030
int good_interface(const struct dirent *if_entry){
1031
ssize_t ssret;
1032
char *flagname = NULL;
1033
int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1034
if_entry->d_name);
1035
if(ret < 0){
1036
perror("asprintf");
1037
return 0;
1038
}
1039
if(if_entry->d_name[0] == '.'){
1040
return 0;
1041
}
1042
int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1043
if(flags_fd == -1){
1044
perror("open");
1045
return 0;
1046
}
1047
typedef short ifreq_flags; /* ifreq.ifr_flags in netdevice(7) */
1048
/* read line from flags_fd */
1049
ssize_t to_read = (sizeof(ifreq_flags)*2)+3; /* "0x1003\n" */
1050
char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1051
flagstring[(size_t)to_read] = '\0';
1052
if(flagstring == NULL){
1053
perror("malloc");
1054
close(flags_fd);
1055
return 0;
1056
}
1057
while(to_read > 0){
1058
ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1059
(size_t)to_read));
1060
if(ssret == -1){
1061
perror("read");
1062
free(flagstring);
1063
close(flags_fd);
1064
return 0;
1065
}
1066
to_read -= ssret;
1067
if(ssret == 0){
1068
break;
1069
}
1070
}
1071
close(flags_fd);
1072
intmax_t tmpmax;
1073
char *tmp;
1074
errno = 0;
1075
tmpmax = strtoimax(flagstring, &tmp, 0);
1076
if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1077
and not (isspace(*tmp)))
1078
or tmpmax != (ifreq_flags)tmpmax){
1079
if(debug){
1080
fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1081
flagstring, if_entry->d_name);
1082
}
1083
free(flagstring);
1084
return 0;
1085
}
1086
free(flagstring);
1087
ifreq_flags flags = (ifreq_flags)tmpmax;
1088
/* Reject the loopback device */
1089
if(flags & IFF_LOOPBACK){
1090
if(debug){
1091
fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1092
if_entry->d_name);
1093
}
1094
return 0;
1095
}
1096
/* Accept point-to-point devices only if connect_to is specified */
1097
if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1098
if(debug){
1099
fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1100
if_entry->d_name);
1101
}
1102
return 1;
1103
}
1104
/* Otherwise, reject non-broadcast-capable devices */
1105
if(not (flags & IFF_BROADCAST)){
1106
if(debug){
1107
fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1108
if_entry->d_name);
1109
}
1110
return 0;
1111
}
1112
/* Accept this device */
1113
if(debug){
1114
fprintf(stderr, "Interface \"%s\" is acceptable\n",
1115
if_entry->d_name);
1116
}
1117
return 1;
1118
}
1119
1120
978
int main(int argc, char *argv[]){
1121
979
AvahiSServiceBrowser *sb = NULL;
1122
980
int error;
1124
982
intmax_t tmpmax;
1125
983
char *tmp;
1126
984
int exitcode = EXIT_SUCCESS;
1127
const char *interface = "";
985
const char *interface = "eth0";
1128
986
struct ifreq network;
1129
987
int sd = -1;
1130
988
bool take_down_interface = false;
1131
989
uid_t uid;
1132
990
gid_t gid;
991
char *connect_to = NULL;
1133
992
char tempdir[] = "/tmp/mandosXXXXXX";
1134
993
bool tempdir_created = false;
1135
994
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1292
1151
if(not debug){
1293
1152
avahi_set_log_function(empty_log);
1294
1153
}
1295
1296
if(interface[0] == '\0'){
1297
struct dirent **direntries;
1298
ret = scandir(sys_class_net, &direntries, good_interface,
1299
alphasort);
1300
if(ret >= 1){
1301
/* Pick the first good interface */
1302
interface = strdup(direntries[0]->d_name);
1303
if(debug){
1304
fprintf(stderr, "Using interface \"%s\"\n", interface);
1305
}
1306
if(interface == NULL){
1307
perror("malloc");
1308
free(direntries);
1309
exitcode = EXIT_FAILURE;
1310
goto end;
1311
}
1312
free(direntries);
1313
} else {
1314
free(direntries);
1315
fprintf(stderr, "Could not find a network interface\n");
1316
exitcode = EXIT_FAILURE;
1317
goto end;
1318
}
1319
}
1320
1154
1321
1155
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1322
1156
from the signal handler */
1325
1159
mc.simple_poll = avahi_simple_poll_new();
1326
1160
if(mc.simple_poll == NULL){
1327
1161
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1328
exitcode = EX_UNAVAILABLE;
1162
exitcode = EXIT_FAILURE;
1329
1163
goto end;
1330
1164
}
1331
1165
1333
1167
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1334
1168
if(ret == -1){
1335
1169
perror("sigaddset");
1336
exitcode = EX_OSERR;
1170
exitcode = EXIT_FAILURE;
1337
1171
goto end;
1338
1172
}
1339
1173
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1340
1174
if(ret == -1){
1341
1175
perror("sigaddset");
1342
exitcode = EX_OSERR;
1176
exitcode = EXIT_FAILURE;
1343
1177
goto end;
1344
1178
}
1345
1179
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1346
1180
if(ret == -1){
1347
1181
perror("sigaddset");
1348
exitcode = EX_OSERR;
1182
exitcode = EXIT_FAILURE;
1349
1183
goto end;
1350
1184
}
1351
1185
/* Need to check if the handler is SIG_IGN before handling:
1355
1189
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1356
1190
if(ret == -1){
1357
1191
perror("sigaction");
1358
return EX_OSERR;
1192
return EXIT_FAILURE;
1359
1193
}
1360
1194
if(old_sigterm_action.sa_handler != SIG_IGN){
1361
1195
ret = sigaction(SIGINT, &sigterm_action, NULL);
1362
1196
if(ret == -1){
1363
1197
perror("sigaction");
1364
exitcode = EX_OSERR;
1198
exitcode = EXIT_FAILURE;
1365
1199
goto end;
1366
1200
}
1367
1201
}
1368
1202
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1369
1203
if(ret == -1){
1370
1204
perror("sigaction");
1371
return EX_OSERR;
1205
return EXIT_FAILURE;
1372
1206
}
1373
1207
if(old_sigterm_action.sa_handler != SIG_IGN){
1374
1208
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1375
1209
if(ret == -1){
1376
1210
perror("sigaction");
1377
exitcode = EX_OSERR;
1211
exitcode = EXIT_FAILURE;
1378
1212
goto end;
1379
1213
}
1380
1214
}
1381
1215
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1382
1216
if(ret == -1){
1383
1217
perror("sigaction");
1384
return EX_OSERR;
1218
return EXIT_FAILURE;
1385
1219
}
1386
1220
if(old_sigterm_action.sa_handler != SIG_IGN){
1387
1221
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1388
1222
if(ret == -1){
1389
1223
perror("sigaction");
1390
exitcode = EX_OSERR;
1224
exitcode = EXIT_FAILURE;
1391
1225
goto end;
1392
1226
}
1393
1227
}
1394
1228
1395
1229
/* If the interface is down, bring it up */
1396
if(strcmp(interface, "none") != 0){
1230
if(interface[0] != '\0'){
1397
1231
if_index = (AvahiIfIndex) if_nametoindex(interface);
1398
1232
if(if_index == 0){
1399
1233
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1400
exitcode = EX_UNAVAILABLE;
1234
exitcode = EXIT_FAILURE;
1401
1235
goto end;
1402
1236
}
1403
1237
1426
1260
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1427
1261
if(sd < 0){
1428
1262
perror("socket");
1429
exitcode = EX_OSERR;
1263
exitcode = EXIT_FAILURE;
1430
1264
#ifdef __linux__
1431
1265
if(restore_loglevel){
1432
1266
ret = klogctl(7, NULL, 0);
1455
1289
}
1456
1290
}
1457
1291
#endif /* __linux__ */
1458
exitcode = EX_OSERR;
1292
exitcode = EXIT_FAILURE;
1459
1293
/* Lower privileges */
1460
1294
errno = 0;
1461
1295
ret = seteuid(uid);
1470
1304
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1471
1305
if(ret == -1){
1472
1306
take_down_interface = false;
1473
perror("ioctl SIOCSIFFLAGS +IFF_UP");
1474
exitcode = EX_OSERR;
1307
perror("ioctl SIOCSIFFLAGS");
1308
exitcode = EXIT_FAILURE;
1475
1309
#ifdef __linux__
1476
1310
if(restore_loglevel){
1477
1311
ret = klogctl(7, NULL, 0);
1543
1377
ret = init_gnutls_global(pubkey, seckey);
1544
1378
if(ret == -1){
1545
1379
fprintf(stderr, "init_gnutls_global failed\n");
1546
exitcode = EX_UNAVAILABLE;
1380
exitcode = EXIT_FAILURE;
1547
1381
goto end;
1548
1382
} else {
1549
1383
gnutls_initialized = true;
1566
1400
1567
1401
if(not init_gpgme(pubkey, seckey, tempdir)){
1568
1402
fprintf(stderr, "init_gpgme failed\n");
1569
exitcode = EX_UNAVAILABLE;
1403
exitcode = EXIT_FAILURE;
1570
1404
goto end;
1571
1405
} else {
1572
1406
gpgme_initialized = true;
1582
1416
char *address = strrchr(connect_to, ':');
1583
1417
if(address == NULL){
1584
1418
fprintf(stderr, "No colon in address\n");
1585
exitcode = EX_USAGE;
1419
exitcode = EXIT_FAILURE;
1586
1420
goto end;
1587
1421
}
1588
1422
1596
1430
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1597
1431
or tmpmax != (uint16_t)tmpmax){
1598
1432
fprintf(stderr, "Bad port number\n");
1599
exitcode = EX_USAGE;
1433
exitcode = EXIT_FAILURE;
1600
1434
goto end;
1601
1435
}
1602
1436
1621
1455
1622
1456
ret = start_mandos_communication(address, port, if_index, af);
1623
1457
if(ret < 0){
1624
switch(errno){
1625
case ENETUNREACH:
1626
case EHOSTDOWN:
1627
case EHOSTUNREACH:
1628
exitcode = EX_NOHOST;
1629
break;
1630
case EINVAL:
1631
exitcode = EX_USAGE;
1632
break;
1633
case EIO:
1634
exitcode = EX_IOERR;
1635
break;
1636
case EPROTO:
1637
exitcode = EX_PROTOCOL;
1638
break;
1639
default:
1640
exitcode = EX_OSERR;
1641
break;
1642
}
1458
exitcode = EXIT_FAILURE;
1643
1459
} else {
1644
1460
exitcode = EXIT_SUCCESS;
1645
1461
}
1672
1488
if(mc.server == NULL){
1673
1489
fprintf(stderr, "Failed to create Avahi server: %s\n",
1674
1490
avahi_strerror(error));
1675
exitcode = EX_UNAVAILABLE;
1491
exitcode = EXIT_FAILURE;
1676
1492
goto end;
1677
1493
}
1678
1494
1687
1503
if(sb == NULL){
1688
1504
fprintf(stderr, "Failed to create service browser: %s\n",
1689
1505
avahi_strerror(avahi_server_errno(mc.server)));
1690
exitcode = EX_UNAVAILABLE;
1506
exitcode = EXIT_FAILURE;
1691
1507
goto end;
1692
1508
}
1693
1509
1745
1561
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1746
1562
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1747
1563
if(ret == -1){
1748
perror("ioctl SIOCSIFFLAGS -IFF_UP");
1564
perror("ioctl SIOCSIFFLAGS");
1749
1565
}
1750
1566
}
1751
1567
ret = (int)TEMP_FAILURE_RETRY(close(sd));
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0