/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

* plugins.d/mandos-client.c: Prefix all printouts with "Mandos plugin
                             mandos-client: ".
* plugins.d/mandos-client.c (main): Wait for network hooks and check
                                    the completion status.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
85
85
                                   raise() */
86
86
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
87
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
88
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
 
89
                                   WEXITSTATUS(), WTERMSIG() */
88
90
 
89
91
#ifdef __linux__
90
92
#include <sys/klog.h>           /* klogctl() */
251
253
    
252
254
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
253
255
    if(rc != GPG_ERR_NO_ERROR){
254
 
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
256
      fprintf(stderr, "Mandos plugin mandos-client: "
 
257
              "bad gpgme_data_new_from_fd: %s: %s\n",
255
258
              gpgme_strsource(rc), gpgme_strerror(rc));
256
259
      return false;
257
260
    }
258
261
    
259
262
    rc = gpgme_op_import(mc.ctx, pgp_data);
260
263
    if(rc != GPG_ERR_NO_ERROR){
261
 
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
264
      fprintf(stderr, "Mandos plugin mandos-client: "
 
265
              "bad gpgme_op_import: %s: %s\n",
262
266
              gpgme_strsource(rc), gpgme_strerror(rc));
263
267
      return false;
264
268
    }
272
276
  }
273
277
  
274
278
  if(debug){
275
 
    fprintf(stderr, "Initializing GPGME\n");
 
279
    fprintf(stderr, "Mandos plugin mandos-client: "
 
280
            "Initializing GPGME\n");
276
281
  }
277
282
  
278
283
  /* Init GPGME */
279
284
  gpgme_check_version(NULL);
280
285
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
281
286
  if(rc != GPG_ERR_NO_ERROR){
282
 
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
287
    fprintf(stderr, "Mandos plugin mandos-client: "
 
288
            "bad gpgme_engine_check_version: %s: %s\n",
283
289
            gpgme_strsource(rc), gpgme_strerror(rc));
284
290
    return false;
285
291
  }
287
293
  /* Set GPGME home directory for the OpenPGP engine only */
288
294
  rc = gpgme_get_engine_info(&engine_info);
289
295
  if(rc != GPG_ERR_NO_ERROR){
290
 
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
296
    fprintf(stderr, "Mandos plugin mandos-client: "
 
297
            "bad gpgme_get_engine_info: %s: %s\n",
291
298
            gpgme_strsource(rc), gpgme_strerror(rc));
292
299
    return false;
293
300
  }
300
307
    engine_info = engine_info->next;
301
308
  }
302
309
  if(engine_info == NULL){
303
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
310
    fprintf(stderr, "Mandos plugin mandos-client: "
 
311
            "Could not set GPGME home dir to %s\n", tempdir);
304
312
    return false;
305
313
  }
306
314
  
307
315
  /* Create new GPGME "context" */
308
316
  rc = gpgme_new(&(mc.ctx));
309
317
  if(rc != GPG_ERR_NO_ERROR){
310
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
311
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
318
    fprintf(stderr, "Mandos plugin mandos-client: "
 
319
            "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
320
            gpgme_strerror(rc));
312
321
    return false;
313
322
  }
314
323
  
333
342
  ssize_t plaintext_length = 0;
334
343
  
335
344
  if(debug){
336
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
345
    fprintf(stderr, "Mandos plugin mandos-client: "
 
346
            "Trying to decrypt OpenPGP data\n");
337
347
  }
338
348
  
339
349
  /* Create new GPGME data buffer from memory cryptotext */
340
350
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
341
351
                               0);
342
352
  if(rc != GPG_ERR_NO_ERROR){
343
 
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
353
    fprintf(stderr, "Mandos plugin mandos-client: "
 
354
            "bad gpgme_data_new_from_mem: %s: %s\n",
344
355
            gpgme_strsource(rc), gpgme_strerror(rc));
345
356
    return -1;
346
357
  }
348
359
  /* Create new empty GPGME data buffer for the plaintext */
349
360
  rc = gpgme_data_new(&dh_plain);
350
361
  if(rc != GPG_ERR_NO_ERROR){
351
 
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
362
    fprintf(stderr, "Mandos plugin mandos-client: "
 
363
            "bad gpgme_data_new: %s: %s\n",
352
364
            gpgme_strsource(rc), gpgme_strerror(rc));
353
365
    gpgme_data_release(dh_crypto);
354
366
    return -1;
358
370
     data buffer */
359
371
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
360
372
  if(rc != GPG_ERR_NO_ERROR){
361
 
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
373
    fprintf(stderr, "Mandos plugin mandos-client: "
 
374
            "bad gpgme_op_decrypt: %s: %s\n",
362
375
            gpgme_strsource(rc), gpgme_strerror(rc));
363
376
    plaintext_length = -1;
364
377
    if(debug){
365
378
      gpgme_decrypt_result_t result;
366
379
      result = gpgme_op_decrypt_result(mc.ctx);
367
380
      if(result == NULL){
368
 
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
381
        fprintf(stderr, "Mandos plugin mandos-client: "
 
382
                "gpgme_op_decrypt_result failed\n");
369
383
      } else {
370
 
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
384
        fprintf(stderr, "Mandos plugin mandos-client: "
 
385
                "Unsupported algorithm: %s\n",
371
386
                result->unsupported_algorithm);
372
 
        fprintf(stderr, "Wrong key usage: %u\n",
 
387
        fprintf(stderr, "Mandos plugin mandos-client: "
 
388
                "Wrong key usage: %u\n",
373
389
                result->wrong_key_usage);
374
390
        if(result->file_name != NULL){
375
 
          fprintf(stderr, "File name: %s\n", result->file_name);
 
391
          fprintf(stderr, "Mandos plugin mandos-client: "
 
392
                  "File name: %s\n", result->file_name);
376
393
        }
377
394
        gpgme_recipient_t recipient;
378
395
        recipient = result->recipients;
379
396
        while(recipient != NULL){
380
 
          fprintf(stderr, "Public key algorithm: %s\n",
 
397
          fprintf(stderr, "Mandos plugin mandos-client: "
 
398
                  "Public key algorithm: %s\n",
381
399
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
382
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
383
 
          fprintf(stderr, "Secret key available: %s\n",
 
400
          fprintf(stderr, "Mandos plugin mandos-client: "
 
401
                  "Key ID: %s\n", recipient->keyid);
 
402
          fprintf(stderr, "Mandos plugin mandos-client: "
 
403
                  "Secret key available: %s\n",
384
404
                  recipient->status == GPG_ERR_NO_SECKEY
385
405
                  ? "No" : "Yes");
386
406
          recipient = recipient->next;
391
411
  }
392
412
  
393
413
  if(debug){
394
 
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
414
    fprintf(stderr, "Mandos plugin mandos-client: "
 
415
            "Decryption of OpenPGP data succeeded\n");
395
416
  }
396
417
  
397
418
  /* Seek back to the beginning of the GPGME plaintext data buffer */
428
449
  }
429
450
  
430
451
  if(debug){
431
 
    fprintf(stderr, "Decrypted password is: ");
 
452
    fprintf(stderr, "Mandos plugin mandos-client: "
 
453
            "Decrypted password is: ");
432
454
    for(ssize_t i = 0; i < plaintext_length; i++){
433
455
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
434
456
    }
456
478
/* GnuTLS log function callback */
457
479
static void debuggnutls(__attribute__((unused)) int level,
458
480
                        const char* string){
459
 
  fprintf(stderr, "GnuTLS: %s", string);
 
481
  fprintf(stderr, "Mandos plugin mandos-client: GnuTLS: %s", string);
460
482
}
461
483
 
462
484
static int init_gnutls_global(const char *pubkeyfilename,
464
486
  int ret;
465
487
  
466
488
  if(debug){
467
 
    fprintf(stderr, "Initializing GnuTLS\n");
 
489
    fprintf(stderr, "Mandos plugin mandos-client: "
 
490
            "Initializing GnuTLS\n");
468
491
  }
469
492
  
470
493
  ret = gnutls_global_init();
471
494
  if(ret != GNUTLS_E_SUCCESS){
472
 
    fprintf(stderr, "GnuTLS global_init: %s\n",
473
 
            safer_gnutls_strerror(ret));
 
495
    fprintf(stderr, "Mandos plugin mandos-client: "
 
496
            "GnuTLS global_init: %s\n", safer_gnutls_strerror(ret));
474
497
    return -1;
475
498
  }
476
499
  
485
508
  /* OpenPGP credentials */
486
509
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
487
510
  if(ret != GNUTLS_E_SUCCESS){
488
 
    fprintf(stderr, "GnuTLS memory error: %s\n",
489
 
            safer_gnutls_strerror(ret));
 
511
    fprintf(stderr, "Mandos plugin mandos-client: "
 
512
            "GnuTLS memory error: %s\n", safer_gnutls_strerror(ret));
490
513
    gnutls_global_deinit();
491
514
    return -1;
492
515
  }
493
516
  
494
517
  if(debug){
495
 
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
518
    fprintf(stderr, "Mandos plugin mandos-client: "
 
519
            "Attempting to use OpenPGP public key %s and"
496
520
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
497
521
            seckeyfilename);
498
522
  }
502
526
     GNUTLS_OPENPGP_FMT_BASE64);
503
527
  if(ret != GNUTLS_E_SUCCESS){
504
528
    fprintf(stderr,
 
529
            "Mandos plugin mandos-client: "
505
530
            "Error[%d] while reading the OpenPGP key pair ('%s',"
506
531
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
507
 
    fprintf(stderr, "The GnuTLS error is: %s\n",
508
 
            safer_gnutls_strerror(ret));
 
532
    fprintf(stderr, "Mandos plugin mandos-client: "
 
533
            "The GnuTLS error is: %s\n", safer_gnutls_strerror(ret));
509
534
    goto globalfail;
510
535
  }
511
536
  
512
537
  /* GnuTLS server initialization */
513
538
  ret = gnutls_dh_params_init(&mc.dh_params);
514
539
  if(ret != GNUTLS_E_SUCCESS){
515
 
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
 
540
    fprintf(stderr, "Mandos plugin mandos-client: "
 
541
            "Error in GnuTLS DH parameter initialization:"
516
542
            " %s\n", safer_gnutls_strerror(ret));
517
543
    goto globalfail;
518
544
  }
519
545
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
520
546
  if(ret != GNUTLS_E_SUCCESS){
521
 
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
 
547
    fprintf(stderr, "Mandos plugin mandos-client: "
 
548
            "Error in GnuTLS prime generation: %s\n",
522
549
            safer_gnutls_strerror(ret));
523
550
    goto globalfail;
524
551
  }
545
572
    }
546
573
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
547
574
  if(ret != GNUTLS_E_SUCCESS){
548
 
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
 
575
    fprintf(stderr, "Mandos plugin mandos-client: "
 
576
            "Error in GnuTLS session initialization: %s\n",
549
577
            safer_gnutls_strerror(ret));
550
578
  }
551
579
  
559
587
      }
560
588
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
561
589
    if(ret != GNUTLS_E_SUCCESS){
562
 
      fprintf(stderr, "Syntax error at: %s\n", err);
563
 
      fprintf(stderr, "GnuTLS error: %s\n",
564
 
              safer_gnutls_strerror(ret));
 
590
      fprintf(stderr, "Mandos plugin mandos-client: "
 
591
              "Syntax error at: %s\n", err);
 
592
      fprintf(stderr, "Mandos plugin mandos-client: "
 
593
              "GnuTLS error: %s\n", safer_gnutls_strerror(ret));
565
594
      gnutls_deinit(*session);
566
595
      return -1;
567
596
    }
576
605
    }
577
606
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
578
607
  if(ret != GNUTLS_E_SUCCESS){
579
 
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
608
    fprintf(stderr, "Mandos plugin mandos-client: "
 
609
            "Error setting GnuTLS credentials: %s\n",
580
610
            safer_gnutls_strerror(ret));
581
611
    gnutls_deinit(*session);
582
612
    return -1;
628
658
    pf = PF_INET;
629
659
    break;
630
660
  default:
631
 
    fprintf(stderr, "Bad address family: %d\n", af);
 
661
    fprintf(stderr, "Mandos plugin mandos-client: "
 
662
            "Bad address family: %d\n", af);
632
663
    errno = EINVAL;
633
664
    return -1;
634
665
  }
639
670
  }
640
671
  
641
672
  if(debug){
642
 
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
 
673
    fprintf(stderr, "Mandos plugin mandos-client: "
 
674
            "Setting up a TCP connection to %s, port %" PRIu16
643
675
            "\n", ip, port);
644
676
  }
645
677
  
672
704
  }
673
705
  if(ret == 0){
674
706
    int e = errno;
675
 
    fprintf(stderr, "Bad address: %s\n", ip);
 
707
    fprintf(stderr, "Mandos plugin mandos-client: "
 
708
            "Bad address: %s\n", ip);
676
709
    errno = e;
677
710
    goto mandos_end;
678
711
  }
685
718
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
686
719
                              -Wunreachable-code*/
687
720
      if(if_index == AVAHI_IF_UNSPEC){
688
 
        fprintf(stderr, "An IPv6 link-local address is incomplete"
 
721
        fprintf(stderr, "Mandos plugin mandos-client: "
 
722
                "An IPv6 link-local address is incomplete"
689
723
                " without a network interface\n");
690
724
        errno = EINVAL;
691
725
        goto mandos_end;
710
744
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
711
745
        perror_plus("if_indextoname");
712
746
      } else {
713
 
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
 
747
        fprintf(stderr, "Mandos plugin mandos-client: "
 
748
                "Connection to: %s%%%s, port %" PRIu16 "\n",
714
749
                ip, interface, port);
715
750
      }
716
751
    } else {
717
 
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
718
 
              port);
 
752
      fprintf(stderr, "Mandos plugin mandos-client: "
 
753
              "Connection to: %s, port %" PRIu16 "\n", ip, port);
719
754
    }
720
755
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
721
756
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
731
766
      perror_plus("inet_ntop");
732
767
    } else {
733
768
      if(strcmp(addrstr, ip) != 0){
734
 
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
 
769
        fprintf(stderr, "Mandos plugin mandos-client: "
 
770
                "Canonical address form: %s\n", addrstr);
735
771
      }
736
772
    }
737
773
  }
791
827
  }
792
828
  
793
829
  if(debug){
794
 
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
830
    fprintf(stderr, "Mandos plugin mandos-client: "
 
831
            "Establishing TLS session with %s\n", ip);
795
832
  }
796
833
  
797
834
  if(quit_now){
817
854
  
818
855
  if(ret != GNUTLS_E_SUCCESS){
819
856
    if(debug){
820
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
857
      fprintf(stderr, "Mandos plugin mandos-client: "
 
858
              "*** GnuTLS Handshake failed ***\n");
821
859
      gnutls_perror(ret);
822
860
    }
823
861
    errno = EPROTO;
827
865
  /* Read OpenPGP packet that contains the wanted password */
828
866
  
829
867
  if(debug){
830
 
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
831
 
            ip);
 
868
    fprintf(stderr, "Mandos plugin mandos-client: "
 
869
            "Retrieving OpenPGP encrypted password from %s\n", ip);
832
870
  }
833
871
  
834
872
  while(true){
872
910
          }
873
911
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
874
912
        if(ret < 0){
875
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
913
          fprintf(stderr, "Mandos plugin mandos-client: "
 
914
                  "*** GnuTLS Re-handshake failed ***\n");
876
915
          gnutls_perror(ret);
877
916
          errno = EPROTO;
878
917
          goto mandos_end;
879
918
        }
880
919
        break;
881
920
      default:
882
 
        fprintf(stderr, "Unknown error while reading data from"
 
921
        fprintf(stderr, "Mandos plugin mandos-client: "
 
922
                "Unknown error while reading data from"
883
923
                " encrypted session with Mandos server\n");
884
924
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
885
925
        errno = EIO;
891
931
  }
892
932
  
893
933
  if(debug){
894
 
    fprintf(stderr, "Closing TLS session\n");
 
934
    fprintf(stderr, "Mandos plugin mandos-client: "
 
935
            "Closing TLS session\n");
895
936
  }
896
937
  
897
938
  if(quit_now){
927
968
        if(ret == 0 and ferror(stdout)){
928
969
          int e = errno;
929
970
          if(debug){
930
 
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
971
            fprintf(stderr, "Mandos plugin mandos-client: "
 
972
                    "Error writing encrypted data: %s\n",
931
973
                    strerror(errno));
932
974
          }
933
975
          errno = e;
991
1033
  switch(event){
992
1034
  default:
993
1035
  case AVAHI_RESOLVER_FAILURE:
994
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
1036
    fprintf(stderr, "Mandos plugin mandos-client: "
 
1037
            "(Avahi Resolver) Failed to resolve service '%s'"
995
1038
            " of type '%s' in domain '%s': %s\n", name, type, domain,
996
1039
            avahi_strerror(avahi_server_errno(mc.server)));
997
1040
    break;
1001
1044
      char ip[AVAHI_ADDRESS_STR_MAX];
1002
1045
      avahi_address_snprint(ip, sizeof(ip), address);
1003
1046
      if(debug){
1004
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1047
        fprintf(stderr, "Mandos plugin mandos-client: "
 
1048
                "Mandos server \"%s\" found on %s (%s, %"
1005
1049
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1006
1050
                ip, (intmax_t)interface, port);
1007
1051
      }
1041
1085
  default:
1042
1086
  case AVAHI_BROWSER_FAILURE:
1043
1087
    
1044
 
    fprintf(stderr, "(Avahi browser) %s\n",
 
1088
    fprintf(stderr, "Mandos plugin mandos-client: "
 
1089
            "(Avahi browser) %s\n",
1045
1090
            avahi_strerror(avahi_server_errno(mc.server)));
1046
1091
    avahi_simple_poll_quit(mc.simple_poll);
1047
1092
    return;
1055
1100
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1056
1101
                                    name, type, domain, protocol, 0,
1057
1102
                                    resolve_callback, NULL) == NULL)
1058
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
1103
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1104
              "Avahi: Failed to resolve service '%s': %s\n",
1059
1105
              name, avahi_strerror(avahi_server_errno(mc.server)));
1060
1106
    break;
1061
1107
    
1065
1111
  case AVAHI_BROWSER_ALL_FOR_NOW:
1066
1112
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
1067
1113
    if(debug){
1068
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
1114
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1115
              "No Mandos server found, still searching...\n");
1069
1116
    }
1070
1117
    break;
1071
1118
  }
1110
1157
  /* Reject the loopback device */
1111
1158
  if(ifr->ifr_flags & IFF_LOOPBACK){
1112
1159
    if(debug){
1113
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1114
 
              ifname);
 
1160
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1161
              "Rejecting loopback interface \"%s\"\n", ifname);
1115
1162
    }
1116
1163
    return false;
1117
1164
  }
1118
1165
  /* Accept point-to-point devices only if connect_to is specified */
1119
1166
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1120
1167
    if(debug){
1121
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1122
 
              ifname);
 
1168
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1169
              "Accepting point-to-point interface \"%s\"\n", ifname);
1123
1170
    }
1124
1171
    return true;
1125
1172
  }
1126
1173
  /* Otherwise, reject non-broadcast-capable devices */
1127
1174
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
1128
1175
    if(debug){
1129
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1130
 
              ifname);
 
1176
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1177
              "Rejecting non-broadcast interface \"%s\"\n", ifname);
1131
1178
    }
1132
1179
    return false;
1133
1180
  }
1134
1181
  /* Reject non-ARP interfaces (including dummy interfaces) */
1135
1182
  if(ifr->ifr_flags & IFF_NOARP){
1136
1183
    if(debug){
1137
 
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n", ifname);
 
1184
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1185
              "Rejecting non-ARP interface \"%s\"\n", ifname);
1138
1186
    }
1139
1187
    return false;
1140
1188
  }
1141
1189
  
1142
1190
  /* Accept this device */
1143
1191
  if(debug){
1144
 
    fprintf(stderr, "Interface \"%s\" is good\n", ifname);
 
1192
    fprintf(stderr, "Mandos plugin mandos-client: "
 
1193
            "Interface \"%s\" is good\n", ifname);
1145
1194
  }
1146
1195
  return true;
1147
1196
}
1159
1208
  struct ifreq ifr;
1160
1209
  if(not get_flags(if_entry->d_name, &ifr)){
1161
1210
    if(debug){
1162
 
      fprintf(stderr, "Failed to get flags for interface \"%s\"\n",
 
1211
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1212
              "Failed to get flags for interface \"%s\"\n",
1163
1213
              if_entry->d_name);
1164
1214
    }
1165
1215
    return 0;
1184
1234
  struct ifreq ifr;
1185
1235
  if(not get_flags(if_entry->d_name, &ifr)){
1186
1236
    if(debug){
1187
 
      fprintf(stderr, "Failed to get flags for interface \"%s\"\n",
 
1237
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1238
              "Failed to get flags for interface \"%s\"\n",
1188
1239
              if_entry->d_name);
1189
1240
    }
1190
1241
    return 0;
1193
1244
  /* Reject down interfaces */
1194
1245
  if(not (ifr.ifr_flags & IFF_UP)){
1195
1246
    if(debug){
1196
 
      fprintf(stderr, "Rejecting down interface \"%s\"\n",
 
1247
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1248
              "Rejecting down interface \"%s\"\n",
1197
1249
              if_entry->d_name);
1198
1250
    }
1199
1251
    return 0;
1202
1254
  /* Reject non-running interfaces */
1203
1255
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1204
1256
    if(debug){
1205
 
      fprintf(stderr, "Rejecting non-running interface \"%s\"\n",
 
1257
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1258
              "Rejecting non-running interface \"%s\"\n",
1206
1259
              if_entry->d_name);
1207
1260
    }
1208
1261
    return 0;
1278
1331
  while(true){
1279
1332
    if(mc.current_server == NULL){
1280
1333
      if (debug){
1281
 
        fprintf(stderr,
 
1334
        fprintf(stderr, "Mandos plugin mandos-client: "
1282
1335
                "Wait until first server is found. No timeout!\n");
1283
1336
      }
1284
1337
      ret = avahi_simple_poll_iterate(s, -1);
1285
1338
    } else {
1286
1339
      if (debug){
1287
 
        fprintf(stderr, "Check current_server if we should run it,"
 
1340
        fprintf(stderr, "Mandos plugin mandos-client: "
 
1341
                "Check current_server if we should run it,"
1288
1342
                " or wait\n");
1289
1343
      }
1290
1344
      /* the current time */
1307
1361
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1308
1362
      
1309
1363
      if (debug){
1310
 
        fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
 
1364
        fprintf(stderr, "Mandos plugin mandos-client: "
 
1365
                "Blocking for %" PRIdMAX " ms\n", block_time);
1311
1366
      }
1312
1367
      
1313
1368
      if(block_time <= 0){
1333
1388
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1334
1389
    }
1335
1390
    if(ret != 0){
1336
 
      if (ret > 0 or errno != EINTR) {
 
1391
      if (ret > 0 or errno != EINTR){
1337
1392
        return (ret != 1) ? ret : 0;
1338
1393
      }
1339
1394
    }
1496
1551
        argp_state_help(state, state->out_stream,
1497
1552
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1498
1553
      case 'V':                 /* --version */
 
1554
        fprintf(state->out_stream, "Mandos plugin mandos-client: ");
1499
1555
        fprintf(state->out_stream, "%s\n", argp_program_version);
1500
1556
        exit(argp_err_exit_status);
1501
1557
        break;
1592
1648
    struct dirent *direntry;
1593
1649
    int numhooks = scandir(HOOKDIR, &direntries, runnable_hook,
1594
1650
                           alphasort);
1595
 
    int devnull = open("/dev/null", O_RDONLY);
1596
 
    for(int i = 0; i < numhooks; i++){
1597
 
      direntry = direntries[0];
1598
 
      char *fullname = NULL;
1599
 
      ret = asprintf(&fullname, "%s/%s", tempdir,
1600
 
                     direntry->d_name);
1601
 
      if(ret < 0){
1602
 
        perror_plus("asprintf");
1603
 
        continue;
1604
 
      }
1605
 
      pid_t hook_pid = fork();
1606
 
      if(hook_pid == 0){
1607
 
        /* Child */
1608
 
        dup2(devnull, STDIN_FILENO);
1609
 
        close(devnull);
1610
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1611
 
        ret = setenv("DEVICE", interface, 1);
1612
 
        if(ret == -1){
1613
 
          perror_plus("setenv");
1614
 
          exit(1);
1615
 
        }
1616
 
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1617
 
        if(ret == -1){
1618
 
          perror_plus("setenv");
1619
 
          exit(1);
1620
 
        }
1621
 
        ret = setenv("MODE", "start", 1);
1622
 
        if(ret == -1){
1623
 
          perror_plus("setenv");
1624
 
          exit(1);
1625
 
        }
1626
 
        char *delaystring;
1627
 
        ret = asprintf(&delaystring, "%f", delay);
1628
 
        if(ret == -1){
 
1651
    if(numhooks == -1){
 
1652
      perror_plus("scandir");
 
1653
    } else {
 
1654
      int devnull = open("/dev/null", O_RDONLY);
 
1655
      for(int i = 0; i < numhooks; i++){
 
1656
        direntry = direntries[0];
 
1657
        char *fullname = NULL;
 
1658
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
1659
                       direntry->d_name);
 
1660
        if(ret < 0){
1629
1661
          perror_plus("asprintf");
1630
 
          exit(1);
 
1662
          continue;
1631
1663
        }
1632
 
        ret = setenv("DELAY", delaystring, 1);
1633
 
        if(ret == -1){
 
1664
        pid_t hook_pid = fork();
 
1665
        if(hook_pid == 0){
 
1666
          /* Child */
 
1667
          dup2(devnull, STDIN_FILENO);
 
1668
          close(devnull);
 
1669
          dup2(STDERR_FILENO, STDOUT_FILENO);
 
1670
          ret = setenv("DEVICE", interface, 1);
 
1671
          if(ret == -1){
 
1672
            perror_plus("setenv");
 
1673
            exit(1);
 
1674
          }
 
1675
          ret = setenv("VERBOSE", debug ? "1" : "0", 1);
 
1676
          if(ret == -1){
 
1677
            perror_plus("setenv");
 
1678
            exit(1);
 
1679
          }
 
1680
          ret = setenv("MODE", "start", 1);
 
1681
          if(ret == -1){
 
1682
            perror_plus("setenv");
 
1683
            exit(1);
 
1684
          }
 
1685
          char *delaystring;
 
1686
          ret = asprintf(&delaystring, "%f", delay);
 
1687
          if(ret == -1){
 
1688
            perror_plus("asprintf");
 
1689
            exit(1);
 
1690
          }
 
1691
          ret = setenv("DELAY", delaystring, 1);
 
1692
          if(ret == -1){
 
1693
            free(delaystring);
 
1694
            perror_plus("setenv");
 
1695
            exit(1);
 
1696
          }
1634
1697
          free(delaystring);
1635
 
          perror_plus("setenv");
1636
 
          exit(1);
1637
 
        }
1638
 
        free(delaystring);
1639
 
        ret = execl(fullname, direntry->d_name, "start", NULL);
1640
 
        perror_plus("execl");
1641
 
      }
1642
 
      free(fullname);
1643
 
      if(quit_now){
1644
 
        goto end;
1645
 
      }
 
1698
          ret = execl(fullname, direntry->d_name, "start", NULL);
 
1699
          perror_plus("execl");
 
1700
        } else {
 
1701
          int status;
 
1702
          if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
1703
            perror_plus("waitpid");
 
1704
            free(fullname);
 
1705
            continue;
 
1706
          }
 
1707
          if(WIFEXITED(status)){
 
1708
            if(WEXITSTATUS(status) != 0){
 
1709
              fprintf(stderr, "Mandos plugin mandos-client: "
 
1710
                      "Warning: network hook \"%s\" exited"
 
1711
                      " with status %d\n", direntry->d_name,
 
1712
                      WEXITSTATUS(status));
 
1713
              free(fullname);
 
1714
              continue;
 
1715
            }
 
1716
          } else if(WIFSIGNALED(status)){
 
1717
            fprintf(stderr, "Mandos plugin mandos-client: "
 
1718
                    "Warning: network hook \"%s\" died by"
 
1719
                    " signal %d\n", direntry->d_name,
 
1720
                    WTERMSIG(status));
 
1721
            free(fullname);
 
1722
            continue;
 
1723
          } else {
 
1724
            fprintf(stderr, "Mandos plugin mandos-client: "
 
1725
                    "Warning: network hook \"%s\" crashed\n",
 
1726
                    direntry->d_name);
 
1727
            free(fullname);
 
1728
            continue;
 
1729
          }
 
1730
        }
 
1731
        free(fullname);
 
1732
        if(quit_now){
 
1733
          goto end;
 
1734
        }
 
1735
      }
 
1736
      close(devnull);
1646
1737
    }
1647
 
    close(devnull);
1648
1738
  }
1649
1739
  
1650
1740
  if(not debug){
1666
1756
      /* Pick the first interface returned */
1667
1757
      interface = strdup(direntries[0]->d_name);
1668
1758
      if(debug){
1669
 
        fprintf(stderr, "Using interface \"%s\"\n", interface);
 
1759
        fprintf(stderr, "Mandos plugin mandos-client: "
 
1760
                "Using interface \"%s\"\n", interface);
1670
1761
      }
1671
1762
      if(interface == NULL){
1672
1763
        perror_plus("malloc");
1677
1768
      free(direntries);
1678
1769
    } else {
1679
1770
      free(direntries);
1680
 
      fprintf(stderr, "Could not find a network interface\n");
 
1771
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1772
              "Could not find a network interface\n");
1681
1773
      exitcode = EXIT_FAILURE;
1682
1774
      goto end;
1683
1775
    }
1689
1781
  srand((unsigned int) time(NULL));
1690
1782
  mc.simple_poll = avahi_simple_poll_new();
1691
1783
  if(mc.simple_poll == NULL){
1692
 
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
1784
    fprintf(stderr, "Mandos plugin mandos-client: "
 
1785
            "Avahi: Failed to create simple poll object.\n");
1693
1786
    exitcode = EX_UNAVAILABLE;
1694
1787
    goto end;
1695
1788
  }
1761
1854
  if(strcmp(interface, "none") != 0){
1762
1855
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1763
1856
    if(if_index == 0){
1764
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1857
      fprintf(stderr, "Mandos plugin mandos-client: "
 
1858
              "No such interface: \"%s\"\n", interface);
1765
1859
      exitcode = EX_UNAVAILABLE;
1766
1860
      goto end;
1767
1861
    }
1908
2002
  
1909
2003
  ret = init_gnutls_global(pubkey, seckey);
1910
2004
  if(ret == -1){
1911
 
    fprintf(stderr, "init_gnutls_global failed\n");
 
2005
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2006
            "init_gnutls_global failed\n");
1912
2007
    exitcode = EX_UNAVAILABLE;
1913
2008
    goto end;
1914
2009
  } else {
1930
2025
  }
1931
2026
  
1932
2027
  if(not init_gpgme(pubkey, seckey, tempdir)){
1933
 
    fprintf(stderr, "init_gpgme failed\n");
 
2028
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2029
            "init_gpgme failed\n");
1934
2030
    exitcode = EX_UNAVAILABLE;
1935
2031
    goto end;
1936
2032
  } else {
1946
2042
    /* (Mainly meant for debugging) */
1947
2043
    char *address = strrchr(connect_to, ':');
1948
2044
    if(address == NULL){
1949
 
      fprintf(stderr, "No colon in address\n");
 
2045
      fprintf(stderr, "Mandos plugin mandos-client: "
 
2046
              "No colon in address\n");
1950
2047
      exitcode = EX_USAGE;
1951
2048
      goto end;
1952
2049
    }
1960
2057
    tmpmax = strtoimax(address+1, &tmp, 10);
1961
2058
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
1962
2059
       or tmpmax != (uint16_t)tmpmax){
1963
 
      fprintf(stderr, "Bad port number\n");
 
2060
      fprintf(stderr, "Mandos plugin mandos-client: "
 
2061
              "Bad port number\n");
1964
2062
      exitcode = EX_USAGE;
1965
2063
      goto end;
1966
2064
    }
1996
2094
        break;
1997
2095
      }
1998
2096
      if(debug){
1999
 
        fprintf(stderr, "Retrying in %d seconds\n",
2000
 
                (int)retry_interval);
 
2097
        fprintf(stderr, "Mandos plugin mandos-client: "
 
2098
                "Retrying in %d seconds\n", (int)retry_interval);
2001
2099
      }
2002
2100
      sleep((int)retry_interval);
2003
2101
    }
2033
2131
  
2034
2132
  /* Check if creating the Avahi server object succeeded */
2035
2133
  if(mc.server == NULL){
2036
 
    fprintf(stderr, "Failed to create Avahi server: %s\n",
 
2134
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2135
            "Failed to create Avahi server: %s\n",
2037
2136
            avahi_strerror(error));
2038
2137
    exitcode = EX_UNAVAILABLE;
2039
2138
    goto end;
2048
2147
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2049
2148
                                   NULL, 0, browse_callback, NULL);
2050
2149
  if(sb == NULL){
2051
 
    fprintf(stderr, "Failed to create service browser: %s\n",
 
2150
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2151
            "Failed to create service browser: %s\n",
2052
2152
            avahi_strerror(avahi_server_errno(mc.server)));
2053
2153
    exitcode = EX_UNAVAILABLE;
2054
2154
    goto end;
2061
2161
  /* Run the main loop */
2062
2162
  
2063
2163
  if(debug){
2064
 
    fprintf(stderr, "Starting Avahi loop search\n");
 
2164
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2165
            "Starting Avahi loop search\n");
2065
2166
  }
2066
2167
 
2067
2168
  ret = avahi_loop_with_timeout(mc.simple_poll,
2068
2169
                                (int)(retry_interval * 1000));
2069
2170
  if(debug){
2070
 
    fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
 
2171
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2172
            "avahi_loop_with_timeout exited %s\n",
2071
2173
            (ret == 0) ? "successfully" : "with error");
2072
2174
  }
2073
2175
  
2074
2176
 end:
2075
2177
  
2076
2178
  if(debug){
2077
 
    fprintf(stderr, "%s exiting\n", argv[0]);
 
2179
    fprintf(stderr, "Mandos plugin mandos-client: "
 
2180
            "%s exiting\n", argv[0]);
2078
2181
  }
2079
2182
  
2080
2183
  /* Cleanup things */
2122
2225
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2123
2226
      if(ret == -1){
2124
2227
        perror_plus("ioctl SIOCGIFFLAGS");
2125
 
      } else if(network.ifr_flags & IFF_UP) {
 
2228
      } else if(network.ifr_flags & IFF_UP){
2126
2229
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2127
2230
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2128
2231
        if(ret == -1){
2160
2263
        }
2161
2264
        ret = remove(fullname);
2162
2265
        if(ret == -1){
2163
 
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
2164
 
                  strerror(errno));
 
2266
          fprintf(stderr, "Mandos plugin mandos-client: "
 
2267
                  "remove(\"%s\"): %s\n", fullname, strerror(errno));
2165
2268
        }
2166
2269
        free(fullname);
2167
2270
      }