← Back to branch summary

~ubuntu-branches/ubuntu/lucid/wpasupplicant/lucid-updates

« back to all changes in this revision

Viewing changes to config.c

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2006-10-05 08:04:01 UTC
  • mfrom: (1.1.5 upstream) (3 etch)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20061005080401-r8lqlix4390yos7b
Tags: 0.5.5-2
http://bugs.debian.org/388316
* Update madwifi headers to latest SVN. (Closes: #388316)
* Remove failed attempt at action locking. [debian/functions.sh,
  debian/wpa_action.sh]
* Add hysteresis checking functions, to avoid "event loops" while
  using wpa-roam. [debian/functions.sh, debian/wpa_action.sh]
* Change of co-maintainer email address.
* Add ishex() function to functions.sh to determine wpa-psk value type in
  plaintext or hex. This effectively eliminates the need for the bogus and
  somewhat confusing wpa-passphrase contruct specific to our scripts and
  allows wpa-psk to work with either a 8 to 63 character long plaintext
  string or 64 character long hex string.
* Adjust README.modes to not refer to the redundant wpa-passphrase stuff.
* Add big fat NOTE about acceptable wpa-psk's to top of example gallery.
* Strip surrounding quotes from wpa-ssid if present, instead of just whining
  about them.
* Update email address in copyright blurb of functions.sh, ifupdown.sh and
  wpa_action.sh.  

Show diffs side-by-side

added added

removed removed

Lines of Context:
config.c
246
246
        if (value == NULL)
247
247
                return NULL;
248
248
        snprintf(value, 20, "%d", *src);
 
249
        value[20 - 1] = '\0';
249
250
        return value;
250
251
}
251
252
 
277
278
        if (value == NULL)
278
279
                return NULL;
279
280
        snprintf(value, 20, MACSTR, MAC2STR(ssid->bssid));
 
281
        value[20 - 1] = '\0';
280
282
        return value;
281
283
}
282
284
 
401
403
static char * wpa_config_write_proto(const struct parse_data *data,
402
404
                                     struct wpa_ssid *ssid)
403
405
{
404
 
        int first = 1;
 
406
        int first = 1, ret;
405
407
        char *buf, *pos, *end;
406
408
 
407
409
        pos = buf = wpa_zalloc(10);
410
412
        end = buf + 10;
411
413
 
412
414
        if (ssid->proto & WPA_PROTO_WPA) {
413
 
                pos += snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
 
415
                ret = snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
 
416
                if (ret < 0 || ret >= end - pos)
 
417
                        return buf;
 
418
                pos += ret;
414
419
                first = 0;
415
420
        }
416
421
 
417
422
        if (ssid->proto & WPA_PROTO_RSN) {
418
 
                pos += snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
 
423
                ret = snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
 
424
                if (ret < 0 || ret >= end - pos)
 
425
                        return buf;
 
426
                pos += ret;
419
427
                first = 0;
420
428
        }
421
429
 
483
491
                                        struct wpa_ssid *ssid)
484
492
{
485
493
        char *buf, *pos, *end;
 
494
        int ret;
486
495
 
487
496
        pos = buf = wpa_zalloc(50);
488
497
        if (buf == NULL)
489
498
                return NULL;
490
499
        end = buf + 50;
491
500
 
492
 
        if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
493
 
                pos += snprintf(pos, end - pos, "%sWPA-PSK",
494
 
                                pos == buf ? "" : " ");
495
 
 
496
 
        if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
497
 
                pos += snprintf(pos, end - pos, "%sWPA-EAP",
498
 
                                pos == buf ? "" : " ");
499
 
 
500
 
        if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
501
 
                pos += snprintf(pos, end - pos, "%sIEEE8021X",
502
 
                                pos == buf ? "" : " ");
503
 
 
504
 
        if (ssid->key_mgmt & WPA_KEY_MGMT_NONE)
505
 
                pos += snprintf(pos, end - pos, "%sNONE",
506
 
                                pos == buf ? "" : " ");
507
 
 
508
 
        if (ssid->key_mgmt & WPA_KEY_MGMT_WPA_NONE)
509
 
                pos += snprintf(pos, end - pos, "%sWPA-NONE",
510
 
                                pos == buf ? "" : " ");
 
501
        if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) {
 
502
                ret = snprintf(pos, end - pos, "%sWPA-PSK",
 
503
                               pos == buf ? "" : " ");
 
504
                if (ret < 0 || ret >= end - pos) {
 
505
                        end[-1] = '\0';
 
506
                        return buf;
 
507
                }
 
508
                pos += ret;
 
509
        }
 
510
 
 
511
        if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 
512
                ret = snprintf(pos, end - pos, "%sWPA-EAP",
 
513
                               pos == buf ? "" : " ");
 
514
                if (ret < 0 || ret >= end - pos) {
 
515
                        end[-1] = '\0';
 
516
                        return buf;
 
517
                }
 
518
                pos += ret;
 
519
        }
 
520
 
 
521
        if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 
522
                ret = snprintf(pos, end - pos, "%sIEEE8021X",
 
523
                               pos == buf ? "" : " ");
 
524
                if (ret < 0 || ret >= end - pos) {
 
525
                        end[-1] = '\0';
 
526
                        return buf;
 
527
                }
 
528
                pos += ret;
 
529
        }
 
530
 
 
531
        if (ssid->key_mgmt & WPA_KEY_MGMT_NONE) {
 
532
                ret = snprintf(pos, end - pos, "%sNONE",
 
533
                               pos == buf ? "" : " ");
 
534
                if (ret < 0 || ret >= end - pos) {
 
535
                        end[-1] = '\0';
 
536
                        return buf;
 
537
                }
 
538
                pos += ret;
 
539
        }
 
540
 
 
541
        if (ssid->key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
 
542
                ret = snprintf(pos, end - pos, "%sWPA-NONE",
 
543
                               pos == buf ? "" : " ");
 
544
                if (ret < 0 || ret >= end - pos) {
 
545
                        end[-1] = '\0';
 
546
                        return buf;
 
547
                }
 
548
                pos += ret;
 
549
        }
511
550
 
512
551
        return buf;
513
552
}
568
607
static char * wpa_config_write_cipher(int cipher)
569
608
{
570
609
        char *buf, *pos, *end;
 
610
        int ret;
571
611
 
572
612
        pos = buf = wpa_zalloc(50);
573
613
        if (buf == NULL)
574
614
                return NULL;
575
615
        end = buf + 50;
576
616
 
577
 
        if (cipher & WPA_CIPHER_CCMP)
578
 
                pos += snprintf(pos, end - pos, "%sCCMP",
579
 
                                pos == buf ? "" : " ");
580
 
 
581
 
        if (cipher & WPA_CIPHER_TKIP)
582
 
                pos += snprintf(pos, end - pos, "%sTKIP",
583
 
                                pos == buf ? "" : " ");
584
 
 
585
 
        if (cipher & WPA_CIPHER_WEP104)
586
 
                pos += snprintf(pos, end - pos, "%sWEP104",
587
 
                                pos == buf ? "" : " ");
588
 
 
589
 
        if (cipher & WPA_CIPHER_WEP40)
590
 
                pos += snprintf(pos, end - pos, "%sWEP40",
591
 
                                pos == buf ? "" : " ");
592
 
 
593
 
        if (cipher & WPA_CIPHER_NONE)
594
 
                pos += snprintf(pos, end - pos, "%sNONE",
595
 
                                pos == buf ? "" : " ");
 
617
        if (cipher & WPA_CIPHER_CCMP) {
 
618
                ret = snprintf(pos, end - pos, "%sCCMP",
 
619
                               pos == buf ? "" : " ");
 
620
                if (ret < 0 || ret >= end - pos) {
 
621
                        end[-1] = '\0';
 
622
                        return buf;
 
623
                }
 
624
                pos += ret;
 
625
        }
 
626
 
 
627
        if (cipher & WPA_CIPHER_TKIP) {
 
628
                ret = snprintf(pos, end - pos, "%sTKIP",
 
629
                               pos == buf ? "" : " ");
 
630
                if (ret < 0 || ret >= end - pos) {
 
631
                        end[-1] = '\0';
 
632
                        return buf;
 
633
                }
 
634
                pos += ret;
 
635
        }
 
636
 
 
637
        if (cipher & WPA_CIPHER_WEP104) {
 
638
                ret = snprintf(pos, end - pos, "%sWEP104",
 
639
                               pos == buf ? "" : " ");
 
640
                if (ret < 0 || ret >= end - pos) {
 
641
                        end[-1] = '\0';
 
642
                        return buf;
 
643
                }
 
644
                pos += ret;
 
645
        }
 
646
 
 
647
        if (cipher & WPA_CIPHER_WEP40) {
 
648
                ret = snprintf(pos, end - pos, "%sWEP40",
 
649
                               pos == buf ? "" : " ");
 
650
                if (ret < 0 || ret >= end - pos) {
 
651
                        end[-1] = '\0';
 
652
                        return buf;
 
653
                }
 
654
                pos += ret;
 
655
        }
 
656
 
 
657
        if (cipher & WPA_CIPHER_NONE) {
 
658
                ret = snprintf(pos, end - pos, "%sNONE",
 
659
                               pos == buf ? "" : " ");
 
660
                if (ret < 0 || ret >= end - pos) {
 
661
                        end[-1] = '\0';
 
662
                        return buf;
 
663
                }
 
664
                pos += ret;
 
665
        }
596
666
 
597
667
        return buf;
598
668
}
709
779
                                        struct wpa_ssid *ssid)
710
780
{
711
781
        char *buf, *pos, *end;
 
782
        int ret;
712
783
 
713
784
        pos = buf = wpa_zalloc(30);
714
785
        if (buf == NULL)
715
786
                return NULL;
716
787
        end = buf + 30;
717
788
 
718
 
        if (ssid->auth_alg & WPA_AUTH_ALG_OPEN)
719
 
                pos += snprintf(pos, end - pos, "%sOPEN",
720
 
                                pos == buf ? "" : " ");
721
 
 
722
 
        if (ssid->auth_alg & WPA_AUTH_ALG_SHARED)
723
 
                pos += snprintf(pos, end - pos, "%sSHARED",
724
 
                                pos == buf ? "" : " ");
725
 
 
726
 
        if (ssid->auth_alg & WPA_AUTH_ALG_LEAP)
727
 
                pos += snprintf(pos, end - pos, "%sLEAP",
728
 
                                pos == buf ? "" : " ");
 
789
        if (ssid->auth_alg & WPA_AUTH_ALG_OPEN) {
 
790
                ret = snprintf(pos, end - pos, "%sOPEN",
 
791
                               pos == buf ? "" : " ");
 
792
                if (ret < 0 || ret >= end - pos) {
 
793
                        end[-1] = '\0';
 
794
                        return buf;
 
795
                }
 
796
                pos += ret;
 
797
        }
 
798
 
 
799
        if (ssid->auth_alg & WPA_AUTH_ALG_SHARED) {
 
800
                ret = snprintf(pos, end - pos, "%sSHARED",
 
801
                               pos == buf ? "" : " ");
 
802
                if (ret < 0 || ret >= end - pos) {
 
803
                        end[-1] = '\0';
 
804
                        return buf;
 
805
                }
 
806
                pos += ret;
 
807
        }
 
808
 
 
809
        if (ssid->auth_alg & WPA_AUTH_ALG_LEAP) {
 
810
                ret = snprintf(pos, end - pos, "%sLEAP",
 
811
                               pos == buf ? "" : " ");
 
812
                if (ret < 0 || ret >= end - pos) {
 
813
                        end[-1] = '\0';
 
814
                        return buf;
 
815
                }
 
816
                pos += ret;
 
817
        }
729
818
 
730
819
        return buf;
731
820
}
807
896
static char * wpa_config_write_eap(const struct parse_data *data,
808
897
                                   struct wpa_ssid *ssid)
809
898
{
810
 
        int i;
 
899
        int i, ret;
811
900
        char *buf, *pos, *end;
812
901
        const struct eap_method_type *eap_methods = ssid->eap_methods;
813
902
        const char *name;
824
913
                     eap_methods[i].method != EAP_TYPE_NONE; i++) {
825
914
                name = eap_get_name(eap_methods[i].vendor,
826
915
                                    eap_methods[i].method);
827
 
                if (name)
828
 
                        pos += snprintf(pos, end - pos, "%s%s",
829
 
                                        pos == buf ? "" : " ", name);
 
916
                if (name) {
 
917
                        ret = snprintf(pos, end - pos, "%s%s",
 
918
                                       pos == buf ? "" : " ", name);
 
919
                        if (ret < 0 || ret >= end - pos)
 
920
                                break;
 
921
                        pos += ret;
 
922
                }
830
923
        }
831
924
 
 
925
        end[-1] = '\0';
 
926
 
832
927
        return buf;
833
928
}
834
929
#endif /* IEEE8021X_EAPOL */
1241
1336
        }
1242
1337
 
1243
1338
        free(config->ctrl_interface);
 
1339
        free(config->ctrl_interface_group);
1244
1340
        free(config->opensc_engine_path);
1245
1341
        free(config->pkcs11_engine_path);
1246
1342
        free(config->pkcs11_module_path);