Bakkalaureatsarbeit

Combine Matlab and DirectShow

Daniel Strigl — Fri, 25 May 2007 09:13:37 GMT

Some weeks ago I had the idea to combine Matlab and DirectShow, and here's the result ...

... a DirectShow filter that will use Matlab to transform a video stream.

The filter will accept the path to a M-File and the Variable Names of the Input and Output Frame.

When the DirectShow Filter Graph starts the "Matlab Video Filter" starts the Matlab Command Shell automatically in the background. For each frame the "Matlab Video Filter" load the Input Frame to a Matlab matrix, put the matrix to the Matlab Command Shell, execute the M-File, get the transformed matrix back from the Matlab Command Shell and copy it to the Output Frame.

The M-File used in the screenshot uses the "Canny Edge Filter" to extract the edges of the video stream and plot the histogram of the Input Frame:

 FrameOut = im2uint8(edge(FrameIn, 'canny'));

            imhist(FrameIn); 

There are two versions of the "Matlab Video Filter", one for 8 Bit Grayscale video streams and one for RGB 24 video streams.

Both Microsoft Visual Studio 2005 projects of the filters can be found here:

My second DirectShow filter

Daniel Strigl — Fri, 11 May 2007 15:01:04 GMT

Today I have finished my second DirectShow filter, a Transform filter to convert a RGB video stream to Grayscale.

The whole Microsoft Visual Studio 2005 project can be downloaded from here.

My first DirectShow filter

Daniel Strigl — Fri, 04 May 2007 12:14:15 GMT

This week I have created my first DirectShow filter, a simple TransInPlace filter that will add a logo to a video stream.

The whole Microsoft Visual Studio 2005 project can be downloaded from here.

My own WiFi Status Monitor

Daniel Strigl — Wed, 03 Jan 2007 20:31:00 GMT

I have written a little MFC application that display some properties about the current association, like

the value of the received signal strength indication (RSSI),
the service set identifier (SSID) of the BSS,
the media access control (MAC) address of the access point and
the IP address associated with the WiFi adapter.

You will find the application under WiFiStatus.zip.

How to connect to an WEP encrypted access point using NDISUIO?

Daniel Strigl — Tue, 02 Jan 2007 21:23:00 GMT

The steps to connect to an WEP encrypted access point using NDISUIO are:

Disassociate from the current service set (OID_802_11_DISASSOCIATE).
Set network mode to Ndis802_11Infrastructure (OID_802_11_INFRASTRUCTURE_MODE).
Set privacy filter mode to Ndis802_11PrivFilterAcceptAll (OID_802_11_PRIVACY_FILTER).
Set the Wired Equivalent Privacy (WEP) keys (OID_802_11_ADD_WEP).
Set authentication mode to Ndis802_11AuthModeOpen, Ndis802_11AuthModeShared or Ndis802_11AuthModeAutoSwitch (OID_802_11_AUTHENTICATION_MODE).
Set encryption mode to Ndis802_11Encryption1Enabled (OID_802_11_ENCRYPTION_STATUS).
Set the service set identifier (SSID) to associate with (OID_802_11_SSID).
Optional: If you want to connect to a specific access point, set the media access control (MAC) address of the access point (OID_802_11_BSSID).
Wait for the NDISUIO_NOTIFICATION_MEDIA_CONNECT event (IOCTL_NDISUIO_REQUEST_NOTIFICATION).

If "Using DHCP" is chosen for the wireless network adapter you have also to renew the IP address.

I have written a console application that will show how to connect to an WEP encrypted access point using NDISUIO and a small console application to renew the IP address:

How to get supported authentication and encryption capabilities of an wireless adapter?

Daniel Strigl — Wed, 27 Dec 2006 02:52:00 GMT

The following sample application, written in C++, will show how to do it:

// capability.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>
#include <ntddndis.h>
#include <nuiouser.h>
#include <winioctl.h>

#define OID_802_11_CAPABILITY 0x0d010122

typedef enum 
{
    Ndis802_11AuthModeWPA2 = Ndis802_11AuthModeWPANone + 1,
    Ndis802_11AuthModeWPA2PSK,
};

typedef struct _NDIS_802_11_AUTHENTICATION_ENCRYPTION 
{
    NDIS_802_11_AUTHENTICATION_MODE AuthModeSupported;
    NDIS_802_11_ENCRYPTION_STATUS EncryptStatusSupported;
} NDIS_802_11_AUTHENTICATION_ENCRYPTION, 
 *PNDIS_802_11_AUTHENTICATION_ENCRYPTION;

typedef struct _NDIS_802_11_CAPABILITY 
{
    ULONG Length;
    ULONG Version;
    ULONG NoOfPMKIDs;
    ULONG NoOfAuthEncryptPairSupported;
    NDIS_802_11_AUTHENTICATION_ENCRYPTION
        AuthenticationEncryptionSupported[1];
} NDIS_802_11_CAPABILITY, *PNDIS_802_11_CAPABILITY;

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc < 2)
    {
        printf("Usage: capability <adapter name>\n");
        printf("       <adapter name> name of the wireless adapter\n");
        return -1;
    }

LPCTSTR pszAdapter = argv[1];

HANDLE hDevice = CreateFile(
        NDISUIO_DEVICE_NAME, GENERIC_READ, 
        FILE_SHARE_READ | FILE_SHARE_WRITE, 
        NULL, OPEN_EXISTING, 
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
        NULL);

if (hDevice == INVALID_HANDLE_VALUE)
    {
        DWORD dwError = GetLastError();

printf("Function \"CreateFile\" failed (0x%08x).\n", dwError);
        return -2;
    }

DWORD dwBytesReturned = 0;

BYTE buf[512];
    PNDISUIO_QUERY_OID pNDISUIOQueryOid = (PNDISUIO_QUERY_OID) buf;
    pNDISUIOQueryOid->ptcDeviceName = (PTCHAR) pszAdapter;
    pNDISUIOQueryOid->Oid = OID_802_11_CAPABILITY;

if (!DeviceIoControl(
        hDevice, IOCTL_NDISUIO_QUERY_OID_VALUE, 
        pNDISUIOQueryOid, sizeof(buf), 
        pNDISUIOQueryOid, sizeof(buf), 
        &dwBytesReturned, NULL))
    {
        DWORD dwError = GetLastError();

CloseHandle(hDevice);
        printf("Function \"DeviceIoControl\" (OID_802_11_CAPABILITY) failed (0x%08x).\n", 
            dwError);
        return -3;
    }

PNDIS_802_11_CAPABILITY pCap = (PNDIS_802_11_CAPABILITY) pNDISUIOQueryOid->Data;

if (pCap->Version != 2) 
    {
        CloseHandle(hDevice);
        printf("Unsupported OID_802_11_CAPABILITY data (ver %d).\n", pCap->Version);
        return -4;
    }

for (ULONG i = 0; i < pCap->NoOfAuthEncryptPairSupported; ++i)
    {
        NDIS_802_11_AUTHENTICATION_MODE authMode = 
            pCap->AuthenticationEncryptionSupported[i].AuthModeSupported;
        NDIS_802_11_ENCRYPTION_STATUS encStat = 
            pCap->AuthenticationEncryptionSupported[i].EncryptStatusSupported;

if (authMode == Ndis802_11AuthModeOpen && 
            encStat == Ndis802_11EncryptionDisabled)
        {
            printf("Open System: none\n");
        }
        else if (authMode == Ndis802_11AuthModeOpen && 
                 encStat == Ndis802_11Encryption1Enabled)
        {
            printf("Open System: WEP\n");
        }
        else if (authMode == Ndis802_11AuthModeShared && 
                 encStat == Ndis802_11EncryptionDisabled)
        {
            printf("Shared Key: none\n");
        }
        else if (authMode == Ndis802_11AuthModeShared && 
                 encStat == Ndis802_11Encryption1Enabled)
        {
            printf("Shared Key: WEP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA && 
                 encStat == Ndis802_11Encryption2Enabled)
        {
            printf("WPA: TKIP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA && 
                 encStat == Ndis802_11Encryption3Enabled)
        {
            printf("WPA: AES\n");
        }
        else if (authMode == Ndis802_11AuthModeWPAPSK && 
                 encStat == Ndis802_11Encryption2Enabled)
        {
            printf("WPA-PSK: TKIP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPAPSK && 
                 encStat == Ndis802_11Encryption3Enabled)
        {
            printf("WPA-PSK: AES\n");
        }
        else if (authMode == Ndis802_11AuthModeWPANone && 
                 encStat == Ndis802_11EncryptionDisabled)
        {
            printf("WPA-None: none\n");
        }
        else if (authMode == Ndis802_11AuthModeWPANone && 
                 encStat == Ndis802_11Encryption2Enabled)
        {
            printf("WPA-None: TKIP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPANone && 
                 encStat == Ndis802_11Encryption3Enabled)
        {
            printf("WPA-None: AES\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA2 && 
                 encStat == Ndis802_11Encryption2Enabled)
        {
            printf("WPA2: TKIP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA2 && 
                 encStat == Ndis802_11Encryption3Enabled)
        {
            printf("WPA2: AES\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA2PSK && 
                 encStat == Ndis802_11Encryption2Enabled)
        {
            printf("WPA-PSK2: TKIP\n");
        }
        else if (authMode == Ndis802_11AuthModeWPA2PSK && 
                 encStat == Ndis802_11Encryption3Enabled)
        {
            printf("WPA-PSK2: AES\n");
        }
        else
        {
            printf("<unknown> (auth = %d, encr = %d)\n", 
                authMode, encStat);
        }
    }

CloseHandle(hDevice);

return 0;
}

The following image shows the supported authentication and encryption capabilities of our HP iPAQ hx2490b:

How to connect to an open access point using NDISUIO?

Daniel Strigl — Sat, 23 Dec 2006 21:40:00 GMT

The steps to connect to an open access point without any encryption using NDISUIO are (see also 802.11 Network Association):

Disassociate from the current service set (OID_802_11_DISASSOCIATE).
Set network mode to Ndis802_11Infrastructure (OID_802_11_INFRASTRUCTURE_MODE).
Set privacy filter mode to Ndis802_11PrivFilterAcceptAll (OID_802_11_PRIVACY_FILTER).
Set authentication mode to Ndis802_11AuthModeOpen (OID_802_11_AUTHENTICATION_MODE).
Set encryption mode to Ndis802_11EncryptionDisabled (OID_802_11_ENCRYPTION_STATUS).
Set the service set identifier (SSID) to associate with (OID_802_11_SSID).
Optional: If you want to connect to a specific access point, set the media access control (MAC) address of the access point (OID_802_11_BSSID).
Wait for the NDISUIO_NOTIFICATION_MEDIA_CONNECT event (IOCTL_NDISUIO_REQUEST_NOTIFICATION).

If "Using DHCP" is chosen for the wireless network adapter you have also to renew the IP address.

I have written a console application that will show how to connect to an open access point using NDISUIO and a small console application to renew the IP address:

How to scan for wireless access points on a Pocket PC?

Daniel Strigl — Thu, 30 Nov 2006 23:31:00 GMT

I have also written a little Win32 console application in C++ that will show how to do it, to run it you have to install the PocketConsole from SymbolicTools:

// accesspoints.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>
#include <stdlib.h>
#include <ntddndis.h>
#include <nuiouser.h>
#include <winioctl.h>
#include "strconv.h"

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc < 2)
    {
        printf("Usage: accesspoints <adapter name> [delay in ms]\n");
        printf("       <adapter name> name of the wireless adapter\n");
        printf("       [delay in ms]  delay between scan and list query\n");
        return -1;
    }

LPCTSTR pszAdapter = argv[1];

if (hDevice == INVALID_HANDLE_VALUE)
    {
        DWORD dwError = GetLastError();

printf("Function \"CreateFile\" failed (0x%08x).\n", dwError);
        return -2;
    }

DWORD dwBytesReturned = 0;

NDISUIO_QUERY_OID NDISUIOQueryOid = {0};
    NDISUIOQueryOid.ptcDeviceName = (PTCHAR) pszAdapter;
    NDISUIOQueryOid.Oid = OID_GEN_PHYSICAL_MEDIUM;

if (!DeviceIoControl(
        hDevice, IOCTL_NDISUIO_QUERY_OID_VALUE,
        &NDISUIOQueryOid, sizeof(NDISUIOQueryOid),
        &NDISUIOQueryOid, sizeof(NDISUIOQueryOid),
        &dwBytesReturned, NULL))
    {
        DWORD dwError = GetLastError();

CloseHandle(hDevice);
        printf("Function \"DeviceIoControl\" (OID_GEN_PHYSICAL_MEDIUM) failed (0x%08x).\n", 
            dwError);
        return -3;
    }

if (*((PNDIS_PHYSICAL_MEDIUM) NDISUIOQueryOid.Data) != NdisPhysicalMediumWirelessLan)
    {
        CloseHandle(hDevice);
        printf("Device \"%s\" is no wireless adapter.\n", CTtoA(pszAdapter));
        return -4;
    }

CTtoW deviceName(pszAdapter);

if (!DeviceIoControl(
        hDevice, IOCTL_NDISUIO_OPEN_DEVICE,
        (LPVOID)(LPCWSTR) deviceName,
        deviceName.GetLength() * sizeof(WCHAR),
        NULL, 0, &dwBytesReturned, NULL))
    {
        DWORD dwError = GetLastError();

CloseHandle(hDevice);
        printf("Function \"DeviceIoControl\" (IOCTL_NDISUIO_OPEN_DEVICE) failed (0x%08x).\n", 
            dwError);
        return -5;
    }

NDISUIO_SET_OID NDISUIOSetOid = {0};  
    NDISUIOSetOid.ptcDeviceName = (PTCHAR) pszAdapter;  
    NDISUIOSetOid.Oid = OID_802_11_BSSID_LIST_SCAN;

if (!DeviceIoControl(  
        hDevice, IOCTL_NDISUIO_SET_OID_VALUE,   
        &NDISUIOSetOid, sizeof(NDISUIOSetOid),   
        NULL, 0,   
        &dwBytesReturned, NULL))  
    {  
        DWORD dwError = GetLastError();  
  
        CloseHandle(hDevice);  
        printf("Function \"DeviceIoControl\" (OID_802_11_BSSID_LIST_SCAN) failed (0x%08x).\n",   
            dwError);  
        return -6;  
    }

if (argc >= 3)
    {
        Sleep((DWORD)_ttoi(argv[2]));
    }

for (int i = 1;; ++i)
    {
        const DWORD queryMemSize = sizeof(NDISUIO_QUERY_OID) + sizeof(NDIS_WLAN_BSSID_EX) * i;
        PNDISUIO_QUERY_OID pNDISUIOQueryOid = (PNDISUIO_QUERY_OID) malloc(queryMemSize);

pNDISUIOQueryOid->ptcDeviceName = (PTCHAR) pszAdapter;
        pNDISUIOQueryOid->Oid = OID_802_11_BSSID_LIST;

if (!DeviceIoControl(
            hDevice, IOCTL_NDISUIO_QUERY_OID_VALUE, 
            pNDISUIOQueryOid, queryMemSize, 
            pNDISUIOQueryOid, queryMemSize, 
            &dwBytesReturned, NULL))
        {
            DWORD dwError = GetLastError();

free(pNDISUIOQueryOid);

if (dwError == ERROR_INVALID_USER_BUFFER ||
                dwError == ERROR_INSUFFICIENT_BUFFER)
                continue;

CloseHandle(hDevice);
            printf("Function \"DeviceIoControl\" (OID_802_11_BSSID_LIST) failed (0x%08x).\n", 
                dwError);
            return -7;
        }

PNDIS_802_11_BSSID_LIST_EX pBssidList = (PNDIS_802_11_BSSID_LIST_EX) pNDISUIOQueryOid->Data;

const int accessPointsCnt = (int) pBssidList->NumberOfItems;

printf("Found %d access point(s).\n", accessPointsCnt);

PNDIS_WLAN_BSSID_EX pBssid = pBssidList->Bssid;

for (int j = 0; j < accessPointsCnt; ++j)
        {
            printf("\n");

printf("MacAddress        : %02X-%02X-%02X-%02X-%02X-%02X\n",
                pBssid->MacAddress[0], pBssid->MacAddress[1],
                pBssid->MacAddress[2], pBssid->MacAddress[3],
                pBssid->MacAddress[4], pBssid->MacAddress[5]);

char* pSSID = (char*) malloc(pBssid->Ssid.SsidLength + 1);
            memcpy(pSSID, pBssid->Ssid.Ssid, pBssid->Ssid.SsidLength);
            pSSID[pBssid->Ssid.SsidLength] = '\0';
            printf("Ssid              : %s\n", pSSID);
            free(pSSID);

printf("Privacy           : %s\n", pBssid->Privacy ? "Yes" : "No");
            printf("Rssi              : %ld dBm\n", pBssid->Rssi);
            printf("NetworkTypeInUse  : %s\n", 
                pBssid->NetworkTypeInUse == Ndis802_11FH ? "Ndis802_11FH" : 
                pBssid->NetworkTypeInUse == Ndis802_11DS ? "Ndis802_11DS" :
                "<unknown>");
            printf("BeaconPeriod      : %lu Kusec\n", pBssid->Configuration.BeaconPeriod);
            printf("ATIMWindow        : %lu Kusec\n", pBssid->Configuration.ATIMWindow);

if (pBssid->NetworkTypeInUse == Ndis802_11DS)
            {
                printf("DSConfig          : %lu kHz\n", pBssid->Configuration.DSConfig);
            }
            else if (pBssid->NetworkTypeInUse == Ndis802_11FH)
            {
                printf("HopPattern        : %lu\n", pBssid->Configuration.FHConfig.HopPattern);
                printf("HopSet            : %lu\n", pBssid->Configuration.FHConfig.HopSet);
                printf("DwellTime         : %lu Kusec\n", pBssid->Configuration.FHConfig.DwellTime);
            }

printf("InfrastructureMode: %s\n",
                pBssid->InfrastructureMode == Ndis802_11IBSS ? "Ndis802_11IBSS" :
                pBssid->InfrastructureMode == Ndis802_11Infrastructure ? "Ndis802_11Infrastructure" :
                pBssid->InfrastructureMode == Ndis802_11AutoUnknown ? "Ndis802_11AutoUnknown" :
                "<unknown>");

printf("SupportedRates    : [0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x]\n",
                pBssid->SupportedRates[0], pBssid->SupportedRates[1], pBssid->SupportedRates[2], 
                pBssid->SupportedRates[3], pBssid->SupportedRates[4], pBssid->SupportedRates[5], 
                pBssid->SupportedRates[6], pBssid->SupportedRates[7]);

printf("                    BSSBasicRateSet (Mbps):");
            for (int n = 0; n < 8; ++n)
            {
                if (pBssid->SupportedRates[n] & 0x80)
                    printf(" %.1f", (pBssid->SupportedRates[n] & 0x7f) * 0.5f);
            }
            printf("\n");

printf("                    Others (Mbps):");
            for (int n = 0; n < 8; ++n)
            {
                if (!(pBssid->SupportedRates[n] & 0x80))
                    printf(" %.1f", (pBssid->SupportedRates[n] & 0x7f) * 0.5f);
            }
            printf("\n");

if (pBssid->Length >= sizeof(NDIS_802_11_BSSID_LIST_EX) && pBssid->IELength > 0)
            {
                printf("IEs               : [");
                for (ULONG n = 0; n < pBssid->IELength; ++n)
                {
                    printf("0x%02x", pBssid->IEs[n]);
                    if (n < pBssid->IELength - 1)
                        printf(", ");
                }
                printf("]\n");
            }
            
            pBssid = (PNDIS_WLAN_BSSID_EX) ((LPBYTE) pBssid + pBssid->Length);
        }

free(pNDISUIOQueryOid);

CloseHandle(hDevice);

return accessPointsCnt;
    }
}

The following image shows the output of the application running on our HP iPAQ hx2490b:

How to list installed network adapters on a Pocket PC and detect if they are wireless?

Daniel Strigl — Fri, 24 Nov 2006 23:02:00 GMT

I have written a little Win32 console application in C++ that will show how to do it, to run it you have to install the PocketConsole from SymbolicTools:

// adapters.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>
#include <iphlpapi.h>
#include <time.h>
#include <ntddndis.h>
#include <nuiouser.h>
#include <winioctl.h>
#include "strconv.h"

/*
 * Windows CE does not have a localtime() function, so create a substitute.
 * See SQLite WinCE Port [http://sourceforge.net/projects/sqlite-wince/].
 */
struct tm* localtime(const time_t* t)
{
    static struct tm y;
    FILETIME uTm, lTm;
    SYSTEMTIME pTm;
    __int64 t64;
    t64 = *t;
    t64 = (t64 + 11644473600) * 10000000;
    uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
    uTm.dwHighDateTime= (DWORD)(t64 >> 32);
    FileTimeToLocalFileTime(&uTm, &lTm);
    FileTimeToSystemTime(&lTm, &pTm);
    y.tm_year = pTm.wYear - 1900;
    y.tm_mon = pTm.wMonth - 1;
    y.tm_wday = pTm.wDayOfWeek;
    y.tm_mday = pTm.wDay;
    y.tm_hour = pTm.wHour;
    y.tm_min = pTm.wMinute;
    y.tm_sec = pTm.wSecond;
    return &y;
}

BOOL IsWireless(LPCTSTR pszAdapter, LPBOOL pbIsWireless)
{
    HANDLE hDevice = CreateFile(
        NDISUIO_DEVICE_NAME, GENERIC_READ, 
        FILE_SHARE_READ | FILE_SHARE_WRITE, 
        NULL, OPEN_EXISTING, 
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
        NULL);

if (hDevice == INVALID_HANDLE_VALUE)
    {
        DWORD dwError = GetLastError();

printf("Function \"CreateFile\" failed (0x%08x).\n", dwError);
        return FALSE;
    }

DWORD dwBytesReturned = 0;
    NDISUIO_QUERY_OID NDISUIOQueryOid;
    NDISUIOQueryOid.ptcDeviceName = (PTCHAR) pszAdapter;
    NDISUIOQueryOid.Oid = OID_802_11_WEP_STATUS;

*pbIsWireless = DeviceIoControl(
        hDevice, IOCTL_NDISUIO_QUERY_OID_VALUE, 
        &NDISUIOQueryOid, sizeof(NDISUIOQueryOid), 
        &NDISUIOQueryOid, sizeof(NDISUIOQueryOid), 
        &dwBytesReturned, NULL);

CloseHandle(hDevice);

return TRUE;
}

int _tmain(int argc, _TCHAR* argv[])
{
    DWORD dwRetVal;
    ULONG ulOutBufLen = 0;

if ((dwRetVal = GetAdaptersInfo(NULL, &ulOutBufLen)) != ERROR_BUFFER_OVERFLOW)
    {
        if (dwRetVal == ERROR_NO_DATA)
            printf("No adapter information exists for the local computer.\n");
        else
            printf("Function \"GetAdaptersInfo\" failed (0x%08x).\n", dwRetVal);

return -1;
    }

IP_ADAPTER_INFO* pAdapterInfo = (IP_ADAPTER_INFO*) malloc(ulOutBufLen);

if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) != ERROR_SUCCESS)
    {
        free(pAdapterInfo);

if (dwRetVal == ERROR_NO_DATA)
            printf("No adapter information exists for the local computer.\n");
        else
            printf("Function \"GetAdaptersInfo\" failed (0x%08x).\n", dwRetVal);

return -2;
    }

while (pAdapterInfo != NULL)
    {
        printf("Adapter Name    : %s\n", pAdapterInfo->AdapterName);
        printf("Description     : %s\n", pAdapterInfo->Description);
        printf("MAC Address     : %02X-%02X-%02X-%02X-%02X-%02X\n",
            pAdapterInfo->Address[0], pAdapterInfo->Address[1],
            pAdapterInfo->Address[2], pAdapterInfo->Address[3],
            pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
        printf("IP Address      : %s\n", 
            pAdapterInfo->IpAddressList.IpAddress.String);
        printf("Subnet Mask     : %s\n", 
            pAdapterInfo->IpAddressList.IpMask.String);
        printf("Gateway         : %s\n", 
            pAdapterInfo->GatewayList.IpAddress.String);

BOOL bIsWireless;
        printf("Is Wireless     : %s\n",
            IsWireless(CAtoT(pAdapterInfo->AdapterName), &bIsWireless) ? 
            bIsWireless ? "Yes" : "No" : "<unknown>");

if (pAdapterInfo->DhcpEnabled) 
        {
            printf("DHCP Enabled    : Yes\n");
            printf("DHCP Server     : %s\n", 
                pAdapterInfo->DhcpServer.IpAddress.String);

struct tm* t = localtime(&(pAdapterInfo->LeaseObtained));
            printf("Lease Obtained  : %02d.%02d.%04d %02d:%02d:%02d\n", 
                t->tm_mday, t->tm_mon + 1, t->tm_year + 1900,
                t->tm_hour, t->tm_min, t->tm_sec);

t = localtime(&(pAdapterInfo->LeaseExpires));
            printf("Lease Expires   : %02d.%02d.%04d %02d:%02d:%02d\n", 
                t->tm_mday, t->tm_mon + 1, t->tm_year + 1900,
                t->tm_hour, t->tm_min, t->tm_sec);
        }
        else
        {
            printf("DHCP Enabled    : No\n");
        }
    
        if (pAdapterInfo->HaveWins) 
        {
            printf("Have WINS       : Yes\n");
            printf("Pri. WINS Server: %s\n", 
                pAdapterInfo->PrimaryWinsServer.IpAddress.String);
            printf("Sec. WINS Server: %s\n", 
                pAdapterInfo->SecondaryWinsServer.IpAddress.String);
        }
        else
        {
            printf("Have WINS       : No\n");
        }

if (pAdapterInfo->Next != NULL)
            printf("\n");

pAdapterInfo = pAdapterInfo->Next;
    }

free(pAdapterInfo);

return 0;
}

The following image shows the output of the application running on our HP iPAQ hx2490b:

String conversion between ANSI and Unicode

Daniel Strigl — Fri, 24 Nov 2006 22:44:00 GMT

For a simple string conversion between ANSI and Unicode on a Pocket PC I have written some C++ classes:

CTtoA for conversion from LPCTSTR to LPCSTR
CTtoW for conversion from LPCTSTR to LPCWSTR
CAtoT for conversion from LPCSTR to LPCTSTR
CWtoT for conversion from LPCWSTR to LPCTSTR
CAtoW for conversion from LPCSTR to LPCWSTR
CWtoA for conversion from LPCWSTR to LPCSTR

strconv.h

    1 //////////////////////////////////////////////////////////////////////////
    2 //
    3 //  strconv.h - Some useful classes for string conversion.
    4 //
    5 //  Copyright (c) 2004-2007 by Daniel Strigl.
    6 //
    7 //  This code may be used in compiled form in any way you desire. 
    8 //  This file may be redistributed unmodified by any means PROVIDING 
    9 //  it is not sold for profit without the authors written consent, 
   10 //  and providing that this notice and the authors name is included. 
   11 //  By the way, if the source code in this file is used in any 
   12 //  application I would appreciate and enjoy hearing about them. 
   13 //
   14 //  This file is provided "as is" with no expressed or implied warranty.
   15 //  The author accepts no liability for any damage, in any form, caused
   16 //  by this code. Use it at your own risk and as with all code expect 
   17 //  bugs! It's been tested, but I'm not perfect ;-)
   18 //
   19 //  Please use the contact page of my blog to report any 
   20 //  bug, comment or suggestion.
   21 //
   22 //  Contact:
   23 //  --------
   24 //
   25 //    Daniel Strigl [http://geekswithblogs.net/dastblog/]
   26 //
   27 //  History:
   28 //  --------
   29 //
   30 //    21 Jul 2004 - Initial version.
   31 //    20 Nov 2006 - Added class CAtoT, CWtoT, CAtoW and CWtoA.
   32 //
   33 //////////////////////////////////////////////////////////////////////////
   34 
   35 #if !defined(_STRCONV_H_)
   36 #define _STRCONV_H_
   37 
   38 //////////////////////////////////////////////////////////////////////////
   39 //
   40 //  CTtoA
   41 //
   42 //      LPCTSTR to LPCSTR conversion.
   43 //
   44 class CTtoA
   45 {
   46     LPSTR m_psz;
   47 
   48 public:
   49     CTtoA(LPCTSTR ptsz) : m_psz(NULL)
   50     {
   51         ASSERT(ptsz != NULL);
   52 #if defined(_UNICODE) // for UNICODE build
   53         const int size = WideCharToMultiByte(CP_ACP, 0, ptsz, -1, 
   54             NULL, 0, NULL, NULL);
   55 #ifdef _DEBUG
   56         if (size == 0) {
   57             ASSERT(!_T("Function \"WideCharToMultiByte\" failed."));
   58         }
   59 #endif // _DEBUG
   60         ASSERT(size > 0);
   61         m_psz = (LPSTR) malloc(sizeof(CHAR)*size);
   62         ASSERT(m_psz != NULL);
   63 #ifdef _DEBUG
   64         memset(m_psz, 0, sizeof(CHAR)*size);
   65 #endif // _DEBUG
   66         VERIFY(WideCharToMultiByte(CP_ACP, 0, ptsz, -1, 
   67             m_psz, size, NULL, NULL) != 0);
   68 #else // for non-UNICODE build
   69         m_psz = _strdup(ptsz);
   70         ASSERT(m_psz != NULL);
   71 #endif // defined(_UNICODE)
   72     }
   73 
   74     CTtoA(const CTtoA& rhs) : m_psz(_strdup(rhs.m_psz))
   75     {
   76         ASSERT(m_psz != NULL);
   77     }
   78 
   79     CTtoA& operator=(const CTtoA& rhs)
   80     {
   81         if (this != &rhs)
   82         {
   83             free(m_psz);
   84             m_psz = _strdup(rhs.m_psz);
   85             ASSERT(m_psz != NULL);
   86         }
   87         return *this;
   88     }
   89 
   90     ~CTtoA()
   91     {
   92         free(m_psz);
   93     }
   94 
   95     size_t GetLength() const { return strlen(m_psz); }
   96 
   97     operator LPCSTR() const { return m_psz; }
   98 };
   99 
  100 //////////////////////////////////////////////////////////////////////////
  101 //
  102 //  CTtoW
  103 //
  104 //      LPCTSTR to LPCWSTR conversion.
  105 //
  106 class CTtoW
  107 {
  108     LPWSTR m_pwsz;
  109 
  110 public:
  111     CTtoW(LPCTSTR ptsz) : m_pwsz(NULL)
  112     {
  113         ASSERT(ptsz != NULL);
  114 #if defined(_UNICODE) // for UNICODE build
  115         m_pwsz = _wcsdup(ptsz);
  116         ASSERT(m_pwsz != NULL);
  117 #else // for non-UNICODE build
  118         const int size = MultiByteToWideChar(CP_ACP, 0, ptsz, -1, NULL, 0);
  119 #ifdef _DEBUG
  120         if (size == 0) {
  121             ASSERT(!_T("Function \"MultiByteToWideChar\" failed."));
  122         }
  123 #endif // _DEBUG
  124         ASSERT(size > 0);
  125         m_pwsz = (LPWSTR) malloc(sizeof(WCHAR)*size);
  126         ASSERT(m_pwsz != NULL);
  127 #ifdef _DEBUG
  128         memset(m_pwsz, 0, sizeof(WCHAR)*size);
  129 #endif // _DEBUG
  130         VERIFY(MultiByteToWideChar(CP_ACP, 0, ptsz, -1, m_pwsz, size) != 0);
  131 #endif // defined(_UNICODE)
  132     }
  133 
  134     CTtoW(const CTtoW& rhs) : m_pwsz(_wcsdup(rhs.m_pwsz))
  135     {
  136         ASSERT(m_pwsz != NULL);
  137     }
  138 
  139     CTtoW& operator=(const CTtoW& rhs)
  140     {
  141         if (this != &rhs)
  142         {
  143             free(m_pwsz);
  144             m_pwsz = _wcsdup(rhs.m_pwsz);
  145             ASSERT(m_pwsz != NULL);
  146         }
  147         return *this;
  148     }
  149 
  150     ~CTtoW()
  151     {
  152         free(m_pwsz);
  153     }
  154 
  155     size_t GetLength() const { return wcslen(m_pwsz); }
  156 
  157     operator LPCWSTR() const { return m_pwsz; }
  158 };
  159 
  160 //////////////////////////////////////////////////////////////////////////
  161 //
  162 //  CAtoT
  163 //
  164 //      LPCSTR to LPCTSTR conversion.
  165 //
  166 class CAtoT
  167 {
  168     LPTSTR m_ptsz;
  169 
  170 public:
  171     CAtoT(LPCSTR psz) : m_ptsz(NULL)
  172     {
  173         ASSERT(psz != NULL);
  174 #if defined(_UNICODE) // for UNICODE build
  175         const int size = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
  176 #ifdef _DEBUG
  177         if (size == 0) {
  178             ASSERT(!_T("Function \"MultiByteToWideChar\" failed."));
  179         }
  180 #endif // _DEBUG
  181         ASSERT(size > 0);
  182         m_ptsz = (LPWSTR) malloc(sizeof(WCHAR)*size);
  183         ASSERT(m_ptsz != NULL);
  184 #ifdef _DEBUG
  185         memset(m_ptsz, 0, sizeof(WCHAR)*size);
  186 #endif // _DEBUG
  187         VERIFY(MultiByteToWideChar(CP_ACP, 0, psz, -1, m_ptsz, size) != 0);
  188 #else // for non-UNICODE build
  189         m_ptsz = _strdup(psz);
  190         ASSERT(m_ptsz != NULL);
  191 #endif // defined(_UNICODE)
  192     }
  193 
  194     CAtoT(const CAtoT& rhs) : m_ptsz(_tcsdup(rhs.m_ptsz))
  195     {
  196         ASSERT(m_ptsz != NULL);
  197     }
  198 
  199     CAtoT& operator=(const CAtoT& rhs)
  200     {
  201         if (this != &rhs)
  202         {
  203             free(m_ptsz);
  204             m_ptsz = _tcsdup(rhs.m_ptsz);
  205             ASSERT(m_ptsz != NULL);
  206         }
  207         return *this;
  208     }
  209 
  210     ~CAtoT()
  211     {
  212         free(m_ptsz);
  213     }
  214 
  215     size_t GetLength() const { return _tcslen(m_ptsz); }
  216 
  217     operator LPCTSTR() const { return m_ptsz; }
  218 };
  219 
  220 //////////////////////////////////////////////////////////////////////////
  221 //
  222 //  CWtoT
  223 //
  224 //      LPCWSTR to LPCTSTR conversion.
  225 //
  226 class CWtoT
  227 {
  228     LPTSTR m_ptsz;
  229 
  230 public:
  231     CWtoT(LPCWSTR pwsz) : m_ptsz(NULL)
  232     {
  233         ASSERT(pwsz != NULL);
  234 #if defined(_UNICODE) // for UNICODE build
  235         m_ptsz = _wcsdup(pwsz);
  236         ASSERT(m_ptsz != NULL);
  237 #else // for non-UNICODE build
  238         const int size = WideCharToMultiByte(CP_ACP, 0, pwsz, -1, 
  239             NULL, 0, NULL, NULL);
  240 #ifdef _DEBUG
  241         if (size == 0) {
  242             ASSERT(!_T("Function \"WideCharToMultiByte\" failed."));
  243         }
  244 #endif // _DEBUG
  245         ASSERT(size > 0);
  246         m_ptsz = (LPSTR) malloc(sizeof(CHAR)*size);
  247         ASSERT(m_ptsz != NULL);
  248 #ifdef _DEBUG
  249         memset(m_ptsz, 0, sizeof(CHAR)*size);
  250 #endif // _DEBUG
  251         VERIFY(WideCharToMultiByte(CP_ACP, 0, pwsz, -1, 
  252             m_ptsz, size, NULL, NULL) != 0);
  253 #endif // defined(_UNICODE)
  254     }
  255 
  256     CWtoT(const CWtoT& rhs) : m_ptsz(_tcsdup(rhs.m_ptsz))
  257     {
  258         ASSERT(m_ptsz != NULL);
  259     }
  260 
  261     CWtoT& operator=(const CWtoT& rhs)
  262     {
  263         if (this != &rhs)
  264         {
  265             free(m_ptsz);
  266             m_ptsz = _tcsdup(rhs.m_ptsz);
  267             ASSERT(m_ptsz != NULL);
  268         }
  269         return *this;
  270     }
  271 
  272     ~CWtoT()
  273     {
  274         free(m_ptsz);
  275     }
  276 
  277     size_t GetLength() const { return _tcslen(m_ptsz); }
  278 
  279     operator LPCTSTR() const { return m_ptsz; }
  280 };
  281 
  282 //////////////////////////////////////////////////////////////////////////
  283 //
  284 //  CAtoW
  285 //
  286 //      LPCSTR to LPCWSTR conversion.
  287 //
  288 class CAtoW
  289 {
  290     LPWSTR m_pwsz;
  291 
  292 public:
  293     CAtoW(LPCSTR psz) : m_pwsz(NULL)
  294     {
  295         ASSERT(psz != NULL);
  296         const int size = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
  297 #ifdef _DEBUG
  298         if (size == 0) {
  299             ASSERT(!_T("Function \"MultiByteToWideChar\" failed."));
  300         }
  301 #endif // _DEBUG
  302         ASSERT(size > 0);
  303         m_pwsz = (LPWSTR) malloc(sizeof(WCHAR)*size);
  304         ASSERT(m_pwsz != NULL);
  305 #ifdef _DEBUG
  306         memset(m_pwsz, 0, sizeof(WCHAR)*size);
  307 #endif // _DEBUG
  308         VERIFY(MultiByteToWideChar(CP_ACP, 0, psz, -1, m_pwsz, size) != 0);
  309     }
  310 
  311     CAtoW(const CAtoW& rhs) : m_pwsz(_wcsdup(rhs.m_pwsz))
  312     {
  313         ASSERT(m_pwsz != NULL);
  314     }
  315 
  316     CAtoW& operator=(const CAtoW& rhs)
  317     {
  318         if (this != &rhs)
  319         {
  320             free(m_pwsz);
  321             m_pwsz = _wcsdup(rhs.m_pwsz);
  322             ASSERT(m_pwsz != NULL);
  323         }
  324         return *this;
  325     }
  326 
  327     ~CAtoW()
  328     {
  329         free(m_pwsz);
  330     }
  331 
  332     size_t GetLength() const { return wcslen(m_pwsz); }
  333 
  334     operator LPCWSTR() const { return m_pwsz; }
  335 };
  336 
  337 //////////////////////////////////////////////////////////////////////////
  338 //
  339 //  CWtoA
  340 //
  341 //      LPCWSTR to LPCSTR conversion.
  342 //
  343 class CWtoA
  344 {
  345     LPSTR m_psz;
  346 
  347 public:
  348     CWtoA(LPCWSTR pwsz) : m_psz(NULL)
  349     {
  350         ASSERT(pwsz != NULL);
  351         const int size = WideCharToMultiByte(CP_ACP, 0, pwsz, -1, 
  352             NULL, 0, NULL, NULL);
  353 #ifdef _DEBUG
  354         if (size == 0) {
  355             ASSERT(!_T("Function \"WideCharToMultiByte\" failed."));
  356         }
  357 #endif // _DEBUG
  358         ASSERT(size > 0);
  359         m_psz = (LPSTR) malloc(sizeof(CHAR)*size);
  360         ASSERT(m_psz != NULL);
  361 #ifdef _DEBUG
  362         memset(m_psz, 0, sizeof(CHAR)*size);
  363 #endif // _DEBUG
  364         VERIFY(WideCharToMultiByte(CP_ACP, 0, pwsz, -1, 
  365             m_psz, size, NULL, NULL) != 0);
  366     }
  367 
  368     CWtoA(const CWtoA& rhs) : m_psz(_strdup(rhs.m_psz))
  369     {
  370         ASSERT(m_psz != NULL);
  371     }
  372 
  373     CWtoA& operator=(const CWtoA& rhs)
  374     {
  375         if (this != &rhs)
  376         {
  377             free(m_psz);
  378             m_psz = _strdup(rhs.m_psz);
  379             ASSERT(m_psz != NULL);
  380         }
  381         return *this;
  382     }
  383 
  384     ~CWtoA()
  385     {
  386         free(m_psz);
  387     }
  388 
  389     size_t GetLength() const { return strlen(m_psz); }
  390 
  391     operator LPCSTR() const { return m_psz; }
  392 };
  393 
  394 //////////////////////////////////////////////////////////////////////////
  395 
  396 #endif // !defined(_STRCONV_H_)

The usage of the classes are realy simple, here is an example:

    1 ...
    2 
    3 #include "strconv.h"
    4 
    5 BOOL IsWireless(LPCTSTR pszAdapter)
    6 {
    7     ...
    8 }
    9 
   10 int _tmain(int argc, _TCHAR* argv[])
   11 {
   12     char szAdapter[64];
   13 
   14     ...
   15 
   16     BOOL bIsWireless = IsWireless(CAtoT(szAdapter));
   17 
   18     ...
   19 
   20     return 0;
   21 }