diff options
Diffstat (limited to 'openembedded')
24 files changed, 2497 insertions, 16 deletions
diff --git a/openembedded/conf/machine/ipaq-pxa270.conf b/openembedded/conf/machine/ipaq-pxa270.conf index 66d3eb38ff..07753ccf64 100644 --- a/openembedded/conf/machine/ipaq-pxa270.conf +++ b/openembedded/conf/machine/ipaq-pxa270.conf @@ -10,8 +10,6 @@ PREFERRED_PROVIDER_virtual/kernel = "handhelds-pxa-2.6" #use this for a hx2xxx ipaq #PREFERRED_PROVIDER_virtual/kernel = "linux-openzaurus" -PREFERRED_VERSIONS_handhelds-pxa-2.6 = "2.6.12-hh3" - PREFERRED_VERSION_orinoco-modules = "0.15rc1" ROOT_FLASH_SIZE = "80" @@ -21,6 +19,7 @@ EXTRA_IMAGECMD_jffs2 = "; sumtool -i ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.rootfs.jf -e 256KiB -p" MODUTILS = "26" +PCMCIA_MANAGER = "pcmciautils" BOOTSTRAP_EXTRA_RDEPENDS = "kernel ipaq-boot-params " BOOTSTRAP_EXTRA_RRECOMMENDS += "${@linux_module_packages('${PXA270_MODULES}', d)}" BOOTSTRAP_EXTRA_RDEPENDS_append = " udev module-init-tools" @@ -34,7 +33,6 @@ SERIAL_CONSOLE = "115200 ttyS0" include conf/machine/include/handheld-common.conf GUI_MACHINE_CLASS = "bigscreen" -GPE_EXTRA_INSTALL += "gaim" # Use tune-xscale per default. Machine independent feeds should be built with tune-strongarm. include conf/machine/include/tune-xscale.conf @@ -47,7 +45,7 @@ HX4700_MODULES = "i2c-pxa asic3_mmc hx4700_bt hx4700_leds hx4700_navpt hx4700_pc hx4700_ts hx4700_wlan snd_hx4700_audio hx4700_power" - +module_autoload_evdev = "evdev" module_autoload_hx4700_power = "hx4700_power" module_autoload_pcmcia = "pcmcia" module_autoload_hx4700_pcmcia = "hx4700_pcmcia" diff --git a/openembedded/packages/gcc/gcc_4.0.2.bb b/openembedded/packages/gcc/gcc_4.0.2.bb index ba64d2421a..540af1cb39 100644 --- a/openembedded/packages/gcc/gcc_4.0.2.bb +++ b/openembedded/packages/gcc/gcc_4.0.2.bb @@ -14,4 +14,14 @@ SRC_URI = "${GNU_MIRROR}/gcc/gcc-${PV}/gcc-${PV}.tar.bz2 \ file://arm-softfloat.patch;patch=1 \ file://ldflags.patch;patch=1" +# uclibc patches below +SRC_URI_append = " file://100-uclibc-conf.patch;patch=1 \ + file://200-uclibc-locale.patch;patch=1 \ + file://301-missing-execinfo_h.patch;patch=1 \ + file://302-c99-snprintf.patch;patch=1 \ + file://303-c99-complex-ugly-hack.patch;patch=1 \ + file://800-arm-bigendian.patch;patch=1 \ + file://zecke-host-cpp-ac-hack.patch;patch=1 " + + include gcc4-build.inc diff --git a/openembedded/packages/lirc/files/lircd.init b/openembedded/packages/lirc/files/lircd.init index 4bb2b7ee0a..11ce62447f 100755 --- a/openembedded/packages/lirc/files/lircd.init +++ b/openembedded/packages/lirc/files/lircd.init @@ -7,6 +7,7 @@ test -f /usr/sbin/lircd || exit 0 +test -f /etc/lircd.conf || exit 0 case "$1" in start) diff --git a/openembedded/packages/lirc/files/lircexec.init b/openembedded/packages/lirc/files/lircexec.init index a9724af0fa..3a8c1a306e 100755 --- a/openembedded/packages/lirc/files/lircexec.init +++ b/openembedded/packages/lirc/files/lircexec.init @@ -8,11 +8,12 @@ test -f /usr/bin/irexec || exit 0 +test -f /etc/lircrc || exit 0 case "$1" in start) echo -n "Starting lircexec daemon: irexec" - start-stop-daemon --start --quiet --exec /usr/bin/irexec + start-stop-daemon --start --quiet --exec /usr/bin/irexec -- --daemon echo "." ;; stop) @@ -25,7 +26,7 @@ case "$1" in start-stop-daemon --stop --quiet --exec /usr/bin/irexec sleep 1 echo -n "Starting lircexec daemon: irexec" - start-stop-daemon --start --quiet --exec /usr/bin/irexec + start-stop-daemon --start --quiet --exec /usr/bin/irexec -- --daemon echo "." ;; *) diff --git a/openembedded/packages/mpfr/mpfr_2.1.1.bb b/openembedded/packages/mpfr/mpfr_2.1.1.bb index 8b739c0803..1bf29fb6b1 100644 --- a/openembedded/packages/mpfr/mpfr_2.1.1.bb +++ b/openembedded/packages/mpfr/mpfr_2.1.1.bb @@ -3,7 +3,7 @@ LICENSE = "LGPL" MAINTAINER = "Rene Wagner <rw@handhelds.org>" SECTION = "libs" DEPENDS = "gmp" -PR = "r1" +PR = "r2" SRC_URI = "http://www.mpfr.org/mpfr-${PV}/mpfr-${PV}.tar.bz2" S = "${WORKDIR}/mpfr-${PV}" @@ -15,5 +15,6 @@ do_stage() { bindir=${STAGING_BINDIR} \ includedir=${STAGING_INCDIR} \ libdir=${STAGING_LIBDIR} \ - datadir=${STAGING_DATADIR} + datadir=${STAGING_DATADIR} \ + infodir=${STAGING_DIR}/${HOST_SYS}/info } diff --git a/openembedded/packages/netbase/netbase/interfaces b/openembedded/packages/netbase/netbase/interfaces index d7b40dc380..fbeb14ffbc 100644 --- a/openembedded/packages/netbase/netbase/interfaces +++ b/openembedded/packages/netbase/netbase/interfaces @@ -16,10 +16,19 @@ iface eth1 inet dhcp # Ethernet/RNDIS gadget (g_ether) # ... or on host side, usbnet and random hwaddr -iface usb0 inet dhcp +iface usb0 inet static + address 192.168.0.202 + netmask 255.255.255.0 + network 192.168.0.0 + gateway 192.168.0.200 + # Zaurus 2.4 Lineo net_fd; obsolete -iface usbd0 inet dhcp +iface usbd0 inet static + address 192.168.129.201 + netmask 255.255.255.0 + network 192.168.129.0 + gateway 192.168.129.200 # iPAQ 2.4 mach-sa1100/usb-eth # (192.168.0.202 is the iPAQ's IP, 192.168.0.200 is the host's IP) diff --git a/openembedded/packages/sharp-binary-only/sharp-flash-header-c700.bb b/openembedded/packages/sharp-binary-only/sharp-flash-header-c700.bb index c02882482e..789c7c2f01 100644 --- a/openembedded/packages/sharp-binary-only/sharp-flash-header-c700.bb +++ b/openembedded/packages/sharp-binary-only/sharp-flash-header-c700.bb @@ -1,6 +1,7 @@ SECTION = "base" SRC_URI = "file://header-c700.bin" LICENSE = "sharp-binary-only" +COMPATIBLE_MACHINE = '(c7x0|spitz|akita)' do_stage() { install -d ${STAGING_LIBDIR}/sharp-flash-header install -m 0644 ${WORKDIR}/header-c700.bin ${STAGING_LIBDIR}/sharp-flash-header/header-c700.bin diff --git a/openembedded/packages/startup-notification/startup-notification_0.8.bb b/openembedded/packages/startup-notification/startup-notification_0.8.bb index 3db849d2ce..36181f4043 100644 --- a/openembedded/packages/startup-notification/startup-notification_0.8.bb +++ b/openembedded/packages/startup-notification/startup-notification_0.8.bb @@ -2,7 +2,7 @@ DESCRIPTION = "Startup notification support" LICENSE = "LGPL" SECTION = "libs" PRIORITY = "optional" -MAINTAINER = "Phil Blundell <pb@nexus.co.uk>" +MAINTAINER = "Phil Blundell <pb@handhelds.org>" DEPENDS = "libx11" PR = "r1" @@ -15,5 +15,5 @@ do_configure_prepend () { } do_stage () { - oe_runmake install DESTDIR="" bindir=${STAGING_BINDIR} includedir=${STAGING_INCDIR} libdir=${STAGING_LIBDIR} prefix=${STAGING_DIR} + autotools_stage_all } diff --git a/openembedded/packages/tslib/tslib/h3900/tslib.sh b/openembedded/packages/tslib/tslib/h3900/tslib.sh index be9448b1dc..0de3534a51 100644 --- a/openembedded/packages/tslib/tslib/h3900/tslib.sh +++ b/openembedded/packages/tslib/tslib/h3900/tslib.sh @@ -11,7 +11,7 @@ case `uname -r` in ;; *) TSLIB_TSDEVICE=`detect-stylus --device` - TSLIB_CONFFILE=/usr/share/tslib/ts.conf-h3600 + TSLIB_CONFFILE=/usr/share/tslib/ts-2.6.conf ;; esac diff --git a/openembedded/packages/tslib/tslib/simpad/tslib.sh b/openembedded/packages/tslib/tslib/simpad/tslib.sh index 8bb94a037f..5301239373 100644 --- a/openembedded/packages/tslib/tslib/simpad/tslib.sh +++ b/openembedded/packages/tslib/tslib/simpad/tslib.sh @@ -7,7 +7,7 @@ case `uname -r` in ;; *) TSLIB_TSDEVICE=/dev/input/event0 - TSLIB_CONFFILE=/usr/share/tslib/ts.conf-simpad + TSLIB_CONFFILE=/usr/share/tslib/ts-2.6.conf ;; esac diff --git a/openembedded/packages/udev/files/mount.sh b/openembedded/packages/udev/files/mount.sh index 7e641b08d7..48c7844690 100644 --- a/openembedded/packages/udev/files/mount.sh +++ b/openembedded/packages/udev/files/mount.sh @@ -8,6 +8,39 @@ MOUNT="/bin/mount" PMOUNT="/usr/bin/pmount" UMOUNT="/bin/umount" +name="`basename "$DEVNAME"`" + +for line in `cat /etc/udev/mount.blacklist | grep -v ^#` +do + if ( echo "$DEVNAME" | grep -q "$line" ) + then + logger "udev/mount.sh" "[$DEVNAME] is blacklisted, ignoring" + exit 0 + fi +done + +automount() { + ! test -d "/media/$name" && mkdir -p "/media/$name" + + if ! $MOUNT -t auto -o sync $DEVNAME "/media/$name" + then + #logger "mount.sh/automount" "$MOUNT -t auto $DEVNAME \"/media/$name\" failed!" + rm_dir "/media/$name" + else + logger "mount.sh/automount" "Auto-mount of [/media/$name] successful" + touch "/tmp/.automount-$name" + fi +} + +rm_dir() { + # We do not want to rm -r populated directories + if test "`find "$1" | wc -l | tr -d " "`" -lt 2 -a -d "$1" + then + ! test -z "$1" && rm -r "$1" + else + logger "mount.sh/automount" "Not removing non-empty directory [$1]" + fi +} if [ "$ACTION" = "add" ] && [ -n "$DEVNAME" ]; then if [ -x "$PMOUNT" ]; then @@ -15,11 +48,20 @@ if [ "$ACTION" = "add" ] && [ -n "$DEVNAME" ]; then elif [ -x $MOUNT ]; then $MOUNT $DEVNAME 2> /dev/null fi + + # If the device isn't mounted at this point, it isn't configured in fstab + cat /proc/mounts | awk '{print $1}' | grep -q "^$DEVNAME$" || automount + fi + + if [ "$ACTION" = "remove" ] && [ -x "$UMOUNT" ] && [ -n "$DEVNAME" ]; then for mnt in `cat /proc/mounts | grep "$DEVNAME" | cut -f 2 -d " " ` do $UMOUNT $mnt done + + # Remove empty directories from auto-mounter + test -e "/tmp/.automount-$name" && rm_dir "/media/$name" fi diff --git a/openembedded/packages/udev/files/network.sh b/openembedded/packages/udev/files/network.sh index 2cfbfa91b3..5016328df4 100644 --- a/openembedded/packages/udev/files/network.sh +++ b/openembedded/packages/udev/files/network.sh @@ -6,6 +6,35 @@ test -x /sbin/cardctl && exit 0 # We get two "add" events for hostap cards due to wifi0 echo "$INTERFACE" | grep -q wifi && exit 0 + +# Check if /etc/init.d/network has been run yet to see if we are +# called by starting /etc/rcS.d/S03udev and not by hotplugging a device +# +# At this stage, network interfaces should not be brought up +# automatically because: +# a) /etc/init.d/network has not been run yet (security issue) +# b) /var has not been populated yet so /etc/resolv,conf points to +# oblivion, making the network unusable +# + +spoofp="`grep ^spoofprotect /etc/network/options`" +if test -z "$spoofp" +then + # This is the default from /etc/init.d/network + spoofp_val=yes +else + spoofp_val=${spoofp#spoofprotect=} +fi + +test "$spoofp_val" = yes && spoofp_val=1 || spoofp_val=0 + +# I think it is safe to assume that "lo" will always be there ;) +if test "`cat /proc/sys/net/ipv4/conf/lo/rp_filter`" != "$spoofp_val" -a -n "$spoofp_val" +then + echo "$INTERFACE" >> /dev/udev_network_queue + exit 0 +fi + # # Code taken from pcmcia-cs:/etc/pcmcia/network # @@ -15,7 +44,7 @@ echo "$INTERFACE" | grep -q wifi && exit 0 if grep -q "iface \+$INTERFACE" /etc/network/interfaces; then case $ACTION in add) - ifup $INTERFACE + ifconfig | grep -q "^$INTERFACE" || ifup $INTERFACE ;; remove) ifdown $INTERFACE diff --git a/openembedded/packages/wpa-supplicant/files/defaults-sane b/openembedded/packages/wpa-supplicant/files/defaults-sane new file mode 100644 index 0000000000..67c4cbddf8 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/files/defaults-sane @@ -0,0 +1,8 @@ +# Useful flags: +# -i <ifname> Interface (required, unless specified in config) +# -D <driver> Wireless Driver +# -d Debugging (-dd for more) +# -q Quiet (-qq for more) + +CONFIG="/etc/wpa_supplicant.conf" +OPTIONS="-i eth1 -D wext" diff --git a/openembedded/packages/wpa-supplicant/files/defconfig-gnutls b/openembedded/packages/wpa-supplicant/files/defconfig-gnutls new file mode 100644 index 0000000000..2df5e51df8 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/files/defconfig-gnutls @@ -0,0 +1,176 @@ +# This file lists the configuration options that are used when building the +# hostapd binary. All lines starting with # are ignored. Configuration option +# lines must be commented out complete, if they are not to be included, i.e., +# just setting VARIABLE=n is not disabling that variable. +# +# This file is included in Makefile, so variables like CFLAGS and LIBS can also +# be modified from here. In most cass, these lines should use += in order not +# to override previous values of the variables. + +CFLAGS = $(TARGET_CFLAGS) -I../hostapd -I../utils -I../driver/modules -Wall -MMD +LIBS = $(TARGET_LDFLAGS) + +# Driver interface for Host AP driver +CONFIG_DRIVER_HOSTAP=y + +# Driver interface for Agere driver +#CONFIG_DRIVER_HERMES=n + +# Driver interface for madwifi driver +#CONFIG_DRIVER_MADWIFI=y + +# Driver interface for Prism54 driver +#CONFIG_DRIVER_PRISM54=y + +# Driver interface for ndiswrapper +#CONFIG_DRIVER_NDISWRAPPER=y + +# Driver interface for Atmel driver +#CONFIG_DRIVER_ATMEL=y + +# Driver interface for Broadcom driver +#CONFIG_DRIVER_BROADCOM=y + +# Driver interface for Intel ipw2100 driver +#CONFIG_DRIVER_IPW2100=y + +# Driver interface for generic Linux wireless extensions +CONFIG_DRIVER_WEXT=y + +# Driver interface for FreeBSD net80211 layer (e.g., Atheros driver) +#CONFIG_DRIVER_BSD=y +#CFLAGS += -I/usr/local/include +#LIBS += -L/usr/local/lib + +# Driver interface for development testing +#CONFIG_DRIVER_TEST=y + +# Driver interface for wired Ethernet drivers +CONFIG_DRIVER_WIRED=y + +# Enable IEEE 802.1X Supplicant (automatically included if any EAP method is +# included) +CONFIG_IEEE8021X_EAPOL=y + +# EAP-MD5 (automatically included if EAP-TTLS is enabled) +CONFIG_EAP_MD5=y + +# EAP-MSCHAPv2 (automatically included if EAP-PEAP is enabled) +CONFIG_EAP_MSCHAPV2=y + +# EAP-TLS +CONFIG_EAP_TLS=y + +# EAL-PEAP +CONFIG_EAP_PEAP=y + +# EAP-TTLS +CONFIG_EAP_TTLS=y + +# EAP-GTC +CONFIG_EAP_GTC=y + +# EAP-OTP +CONFIG_EAP_OTP=y + +# EAP-SIM (enable CONFIG_PCSC, if EAP-SIM is used) +#CONFIG_EAP_SIM=y + +# EAP-PSK (experimental; this is _not_ needed for WPA-PSK) +#CONFIG_EAP_PSK=y + +# EAP-PAX +#CONFIG_EAP_PAX=y + +# LEAP +CONFIG_EAP_LEAP=y + +# EAP-AKA (enable CONFIG_PCSC, if EAP-AKA is used) +#CONFIG_EAP_AKA=y + +# PKCS#12 (PFX) support (used to read private key and certificate file from +# a file that usually has extension .p12 or .pfx) +CONFIG_PKCS12=y + +# Smartcard support (i.e., private key on a smartcard), e.g., with openssl +# engine. +CONFIG_SMARTCARD=y + +# PC/SC interface for smartcards (USIM, GSM SIM) +# Enable this if EAP-SIM or EAP-AKA is included +#CONFIG_PCSC=y + +# Development testing +#CONFIG_EAPOL_TEST=y + +# Replace native Linux implementation of packet sockets with libdnet/libpcap. +# This will be automatically set for non-Linux OS. +#CONFIG_DNET_PCAP=y + +# Include control interface for external programs, e.g, wpa_cli +CONFIG_CTRL_IFACE=y + +# Include support for GNU Readline and History Libraries in wpa_cli. +# When building a wpa_cli binary for distribution, please note that these +# libraries are licensed under GPL and as such, BSD license may not apply for +# the resulting binary. +#CONFIG_READLINE=y + +# Remove debugging code that is printing out debug message to stdout. +# This can be used to reduce the size of the wpa_supplicant considerably +# if debugging code is not needed. The size reduction can be around 35% +# (e.g., 90 kB). +#CONFIG_NO_STDOUT_DEBUG=y + +# Remove WPA support, e.g., for wired-only IEEE 802.1X supplicant, to save +# 35-50 kB in code size. +#CONFIG_NO_WPA=y + +# Select configuration backend: +# file = text file (e.g., wpa_supplicant.conf) +# winreg = Windows registry (see win_example.reg for an example) +CONFIG_BACKEND=file + +# Select program entry point implementation: +# main = UNIX/POSIX like main() function (default) +# main_winsvc = Windows service (read parameters from registry) +# main_none = Very basic example (development use only) +#CONFIG_MAIN=main + +# Select wrapper for operatins system and C library specific functions +# unix = UNIX/POSIX like systems (default) +# win32 = Windows systems +# none = Empty template +#CONFIG_OS=unix + +# Select event loop implementation +# eloop = select() loop (default) +# eloop_win = Windows events and WaitForMultipleObject() loop +# eloop_none = Empty template +#CONFIG_ELOOP=eloop + +# Select layer 2 packet implementation +# linux = Linux packet socket (default) +# pcap = libpcap/libdnet/WinPcap +# freebsd = FreeBSD libpcap +# winpcap = WinPcap with receive thread +# none = Empty template +#CONFIG_L2_PACKET=linux + +# IEEE 802.11i/IEEE 802.11e STAKey negotiation for direct link connection +#CONFIG_STAKEY=y + +# Select TLS implementation +# openssl = OpenSSL (default) +# gnutls = GnuTLS (needed for TLS/IA, see also CONFIG_GNUTLS_EXTRA) +# none = Empty template +CONFIG_TLS=gnutls + +# Whether to enable TLS/IA support, which is required for EAP-TTLSv1. +# You need CONFIG_TLS=gnutls for this to have any effect. Please note that +# even though the core GnuTLS library is released under LGPL, this extra +# library uses GPL and as such, the terms of GPL apply to the combination +# of wpa_supplicant and GnuTLS if this option is enabled. BSD license may not +# apply for distribution of the resulting binary. +CONFIG_GNUTLS_EXTRA=y + diff --git a/openembedded/packages/wpa-supplicant/files/slugos/defaults-sane b/openembedded/packages/wpa-supplicant/files/slugos/defaults-sane new file mode 100644 index 0000000000..df4268b3a6 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/files/slugos/defaults-sane @@ -0,0 +1,8 @@ +# Useful flags: +# -i <ifname> Interface (required, unless specified in config) +# -D <driver> Wireless Driver +# -d Debugging (-dd for more) +# -q Quiet (-qq for more) + +CONFIG="/etc/wpa_supplicant.conf" +OPTIONS="-i ath0 -D madwifi" diff --git a/openembedded/packages/wpa-supplicant/files/wpa_supplicant.conf-sane b/openembedded/packages/wpa-supplicant/files/wpa_supplicant.conf-sane new file mode 100644 index 0000000000..c91ffe0c84 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/files/wpa_supplicant.conf-sane @@ -0,0 +1,7 @@ +ctrl_interface=/var/run/wpa_supplicant +ctrl_interface_group=0 +update_config=1 + +network={ + key_mgmt=NONE +} diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/defconfig b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/defconfig new file mode 100644 index 0000000000..0e45d01b88 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/defconfig @@ -0,0 +1,160 @@ +# This file lists the configuration options that are used when building the +# hostapd binary. All lines starting with # are ignored. Configuration option +# lines must be commented out complete, if they are not to be included, i.e., +# just setting VARIABLE=n is not disabling that variable. +# +# This file is included in Makefile, so variables like CFLAGS and LIBS can also +# be modified from here. In most cass, these lines should use += in order not +# to override previous values of the variables. + +CFLAGS = $(TARGET_CFLAGS) -I../hostapd -I../utils -I../driver/modules -Wall -MMD + +# for wpa_supplicant, wpa_cli +LIBS = $(TARGET_LDFLAGS) + +# for wpa_passphrase: +LIBS_p = $(TARGET_LDFLAGS) + + +# Uncomment following two lines and fix the paths if you have installed openssl +# in non-default location +#CFLAGS += -I/usr/local/openssl/include +#LIBS += -L/usr/local/openssl/lib + +# Example configuration for various cross-compilation platforms + +#### sveasoft (e.g., for Linksys WRT54G) ###################################### +#CC=mipsel-uclibc-gcc +#CC=/opt/brcm/hndtools-mipsel-uclibc/bin/mipsel-uclibc-gcc +#CFLAGS += -Os +#CPPFLAGS += -I../src/include -I../../src/router/openssl/include +#LIBS += -L/opt/brcm/hndtools-mipsel-uclibc-0.9.19/lib -lssl +############################################################################### + +#### openwrt (e.g., for Linksys WRT54G) ####################################### +#CC=mipsel-uclibc-gcc +#CC=/opt/brcm/hndtools-mipsel-uclibc/bin/mipsel-uclibc-gcc +#CFLAGS += -Os +#CPPFLAGS=-I../src/include -I../openssl-0.9.7d/include \ +# -I../WRT54GS/release/src/include +#LIBS = -lssl +############################################################################### + + +# Driver interface for Host AP driver +#CONFIG_DRIVER_HOSTAP=y + +# Driver interface for Agere driver +#CONFIG_DRIVER_HERMES=y + +# Driver interface for madwifi driver +#CONFIG_DRIVER_MADWIFI=y +# Change include directories to match with the local setup +#CFLAGS += -I../madwifi/wpa + +# Driver interface for Prism54 driver +#CONFIG_DRIVER_PRISM54=y + +# Driver interface for ndiswrapper +#CONFIG_DRIVER_NDISWRAPPER=y + +# Driver interface for Atmel driver +#CONFIG_DRIVER_ATMEL=y + +# Driver interface for Broadcom driver +#CONFIG_DRIVER_BROADCOM=y +# Example path for wlioctl.h; change to match your configuration +#CFLAGS += -I/opt/WRT54GS/release/src/include + +# Driver interface for Intel ipw2100 driver +#CONFIG_DRIVER_IPW2100=y + +# Driver interface for the Zydas zd1211 driver +CONFIG_DRIVER_ZD1211=y + +# Driver interface for generic Linux wireless extensions +CONFIG_DRIVER_WEXT=y + +# Driver interface for FreeBSD net80211 layer (e.g., Atheros driver) +#CONFIG_DRIVER_BSD=y +#CFLAGS += -I/usr/local/include +#LIBS += -L/usr/local/lib + +# Driver interface for Windows NDIS +#CONFIG_DRIVER_NDIS=y +#CFLAGS += -I/usr/include/w32api/ddk +#LIBS += -L/usr/local/lib +# For native build using mingw +#CONFIG_NATIVE_WINDOWS=y +# Additional directories for cross-compilation on Linux host for mingw target +#CFLAGS += -I/opt/mingw/mingw32/include/ddk +#LIBS += -L/opt/mingw/mingw32/lib +#CC=mingw32-gcc + +# Driver interface for development testing +#CONFIG_DRIVER_TEST=y + +# Enable IEEE 802.1X Supplicant (automatically included if any EAP method is +# included) +CONFIG_IEEE8021X_EAPOL=y + +# EAP-MD5 (automatically included if EAP-TTLS is enabled) +CONFIG_EAP_MD5=y + +# EAP-MSCHAPv2 (automatically included if EAP-PEAP is enabled) +CONFIG_EAP_MSCHAPV2=y + +# EAP-TLS +CONFIG_EAP_TLS=y + +# EAL-PEAP +CONFIG_EAP_PEAP=y + +# EAP-TTLS +CONFIG_EAP_TTLS=y + +# EAP-GTC +CONFIG_EAP_GTC=y + +# EAP-OTP +CONFIG_EAP_OTP=y + +# EAP-SIM (enable CONFIG_PCSC, if EAP-SIM is used) +#CONFIG_EAP_SIM=y + +# EAP-PSK (experimental; this is _not_ needed for WPA-PSK) +#CONFIG_EAP_PSK=y + +# LEAP +CONFIG_EAP_LEAP=y + +# EAP-AKA (enable CONFIG_PCSC, if EAP-AKA is used) +#CONFIG_EAP_AKA=y + +# PKCS#12 (PFX) support (used to read private key and certificate file from +# a file that usually has extension .p12 or .pfx) +CONFIG_PKCS12=y + +# PC/SC interface for smartcards (USIM, GSM SIM) +# Enable this if EAP-SIM or EAP-AKA is included +#CONFIG_PCSC=y + +# Development testing +#CONFIG_EAPOL_TEST=y + +# Replace native Linux implementation of packet sockets with libdnet/libpcap. +# This will be automatically set for non-Linux OS. +#CONFIG_DNET_PCAP=y + +# Include control interface for external programs, e.g, wpa_cli +CONFIG_CTRL_IFACE=y + +# Include interface for using external supplicant (Xsupplicant) for EAP +# authentication +#CONFIG_XSUPPLICANT_IFACE=y + +# Include support for GNU Readline and History Libraries in wpa_cli. +# When building a wpa_cli binary for distribution, please note that these +# libraries are licensed under GPL and as such, BSD license may not apply for +# the resulting binary. +#CONFIG_READLINE=y diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-hermes.patch b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-hermes.patch new file mode 100644 index 0000000000..4044835e1c --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-hermes.patch @@ -0,0 +1,884 @@ +--- /dev/null ++++ wpa_supplicant-0.4.7/driver_hermes.c +@@ -0,0 +1,705 @@ ++/* ++ * WPA Supplicant - testing driver interface ++ * Copyright (c) 2004-2005, Jouni Malinen <jkmaline@cc.hut.fi> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ */ ++ ++#include <stdlib.h> ++#include <stdio.h> ++#include <unistd.h> ++#include <string.h> ++#include <sys/ioctl.h> ++#include <errno.h> ++#include <net/if_arp.h> ++ ++#include "wireless_copy.h" ++#include "common.h" ++#include "driver.h" ++ ++#include "eloop.h" ++#include "wpa_supplicant.h" ++#include "priv_netlink.h" ++ ++#include "hostap_common.h" ++#include "driver_wext.h" ++#include "driver_hermes.h" ++ ++ ++ ++/* Enumeration for supported Hermes Types */ ++enum ++{ ++ WL_HERMES_UNKNOWN = 0, ++ WL_HERMES_1 = 1, ++ WL_HERMES_2 = 2, ++ WL_HERMES_25 = 3 ++}; ++ ++ ++ ++ ++struct wpa_driver_hermes_data { ++ void *wext; /* private data for driver_wext */ ++ void *ctx; ++ char ifname[IFNAMSIZ + 1]; ++ int sock; ++ int type; ++}; ++ ++ ++ ++/****************************************************************************/ ++/* */ ++/* Routines for basic device access to Agere Hermes-I/Hermes-II via the UIL */ ++/* */ ++/****************************************************************************/ ++ ++IFBP _connect(void *priv) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ int result = 0; ++ IFBP ifbp = NULL; ++ struct uilreq urq; ++ ++ //wpa_printf(MSG_DEBUG, "%s: %s %d", __FUNCTION__, drv->ifname, drv->sock); ++ ++ memset(&urq, 0, sizeof(urq)); ++ ++ strcpy(urq.ifr_name, drv->ifname); ++ urq.command = UIL_FUN_CONNECT; ++ ++ result = ioctl(drv->sock, WVLAN2_IOCTL_UIL, &urq); ++ if (result == 0 && urq.result == UIL_SUCCESS) { ++ ifbp = urq.hcfCtx; ++ } else { ++ wpa_printf(MSG_DEBUG, "%s: could not set IFBP, result %d", __FUNCTION__, result); ++ } ++ ++ return ifbp; ++} ++ ++ ++void _disconnect(void *priv, IFBP ifbp) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ int result = 0; ++ struct uilreq urq; ++ ++ //wpa_printf(MSG_DEBUG, "%s: %s", __FUNCTION__, drv->ifname); ++ ++ if (ifbp != NULL) { ++ memset(&urq, 0, sizeof(struct uilreq)); ++ ++ strcpy(urq.ifr_name, drv->ifname); ++ urq.command = UIL_FUN_DISCONNECT; ++ urq.hcfCtx = ifbp; ++ ++ result = ioctl(drv->sock, WVLAN2_IOCTL_UIL, &urq); ++ ++ if (result != 0 || urq.result != UIL_SUCCESS) { ++ wpa_printf( MSG_WARNING, "wl_disconnect(): ioctl() failed, errno: %d", errno ); ++ wpa_printf( MSG_WARNING, "wl_disconnect(): urq.result: %d", urq.result ); ++ } ++ } else { ++ wpa_printf(MSG_WARNING, "wl_disconnect(): called with NULL ifbp"); ++ } ++ ++ return; ++} ++ ++int _get_info(void *priv, ltv_t *ltv) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ int result = 0; ++ IFBP ifbp = NULL; ++ struct uilreq urq; ++ ++ //wpa_printf(MSG_DEBUG, "%s: %s", __FUNCTION__, drv->ifname); ++ ++ /* First, connect to the device */ ++ ifbp = _connect(priv); ++ if (ifbp != NULL && ltv != NULL) { ++ memset(&urq, 0, sizeof(struct uilreq)); ++ ++ strcpy(urq.ifr_name, drv->ifname); ++ urq.hcfCtx = ifbp; ++ urq.command = UIL_FUN_GET_INFO; ++ urq.len = sizeof(ltv_t); ++ urq.data = ltv; ++ ++ result = ioctl(drv->sock, WVLAN2_IOCTL_UIL, &urq); ++ ++ if (result != 0 || urq.result != UIL_SUCCESS) { ++ wpa_printf(MSG_WARNING, "wl_disconnect(): ioctl() failed, errno: %d", errno); ++ wpa_printf(MSG_WARNING, "wl_disconnect(): urq.result: %d", urq.result); ++ } ++ _disconnect(priv, ifbp); ++ } else { ++ wpa_printf( MSG_WARNING, "Could not connect to the device, or LTV NULL"); ++ result = -1; ++ } ++ ++ return result; ++} ++ ++int _put_info(void *priv, ltv_t *ltv) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ int result = 0; ++ IFBP ifbp = NULL; ++ struct uilreq urq; ++ ++ //wpa_printf(MSG_DEBUG, "%s: %s", __FUNCTION__, drv->ifname); ++ ++ /* First, connect to the device */ ++ ifbp = _connect(priv); ++ if (ifbp != NULL && ltv != NULL) { ++ memset(&urq, 0, sizeof(struct uilreq)); ++ ++ strcpy(urq.ifr_name, drv->ifname); ++ urq.hcfCtx = ifbp; ++ urq.command = UIL_FUN_PUT_INFO; ++ urq.len = sizeof( ltv_t ); ++ urq.data = ltv; ++ ++ result = ioctl(drv->sock, WVLAN2_IOCTL_UIL, &urq); ++ ++ if (result != 0 || urq.result != UIL_SUCCESS) { ++ wpa_printf(MSG_WARNING, "_put_info(): ioctl() failed, errno: %d", errno); ++ wpa_printf(MSG_WARNING, "_put_info(): urq.result: %d", urq.result); ++ } ++ ++ _disconnect(priv, ifbp); ++ } else { ++ wpa_printf(MSG_WARNING, "%s: could not connect to the device, or LTV NULL", __FUNCTION__ ); ++ result = -1; ++ } ++ ++ return result; ++} ++ ++ ++static void _detect_hermes_type(void *priv) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ CFG_FW_IDENTITY_STRCT *fw_id; ++ ltv_t ltv; ++ int result; ++ ++ //wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ drv->type = WL_HERMES_UNKNOWN; ++ ++ if (drv->sock >= 0) { ++ fw_id = (CFG_FW_IDENTITY_STRCT *)<v; ++ fw_id->len = ( sizeof(CFG_FW_IDENTITY_STRCT) / sizeof( hcf_16 )) - 1; ++ fw_id->typ = CFG_FW_IDENTITY; ++ ++ result = _get_info(priv, (ltv_t *)fw_id); ++ if (result == HCF_SUCCESS) { ++ //wpa_printf(MSG_DEBUG, "PRI CompID : %d", fw_id->comp_id); ++ //wpa_printf(MSG_DEBUG, "PRI Variant : %d", fw_id->variant); ++ //wpa_printf(MSG_DEBUG, "PRI Version : %d.%02d", fw_id->version_major, fw_id->version_minor); ++ ++ switch(fw_id->comp_id) { ++ case COMP_ID_FW_STA: ++ switch (fw_id->variant) { ++ case 1: ++ case 2: ++ wpa_printf(MSG_DEBUG, "found Hermes 1 STA"); ++ drv->type = WL_HERMES_1; ++ break; ++ ++ case 3: ++ wpa_printf(MSG_DEBUG, "found Hermes 2 STA"); ++ drv->type = WL_HERMES_2; ++ break; ++ case 4: ++ wpa_printf(MSG_DEBUG, "found Hermes 2.5 STA"); ++ drv->type = WL_HERMES_25; ++ break; ++ } ++ break; ++ ++ case COMP_ID_FW_AP: ++ switch (fw_id->variant) { ++ case 1: ++ wpa_printf(MSG_DEBUG, "found Hermes 1 AP"); ++ drv->type = WL_HERMES_1; ++ break; ++ ++ case 2: ++ wpa_printf(MSG_DEBUG, "found Hermes 2 AP" ); ++ drv->type = WL_HERMES_2; ++ break; ++ } ++ break; ++ ++ default: ++ wpa_printf(MSG_WARNING, "could not detect Hermes type!"); ++ break; ++ } ++ } ++ } ++} ++ ++ ++ ++/****************************************************************************/ ++ ++ ++static int wpa_driver_hermes_set_wpa_ie(void *priv, const char *wpa_ie, ++ size_t wpa_ie_len) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ ltv_t ltv; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ ltv.len = 2; ++ ltv.typ = CFG_SET_WPA_AUTH_KEY_MGMT_SUITE; ++ ++ switch(drv->type) { ++ case WL_HERMES_1: ++ ltv.u.u16[0] = 2; ++ break; ++ ++ case WL_HERMES_2: ++ case WL_HERMES_25: ++ ltv.u.u16[0] = 4; ++ break; ++ ++ default: ++ ltv.u.u16[0] = 0; ++ break; ++ } ++ ++ return _put_info(priv, <v); ++} ++ ++ ++static int wpa_driver_hermes_set_wpa(void *priv, int enabled) ++{ ++ ltv_t ltv; ++ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); ++ ++ ltv.len = 2; ++ ltv.typ = CFG_CNF_ENCRYPTION; ++ ltv.u.u16[0] = enabled ? 2 : 0; /* Setting CFG_CNF_ENCRYPTION to 2 sets WPA: TKIP or better */ ++ ++ return _put_info(priv, <v); ++} ++ ++ ++static int wpa_driver_hermes_set_key(void *priv, wpa_alg alg, ++ const u8 *addr, int key_idx, ++ int set_tx, const u8 *seq, size_t seq_len, ++ const u8 *key, size_t key_len) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ int ret = 0; ++ char *alg_name; ++ ltv_t ltv; ++ int count = 0; ++ int buf_idx = 0; ++ hcf_8 tsc[] = { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00 }; ++ hcf_8 rsc[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; ++ ++ ++ switch (alg) { ++ case WPA_ALG_NONE: ++ alg_name = "none"; ++ break; ++ case WPA_ALG_WEP: ++ alg_name = "WEP"; ++ break; ++ case WPA_ALG_TKIP: ++ alg_name = "TKIP"; ++ break; ++ case WPA_ALG_CCMP: ++ alg_name = "CCMP"; ++ break; ++ default: ++ return -1; ++ } ++ ++ wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%d " ++ "key_len=%d", __FUNCTION__, alg_name, key_idx, set_tx, ++ seq_len, key_len); ++ ++ if (seq_len > IW_ENCODE_SEQ_MAX_SIZE) { ++ wpa_printf(MSG_DEBUG, "%s: Invalid seq_len %lu", __FUNCTION__, (unsigned long) seq_len); ++ return -2; ++ } ++ ++ /* Check the key index here; if 0, load as Pairwise Key, otherwise, load as ++ a group key. Note that for the Hermes, the RIDs for group/pairwise keys ++ are different from each other and different than the default WEP keys as ++ well. */ ++ switch (alg) { ++ case WPA_ALG_TKIP: ++ /* Make sure that there is no data queued up in the firmware before ++ setting the TKIP keys. If this check is not performed, some data ++ may be sent out with incorrect MIC and cause synchronizarion ++ errors with the AP */ ++ /* Check every 1ms for 100ms */ ++ for (count = 0; count < 100; count++) { ++ usleep(1000); ++ ++ ltv.len = 2; ++ ltv.typ = 0xFD91; // This RID not defined in HCF yet!!! ++ ltv.u.u16[0] = 0; ++ ++ _get_info( priv, <v); ++ ++ if (ltv.u.u16[0] == 0) ++ break; ++ } ++ ++ if (count == 100) ++ wpa_printf(MSG_DEBUG, "%s: Timed out waiting for TxQ!", __FUNCTION__); ++ ++ ++ switch (key_idx) { ++ case 0: ++ /* Only load key as pairwise key for Hermes-II and II.5. For Hermes-I, ++ fall through to the next case and load the pairwise key as ++ a Group Key at index 0. */ ++ if (drv->type == WL_HERMES_2 || drv->type == WL_HERMES_25) { ++ ltv.len = 28; ++ ltv.typ = CFG_ADD_TKIP_MAPPED_KEY; ++ ++ /* Load the BSSID */ ++ memcpy(<v.u.u8[buf_idx], addr, ETH_ALEN); ++ buf_idx += ETH_ALEN; ++ ++ /* Load the TKIP key */ ++ memcpy(<v.u.u8[buf_idx], &key[0], 16); ++ buf_idx += 16; ++ ++ /* Load the TSC */ ++ memcpy(<v.u.u8[buf_idx], tsc, 8); ++ buf_idx += 8; ++ ++ /* Load the RSC */ ++ /* Copy the RSC from the supplicant to a local buffer, because ++ the RSC doesn't always contain the padding needed */ ++ memcpy(rsc, seq, seq_len); ++ memcpy(<v.u.u8[buf_idx], rsc, 8); ++ buf_idx += 8; ++ ++ /* Load the TxMIC key */ ++ memcpy(<v.u.u8[buf_idx], &key[16], 8); ++ buf_idx += 8; ++ ++ /* Load the RxMIC key */ ++ memcpy(<v.u.u8[buf_idx], &key[24], 8); ++ ++ /* Send the request to the Hermes */ ++ _put_info(priv, <v); ++ break; ++ } ++ ++ case 1: ++ case 2: ++ case 3: ++ ltv.len = 26; ++ ltv.typ = CFG_ADD_TKIP_DEFAULT_KEY; ++ ++ /* Load the key Index */ ++ ltv.u.u16[buf_idx] = key_idx; ++ ++ /* If this is a Tx Key, set bit 8000 */ ++ if (set_tx) ++ ltv.u.u16[buf_idx] |= 0x8000; ++ ++ buf_idx += 2; ++ ++ /* Load the RSC */ ++ /* Copy the RSC from the supplicant to a local buffer, because ++ the RSC doesn't always contain the padding needed */ ++ memcpy(rsc, seq, seq_len); ++ memcpy(<v.u.u8[buf_idx], rsc, 8); ++ buf_idx += 8; ++ ++ /* Load the TKIP, TxMIC, and RxMIC keys in one shot, because in ++ CFG_ADD_TKIP_DEFAULT_KEY they are back-to-back */ ++ memcpy(<v.u.u8[buf_idx], key, key_len); ++ buf_idx += key_len; ++ ++ /* Load the TSC */ ++ memcpy(<v.u.u8[buf_idx], tsc, 8); ++ ++ /* Send the request to the Hermes */ ++ _put_info(priv, <v); ++ break; ++ ++ default: ++ break; ++ } ++ ++ break; ++ ++ case WPA_ALG_WEP: ++ case WPA_ALG_CCMP: ++ break; ++ ++ case WPA_ALG_NONE: ++ switch (key_idx) { ++ case 0: ++ if (drv->type == WL_HERMES_2 || drv->type == WL_HERMES_25) { ++ /* Only clear a pairwise key for Hermes-II. For Hermes-I, ++ fall through to the next case and clear the key as a ++ Group Key at index 0. */ ++ if (addr) { ++ ltv.len = 7; ++ ltv.typ = CFG_REMOVE_TKIP_MAPPED_KEY; ++ ++ memcpy(<v.u.u8[0], addr, ETH_ALEN); ++ ++ _put_info(priv, <v); ++ } ++ break; ++ } ++ ++ case 1: ++ case 2: ++ case 3: ++ /* Clear the Group TKIP keys by index */ ++ ltv.len = 2; ++ ltv.typ = CFG_REMOVE_TKIP_DEFAULT_KEY; ++ ++ ltv.u.u16[0] = key_idx; ++ ++ _put_info(priv, <v); ++ break; ++ ++ default: ++ break; ++ } ++ break; ++ ++ default: ++ break; ++ } ++ ++ return ret; ++} ++ ++ ++static int wpa_driver_hermes_set_countermeasures(void *priv, int enabled) ++{ ++ ltv_t ltv; ++ ++ /* The supplicant handles all the timers related to MIC failure and ++ countermeasures. When countermeasures are enabled, shut down the card; ++ when disable, re-enable the card. Make sure that the EAPOL message ++ is getting out before card disable */ ++ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ ++ ltv.len = 2; ++ ltv.typ = CFG_DRIVER_ENABLE; ++ ltv.u.u16[0] = enabled ? 0 : 1; ++ ++ return _put_info(priv, <v); ++} ++ ++ ++static int wpa_driver_hermes_set_drop_unencrypted(void *priv, int enabled) ++{ ++ ltv_t ltv; ++ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ ++ ltv.len = 2; ++ ltv.typ = CFG_CNF_EXCL_UNENCRYPTED; ++ ltv.u.u16[0] = enabled; ++ ++ return _put_info(priv, <v); ++} ++ ++ ++static int wpa_driver_hermes_deauthenticate(void *priv, const u8 *addr, ++ int reason_code) ++{ ++ wpa_printf(MSG_DEBUG, "%s: *DUMMY* %d", __FUNCTION__, reason_code); ++ ++ return 0; ++} ++ ++ ++static int wpa_driver_hermes_disassociate(void *priv, const u8 *addr, int reason_code) ++{ ++ ltv_t ltv; ++ ++ wpa_printf(MSG_DEBUG, "%s: reason=%d", __FUNCTION__, reason_code); ++ ++ ltv.len = 2; ++ ltv.typ = 0xFCC8; // This RID not defined in HCF yet!!! ++ memcpy( <v.u.u8[0], addr, ETH_ALEN ); ++ ltv.u.u16[ETH_ALEN / 2] = reason_code; ++ ++ return _put_info( priv, <v); ++} ++ ++ ++static int wpa_driver_hermes_associate( ++ void *priv, struct wpa_driver_associate_params *params) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ ++#if 0 ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++#else ++ wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d " ++ "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d", ++ __func__, priv, params->freq, params->pairwise_suite, ++ params->group_suite, params->key_mgmt_suite, ++ params->auth_alg, params->mode); ++ if (params->bssid) { ++ wpa_printf(MSG_DEBUG, " bssid=" MACSTR, ++ MAC2STR(params->bssid)); ++ } ++ if (params->ssid) { ++ wpa_hexdump_ascii(MSG_DEBUG, " ssid", ++ params->ssid, params->ssid_len); ++ } ++ if (params->wpa_ie) { ++ wpa_hexdump(MSG_DEBUG, " wpa_ie", ++ params->wpa_ie, params->wpa_ie_len); ++ } ++#endif ++ ++ if (wpa_driver_hermes_set_wpa_ie(priv, params->wpa_ie, params->wpa_ie_len) < 0) ++ return -1; ++ if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0) ++ return -1; ++ if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len) < 0) ++ return -1; ++#ifdef UNSUPPORTED_IN_HERMES_DRIVER ++ if (wpa_driver_wext_hermes_bssid(drv->wext, params->bssid) < 0) ++ return -1; ++#endif ++ ++ return 0; ++} ++ ++ ++static int wpa_driver_hermes_get_bssid(void *priv, u8 *bssid) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ return wpa_driver_wext_get_bssid(drv->wext, bssid); ++} ++ ++ ++static int wpa_driver_hermes_get_ssid(void *priv, u8 *ssid) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ return wpa_driver_wext_get_ssid(drv->wext, ssid); ++} ++ ++ ++static int wpa_driver_hermes_scan(void *priv, const u8 *ssid, size_t ssid_len) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ return wpa_driver_wext_scan(drv->wext, ssid, ssid_len); ++} ++ ++ ++static int wpa_driver_hermes_get_scan_results(void *priv, ++ struct wpa_scan_result *results, ++ size_t max_size) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ return wpa_driver_wext_get_scan_results(drv->wext, results, max_size); ++} ++ ++ ++static void * wpa_driver_hermes_init(void *ctx, const char *ifname) ++{ ++ struct wpa_driver_hermes_data *drv; ++ ++ wpa_printf(MSG_DEBUG, "%s: %s", __FUNCTION__, ifname); ++ ++ drv = malloc(sizeof(*drv)); ++ if (drv == NULL) ++ return NULL; ++ memset(drv, 0, sizeof(*drv)); ++ ++ /* Initialize wireless context */ ++ drv->wext = wpa_driver_wext_init(ctx, ifname); ++ if (drv->wext == NULL) { ++ perror("no wext context"); ++ goto no_wext; ++ } ++ ++ drv->ctx = ctx; ++ strncpy(drv->ifname, ifname, sizeof(drv->ifname)); ++ ++ drv->sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (drv->sock < 0) { ++ perror("socket(PF_INET,SOCK_DGRAM)"); ++ goto no_sock; ++ } ++ ++ _detect_hermes_type(drv); ++ ++ return drv; ++ ++no_sock: ++ wpa_driver_wext_deinit(drv->wext); ++no_wext: ++ free(drv); ++ return NULL; ++} ++ ++ ++static void wpa_driver_hermes_deinit(void *priv) ++{ ++ struct wpa_driver_hermes_data *drv = priv; ++ wpa_driver_wext_deinit(drv->wext); ++ close(drv->sock); ++ free(drv); ++} ++ ++ ++ ++ ++struct wpa_driver_ops wpa_driver_hermes_ops = { ++ .name = "hermes", ++ .desc = "wpa_supplicant hermes driver", ++ ++ .init = wpa_driver_hermes_init, ++ .deinit = wpa_driver_hermes_deinit, ++ ++ // from old driver_hermes.c: ++ .get_bssid = wpa_driver_hermes_get_bssid, ++ .get_ssid = wpa_driver_hermes_get_ssid, ++ .set_wpa = wpa_driver_hermes_set_wpa, ++ .set_key = wpa_driver_hermes_set_key, ++ //.events_init = wpa_driver_wext_events_init, ++ //.events_deinit = wpa_driver_wext_events_deinit, ++ .set_countermeasures = wpa_driver_hermes_set_countermeasures, ++ .set_drop_unencrypted = wpa_driver_hermes_set_drop_unencrypted, ++ .scan = wpa_driver_hermes_scan, ++ .get_scan_results = wpa_driver_hermes_get_scan_results, ++ .deauthenticate = wpa_driver_hermes_deauthenticate, ++ .disassociate = wpa_driver_hermes_disassociate, ++ .associate = wpa_driver_hermes_associate, ++ ++ ++#if 0 ++ /* Not possible with current Hermes driver: ++ .set_auth_alg = wpa_driver_hermes_set_auth_alg, */ ++#endif ++}; +--- /dev/null ++++ wpa_supplicant-0.4.7/driver_hermes.h +@@ -0,0 +1,173 @@ ++#ifndef HERMES_DRIVER_H ++#define HERMES_DRIVER_H ++ ++typedef unsigned char hcf_8; ++typedef unsigned short hcf_16; ++typedef unsigned long hcf_32; ++typedef hcf_16 hcf_io; ++typedef hcf_8 *wci_bufp; ++ ++typedef struct { ++ hcf_16 len; ++ hcf_16 typ; ++ unsigned short * bufp; ++} RID_LOG_STRCT; ++typedef RID_LOG_STRCT *RID_LOGP; ++ ++typedef struct { ++ hcf_16 len; ++ hcf_16 typ; ++ hcf_16 comp_id; ++ hcf_16 variant; ++ hcf_16 version_major; ++ hcf_16 version_minor; ++} CFG_FW_IDENTITY_STRCT; ++ ++typedef struct { ++ hcf_32 TxUnicastFrames; ++ hcf_32 TxMulticastFrames; ++ hcf_32 TxFragments; ++ hcf_32 TxUnicastOctets; ++ hcf_32 TxMulticastOctets; ++ hcf_32 TxDeferredTransmissions; ++ hcf_32 TxSingleRetryFrames; ++ hcf_32 TxMultipleRetryFrames; ++ hcf_32 TxRetryLimitExceeded; ++ hcf_32 TxDiscards; ++ hcf_32 RxUnicastFrames; ++ hcf_32 RxMulticastFrames; ++ hcf_32 RxFragments; ++ hcf_32 RxUnicastOctets; ++ hcf_32 RxMulticastOctets; ++ hcf_32 RxFCSErrors; ++ hcf_32 RxDiscardsNoBuffer; ++ hcf_32 TxDiscardsWrongSA; ++ hcf_32 RxWEPUndecryptable; ++ hcf_32 RxMsgInMsgFragments; ++ hcf_32 RxMsgInBadMsgFragments; ++ hcf_32 RxDiscardsWEPICVError; ++ hcf_32 RxDiscardsWEPExcluded; ++} CFG_HERMES_TALLIES_STRCT; ++ ++typedef struct { ++ hcf_32 not_used_NoBufInq; ++ hcf_32 NoBufInfo; ++ hcf_32 NoBufMB; ++ hcf_32 MiscErr; ++ hcf_32 EngCnt; ++} CFG_HCF_TALLIES_STRCT; ++ ++typedef struct { ++ hcf_io IFB_IOBase; ++ hcf_16 IFB_IORange; ++ ++ hcf_32 IFB_TickIni; ++ ++ hcf_16 IFB_Version; ++ hcf_16 IFB_CardStat; ++ hcf_16 IFB_TraceLvl; ++ hcf_16 *IFB_MBp; ++ hcf_16 IFB_MBSize; ++ hcf_16 IFB_MBWp; ++ hcf_16 IFB_MBRp; ++ hcf_16 IFB_MBInfoLen; ++ ++ hcf_16 IFB_DLMode; ++ hcf_16 IFB_Magic; ++ hcf_16 IFB_Cmd; ++ hcf_16 IFB_RxFID; ++ RID_LOGP IFB_RIDLogp; ++ hcf_16 IFB_Monitor; ++ hcf_16 IFB_TxFid; ++ hcf_16 IFB_RxLen; ++ hcf_16 IFB_DefunctStat; ++ ++ hcf_16 IFB_ErrCmd; ++ hcf_16 IFB_ErrQualifier; ++ hcf_16 IFB_lal; ++ wci_bufp IFB_lap; ++ hcf_16 IFB_LinkStat; ++ ++ void (*IFB_MICRxRtn)( hcf_32*, hcf_32 ); ++ void (*IFB_MICTxRtn)( hcf_32*, hcf_32 ); ++ hcf_16 IFB_rx_tlen; ++ hcf_16 IFB_tx_tlen; ++ hcf_8 IFB_rx_32[4]; ++ hcf_8 IFB_tx_32[4]; ++ hcf_16 IFB_RscInd; ++ hcf_16 IFB_MB_FID; ++ hcf_16 IFB_DLTarget[2]; ++ ++ hcf_16 IFB_DLPage; ++ hcf_16 IFB_DLOffset; ++ hcf_16 IFB_DLLen; ++ ++ hcf_16 volatile IFB_IntOffCnt; ++ hcf_16 IFB_IntEnMask; ++ ++ CFG_FW_IDENTITY_STRCT IFB_FWIdentity; ++ hcf_16 IFB_Tally; ++ hcf_16 IFB_TallyTyp; ++ ++ CFG_HERMES_TALLIES_STRCT IFB_NIC_Tallies; ++ CFG_HCF_TALLIES_STRCT IFB_HCF_Tallies; ++ ++ void *IFB_MSFSup; ++} IFB_STRCT; ++ ++typedef IFB_STRCT* IFBP; ++ ++struct uilreq ++{ ++ union ++ { ++ char ifrn_name[16]; ++ } ifr_ifrn; ++ ++ IFBP hcfCtx; ++ __u8 command; ++ __u8 result; ++ __u16 len; ++ void *data; ++}; ++ ++typedef struct ++{ ++ hcf_16 len; ++ hcf_16 typ; ++ union ++ { ++ hcf_8 u8[(512 - (sizeof(hcf_16) * 2)) / sizeof(hcf_8)]; ++ hcf_16 u16[(512 - (sizeof(hcf_16) * 2)) / sizeof(hcf_16)]; ++ hcf_32 u32[(512 - (sizeof(hcf_16) * 2)) / sizeof(hcf_32)]; ++ } u; ++} ltv_t; ++ ++ ++#define UIL_FUN_CONNECT 0x00 ++#define UIL_FUN_DISCONNECT 0x01 ++#define UIL_FUN_GET_INFO 0x04 ++#define UIL_FUN_PUT_INFO 0x05 ++ ++#define GENERIC_INFO_ELEM 0xdd ++#define RSN_INFO_ELEM 0x30 ++ ++#define CFG_DRIVER_ENABLE 0x0902 ++#define CFG_CNF_ENCRYPTION 0xFC20 ++#define CFG_ADD_TKIP_DEFAULT_KEY 0xFCB4 ++#define CFG_SET_WPA_AUTH_KEY_MGMT_SUITE 0xFCB5 ++#define CFG_REMOVE_TKIP_DEFAULT_KEY 0xFCB6 ++#define CFG_ADD_TKIP_MAPPED_KEY 0xFCB7 ++#define CFG_REMOVE_TKIP_MAPPED_KEY 0xFCB8 ++#define CFG_FW_IDENTITY 0xFD20 ++#define CFG_CNF_EXCL_UNENCRYPTED 0xFC22 ++ ++#define HCF_SUCCESS 0x00 ++#define UIL_SUCCESS 0x00 ++ ++#define COMP_ID_FW_STA 31 ++#define COMP_ID_FW_AP 32 ++ ++#define WVLAN2_IOCTL_UIL SIOCDEVPRIVATE ++ ++#endif diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-zd1211.patch b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-zd1211.patch new file mode 100644 index 0000000000..3c731c1256 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/driver-zd1211.patch @@ -0,0 +1,535 @@ +diff -Nur wpa_supplicant-0.4.7/defconfig wpa_supplicant-0.4.7.new/defconfig +--- wpa_supplicant-0.4.7/defconfig 2005-09-24 20:30:43.000000000 +0200 ++++ wpa_supplicant-0.4.7.new/defconfig 2005-12-26 19:18:14.000000000 +0100 +@@ -68,6 +68,9 @@ + # Driver interface for Intel ipw2100/2200 driver + #CONFIG_DRIVER_IPW=y + ++# Driver interface for Zydas zd1211 driver ++#CONFIG_DRIVER_ZD1211=y ++ + # Driver interface for generic Linux wireless extensions + CONFIG_DRIVER_WEXT=y + +diff -Nur wpa_supplicant-0.4.7/drivers.c wpa_supplicant-0.4.7.new/drivers.c +--- wpa_supplicant-0.4.7/drivers.c 2005-02-20 01:15:54.000000000 +0100 ++++ wpa_supplicant-0.4.7.new/drivers.c 2005-12-26 19:19:16.000000000 +0100 +@@ -55,6 +55,9 @@ + #ifdef CONFIG_DRIVER_TEST + extern struct wpa_driver_ops wpa_driver_test_ops; /* driver_test.c */ + #endif /* CONFIG_DRIVER_TEST */ ++#ifdef CONFIG_DRIVER_ZD1211 ++extern struct wpa_driver_ops wpa_driver_zd1211_ops; /* driver_zd1211.c */ ++#endif /* CONFIG_DRIVER_ZD1211 */ + + + struct wpa_driver_ops *wpa_supplicant_drivers[] = +@@ -98,5 +101,8 @@ + #ifdef CONFIG_DRIVER_TEST + &wpa_driver_test_ops, + #endif /* CONFIG_DRIVER_TEST */ ++#ifdef CONFIG_DRIVER_ZD1211 ++ &wpa_driver_zd1211_ops, ++#endif /* CONFIG_DRIVER_ZD1211 */ + NULL + }; +diff -Nur wpa_supplicant-0.4.7/driver_zd1211.c wpa_supplicant-0.4.7.new/driver_zd1211.c +--- wpa_supplicant-0.4.7/driver_zd1211.c 1970-01-01 01:00:00.000000000 +0100 ++++ wpa_supplicant-0.4.7.new/driver_zd1211.c 2005-12-27 16:28:46.000000000 +0100 +@@ -0,0 +1,408 @@ ++#include <stdlib.h> ++#include <stdio.h> ++#include <unistd.h> ++#include <string.h> ++#include <sys/ioctl.h> ++#include <errno.h> ++ ++#include "common.h" ++#include "driver.h" ++#include "driver_wext.h" ++#include "eloop.h" ++#include "wireless_copy.h" ++#include "wpa_supplicant.h" ++ ++#include "zd1211_common.h" ++ ++ ++struct wpa_driver_zd1211_data { ++ void *ctx; ++ void *wext; /* private data for driver_wext */ ++ char ifname[IFNAMSIZ + 1]; ++ int sock; ++}; ++ ++ ++static int zd1211_ioctl(struct wpa_driver_zd1211_data *zd1211_drv, struct zd1211_wlan_param *param, int len, int show_err) { ++ struct iwreq iwr; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, zd1211_drv->ifname, IFNAMSIZ); ++ iwr.u.data.pointer = (caddr_t) param; ++ iwr.u.data.length = len; ++ ++ if (ioctl(zd1211_drv->sock, ZD_IOCTL_WPA, &iwr) < 0) { ++ int ret; ++ ++ ret = errno; ++ if (show_err) ++ perror("ioctl[ZD_IOCTL_WPA]"); ++ return ret; ++ } ++ ++ return 0; ++} ++ ++ ++static int zd1211_set_param(struct wpa_driver_zd1211_data *zd1211_drv, int op, int arg, int show_err) { ++ struct iwreq iwr; ++ int *i, ret = 0; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, zd1211_drv->ifname, IFNAMSIZ); ++ i = (int *) iwr.u.name; ++ *i++ = op; ++ *i++ = arg; ++ ++ if (ioctl(zd1211_drv->sock, ZD_IOCTL_PARAM, &iwr) < 0) { ++ perror("ioctl[ZD_IOCTL_PARAM]"); ++ ret = -1; ++ } ++ ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_get_scan_results(void *priv, struct wpa_scan_result *results, size_t max_size) { ++ struct wpa_driver_zd1211_data *zd1211_drv; ++ ++ zd1211_drv = priv; ++ return wpa_driver_wext_get_scan_results(zd1211_drv->wext, results, max_size); ++} ++ ++ ++static int wpa_driver_zd1211_get_bssid(void *priv, u8 *bssid) { ++ struct wpa_driver_zd1211_data *zd1211_drv; ++ ++ zd1211_drv = priv; ++ return wpa_driver_wext_get_bssid(zd1211_drv->wext, bssid); ++} ++ ++ ++static int wpa_driver_zd1211_get_ssid(void *priv, u8 *ssid) { ++ struct wpa_driver_zd1211_data *zd1211_drv; ++ ++ zd1211_drv = priv; ++ return wpa_driver_wext_get_ssid(zd1211_drv->wext, ssid); ++} ++ ++ ++static int wpa_driver_zd1211_set_auth_alg(void *priv, int auth_alg) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ int algs = 0; ++ ++ if (auth_alg & AUTH_ALG_OPEN_SYSTEM) ++ algs = 0; ++ if (auth_alg & AUTH_ALG_SHARED_KEY) ++ algs = 1; ++ ++ return zd1211_set_param(zd1211_drv, ZD_PARAM_AUTH_ALGS, algs, 1); ++} ++ ++ ++static int wpa_driver_zd1211_set_countermeasures(void *priv, int enabled) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ ++ /* Enable the countermeasure */ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return zd1211_set_param(zd1211_drv, ZD_PARAM_COUNTERMEASURES, enabled, 1); ++} ++ ++ ++static int wpa_driver_zd1211_set_drop_unencrypted(void *priv, int enabled) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ ++ /* Enable the countermeasure */ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return zd1211_set_param(zd1211_drv, ZD_PARAM_DROPUNENCRYPTED, enabled, 1); ++} ++ ++ ++static int wpa_driver_zd1211_set_key(void *priv, wpa_alg alg, ++ const u8 *addr, int key_idx, ++ int set_tx, const u8 *seq, size_t seq_len, ++ const u8 *key, size_t key_len) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ struct zd1211_wlan_param *param; ++ u8 *buf; ++ size_t blen; ++ int ret = 0; ++ char *alg_name; ++ ++ switch (alg) { ++ case WPA_ALG_NONE: ++ alg_name = "NONE"; ++ break; ++ case WPA_ALG_WEP: ++ alg_name = "WEP"; ++ break; ++ case WPA_ALG_TKIP: ++ alg_name = "TKIP"; ++ break; ++ case WPA_ALG_CCMP: ++ alg_name = "CCMP"; ++ break; ++ default: ++ return -1; ++ } ++ ++ wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%d " ++ "key_len=%d", __FUNCTION__, alg_name, key_idx, set_tx, ++ seq_len, key_len); ++ ++ if (seq_len > 8) ++ return -2; ++ ++ blen = sizeof(*param) + key_len; ++ buf = malloc(blen); ++ if (buf == NULL) ++ return -1; ++ memset(buf, 0, blen); ++ ++ param = (struct zd1211_wlan_param *) buf; ++ param->cmd = ZD_CMD_SET_ENCRYPT_KEY; ++ /* TODO: In theory, STA in client mode can use five keys; four default ++ * keys for receiving (with keyidx 0..3) and one individual key for ++ * both transmitting and receiving (keyidx 0) _unicast_ packets. Now, ++ * keyidx 0 is reserved for this unicast use and default keys can only ++ * use keyidx 1..3 (i.e., default key with keyidx 0 is not supported). ++ * This should be fine for more or less all cases, but for completeness ++ * sake, the driver could be enhanced to support the missing key. */ ++#if 0 ++ if (addr == NULL) ++ memset(param->sta_addr, 0xff, ETH_ALEN); ++ else ++ memcpy(param->sta_addr, addr, ETH_ALEN); ++#else ++ memset(param->sta_addr, 0xff, ETH_ALEN); ++#endif ++ strncpy(param->u.crypt.alg, alg_name, ZD_CRYPT_ALG_NAME_LEN); ++ param->u.crypt.flags = set_tx ? ZD_FLAG_SET_TX_KEY : 0; ++ param->u.crypt.idx = key_idx; ++ memcpy(param->u.crypt.seq, seq, seq_len); ++ param->u.crypt.key_len = key_len; ++ memcpy((u8 *) param->u.crypt.key, key, key_len); ++ ++ /* Dump key context */ ++ if(alg == WPA_ALG_TKIP) { ++ int ii; ++ ++ wpa_printf(MSG_DEBUG, "Key Context:"); ++ for(ii = 0; ii < key_len; ) { ++ printf("0x%02x ", key[ii]); ++ ++ if((++ii % 16) == 0) ++ printf("\n"); ++ } ++ ++ printf("\n"); ++ } ++ ++ if (zd1211_ioctl(zd1211_drv, param, blen, 1)) { ++ wpa_printf(MSG_WARNING, "Failed to set encryption."); ++ //show_set_key_error(param); ++ ret = -1; ++ } ++ free(buf); ++ ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_set_wpa_ie(struct wpa_driver_zd1211_data *zd1211_drv, const u8 *wpa_ie, size_t wpa_ie_len) { ++ int res; ++ struct zd1211_wlan_param *param; ++ size_t blen = ZD_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len; ++ ++ if (blen < sizeof(*param)) ++ blen = sizeof(*param); ++ ++ param = (struct zd1211_wlan_param *) malloc(blen); ++ if (param == NULL) ++ return -1; ++ ++ memset(param, 0, blen); ++ param->cmd = ZD_CMD_SET_GENERIC_ELEMENT; ++ param->u.generic_elem.len = wpa_ie_len; ++ memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len); ++ res = zd1211_ioctl(zd1211_drv, param, blen, 1); ++ ++ free(param); ++ ++ return res; ++} ++ ++ ++static int wpa_driver_zd1211_set_wpa(void *priv, int enabled) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ int ret = 0; ++ ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ ++ if (!enabled && wpa_driver_zd1211_set_wpa_ie(zd1211_drv, NULL, 0) < 0) ++ ret = -1; ++ if (zd1211_set_param(zd1211_drv, ZD_PARAM_ROAMING, enabled, 1) < 0) ++ ret = -1; ++ if (zd1211_set_param(zd1211_drv, ZD_PARAM_PRIVACY, enabled, 1) < 0) ++ ret = -1; ++ if (zd1211_set_param(zd1211_drv, ZD_PARAM_WPA, enabled, 1) < 0) ++ ret = -1; ++ ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_associate(void *priv, struct wpa_driver_associate_params *params) { ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ int ret = 0; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ /* Because there might be the case, two or more APs with the same ++ * SSID, in order to identify them, we need to set the BSSID. */ ++ if (wpa_driver_zd1211_set_wpa_ie(zd1211_drv, params->wpa_ie, params->wpa_ie_len) < 0) ++ ret = -1; ++ if (wpa_driver_wext_set_ssid(zd1211_drv->wext, params->ssid, params->ssid_len) < 0) ++ ret = -1; ++ ++ // Mark for test ++ //if (wpa_driver_wext_set_bssid(ifname, bssid) < 0) ++ // ret = -1; ++ ++#if 0 ++ /* Allow unencrypted EAPOL messages even if pairwise keys are set when ++ * not using WPA. IEEE 802.1X specifies that these frames are not ++ * encrypted, but WPA encrypts them when pairwise keys are in use. */ ++ if (key_mgmt_suite == KEY_MGMT_802_1X || ++ key_mgmt_suite == KEY_MGMT_PSK) ++ allow_unencrypted_eapol = 0; ++ else ++ allow_unencrypted_eapol = 1; ++ ++ if (prism2param(ifname, PRISM2_PARAM_IEEE_802_1X, ++ allow_unencrypted_eapol) < 0) { ++ wpa_printf(MSG_DEBUG, "hostap: Failed to configure " ++ "ieee_802_1x param"); ++ /* Ignore this error.. driver_hostap.c can also be used with ++ * other drivers that do not support this prism2_param. */ ++ } ++#endif ++ ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_deauthenticate(void *priv, const u8 *addr, int reason_code) { ++ struct zd1211_wlan_param *param; ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ int blen; ++ int ret; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ blen = sizeof(*param); ++ param = (struct zd1211_wlan_param *) malloc(blen); ++ if (param == NULL) ++ return -1; ++ ++ memset(param, 0, blen); ++ param->cmd = ZD_CMD_SET_MLME; ++ param->u.mlme.cmd = MLME_STA_DEAUTH; ++ param->u.mlme.reason_code = reason_code; ++ memcpy(param->sta_addr, addr, ETH_ALEN); ++ ret = zd1211_ioctl(zd1211_drv, param, blen, 1); ++ usleep(100000); ++ free(param); ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_disassociate(void *priv, const u8 *addr, int reason_code) { ++ struct zd1211_wlan_param *param; ++ struct wpa_driver_zd1211_data *zd1211_drv = priv; ++ int blen; ++ int ret; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ blen = sizeof(*param); ++ param = (struct zd1211_wlan_param *) malloc(blen); ++ if (param == NULL) ++ return -1; ++ ++ memset(param, 0, blen); ++ param->cmd = ZD_CMD_SET_MLME; ++ param->u.mlme.cmd = MLME_STA_DISASSOC; ++ param->u.mlme.reason_code = reason_code; ++ memcpy(param->sta_addr, addr, ETH_ALEN); ++ ret = zd1211_ioctl(zd1211_drv, param, blen, 1); ++ free(param); ++ return ret; ++} ++ ++ ++static int wpa_driver_zd1211_scan(void *priv, const u8 *ssid, size_t ssid_len) { ++ struct wpa_driver_zd1211_data *zd1211_drv; ++ ++ zd1211_drv = priv; ++ return wpa_driver_wext_scan(zd1211_drv->wext, ssid, ssid_len); ++} ++ ++ ++static void * wpa_driver_zd1211_init(void *ctx, const char *ifname) { ++ struct wpa_driver_zd1211_data *zd1211_drv; ++ ++ zd1211_drv = malloc(sizeof(*zd1211_drv)); ++ if (zd1211_drv == NULL) ++ return NULL; ++ memset(zd1211_drv, 0, sizeof(*zd1211_drv)); ++ ++ zd1211_drv->wext = wpa_driver_wext_init(ctx, ifname); ++ if (zd1211_drv->wext == NULL) ++ goto exit_no_wext; ++ ++ zd1211_drv->ctx = ctx; ++ strncpy(zd1211_drv->ifname, ifname, sizeof(zd1211_drv->ifname)); ++ ++ zd1211_drv->sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (zd1211_drv->sock < 0) ++ goto exit_no_socket; ++ ++ return zd1211_drv; ++ ++exit_no_socket: ++ wpa_driver_wext_deinit(zd1211_drv->wext); ++exit_no_wext: ++ free(zd1211_drv); ++ return NULL; ++} ++ ++ ++static void wpa_driver_zd1211_deinit(void *ctx) { ++ struct wpa_driver_zd1211_data *zd1211_drv = ctx; ++ ++ wpa_driver_wext_deinit(zd1211_drv->wext); ++ close(zd1211_drv->sock); ++ free(zd1211_drv); ++} ++ ++ ++struct wpa_driver_ops wpa_driver_zd1211_ops = { ++ .name = "zd1211", ++ .desc = "Zydas zd1211 drivers", ++ .init = wpa_driver_zd1211_init, ++ .deinit = wpa_driver_zd1211_deinit, ++ .associate = wpa_driver_zd1211_associate, ++ .deauthenticate = wpa_driver_zd1211_deauthenticate, ++ .disassociate = wpa_driver_zd1211_disassociate, ++ .get_bssid = wpa_driver_zd1211_get_bssid, ++ .get_scan_results = wpa_driver_zd1211_get_scan_results, ++ .get_ssid = wpa_driver_zd1211_get_ssid, ++// .get_capa = wpa_driver_zd1211_get_capa, ++ .scan = wpa_driver_zd1211_scan, ++ .set_auth_alg = wpa_driver_zd1211_set_auth_alg, ++ .set_countermeasures = wpa_driver_zd1211_set_countermeasures, ++ .set_drop_unencrypted = wpa_driver_zd1211_set_drop_unencrypted, ++ .set_key = wpa_driver_zd1211_set_key, ++ .set_wpa = wpa_driver_zd1211_set_wpa, ++}; +diff -Nur wpa_supplicant-0.4.7/Makefile wpa_supplicant-0.4.7.new/Makefile +--- wpa_supplicant-0.4.7/Makefile 2005-11-21 02:42:12.000000000 +0100 ++++ wpa_supplicant-0.4.7.new/Makefile 2005-12-26 19:17:14.000000000 +0100 +@@ -107,6 +107,12 @@ + CONFIG_WIRELESS_EXTENSION=y + endif + ++ifdef CONFIG_DRIVER_ZD1211 ++CFLAGS += -DCONFIG_DRIVER_ZD1211 ++OBJS_d += driver_zd1211.o ++CONFIG_WIRELESS_EXTENSION=y ++endif ++ + ifdef CONFIG_DRIVER_BSD + CFLAGS += -DCONFIG_DRIVER_BSD + OBJS_d += driver_bsd.o +diff -Nur wpa_supplicant-0.4.7/zd1211_common.h wpa_supplicant-0.4.7.new/zd1211_common.h +--- wpa_supplicant-0.4.7/zd1211_common.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpa_supplicant-0.4.7.new/zd1211_common.h 2005-12-27 16:00:36.000000000 +0100 +@@ -0,0 +1,68 @@ ++#ifndef ZD1211_COMMON_H ++#define ZD1211_COMMON_H ++ ++ ++#define ZD_IOCTL_WPA (SIOCDEVPRIVATE + 1) ++#define ZD_IOCTL_PARAM (SIOCDEVPRIVATE + 2) ++ ++#define ZD_PARAM_ROAMING 0x0001 ++#define ZD_PARAM_PRIVACY 0x0002 ++#define ZD_PARAM_WPA 0x0003 ++#define ZD_PARAM_COUNTERMEASURES 0x0004 ++#define ZD_PARAM_DROPUNENCRYPTED 0x0005 ++#define ZD_PARAM_AUTH_ALGS 0x0006 ++ ++#define ZD_CMD_SET_ENCRYPT_KEY 0x0001 ++#define ZD_CMD_SET_MLME 0x0002 ++//#define ZD_CMD_SCAN_REQ 0x0003 ++#define ZD_CMD_SET_GENERIC_ELEMENT 0x0004 ++ ++#define ZD_FLAG_SET_TX_KEY 0x0001 ++ ++#define ZD_GENERIC_ELEMENT_HDR_LEN \ ++((int) (&((struct zd1211_wlan_param *) 0)->u.generic_elem.data)) ++ ++#define ZD_CRYPT_ALG_NAME_LEN 16 ++#define ZD_MAX_KEY_SIZE 32 ++#define ZD_MAX_GENERIC_SIZE 64 ++ ++/* structure definition */ ++ ++struct zd1211_wlan_param { ++ u32 cmd; ++ u8 sta_addr[ETH_ALEN]; ++ union { ++ struct { ++ u8 alg[ZD_CRYPT_ALG_NAME_LEN]; ++ u32 flags; ++ u32 err; ++ u8 idx; ++ u8 seq[8]; /* sequence counter (set: RX, get: TX) */ ++ u16 key_len; ++ u8 key[ZD_MAX_KEY_SIZE]; ++ } crypt; ++/* ++ struct { ++ u32 flags_and; ++ u32 flags_or; ++ } set_flags_sta; ++*/ ++ struct { ++ u8 len; ++ u8 data[ZD_MAX_GENERIC_SIZE]; ++ } generic_elem; ++ struct { ++#define MLME_STA_DEAUTH 0 ++#define MLME_STA_DISASSOC 1 ++ u16 cmd; ++ u16 reason_code; ++ } mlme; ++ struct { ++ u8 ssid_len; ++ u8 ssid[32]; ++ } scan_req; ++ } u; ++}; ++ ++ ++#endif diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/madwifi-bsd-fix.diff b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/madwifi-bsd-fix.diff new file mode 100644 index 0000000000..974eb39627 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/madwifi-bsd-fix.diff @@ -0,0 +1,12 @@ +--- driver_madwifi.c.orig 2005-03-18 15:12:53.392793216 +0100 ++++ driver_madwifi.c 2005-03-18 15:13:09.246383104 +0100 +@@ -25,7 +25,8 @@ + #include "eloop.h" + #include "wpa_supplicant.h" + +-#include <include/compat.h> ++#include <net80211/compat.h> ++#include <net80211/_ieee80211.h> + #include <net80211/ieee80211.h> + #include <net80211/ieee80211_crypto.h> + #include <net80211/ieee80211_ioctl.h> diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/wpa_supplicant.conf b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/wpa_supplicant.conf new file mode 100644 index 0000000000..da407b5ef3 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant-0.4.7/wpa_supplicant.conf @@ -0,0 +1,502 @@ +##### Example wpa_supplicant configuration file ############################### +# Empty lines and lines starting with # are ignored + +# NOTE! This file may contain password information and should probably be made +# readable only by root user on multiuser systems. + +# global configuration (shared by all network blocks) +# +# Interface for separate control program. If this is specified, wpa_supplicant +# will create this directory and a UNIX domain socket for listening to requests +# from external programs (CLI/GUI, etc.) for status information and +# configuration. The socket file will be named based on the interface name, so +# multiple wpa_supplicant processes can be run at the same time if more than +# one interface is used. +# /var/run/wpa_supplicant is the recommended directory for sockets and by +# default, wpa_cli will use it when trying to connect with wpa_supplicant. +ctrl_interface=/var/run/wpa_supplicant + +# Access control for the control interface can be configured by setting the +# directory to allow only members of a group to use sockets. This way, it is +# possible to run wpa_supplicant as root (since it needs to change network +# configuration and open raw sockets) and still allow GUI/CLI components to be +# run as non-root users. However, since the control interface can be used to +# change the network configuration, this access needs to be protected in many +# cases. By default, wpa_supplicant is configured to use gid 0 (root). If you +# want to allow non-root users to use the control interface, add a new group +# and change this value to match with that group. Add users that should have +# control interface access to this group. If this variable is commented out or +# not included in the configuration file, group will not be changed from the +# value it got by default when the directory or socket was created. +# +# This variable can be a group name or gid. +#ctrl_interface_group=wheel +ctrl_interface_group=0 + +# IEEE 802.1X/EAPOL version +# wpa_supplicant was implemented based on IEEE 802-1X-REV-d8 which defines +# EAPOL version 2. However, there are many APs that do not handle the new +# version number correctly (they seem to drop the frames completely). In order +# to make wpa_supplicant interoperate with these APs, the version number is set +# to 1 by default. This configuration value can be used to set it to the new +# version (2). +eapol_version=1 + +# AP scanning/selection +# By default, wpa_supplicant requests driver to perform AP scanning and then +# uses the scan results to select a suitable AP. Another alternative is to +# allow the driver to take care of AP scanning and selection and use +# wpa_supplicant just to process EAPOL frames based on IEEE 802.11 association +# information from the driver. +# 1: wpa_supplicant initiates scanning and AP selection +# 0: driver takes care of scanning, AP selection, and IEEE 802.11 association +# parameters (e.g., WPA IE generation); this mode can also be used with +# non-WPA drivers when using IEEE 802.1X mode; do not try to associate with +# APs (i.e., external program needs to control association) +# 2: like 0, but associate with APs using security policy and SSID (but not +# BSSID); this can be used, e.g., with ndiswrapper and NDIS driver to +# enable operation with hidden SSIDs and optimized roaming; in this mode, +# only the first network block in the configuration file is used and this +# configuration should have explicit security policy (i.e., only one option +# in the lists) for key_mgmt, pairwise, group, proto variables +ap_scan=1 + +# EAP fast re-authentication +# By default, fast re-authentication is enabled for all EAP methods that +# support it. This variable can be used to disable fast re-authentication. +# Normally, there is no need to disable this. +fast_reauth=1 + +# network block +# +# Each network (usually AP's sharing the same SSID) is configured as a separate +# block in this configuration file. The network blocks are in preference order +# (the first match is used). +# +# network block fields: +# +# ssid: SSID (mandatory); either as an ASCII string with double quotation or +# as hex string; network name +# +# scan_ssid: +# 0 = do not scan this SSID with specific Probe Request frames (default) +# 1 = scan with SSID-specific Probe Request frames (this can be used to +# find APs that do not accept broadcast SSID or use multiple SSIDs; +# this will add latency to scanning, so enable this only when needed) +# +# bssid: BSSID (optional); if set, this network block is used only when +# associating with the AP using the configured BSSID +# +# priority: priority group (integer) +# By default, all networks will get same priority group (0). If some of the +# networks are more desirable, this field can be used to change the order in +# which wpa_supplicant goes through the networks when selecting a BSS. The +# priority groups will be iterated in decreasing priority (i.e., the larger the +# priority value, the sooner the network is matched against the scan results). +# Within each priority group, networks will be selected based on security +# policy, signal strength, etc. +# Please note that AP scanning with scan_ssid=1 is not using this priority to +# select the order for scanning. Instead, it uses the order the networks are in +# the configuration file. +# +# mode: IEEE 802.11 operation mode +# 0 = infrastructure (Managed) mode, i.e., associate with an AP (default) +# 1 = IBSS (ad-hoc, peer-to-peer) +# Note: IBSS can only be used with key_mgmt NONE (plaintext and static WEP) +# and key_mgmt=WPA-NONE (fixed group key TKIP/CCMP). In addition, ap_scan has +# to be set to 2 for IBSS. WPA-None requires following network block options: +# proto=WPA, key_mgmt=WPA-NONE, pairwise=NONE, group=TKIP (or CCMP, but not +# both), and psk must also be set. +# +# proto: list of accepted protocols +# WPA = WPA/IEEE 802.11i/D3.0 +# RSN = WPA2/IEEE 802.11i (also WPA2 can be used as an alias for RSN) +# If not set, this defaults to: WPA RSN +# +# key_mgmt: list of accepted authenticated key management protocols +# WPA-PSK = WPA pre-shared key (this requires 'psk' field) +# WPA-EAP = WPA using EAP authentication (this can use an external +# program, e.g., Xsupplicant, for IEEE 802.1X EAP Authentication +# IEEE8021X = IEEE 802.1X using EAP authentication and (optionally) dynamically +# generated WEP keys +# NONE = WPA is not used; plaintext or static WEP could be used +# If not set, this defaults to: WPA-PSK WPA-EAP +# +# auth_alg: list of allowed IEEE 802.11 authentication algorithms +# OPEN = Open System authentication (required for WPA/WPA2) +# SHARED = Shared Key authentication (requires static WEP keys) +# LEAP = LEAP/Network EAP (only used with LEAP) +# If not set, automatic selection is used (Open System with LEAP enabled if +# LEAP is allowed as one of the EAP methods). +# +# pairwise: list of accepted pairwise (unicast) ciphers for WPA +# CCMP = AES in Counter mode with CBC-MAC [RFC 3610, IEEE 802.11i/D7.0] +# TKIP = Temporal Key Integrity Protocol [IEEE 802.11i/D7.0] +# NONE = Use only Group Keys (deprecated, should not be included if APs support +# pairwise keys) +# If not set, this defaults to: CCMP TKIP +# +# group: list of accepted group (broadcast/multicast) ciphers for WPA +# CCMP = AES in Counter mode with CBC-MAC [RFC 3610, IEEE 802.11i/D7.0] +# TKIP = Temporal Key Integrity Protocol [IEEE 802.11i/D7.0] +# WEP104 = WEP (Wired Equivalent Privacy) with 104-bit key +# WEP40 = WEP (Wired Equivalent Privacy) with 40-bit key [IEEE 802.11] +# If not set, this defaults to: CCMP TKIP WEP104 WEP40 +# +# psk: WPA preshared key; 256-bit pre-shared key +# The key used in WPA-PSK mode can be entered either as 64 hex-digits, i.e., +# 32 bytes or as an ASCII passphrase (in which case, the real PSK will be +# generated using the passphrase and SSID). ASCII passphrase must be between +# 8 and 63 characters (inclusive). +# This field is not needed, if WPA-EAP is used. +# Note: Separate tool, wpa_passphrase, can be used to generate 256-bit keys +# from ASCII passphrase. This process uses lot of CPU and wpa_supplicant +# startup and reconfiguration time can be optimized by generating the PSK only +# only when the passphrase or SSID has actually changed. +# +# eapol_flags: IEEE 802.1X/EAPOL options (bit field) +# Dynamic WEP key require for non-WPA mode +# bit0 (1): require dynamically generated unicast WEP key +# bit1 (2): require dynamically generated broadcast WEP key +# (3 = require both keys; default) +# +# Following fields are only used with internal EAP implementation. +# eap: space-separated list of accepted EAP methods +# MD5 = EAP-MD5 (unsecure and does not generate keying material -> +# cannot be used with WPA; to be used as a Phase 2 method +# with EAP-PEAP or EAP-TTLS) +# MSCHAPV2 = EAP-MSCHAPv2 (cannot be used separately with WPA; to be used +# as a Phase 2 method with EAP-PEAP or EAP-TTLS) +# OTP = EAP-OTP (cannot be used separately with WPA; to be used +# as a Phase 2 method with EAP-PEAP or EAP-TTLS) +# GTC = EAP-GTC (cannot be used separately with WPA; to be used +# as a Phase 2 method with EAP-PEAP or EAP-TTLS) +# TLS = EAP-TLS (client and server certificate) +# PEAP = EAP-PEAP (with tunnelled EAP authentication) +# TTLS = EAP-TTLS (with tunnelled EAP or PAP/CHAP/MSCHAP/MSCHAPV2 +# authentication) +# If not set, all compiled in methods are allowed. +# +# identity: Identity string for EAP +# anonymous_identity: Anonymous identity string for EAP (to be used as the +# unencrypted identity with EAP types that support different tunnelled +# identity, e.g., EAP-TTLS) +# password: Password string for EAP +# ca_cert: File path to CA certificate file. This file can have one or more +# trusted CA certificates. If ca_cert is not included, server certificate +# will not be verified. This is insecure and the CA file should always be +# configured. +# client_cert: File path to client certificate file (PEM/DER) +# private_key: File path to client private key file (PEM/DER/PFX) +# When PKCS#12/PFX file (.p12/.pfx) is used, client_cert should be +# commented out. Both the private key and certificate will be read from +# the PKCS#12 file in this case. +# private_key_passwd: Password for private key file +# dh_file: File path to DH/DSA parameters file (in PEM format) +# This is an optional configuration file for setting parameters for an +# ephemeral DH key exchange. In most cases, the default RSA +# authentication does not use this configuration. However, it is possible +# setup RSA to use ephemeral DH key exchange. In addition, ciphers with +# DSA keys always use ephemeral DH keys. This can be used to achieve +# forward secrecy. If the file is in DSA parameters format, it will be +# automatically converted into DH params. +# subject_match: Substring to be matched against the subject of the +# authentication server certificate. If this string is set, the server +# sertificate is only accepted if it contains this string in the subject. +# The subject string is in following format: +# /C=US/ST=CA/L=San Francisco/CN=Test AS/emailAddress=as@example.com +# phase1: Phase1 (outer authentication, i.e., TLS tunnel) parameters +# (string with field-value pairs, e.g., "peapver=0" or +# "peapver=1 peaplabel=1") +# 'peapver' can be used to force which PEAP version (0 or 1) is used. +# 'peaplabel=1' can be used to force new label, "client PEAP encryption", +# to be used during key derivation when PEAPv1 or newer. Most existing +# PEAPv1 implementation seem to be using the old label, "client EAP +# encryption", and wpa_supplicant is now using that as the default value. +# Some servers, e.g., Radiator, may require peaplabel=1 configuration to +# interoperate with PEAPv1; see eap_testing.txt for more details. +# 'peap_outer_success=0' can be used to terminate PEAP authentication on +# tunneled EAP-Success. This is required with some RADIUS servers that +# implement draft-josefsson-pppext-eap-tls-eap-05.txt (e.g., +# Lucent NavisRadius v4.4.0 with PEAP in "IETF Draft 5" mode) +# sim_min_num_chal=3 can be used to configure EAP-SIM to require three +# challenges (by default, it accepts 2 or 3) +# phase2: Phase2 (inner authentication with TLS tunnel) parameters +# (string with field-value pairs, e.g., "auth=MSCHAPV2" for EAP-PEAP or +# "autheap=MSCHAPV2 autheap=MD5" for EAP-TTLS) +# Following certificate/private key fields are used in inner Phase2 +# authentication when using EAP-TTLS or EAP-PEAP. +# ca_cert2: File path to CA certificate file. This file can have one or more +# trusted CA certificates. If ca_cert2 is not included, server +# certificate will not be verified. This is insecure and the CA file +# should always be configured. +# client_cert2: File path to client certificate file +# private_key2: File path to client private key file +# private_key2_passwd: Password for private key file +# dh_file2: File path to DH/DSA parameters file (in PEM format) +# subject_match2: Substring to be matched against the subject of the +# authentication server certificate. +# +# EAP-PSK variables: +# eappsk: 16-byte (128-bit, 32 hex digits) pre-shared key in hex format +# nai: user NAI +# server_nai: authentication server NAI +# +# EAP-FAST variables: +# pac_file: File path for the PAC entries. wpa_supplicant will need to be able +# to create this file and write updates to it when PAC is being +# provisioned or refreshed. +# phase1: fast_provisioning=1 option enables in-line provisioning of EAP-FAST +# credentials (PAC) +# +# wpa_supplicant supports number of "EAP workarounds" to work around +# interoperability issues with incorrectly behaving authentication servers. +# These are enabled by default because some of the issues are present in large +# number of authentication servers. Strict EAP conformance mode can be +# configured by disabling workarounds with eap_workaround=0. + +# Example blocks: + +# Simple case: WPA-PSK, PSK as an ASCII passphrase, allow all valid ciphers +network={ + ssid="simple" + psk="very secret passphrase" + priority=5 +} + +# Same as previous, but request SSID-specific scanning (for APs that reject +# broadcast SSID) +network={ + ssid="second ssid" + scan_ssid=1 + psk="very secret passphrase" + priority=2 +} + +# Only WPA-PSK is used. Any valid cipher combination is accepted. +network={ + ssid="example" + proto=WPA + key_mgmt=WPA-PSK + pairwise=CCMP TKIP + group=CCMP TKIP WEP104 WEP40 + psk=06b4be19da289f475aa46a33cb793029d4ab3db7a23ee92382eb0106c72ac7bb + priority=2 +} + +# Only WPA-EAP is used. Both CCMP and TKIP is accepted. An AP that used WEP104 +# or WEP40 as the group cipher will not be accepted. +network={ + ssid="example" + proto=RSN + key_mgmt=WPA-EAP + pairwise=CCMP TKIP + group=CCMP TKIP + eap=TLS + identity="user@example.com" + ca_cert="/etc/cert/ca.pem" + client_cert="/etc/cert/user.pem" + private_key="/etc/cert/user.prv" + private_key_passwd="password" + priority=1 +} + +# EAP-PEAP/MSCHAPv2 configuration for RADIUS servers that use the new peaplabel +# (e.g., Radiator) +network={ + ssid="example" + key_mgmt=WPA-EAP + eap=PEAP + identity="user@example.com" + password="foobar" + ca_cert="/etc/cert/ca.pem" + phase1="peaplabel=1" + phase2="auth=MSCHAPV2" + priority=10 +} + +# EAP-TTLS/EAP-MD5-Challenge configuration with anonymous identity for the +# unencrypted use. Real identity is sent only within an encrypted TLS tunnel. +network={ + ssid="example" + key_mgmt=WPA-EAP + eap=TTLS + identity="user@example.com" + anonymous_identity="anonymous@example.com" + password="foobar" + ca_cert="/etc/cert/ca.pem" + priority=2 +} + +# EAP-TTLS/MSCHAPv2 configuration with anonymous identity for the unencrypted +# use. Real identity is sent only within an encrypted TLS tunnel. +network={ + ssid="example" + key_mgmt=WPA-EAP + eap=TTLS + identity="user@example.com" + anonymous_identity="anonymous@example.com" + password="foobar" + ca_cert="/etc/cert/ca.pem" + phase2="auth=MSCHAPV2" +} + +# WPA-EAP, EAP-TTLS with different CA certificate used for outer and inner +# authentication. +network={ + ssid="example" + key_mgmt=WPA-EAP + eap=TTLS + # Phase1 / outer authentication + anonymous_identity="anonymous@example.com" + ca_cert="/etc/cert/ca.pem" + # Phase 2 / inner authentication + phase2="autheap=TLS" + ca_cert2="/etc/cert/ca2.pem" + client_cert2="/etc/cer/user.pem" + private_key2="/etc/cer/user.prv" + private_key2_passwd="password" + priority=2 +} + +# Both WPA-PSK and WPA-EAP is accepted. Only CCMP is accepted as pairwise and +# group cipher. +network={ + ssid="example" + bssid=00:11:22:33:44:55 + proto=WPA RSN + key_mgmt=WPA-PSK WPA-EAP + pairwise=CCMP + group=CCMP + psk=06b4be19da289f475aa46a33cb793029d4ab3db7a23ee92382eb0106c72ac7bb +} + +# Special characters in SSID, so use hex string. Default to WPA-PSK, WPA-EAP +# and all valid ciphers. +network={ + ssid=00010203 + psk=000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f +} + + +# EAP-SIM with a GSM SIM or USIM +network={ + ssid="eap-sim-test" + key_mgmt=WPA-EAP + eap=SIM + pin="1234" + pcsc="" +} + + +# EAP-PSK +network={ + ssid="eap-psk-test" + key_mgmt=WPA-EAP + eap=PSK + identity="eap_psk_user" + eappsk=06b4be19da289f475aa46a33cb793029 + nai="eap_psk_user@example.com" + server_nai="as@example.com" +} + + +# IEEE 802.1X/EAPOL with dynamically generated WEP keys (i.e., no WPA) using +# EAP-TLS for authentication and key generation; require both unicast and +# broadcast WEP keys. +network={ + ssid="1x-test" + key_mgmt=IEEE8021X + eap=TLS + identity="user@example.com" + ca_cert="/etc/cert/ca.pem" + client_cert="/etc/cert/user.pem" + private_key="/etc/cert/user.prv" + private_key_passwd="password" + eapol_flags=3 +} + + +# LEAP with dynamic WEP keys +network={ + ssid="leap-example" + key_mgmt=IEEE8021X + eap=LEAP + identity="user" + password="foobar" +} + +# EAP-FAST with WPA (WPA or WPA2) +network={ + ssid="eap-fast-test" + key_mgmt=WPA-EAP + eap=FAST + anonymous_identity="FAST-000102030405" + identity="username" + password="password" + phase1="fast_provisioning=1" + pac_file="/etc/wpa_supplicant.eap-fast-pac" +} + +# Plaintext connection (no WPA, no IEEE 802.1X) +network={ + ssid="plaintext-test" + key_mgmt=NONE +} + + +# Shared WEP key connection (no WPA, no IEEE 802.1X) +network={ + ssid="static-wep-test" + key_mgmt=NONE + wep_key0="abcde" + wep_key1=0102030405 + wep_key2="1234567890123" + wep_tx_keyidx=0 + priority=5 +} + + +# Shared WEP key connection (no WPA, no IEEE 802.1X) using Shared Key +# IEEE 802.11 authentication +network={ + ssid="static-wep-test2" + key_mgmt=NONE + wep_key0="abcde" + wep_key1=0102030405 + wep_key2="1234567890123" + wep_tx_keyidx=0 + priority=5 + auth_alg=SHARED +} + + +# IBSS/ad-hoc network with WPA-None/TKIP. +network={ + ssid="test adhoc" + mode=1 + proto=WPA + key_mgmt=WPA-NONE + pairwise=NONE + group=TKIP + psk="secret passphrase" +} + + +# Catch all example that allows more or less all configuration modes +network={ + ssid="example" + scan_ssid=1 + key_mgmt=WPA-EAP WPA-PSK IEEE8021X NONE + pairwise=CCMP TKIP + group=CCMP TKIP WEP104 WEP40 + psk="very secret passphrase" + eap=TTLS PEAP TLS + identity="user@example.com" + password="foobar" + ca_cert="/etc/cert/ca.pem" + client_cert="/etc/cert/user.pem" + private_key="/etc/cert/user.prv" + private_key_passwd="password" + phase1="peaplabel=0" +} diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant_0.3.8.bb b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.3.8.bb index 82b4eb50ca..684d7da8eb 100644 --- a/openembedded/packages/wpa-supplicant/wpa-supplicant_0.3.8.bb +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.3.8.bb @@ -5,11 +5,12 @@ MAINTAINER = "Holger Schurig" HOMEPAGE = "http://hostap.epitest.fi/wpa_supplicant/" DEPENDS = "openssl" DEPENDS_mtx-1_append = "madwifi-modules" -PR = "r0" +PR = "r1" SRC_URI = "http://hostap.epitest.fi/releases/wpa_supplicant-${PV}.tar.gz \ file://madwifi-bsd-fix.diff;patch=1;pnum=0 \ file://defconfig \ + file://driver-hermes.patch;patch=1 \ file://wpa_supplicant.conf" S = "${WORKDIR}/wpa_supplicant-${PV}" diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant_0.4.7.bb b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.4.7.bb new file mode 100644 index 0000000000..268255c39e --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.4.7.bb @@ -0,0 +1,38 @@ +DESCRIPTION = "A Client for Wi-Fi Protected Access (WPA)." +SECTION = "network" +LICENSE = "GPL" +MAINTAINER = "Holger Schurig" +HOMEPAGE = "http://hostap.epitest.fi/wpa_supplicant/" +DEPENDS = "openssl" +DEPENDS_mtx-1_append = "madwifi-modules" +PR = "r1" + +SRC_URI = "http://hostap.epitest.fi/releases/wpa_supplicant-${PV}.tar.gz \ + file://madwifi-bsd-fix.diff;patch=1;pnum=0 \ + file://defconfig \ + file://driver-hermes.patch;patch=1 \ + file://driver-zd1211.patch;patch=1 \ + file://wpa_supplicant.conf" + +S = "${WORKDIR}/wpa_supplicant-${PV}" + +do_configure () { + install -m 0755 ${WORKDIR}/defconfig .config +} + +do_compile () { + make +} + +do_install () { + install -d ${D}${sbindir} + install -m755 wpa_supplicant ${D}${sbindir} + install -m755 wpa_passphrase ${D}${sbindir} + install -m755 wpa_cli ${D}${sbindir} + + install -d ${D}${sysconfdir} + install -m644 ${WORKDIR}/wpa_supplicant.conf ${D}${sysconfdir} + + install -d ${D}${docdir}/wpa_supplicant + install -m644 README ${D}${docdir}/wpa_supplicant +} diff --git a/openembedded/packages/wpa-supplicant/wpa-supplicant_0.5.1.bb b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.5.1.bb new file mode 100644 index 0000000000..236992f8f0 --- /dev/null +++ b/openembedded/packages/wpa-supplicant/wpa-supplicant_0.5.1.bb @@ -0,0 +1,58 @@ +DESCRIPTION = "A Client for Wi-Fi Protected Access (WPA)." +SECTION = "network" +LICENSE = "GPL" +MAINTAINER = "Holger Schurig" +MAINTAINER = "Eric Shattow <lucent@gmail.com>" +HOMEPAGE = "http://hostap.epitest.fi/wpa_supplicant/" +DEPENDS = "gnutls madwifi-ng" + +PR = "r4" +DEFAULT_PREFERENCE = "-1" + +SRC_URI = "http://hostap.epitest.fi/releases/wpa_supplicant-${PV}.tar.gz \ + file://defconfig-gnutls \ + file://init.sh \ + file://defaults-sane \ + file://wpa_supplicant.conf \ + file://wpa_supplicant.conf-sane" + +S = "${WORKDIR}/wpa_supplicant-${PV}" + +PACKAGES_prepend = "wpa-supplicant-passphrase wpa-supplicant-cli " +FILES_wpa-supplicant-passphrase = "/usr/sbin/wpa_passphrase" +FILES_wpa-supplicant-cli = "/usr/sbin/wpa_cli" + +RRECOMMENDS_${PN} = "wpa-supplicant-passphrase wpa-supplicant-cli" + +INITSCRIPT_NAME = "wpa" +INITSCRIPT_PARAMS = "defaults 10" +inherit update-rc.d + +do_configure () { + install -m 0755 ${WORKDIR}/defconfig-gnutls .config + echo "CONFIG_DRIVER_MADWIFI=y" >> .config + echo "CFLAGS += -I${STAGING_INCDIR}/madwifi-ng" >> .config +} + +do_compile () { + make +} + +do_install () { + install -d ${D}${sbindir} + install -m755 wpa_supplicant ${D}${sbindir} + install -m755 wpa_passphrase ${D}${sbindir} + install -m755 wpa_cli ${D}${sbindir} + + install -d ${D}${localstatedir}/run/wpa_supplicant + + install -d ${D}${docdir}/wpa_supplicant + install -m644 README ${WORKDIR}/wpa_supplicant.conf ${D}${docdir}/wpa_supplicant + + install -d ${D}${sysconfdir}/init.d + install -m700 ${WORKDIR}/init.sh ${D}${sysconfdir}/init.d/wpa + + install -d ${D}${sysconfdir}/default + install -m600 ${WORKDIR}/defaults-sane ${D}${sysconfdir}/default/wpa + install -m600 ${WORKDIR}/wpa_supplicant.conf-sane ${D}${sysconfdir}/wpa_supplicant.conf +} |